diff --git a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
index b710a38..cde1026 100644
--- a/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
+++ b/compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt
@@ -58,14 +58,14 @@
                             val name = overriddenDescriptor.getName()
 
                             // this is the actual member of delegateExpressionType that we are delegating to
-                            (scope.getFunctions(name, NoLookupLocation.FROM_BACKEND) + scope.getProperties(name, NoLookupLocation.FROM_BACKEND))
+                           ^(scope.getFunctions(name, NoLookupLocation.FROM_BACKEND) + scope.getProperties(name, NoLookupLocation.FROM_BACKEND))
                                     .first {
                                         (listOf(it) + DescriptorUtils.getAllOverriddenDescriptors(it)).map { it.getOriginal() }.contains(overriddenDescriptor.getOriginal())
                                     }
                         }
                 assert(actualDelegates.size() <= 1) { "Many delegates found for $delegatingMember: $actualDelegates" }
 
-                actualDelegates.firstOrNull()
+               ^actualDelegates.firstOrNull()
             }
     }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractAccessorForFunctionDescriptor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractAccessorForFunctionDescriptor.kt
index 3026db4b..8494c81 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractAccessorForFunctionDescriptor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AbstractAccessorForFunctionDescriptor.kt
@@ -39,7 +39,7 @@
             copy.addUpperBound(upperBound)
         }
         copy.setInitialized()
-        copy
+       ^copy
     }
 
     protected fun copyValueParameters(descriptor: FunctionDescriptor): List<ValueParameterDescriptor> =
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
index 3d7291a..5fb6fef 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MultifileClassCodegen.kt
@@ -79,7 +79,7 @@
         if (singleSourceFile != null) {
             classBuilder.visitSource(singleSourceFile.name, null)
         }
-        classBuilder
+       ^classBuilder
     }
 
     public fun generate(errorHandler: CompilationErrorHandler) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
index 16d4e4e..66c03b0 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyReferenceCodegen.kt
@@ -116,7 +116,7 @@
             val getter = target.getGetter() ?: run {
                 val defaultGetter = DescriptorFactory.createDefaultGetter(target, Annotations.EMPTY)
                 defaultGetter.initialize(target.getType())
-                defaultGetter
+               ^defaultGetter
             }
 
             val method = typeMapper.mapSignature(getter).getAsmMethod()
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt
index f409a45..31c6369 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/classFileUtils.kt
@@ -53,6 +53,6 @@
                 val (packageFqName, packageParts) = it
                 val newPackageParts = PackageParts(packageFqName)
                 packageParts.forEach { newPackageParts.parts.addAll(it.parts) }
-                newPackageParts
+               ^newPackageParts
             }
 }
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/CoveringTryCatchNodeProcessor.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/CoveringTryCatchNodeProcessor.kt
index 7320c9f..7d7a8a8 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/CoveringTryCatchNodeProcessor.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/CoveringTryCatchNodeProcessor.kt
@@ -67,7 +67,7 @@
                     result = instructionIndex(t1.endLabel) - instructionIndex(t2.endLabel)
                 }
             }
-            result
+           ^result
         }
 
         Collections.sort<TryCatchBlockNodeInfo>(intervals, comp)
@@ -197,12 +197,12 @@
         val newPartInterval = if (keepStart) {
             val oldEnd = endLabel
             node.end = split.startLabel
-            Pair(split.endLabel, oldEnd)
+           ^Pair(split.endLabel, oldEnd)
         }
         else {
             val oldStart = startLabel
             node.start = split.endLabel
-            Pair(oldStart, split.startLabel)
+           ^Pair(oldStart, split.startLabel)
         }
 
         return SplitPair(this, LocalVarNodeWrapper(
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
index 6fc8044..8c5d89d 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAP.kt
@@ -33,7 +33,7 @@
     fun build(): String? {
         var realMappings = fileMappings.filter {
             val mappings = it.lineMappings
-            mappings.isNotEmpty() && mappings.first() != RangeMapping.SKIP
+           ^mappings.isNotEmpty() && mappings.first() != RangeMapping.SKIP
         }
 
         if (realMappings.isEmpty()) {
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAPAndMethodNode.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAPAndMethodNode.kt
index 6ab9f05..4755429 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAPAndMethodNode.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/SMAPAndMethodNode.kt
@@ -36,7 +36,7 @@
             }
             if (index < 0)
                 throw IllegalStateException("Unmapped label in inlined function $it ${it.line}")
-            LabelAndMapping(it, classSMAP.intervals[index])
+           ^LabelAndMapping(it, classSMAP.intervals[index])
         }.toList()
 
     val ranges = lineNumbers.asSequence().map { it.mapper }.distinct().toList();
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TryBlockClustering.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TryBlockClustering.kt
index 3583370..37c9f9a 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TryBlockClustering.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/TryBlockClustering.kt
@@ -63,12 +63,12 @@
         val newPartInterval = if (keepStart) {
             val oldEnd = endLabel
             node.end = splitBy.startLabel
-            Pair(splitBy.endLabel, oldEnd)
+           ^Pair(splitBy.endLabel, oldEnd)
         }
         else {
             val oldStart = startLabel
             node.start = splitBy.endLabel
-            Pair(oldStart, splitBy.startLabel)
+           ^Pair(oldStart, splitBy.startLabel)
         }
         return SplitPair(
                 this,
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt
index 400a0dc..b15a029 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/inline/inlineCodegenUtils.kt
@@ -40,12 +40,12 @@
         is KotlinJvmBinarySourceElement -> {
             assert(this is DeserializedSimpleFunctionDescriptor) { "Expected DeserializedSimpleFunctionDescriptor, got: $this" }
             val kotlinClass = source.binaryClass as VirtualFileKotlinClass
-            kotlinClass.file.canonicalPath!!
+           ^kotlinClass.file.canonicalPath!!
         }
         else -> {
             val classId = InlineCodegenUtil.getContainerClassId(this)!!
             val className = JvmClassName.byClassId(classId).internalName
-            cache.getClassFilePath(className)
+           ^cache.getClassFilePath(className)
         }
     }
 }
\ No newline at end of file
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt
index 4649358..c8eda66 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt
@@ -100,7 +100,7 @@
                 val newTcb = TryCatchBlockNode(getNew(oldTcb.start), getNew(oldTcb.end), getNew(oldTcb.handler), oldTcb.type)
                 newTcb.visibleTypeAnnotations = oldTcb.visibleTypeAnnotations
                 newTcb.invisibleTypeAnnotations = oldTcb.invisibleTypeAnnotations
-                newTcb
+               ^newTcb
             }
         }
 
diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt
index db810ae..d21e42a 100644
--- a/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt
+++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt
@@ -56,7 +56,7 @@
 private fun transformTryCatchBlocks(methodNode: MethodNode, newTryStartLabels: HashMap<LabelNode, LabelNode>) {
     methodNode.tryCatchBlocks = methodNode.tryCatchBlocks.map { tcb ->
         val newTryStartLabel = newTryStartLabels[tcb.start]
-        if (newTryStartLabel == null)
+       ^if (newTryStartLabel == null)
             tcb
         else
             TryCatchBlockNode(newTryStartLabel, tcb.end, tcb.handler, tcb.type)
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
index 02536cc..2a0ee76f 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt
@@ -124,6 +124,6 @@
             val facadeFqName =
                     if (isCompiled) packageFqName.child(Name.identifier(virtualFile.nameWithoutExtension))
                     else JvmFileClassUtil.getFileClassInfoNoResolve(this).facadeClassFqName
-            CachedValueProvider.Result(facadeFqName, this)
+           ^CachedValueProvider.Result(facadeFqName, this)
         }
     }
\ No newline at end of file
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
index 11c1d78..62f33fe 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
@@ -115,7 +115,7 @@
 }.let {
     it.javaAnalysisInit()
 
-    ContainerForTopDownAnalyzerForJvm(it)
+   ^ContainerForTopDownAnalyzerForJvm(it)
 }
 
 private fun StorageComponentContainer.javaAnalysisInit() {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt
index 9a10761..764dc6d 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt
@@ -30,7 +30,7 @@
     override fun getClasses(nameFilter: (Name) -> Boolean): Collection<JavaClass> {
         val psiClasses = getPsi().getClasses(scope).filter {
             val name = it.getName()
-            name != null && nameFilter(Name.identifier(name))
+           ^name != null && nameFilter(Name.identifier(name))
         }
         return classes(psiClasses)
     }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
index e723a26..ff4b113 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt
@@ -73,7 +73,7 @@
                 catch (e: Throwable) {
                     LOG.warn(renderFileReadingErrorMessage(file))
                 }
-                null
+               ^null
             }
         }
 
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
index 0967f16..6b23068 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt
@@ -111,20 +111,20 @@
                                     }
                                     else {
                                         val packageFqName = it.packageFqName.replace('.', '/')
-                                        it.parts.map { packageFqName + "/" + it }
+                                       ^it.parts.map { packageFqName + "/" + it }
                                     }
 
-                            allParts.filterNot { it in obsoletePackageParts }
+                           ^allParts.filterNot { it in obsoletePackageParts }
                         } ?: emptyList<String>()
 
                 val dataOfPackageParts = actualPackagePartFiles.map { incrementalCache.getPackagePartData(it) }.filterNotNull()
 
-                if (dataOfPackageParts.isEmpty()) {
+               ^if (dataOfPackageParts.isEmpty()) {
                     JetScope.Empty
                 }
                 else {
                     val scopes = dataOfPackageParts.map { IncrementalPackageScope(JvmProtoBufUtil.readPackageDataFrom(it)) }
-                    ChainedScope(this,
+                   ^ChainedScope(this,
                                  "Member scope for incremental compilation: union of package parts data",
                                  *scopes.toTypedArray<JetScope>()
                     )
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
index 01bdfb9..d77d9ca 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt
@@ -62,7 +62,7 @@
 
         val moduleClassResolver = ModuleClassResolverImpl { javaClass ->
             val moduleInfo = platformParameters.moduleByJavaClass(javaClass)
-            resolverForProject.resolverForModule(moduleInfo as M).componentProvider.get<JavaDescriptorResolver>()
+           ^resolverForProject.resolverForModule(moduleInfo as M).componentProvider.get<JavaDescriptorResolver>()
         }
         val container = createContainerForLazyResolveWithJava(
                 moduleContext,
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt
index 1533720f3..8bbd2ee 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt
@@ -42,7 +42,7 @@
 
     private val kPropertyClasses by storageManager.createLazyValue {
         val reflectionTypes = ReflectionTypes(module)
-        setOf(reflectionTypes.kProperty0, reflectionTypes.kProperty1, reflectionTypes.kProperty2)
+       ^setOf(reflectionTypes.kProperty0, reflectionTypes.kProperty1, reflectionTypes.kProperty2)
     }
 
     override fun <F : CallableDescriptor> check(resolvedCall: ResolvedCall<F>, context: BasicCallResolutionContext) {
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt
index 4151400..1ccbbcc 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt
@@ -30,6 +30,6 @@
 
     return subParams.zip(superParams).all {
         p -> val (subParam, superParam) = p
-        subParam.getAsmType() == superParam.getAsmType()
+       ^subParam.getAsmType() == superParam.getAsmType()
     }
 }
diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
index 66a3a34..96c53f9 100644
--- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
+++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt
@@ -130,7 +130,7 @@
             if (!propertyType.isSubtypeOf(parameter.type)) return false
             if (descriptor.findOverridden {
                 val baseProperty = SyntheticJavaPropertyDescriptor.findByGetterOrSetter(it, this)
-                baseProperty?.getMethod?.name == getMethod.name
+               ^baseProperty?.getMethod?.name == getMethod.name
             } == null) return false
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
index 4565d6a..f8f1b36 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt
@@ -184,7 +184,7 @@
                 val descriptor = resolverForProject.descriptorForModule(module)
                 val computeResolverForModule = storageManager.createLazyValue {
                     val content = modulesContent(module)
-                    createResolverForModule(
+                   ^createResolverForModule(
                             module, descriptor, projectContext.withModule(descriptor), modulesContent(module),
                             platformParameters, targetEnvironment, resolverForProject,
                             packagePartProviderFactory(module, content)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariableDataCollector.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariableDataCollector.kt
index 6f9a084..3d270fe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariableDataCollector.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariableDataCollector.kt
@@ -68,7 +68,7 @@
             val lexicalScope = lexicalScopeVariableInfo.declaredIn[variable]
             // '-1' for variables declared outside this pseudocode
             val depth = lexicalScope?.depth ?: -1
-            depth <= toDepth
+           ^depth <= toDepth
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
index 5504c17..37b9cca 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt
@@ -103,7 +103,7 @@
             currentTextRange, element ->
 
             val elementRange = element.getTextRange()!!
-            if (currentTextRange == null) {
+           ^if (currentTextRange == null) {
                 elementRange
             }
             else if (currentTextRange.getEndOffset() == elementRange.getStartOffset()) {
@@ -111,7 +111,7 @@
             }
             else {
                 result.add(currentTextRange)
-                elementRange
+               ^elementRange
             }
         }
         if (lastRange != null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
index 60e6286..2fc0466 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt
@@ -192,7 +192,7 @@
                                 else ->
                                     parameter.getType()
                             }
-                            addSubtypesOf(expectedType)
+                           ^addSubtypesOf(expectedType)
                         }
                     }
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt
index 8860078..03569b1 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt
@@ -104,7 +104,7 @@
 
             other.add(annotationWithTarget)
         }
-        map to AnnotationsImpl.create(other)
+       ^map to AnnotationsImpl.create(other)
     }
 
     public fun getOtherAnnotations(): Annotations = LazySplitAnnotations(storageManager, null)
@@ -119,7 +119,7 @@
         private val annotations by storageManager.createLazyValue {
             val splitAnnotations = this@AnnotationSplitter.splitAnnotations()
 
-            if (target != null)
+           ^if (target != null)
                 AnnotationsImpl.create(splitAnnotations.first[target] ?: emptyList())
             else
                 splitAnnotations.second
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
index 04cc406..a2e1d40 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt
@@ -60,7 +60,7 @@
                      + "This is usually a bad idea, because descriptors' toString() includes some debug information, "
                      + "which should not be seen by the user.\nDescriptor: " + element)
         }
-        element.toString()
+       ^element.toString()
     }
 
     public val STRING: Renderer<String> = Renderer { it }
@@ -68,7 +68,7 @@
     public val THROWABLE: Renderer<Throwable> = Renderer {
         val writer = StringWriter()
         it.printStackTrace(PrintWriter(writer))
-        StringUtil.first(writer.toString(), 2048, true)
+       ^StringUtil.first(writer.toString(), 2048, true)
     }
 
     public val NAME: Renderer<Named> = Renderer { it.getName().asString() }
@@ -80,7 +80,7 @@
     public val RENDER_CLASS_OR_OBJECT: Renderer<JetClassOrObject> = Renderer {
         classOrObject: JetClassOrObject ->
         val name = if (classOrObject.getName() != null) " '" + classOrObject.getName() + "'" else ""
-        if (classOrObject is JetClass) "Class" + name else "Object" + name
+       ^if (classOrObject is JetClass) "Class" + name else "Object" + name
     }
 
     public val RENDER_CLASS_OR_OBJECT_NAME: Renderer<ClassDescriptor> = Renderer { it.renderKindWithName() }
@@ -373,7 +373,7 @@
             val arrow = if (bound.kind == LOWER_BOUND) ">: " else if (bound.kind == UPPER_BOUND) "<: " else ":= "
             val renderer = if (short) DescriptorRenderer.SHORT_NAMES_IN_TYPES else DescriptorRenderer.FQ_NAMES_IN_TYPES
             val renderedBound = arrow + renderer.renderType(bound.constrainingType) +  if (!bound.isProper) "*" else ""
-            if (short) renderedBound else renderedBound + '(' + bound.position + ')'
+           ^if (short) renderedBound else renderedBound + '(' + bound.position + ')'
         }
         val typeVariableName = typeBounds.typeVariable.getName()
         return if (typeBounds.bounds.isEmpty()) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
index 42e2857..4cf0a0d 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt
@@ -118,7 +118,7 @@
             val typeReference = entry.getTypeReference()
             val userType = typeReference?.getStubOrPsiChild(JetStubElementTypes.USER_TYPE)
 
-            name == userType?.getReferencedName()
+           ^name == userType?.getReferencedName()
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt
index f661e93..0f63745 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt
@@ -66,7 +66,7 @@
         else {
             val parameterList = getValueParameterList()!!
             val newModifierList = JetPsiFactory(getProject()).createModifierList(annotationEntry.text)
-            (addBefore(newModifierList, parameterList) as JetModifierList).annotationEntries.first()
+           ^(addBefore(newModifierList, parameterList) as JetModifierList).annotationEntries.first()
         }
     }
 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
index c6bb1f6..5a9d8bd5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/KotlinStringLiteralTextEscaper.kt
@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.psi
 
-import com.intellij.psi.LiteralTextEscaper
 import com.intellij.openapi.util.TextRange
+import com.intellij.psi.LiteralTextEscaper
 import gnu.trove.TIntArrayList
 import org.jetbrains.kotlin.psi.psiUtil.getContentRange
 import org.jetbrains.kotlin.psi.psiUtil.isSingleQuoted
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
index 26916e5..210f9e5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt
@@ -68,7 +68,7 @@
                     val anchor = getNameIdentifier()
                     val newTypeRef = addBefore(typeRef, anchor) as JetTypeReference
                     addAfter(JetPsiFactory(getProject()).createDot(), newTypeRef)
-                    newTypeRef
+                   ^newTypeRef
                 }
         if (needParentheses) {
             val argList = JetPsiFactory(getProject()).createCallArguments("()")
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
index 0bdbc6e..c81a3a7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt
@@ -96,7 +96,7 @@
     @Suppress("NAME_SHADOWING")
     val args = args.zip(argumentTypes).map {
         val (arg, type) = it
-        if (type is PlainTextArgumentType)
+       ^if (type is PlainTextArgumentType)
             (type.toPlainText as Function1<in Any, String>).invoke(arg) // TODO: see KT-7833
         else
             arg
@@ -220,7 +220,7 @@
                         check(endIndex > i, "empty placeholder text")
                         val text = pattern.substring(i, endIndex)
                         i = endIndex + 1
-                        text
+                       ^text
                     }
 
                     append(placeholderText)
@@ -232,7 +232,7 @@
             else {
                 append(c)
             }
-            i++
+           ^i++
         }
     }.toString()
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/PsiChildRange.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/PsiChildRange.kt
index 7557865..6935c3a 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/PsiChildRange.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/PsiChildRange.kt
@@ -37,7 +37,7 @@
         }
         else {
             val afterLast = last!!.getNextSibling()
-            first.siblings().takeWhile { it != afterLast }
+           ^first.siblings().takeWhile { it != afterLast }
         }
         return sequence.iterator()
     }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
index 41db8ad..eb07022 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt
@@ -68,7 +68,7 @@
 public fun JetSimpleNameExpression.getTopmostParentQualifiedExpressionForSelector(): JetQualifiedExpression? {
     return sequence<JetExpression>(this) {
         val parentQualified = it.getParent() as? JetQualifiedExpression
-        if (parentQualified?.getSelectorExpression() == it) parentQualified else null
+       ^if (parentQualified?.getSelectorExpression() == it) parentQualified else null
     }.last() as? JetQualifiedExpression
 }
 
@@ -81,7 +81,7 @@
         is JetCallExpression -> getCalleeExpression()
         is JetQualifiedExpression -> {
             val selector = getSelectorExpression()
-            if (selector is JetCallExpression) selector.getCalleeExpression() else selector
+           ^if (selector is JetCallExpression) selector.getCalleeExpression() else selector
         }
         is JetUserType -> getReferenceExpression()
         else -> null
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt
index 38d2aeb..5f9800e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt
@@ -258,7 +258,7 @@
                 .parentsWithSelf
                 .first {
                     val parent = it.getParent()
-                    it is PsiFile || parent.getTextRange() !in currentRange
+                   ^it is PsiFile || parent.getTextRange() !in currentRange
                 }
         result.add(element)
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
index 10d920a..911d1f9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt
@@ -58,11 +58,11 @@
         return try {
             val value = property.invoke(this)
             val name = getPropertyName(property)
-            "$name=$value"
+           ^"$name=$value"
         }
         catch (e: Exception) {
             LOGGER.error(e)
-            null
+           ^null
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
index 343be19..9904bd5 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt
@@ -54,7 +54,7 @@
         when (this) {
             is PropertyAccessorDescriptor -> {
                 val propertyDescriptor = getCorrespondingProperty()
-                predicate(propertyDescriptor.getContainingDeclaration()) &&
+               ^predicate(propertyDescriptor.getContainingDeclaration()) &&
                 (hasPlatformStaticAnnotation() || propertyDescriptor.hasPlatformStaticAnnotation())
             }
             else -> predicate(getContainingDeclaration()) && hasPlatformStaticAnnotation()
@@ -77,7 +77,7 @@
                 /* nullable = */false, /* arguments = */emptyList()
         )
 
-        AnnotationDescriptorImpl(
+       ^AnnotationDescriptorImpl(
                 type,
                 emptyMap(), SourceElement.NO_SOURCE
         )
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt
index 5468b50..1a02931 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt
@@ -80,7 +80,7 @@
 
             if (d1 !is TypeParameterDescriptor || d2 !is TypeParameterDescriptor) return@eq false
 
-            areTypeParametersEquivalent(d1, d2, {x, y -> x == a && y == b})
+           ^areTypeParametersEquivalent(d1, d2, {x, y -> x == a && y == b})
         }
 
         return overridingUtil.isOverridableByIncludingReturnType(a, b).getResult() == OverrideCompatibilityInfo.Result.OVERRIDABLE
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
index c3744b7..adc12e9 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
@@ -122,7 +122,7 @@
         else if (function.hasBody()) {
             DeferredType.createRecursionIntolerant(storageManager, trace) {
                 val type = expressionTypingServices.getBodyExpressionType(trace, scope, dataFlowInfo, function, functionDescriptor)
-                transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace)
+               ^transformAnonymousTypeIfNeeded(functionDescriptor, function, type, trace)
             }
         }
         else {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
index ea2babd..7c30de3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt
@@ -57,7 +57,7 @@
             return userType.referenceExpression?.let {
                 val classifier = scope.getClassifier(it.getReferencedNameAsName(), KotlinLookupLocation(it))
                 storageResult(trace, it, listOfNotNull(classifier), scope.ownerDescriptor, inImport = false, isQualifier = false)
-                classifier
+               ^classifier
             }
         }
 
@@ -259,7 +259,7 @@
 
         val firstDescriptor = scopeForFirstPart?.let {
                 val firstPart = path.first()
-                it.getClassifier(firstPart.name, firstPart.location)?.apply {
+               ^it.getClassifier(firstPart.name, firstPart.location)?.apply {
                     storageResult(trace, firstPart.expression, listOf(this), shouldBeVisibleFrom, inImport)
                 }
             }
@@ -282,7 +282,7 @@
                     } else null
 
 
-                    if (packageView != null && !packageView.isEmpty()) {
+                   ^if (packageView != null && !packageView.isEmpty()) {
                         packageView
                     } else {
                         descriptor.memberScope.getClassifier(qualifierPart.name, qualifierPart.location)
@@ -291,7 +291,7 @@
                 else -> null
             }
             storageResult(trace, qualifierPart.expression, listOfNotNull(nextDescriptor), shouldBeVisibleFrom, inImport)
-            nextDescriptor
+           ^nextDescriptor
         }
     }
 
@@ -312,7 +312,7 @@
                 return Pair(packageDescriptor, prefixSize)
             }
             fqName = fqName.parent()
-            prefixSize--
+           ^prefixSize--
         }
         return Pair(getPackage(FqName.ROOT), 0)
     }
@@ -330,7 +330,7 @@
                 "Containing Declaration must be not null for package with fqName: ${currentView.fqName}, " +
                 "path: ${path.joinToString()}, packageView fqName: ${packageView.fqName}"
             }
-            parentView!!
+           ^parentView!!
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
index 13dc2c5..b803724 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt
@@ -78,7 +78,7 @@
         val isErrorBinding = run {
             val sizeIsEqual = psiTypeArguments.size() == jetType.getArguments().size()
                               && psiTypeArguments.size() == jetType.getConstructor().getParameters().size()
-            jetType.isError() || !sizeIsEqual
+           ^jetType.isError() || !sizeIsEqual
         }
 
         return psiTypeArguments.indices.map { index: Int ->
@@ -118,7 +118,7 @@
         val isErrorBinding = jetType.isError() || jetType.getConstructor().getParameters().size() != jetType.getArguments().size()
         return jetType.getArguments().indices.map {
             val typeProjection = jetType.getArguments()[it]
-            TypeArgumentBindingImpl(
+           ^TypeArgumentBindingImpl(
                     typeProjection,
                     if (isErrorBinding) null else jetType.getConstructor().getParameters()[it],
                     NoTypeElementBinding(trace, psiElement, typeProjection.getType())
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
index a7a796e..838b7b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt
@@ -278,11 +278,11 @@
 
             val projectionKind = argumentElement.getProjectionKind()
             ModifierCheckerCore.check(argumentElement, c.trace, null)
-            if (projectionKind == JetProjectionKind.STAR) {
+           ^if (projectionKind == JetProjectionKind.STAR) {
                 val parameters = constructor.getParameters()
-                if (parameters.size() > i) {
+               ^if (parameters.size() > i) {
                     val parameterDescriptor = parameters[i]
-                    TypeUtils.makeStarProjection(parameterDescriptor)
+                   ^TypeUtils.makeStarProjection(parameterDescriptor)
                 }
                 else {
                     TypeProjectionImpl(OUT_VARIANCE, ErrorUtils.createErrorType("*"))
@@ -302,7 +302,7 @@
                         }
                     }
                 }
-                TypeProjectionImpl(kind, type)
+               ^TypeProjectionImpl(kind, type)
             }
 
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
index 9e393f6..6e50626 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt
@@ -155,7 +155,7 @@
     return resolutionResults?.let { results ->
         if (results.isSomething()) {
             resolvedToSomething[0] = true
-            OverloadResolutionResultsUtil.getResultingCall(results, context.contextDependency)?.let { call ->
+           ^OverloadResolutionResultsUtil.getResultingCall(results, context.contextDependency)?.let { call ->
                 call.getResultingDescriptor()
             }
         }
@@ -229,7 +229,7 @@
             if (reportOn != null) {
                 context.trace.report(UNSUPPORTED.on(reportOn, "References to variables aren't supported yet"))
             }
-            null
+           ^null
         }
         else ->
             throw UnsupportedOperationException("Callable reference resolved to an unsupported descriptor: $descriptor")
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
index ae690dc..29e6d1e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt
@@ -159,7 +159,7 @@
             updateSystemIfSuccessful {
                 system ->
                 constraintSystemCompleter.completeConstraintSystem(system, this)
-                !system.filterConstraintsOut(TYPE_BOUND_POSITION).getStatus().hasOnlyErrorsDerivedFrom(FROM_COMPLETER)
+               ^!system.filterConstraintsOut(TYPE_BOUND_POSITION).getStatus().hasOnlyErrorsDerivedFrom(FROM_COMPLETER)
             }
         }
 
@@ -167,7 +167,7 @@
             updateSystemIfSuccessful {
                 system ->
                 system.addSupertypeConstraint(builtIns.getUnitType(), returnType, EXPECTED_TYPE_POSITION.position())
-                system.getStatus().isSuccessful()
+               ^system.getStatus().isSuccessful()
             }
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
index 557cf6a..cd12af7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt
@@ -181,9 +181,9 @@
         val receiverValue = ExpressionTypingUtils.normalizeReceiverValueForVisibility(candidateCall.getDispatchReceiver(),
                                                                                       trace.getBindingContext())
         val invisibleMember = Visibilities.findInvisibleMember(receiverValue, candidateDescriptor, scope.ownerDescriptor)
-        if (invisibleMember != null) {
+       ^if (invisibleMember != null) {
             tracing.invisibleMember(trace, invisibleMember)
-            OTHER_ERROR
+           ^OTHER_ERROR
         } else {
             SUCCESS
         }
@@ -192,13 +192,13 @@
     private fun CallCandidateResolutionContext<*>.checkExtensionReceiver() = checkAndReport {
         val receiverParameter = candidateCall.getCandidateDescriptor().getExtensionReceiverParameter()
         val receiverArgument = candidateCall.getExtensionReceiver()
-        if (receiverParameter != null && !receiverArgument.exists()) {
+       ^if (receiverParameter != null && !receiverArgument.exists()) {
             tracing.missingReceiver(candidateCall.getTrace(), receiverParameter)
-            OTHER_ERROR
+           ^OTHER_ERROR
         }
         else if (receiverParameter == null && receiverArgument.exists()) {
             tracing.noReceiverAllowed(candidateCall.getTrace())
-            if (call.getCalleeExpression() is JetSimpleNameExpression) {
+           ^if (call.getCalleeExpression() is JetSimpleNameExpression) {
                 RECEIVER_PRESENCE_ERROR
             }
             else {
@@ -233,7 +233,7 @@
             "Shouldn't happen because of TaskPrioritizer: $candidateDescriptor"
         }
 
-        SUCCESS
+       ^SUCCESS
     }
 
     private fun checkOuterClassMemberIsAccessible(context: CallCandidateResolutionContext<*>): Boolean {
@@ -282,7 +282,7 @@
             && !KotlinBuiltIns.isExtensionFunctionType(candidateCall.getDispatchReceiver().getType())
         ) {
             tracing.freeFunctionCalledAsExtension(trace)
-            OTHER_ERROR
+           ^OTHER_ERROR
         } else {
             SUCCESS
         }
@@ -399,7 +399,7 @@
 
         val erasedReceiverType = getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor)
 
-        if (!smartCastManager.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, this)) {
+       ^if (!smartCastManager.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, this)) {
             RECEIVER_TYPE_ERROR
         } else {
             SUCCESS
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
index d2b6c54..b641086 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt
@@ -209,7 +209,7 @@
                     ArgumentTypeResolver.getFunctionLiteralArgumentIfAny(argumentExpression, context)?.let { functionLiteral ->
                         addConstraintForFunctionLiteral(functionLiteral, valueArgument, valueParameterDescriptor, constraintSystem, context)
                     }
-                    ArgumentTypeResolver.getCallableReferenceExpressionIfAny(argumentExpression, context)?.let { callableReference ->
+                   ^ArgumentTypeResolver.getCallableReferenceExpressionIfAny(argumentExpression, context)?.let { callableReference ->
                         addConstraintForCallableReference(callableReference, valueArgument, valueParameterDescriptor, constraintSystem, context)
                     }
                 }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
index 48b9151..a0125b0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt
@@ -200,7 +200,7 @@
                             c.context.call
                     )
                 }
-                members
+               ^members
             }
         }
     }
@@ -221,7 +221,7 @@
                 it.getNonExtensionsByName(dynamicScope, c.name, createLookupLocation(c))
             }
 
-            convertWithReceivers(dynamicDescriptors, explicitReceiver.value, NO_RECEIVER, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call)
+           ^convertWithReceivers(dynamicDescriptors, explicitReceiver.value, NO_RECEIVER, createKind(DISPATCH_RECEIVER, isExplicit), c.context.call)
         }
     }
 
@@ -240,7 +240,7 @@
         c.result.addCandidates {
             val memberExtensions =
                     callableDescriptorCollector.getExtensionsByName(dispatchReceiver.type.memberScope, c.name, receiverParameter.types, createLookupLocation(c))
-            convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter.value, receiverKind, c.context.call)
+           ^convertWithReceivers(memberExtensions, dispatchReceiver, receiverParameter.value, receiverKind, c.context.call)
         }
     }
 
@@ -273,7 +273,7 @@
             c.result.addCandidates {
                 val descriptors = it.getNonExtensionsByName(c.scope.asJetScope(), c.name, lookupLocation)
                         .filter { !ExpressionTypingUtils.isLocal(c.scope.ownerDescriptor, it) }
-                convertWithImpliedThisAndNoReceiver(c.scope, descriptors, c.context.call)
+               ^convertWithImpliedThisAndNoReceiver(c.scope, descriptors, c.context.call)
             }
         }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
index 8ede666..7378714 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt
@@ -49,7 +49,7 @@
                     true
             )
             fakeOverride.addOverriddenDescriptor(synthesizedSuperFun)
-            fakeOverride
+           ^fakeOverride
         }
 
         result.add(synthesized.substitute(TypeSubstitutor.create(invoke.getDispatchReceiverParameter()!!.getType()))!!)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
index e4b65df..9466855 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt
@@ -53,7 +53,7 @@
 
     return resolvedValueArgument.getArguments().any { argument ->
         val argumentMapping = getArgumentMapping(argument)
-        argumentMapping is ArgumentMatch && argumentMapping.status == ArgumentMatchStatus.TYPE_MISMATCH
+       ^argumentMapping is ArgumentMatch && argumentMapping.status == ArgumentMatchStatus.TYPE_MISMATCH
     }
 }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
index 24c1ff5..e2df648 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt
@@ -766,7 +766,7 @@
             JetTokens.EXCLEQ -> !result
             JetTokens.IDENTIFIER -> {
                 assert (operationReference.getReferencedNameAsName() == OperatorConventions.EQUALS, "This method should be called only for equals operations")
-                result
+               ^result
             }
             else -> throw IllegalStateException("Unknown equals operation token: $operationToken ${operationReference.getText()}")
         }
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/MutableDiagnosticsWithSuppression.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/MutableDiagnosticsWithSuppression.kt
index cac67e1..eccfa8e 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/MutableDiagnosticsWithSuppression.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/MutableDiagnosticsWithSuppression.kt
@@ -34,7 +34,7 @@
     //NOTE: CachedValuesManager is not used because it requires Project passed to this object
     private val cache = CachedValueImpl(CachedValueProvider {
         val allDiagnostics = delegateDiagnostics.noSuppression().all() + diagnosticList
-        CachedValueProvider.Result(DiagnosticsWithSuppression(bindingContext, allDiagnostics), modificationTracker)
+       ^CachedValueProvider.Result(DiagnosticsWithSuppression(bindingContext, allDiagnostics), modificationTracker)
     })
 
     private fun readonlyView() = cache.getValue()!!
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
index 60cc5b0..a564ffe 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt
@@ -58,7 +58,7 @@
             builder.put(importedName, directive)
         }
 
-        builder.build()
+       ^builder.build()
     }
 
     override fun importsForName(name: Name) = nameToDirectives.get(name)
@@ -92,13 +92,13 @@
 
             return storageManager.compute {
                 val cachedStatus = importResolveStatus
-                if (cachedStatus != null) {
+               ^if (cachedStatus != null) {
                     cachedStatus.scope
                 }
                 else {
                     directiveUnderResolve = directive
 
-                    try {
+                   ^try {
                         // todo use packageViewFragment for visibility
                         val directiveImportScope = qualifiedExpressionResolver.processImportReference(
                                 directive, moduleDescriptor, traceForImportResolve, moduleDescriptor)
@@ -107,7 +107,7 @@
                         PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(moduleDescriptor, traceForImportResolve, directive, descriptors)
 
                         importResolveStatus = ImportResolveStatus(directiveImportScope, descriptors)
-                        directiveImportScope
+                       ^directiveImportScope
                     }
                     finally {
                         directiveUnderResolve = null
@@ -200,7 +200,7 @@
                 descriptors = descriptors.concat(descriptorsForImport)
             }
 
-            descriptors ?: emptySet<D>()
+           ^descriptors ?: emptySet<D>()
         }
     }
 
@@ -233,7 +233,7 @@
     override fun getClassifier(name: Name, location: LookupLocation): ClassifierDescriptor? {
         return importResolver.selectSingleFromImports(name) { scope, name ->
             val descriptor = scope.getClassifier(name, location)
-            if (descriptor != null && isClassVisible(descriptor as ClassDescriptor/*no type parameter can be imported*/)) descriptor else null
+           ^if (descriptor != null && isClassVisible(descriptor as ClassDescriptor/*no type parameter can be imported*/)) descriptor else null
         }
     }
 
@@ -301,7 +301,7 @@
                     descriptors.addAll(importResolver.getImportScope(directive).getDescriptors(kindFilter, nameFilter))
                 }
             }
-            descriptors
+           ^descriptors
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
index 79e074e..d6bf5cc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt
@@ -66,7 +66,7 @@
     private val index = storageManager.createLazyValue<Index> {
         val index = Index()
         doCreateIndex(index)
-        index
+       ^index
     }
 
     protected abstract fun doCreateIndex(index: Index)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
index 613212c..8fd5471 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt
@@ -34,7 +34,7 @@
         val allFiles = ArrayList<JetFile>()
         sourceFiles.filterTo(allFiles) {
             val vFile = it.getVirtualFile().sure { "Source files should be physical files" }
-            filesScope.contains(vFile)
+           ^filesScope.contains(vFile)
         }
         allFiles addAll syntheticFiles
         return FileBasedDeclarationProviderFactory(storageManager, allFiles)
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
index 816bcab..5f8cb98 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt
@@ -44,7 +44,7 @@
             arrayOf(classDescriptor.staticScope, it.unsubstitutedInnerClassesScope)
         } ?: arrayOf(classDescriptor.staticScope)
 
-        LexicalChainedScope(getOuterScope(), classDescriptor, false,
+       ^LexicalChainedScope(getOuterScope(), classDescriptor, false,
                             classDescriptor.companionObjectDescriptor?.thisAsReceiverParameter,
                             "Scope with static members and companion object for ${classDescriptor.name}",
                             memberScopes = *staticScopes)
@@ -53,7 +53,7 @@
     public val scopeForMemberDeclarationResolution: () -> LexicalScope = storageManager.createLazyValue {
         val scopeWithGenerics = scopeWithGenerics(scopeWithStaticMembersAndCompanionObjectReceiver(),
                                                   "Scope with generics for ${classDescriptor.name}")
-        LexicalChainedScope(scopeWithGenerics, classDescriptor, true, classDescriptor.thisAsReceiverParameter,
+       ^LexicalChainedScope(scopeWithGenerics, classDescriptor, true, classDescriptor.thisAsReceiverParameter,
                             "Scope for member declaration resolution: ${classDescriptor.name}",
                             classDescriptor.unsubstitutedInnerClassesScope)
     }
@@ -75,7 +75,7 @@
         assert(primaryConstructorParameters != null) {
             "primary constructor parameters must be not null, because primary constructor exist: $primaryConstructor"
         }
-        LexicalScopeImpl(scopeForMemberDeclarationResolution(), primaryConstructor, false, null,
+       ^LexicalScopeImpl(scopeForMemberDeclarationResolution(), primaryConstructor, false, null,
                          "Scope for initializer resolution: ${classDescriptor.name}") {
             primaryConstructorParameters!!.forEachIndexed {
                 index, parameter ->
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
index aa33fbf..57f6d86 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt
@@ -62,7 +62,7 @@
 
         val descriptor = LazyAnnotationDescriptor(c, entry)
         val target = entry.getUseSiteTarget()?.getAnnotationUseSiteTarget()
-        AnnotationWithTarget(descriptor, target)
+       ^AnnotationWithTarget(descriptor, target)
     }
 
     override fun findAnnotation(fqName: FqName): AnnotationDescriptor? {
@@ -89,7 +89,7 @@
                 .asSequence()
                 .map {
                     val (descriptor, target) = annotation(it)
-                    if (target == null) null else AnnotationWithTarget(descriptor, target)
+                   ^if (target == null) null else AnnotationWithTarget(descriptor, target)
                 }.filterNotNull().toList()
     }
 
@@ -100,7 +100,7 @@
                 .asSequence()
                 .map {
                     val (descriptor, target) = annotation(it)
-                    if (target == null) descriptor else null // Filter out annotations with target
+                   ^if (target == null) descriptor else null // Filter out annotations with target
                 }.filterNotNull().iterator()
     }
 
@@ -145,7 +145,7 @@
         @Suppress("UNCHECKED_CAST")
         return resolutionResults.getResultingCall().getValueArguments()
                 .mapValues { val (valueParameter, resolvedArgument) = it;
-                    if (resolvedArgument == null) null
+                   ^if (resolvedArgument == null) null
                     else c.annotationResolver.getAnnotationArgumentValue(c.trace, valueParameter, resolvedArgument)
                 }
                 .filterValues { it != null } as Map<ValueParameterDescriptor, ConstantValue<*>>
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
index 5df16fb..dac61e0 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt
@@ -256,7 +256,7 @@
 
             result.addAll(functions)
 
-            n++
+           ^n++
         }
         result.addAll(getFunctions(Name.identifier("copy"), location))
     }
@@ -303,7 +303,7 @@
                     thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, constructor, trace
             )
             setDeferredReturnType(descriptor)
-            descriptor
+           ^descriptor
         }
     }
 
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
index 9f36b9a..a451b0b 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt
@@ -40,7 +40,7 @@
 
     private val scriptResultProperty: NotNullLazyValue<PropertyDescriptor> = resolveSession.getStorageManager().createLazyValue {
         val scriptInfo = declarationProvider.getOwnerInfo() as JetScriptInfo
-        createScriptResultProperty(resolveSession.getScriptDescriptor(scriptInfo.script))
+       ^createScriptResultProperty(resolveSession.getScriptDescriptor(scriptInfo.script))
     }
 
     override fun computeExtraDescriptors(location: LookupLocation): Collection<DeclarationDescriptor> {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
index 1749e36..1d264dc 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt
@@ -85,7 +85,7 @@
                     scriptBodyResolver.resolveScriptReturnType(jetScript, this, resolveSession.getTrace())
                 }
         )
-        result
+       ^result
     }
 
     override fun getScriptCodeDescriptor() = scriptCodeDescriptor()
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
index 9950290..450c6b3 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt
@@ -48,7 +48,7 @@
         if (it is MemberScopeToFileScopeAdapter) {
             jetScopeRefactoringHack = it.memberScope
         }
-        it.implicitReceiver
+       ^it.implicitReceiver
     }
 
     return if (jetScopeRefactoringHack != null) {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
index c517be8..273a0d7 100644
--- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
+++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt
@@ -206,7 +206,7 @@
                 && !JetTypeChecker.DEFAULT.isSubtypeOf(type, expectedReturnType)) {
                 context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(it, expectedReturnType))
             }
-            type
+           ^type
         }
 
         val expectedType = declaredReturnType ?: (expectedReturnType ?: NO_EXPECTED_TYPE)
diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
index fb56b52..9022f9c 100644
--- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
+++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt
@@ -44,7 +44,7 @@
                 addArgument(argument)
             }
 
-            build()
+           ^build()
         }
     }
 
@@ -128,6 +128,6 @@
             }
         }, Unit)
 
-        this
+       ^this
     }
 }
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
index 8580e53..63a3405 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt
@@ -49,7 +49,7 @@
 
     private val explicitReceiverValue = explicitReceiverData?.let {
         val type = bindingContext.getType(it.expression) ?: return@let null
-        ExpressionReceiver(it.expression, type)
+       ^ExpressionReceiver(it.expression, type)
     } ?: ReceiverValue.NO_RECEIVER
 
     public fun <TDescriptor : DeclarationDescriptor> filter(declarations: Collection<TDescriptor>): Collection<TDescriptor> {
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
index 4d74e2f..7c0e349 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt
@@ -109,7 +109,7 @@
                 if (substitutor == null && it.nullability() == TypeNullability.NULLABLE && extensionReceiverType.nullability() == TypeNullability.NOT_NULL) {
                     substitutor = extensionReceiverType.checkIsSuperTypeOf(it.makeNotNullable())
                 }
-                substitutor
+               ^substitutor
             }
             .filterNotNull()
     if (getTypeParameters().isEmpty()) { // optimization for non-generic callables
@@ -124,7 +124,7 @@
     return when (this) {
         is ExpressionReceiver -> {
             val thisRef = (JetPsiUtil.deparenthesize(this.getExpression()) as? JetThisExpression)?.getInstanceReference() ?: return null
-            bindingContext[BindingContext.REFERENCE_TARGET, thisRef]
+           ^bindingContext[BindingContext.REFERENCE_TARGET, thisRef]
         }
 
         is ThisReceiver -> this.getDeclarationDescriptor()
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
index 4f6bdb4..8d8180b 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt
@@ -61,7 +61,7 @@
         val owner = receiver.getContainingDeclaration()
         val (expressionText, isImmediateThis) = if (owner in outerDeclarationsWithInstance) {
             val thisWithLabel = thisQualifierName(receiver)?.let { "this@${it.render()}" }
-            if (index == 0)
+           ^if (index == 0)
                 (thisWithLabel ?: "this") to true
             else
                 thisWithLabel to false
diff --git a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
index c6bce01..c015201 100644
--- a/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
+++ b/idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt
@@ -94,7 +94,7 @@
             else if (statement is JetMultiDeclaration) {
                 if (statement.getEntries().any {
                     val name = it.getName()
-                    name != null && nameFilter(name)
+                   ^name != null && nameFilter(name)
                 }) {
                     statementMarks.mark(statement, MarkLevel.NEED_REFERENCE_RESOLVE)
                 }
@@ -372,7 +372,7 @@
                 if (condition.isTrueConstant()) {
                     insideLoopLevel++
                     loop.getBody()?.accept(this)
-                    insideLoopLevel--
+                   ^insideLoopLevel--
                 }
                 else {
                     // do not make sense to search exits inside while-loop as not necessary enter it at all
@@ -542,7 +542,7 @@
 
                 is JetContainerNode -> { //TODO - not quite correct
                     val pparent = parent.getParent() as? JetExpression
-                    pparent != null && isValueNeeded(pparent)
+                   ^pparent != null && isValueNeeded(pparent)
                 }
 
                 is JetDeclarationWithBody -> {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
index da92ea1..dc61c4a 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/CodeFragmentAnalyzer.kt
@@ -77,7 +77,7 @@
                            if (parent is JetWhenEntry || parent is JetIfExpression || parent is JetBlockExpression) return this
                            if (parent is JetExpression) return parent
                        }
-                       null
+                      ^null
                    }
                } ?: this
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
index 0a45e48..c66375b 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IDELightClassGenerationSupport.kt
@@ -233,7 +233,7 @@
         return groupedByFqNameAndModuleInfo.flatMap {
             val (key, files) = it
             val (fqName, moduleInfo) = key
-            createLightClassForFileFacade(fqName, files, moduleInfo)
+           ^createLightClassForFileFacade(fqName, files, moduleInfo)
         }
     }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfos.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfos.kt
index 55270e4..dd72354 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfos.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/IdeaModuleInfos.kt
@@ -49,11 +49,11 @@
         }
         is LibraryOrderEntry -> {
             val library = orderEntry.getLibrary() ?: return listOf()
-            emptyOrSingletonList(LibraryInfo(project, library))
+           ^emptyOrSingletonList(LibraryInfo(project, library))
         }
         is JdkOrderEntry -> {
             val sdk = orderEntry.getJdk() ?: return listOf()
-            emptyOrSingletonList(SdkInfo(project, sdk))
+           ^emptyOrSingletonList(SdkInfo(project, sdk))
         }
         else -> {
             throw IllegalStateException("Unexpected order entry $orderEntry")
@@ -75,7 +75,7 @@
     dependencyEnumerator.forEach {
         orderEntry ->
         result.addAll(orderEntryToModuleInfo(module.getProject(), orderEntry!!, productionOnly))
-        true
+       ^true
     }
     return result.toList()
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
index 3a9cc6f..04588fd 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JavaResolveExtension.kt
@@ -87,7 +87,7 @@
 private fun <T : DeclarationDescriptorWithSource> Collection<T>.findByJavaElement(javaElement: JavaElement): T? {
     return firstOrNull { member ->
         val memberJavaElement = (member.getOriginal().getSource() as? JavaSourceElement)?.javaElement
-        when {
+       ^when {
             memberJavaElement == javaElement ->
                 true
             memberJavaElement is JavaElementImpl<*> && javaElement is JavaElementImpl<*> ->
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsProjectDetector.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsProjectDetector.kt
index ff1e44f..145cfa1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsProjectDetector.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/JsProjectDetector.kt
@@ -29,7 +29,7 @@
     public fun isJsProject(project: Project): Boolean {
         return CachedValuesManager.getManager(project).getCachedValue(project) {
             val result = ModuleManager.getInstance(project).getModules().any { ProjectStructureUtil.isJsKotlinModule(it) }
-            CachedValueProvider.Result(result, ProjectRootModificationTracker.getInstance(project))
+           ^CachedValueProvider.Result(result, ProjectRootModificationTracker.getInstance(project))
         }
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
index 9f456e6..527a7e7 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt
@@ -96,7 +96,7 @@
         return when {
             syntheticFileModule is ModuleSourceInfo -> {
                 val dependentModules = syntheticFileModule.getDependentModules()
-                ProjectResolutionFacade(project) {
+               ^ProjectResolutionFacade(project) {
                     globalResolveSessionProvider(
                             project,
                             targetPlatform,
@@ -126,7 +126,7 @@
                 // currently the only known scenario is when we cannot determine that file is a library source
                 // (file under both classes and sources root)
                 LOG.warn("Creating cache with synthetic files ($files) in classes of library $syntheticFileModule")
-                ProjectResolutionFacade(project) {
+               ^ProjectResolutionFacade(project) {
                     globalResolveSessionProvider(
                             project,
                             targetPlatform,
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/LibraryDependenciesCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/LibraryDependenciesCache.kt
index 7fc3334..e674d16 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/LibraryDependenciesCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/LibraryDependenciesCache.kt
@@ -44,7 +44,7 @@
         val condition = Condition<OrderEntry>() { orderEntry ->
             if (orderEntry is ModuleOrderEntry) {
                 val module = orderEntry.getModule()
-                module != null && module !in processedModules
+               ^module != null && module !in processedModules
             }
             else {
                 true
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
index 552d462..05cbe13 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ModuleDependencyMapper.kt
@@ -58,7 +58,7 @@
         val jvmPlatformParameters = JvmPlatformParameters {
             javaClass: JavaClass ->
             val psiClass = (javaClass as JavaClassImpl).getPsi()
-            psiClass.getModuleInfo()
+           ^psiClass.getModuleInfo()
         }
 
         val resolverForProject = analyzerFacade.setupResolverForProject(
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
index ad79972..bbc002d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/ProjectResolutionFacade.kt
@@ -61,7 +61,7 @@
                         return PerFileAnalysisCache(file!!, resolverProvider.resolverForProject.resolverForModule(file.getModuleInfo()).componentProvider)
                     }
                 }
-                CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
+               ^CachedValueProvider.Result(results, PsiModificationTracker.MODIFICATION_COUNT, resolverProvider.exceptionTracker)
             }, false)
 
     fun getAnalysisResultsForElements(elements: Collection<JetElement>): AnalysisResult {
@@ -73,7 +73,7 @@
             val perFileCache = synchronized(slruCache) {
                 slruCache[it.getContainingJetFile()]
             }
-            perFileCache.getAnalysisResults(it)
+           ^perFileCache.getAnalysisResults(it)
         }
         val withError = results.firstOrNull { it.isError() }
         val bindingContext = CompositeBindingContext.create(results.map { it.bindingContext })
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/moduleDependents.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/moduleDependents.kt
index 9a71fab..de964dd 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/moduleDependents.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/moduleDependents.kt
@@ -85,6 +85,6 @@
                 }
             }
         }
-        CachedValueProvider.Result(index, ProjectRootModificationTracker.getInstance(project))
+       ^CachedValueProvider.Result(index, ProjectRootModificationTracker.getInstance(project))
     }!!
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
index ab5c5a24..0143745 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt
@@ -76,7 +76,7 @@
         val options = requests.map { it.options }
         val elementToOptions = (elements zip options).toMap()
         //TODO: this is not correct because it should not shorten deep into the elements!
-        ShortenReferences({ elementToOptions[it] ?: ShortenReferences.Options.DEFAULT }).process(elements.filterNotNull())
+       ^ShortenReferences({ elementToOptions[it] ?: ShortenReferences.Options.DEFAULT }).process(elements.filterNotNull())
     }
 }
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/ModuleTypeCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/ModuleTypeCache.kt
index a9bf3e8..4e00dd7 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/ModuleTypeCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/ModuleTypeCache.kt
@@ -42,7 +42,7 @@
             {
                 module: Module? ->
                 val moduleType = if (module != null) computeType(module) else null
-                CachedValueProvider.Result.create<ModuleType>(moduleType, vfsModificationTracker)
+               ^CachedValueProvider.Result.create<ModuleType>(moduleType, vfsModificationTracker)
             }, false)
 
     fun isGradleModule(module: Module) = getModuleType(module) == ModuleType.GRADLE
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
index eb3634c..4509341 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt
@@ -39,7 +39,7 @@
 
         (psiFile as? PsiFileImpl)?.markInvalidated()
 
-        text
+       ^text
     }
 
     override fun createFile(project: Project, file: VirtualFile, fileType: FileType): PsiFile? {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
index 6b21b47..e4748b5 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt
@@ -58,7 +58,7 @@
         type ->
         val typeConstructorData = type.getTypeConstructorData()
         assert(typeConstructorData.kind == TypeConstructorKind.CLASS)
-        c.nameResolver.getClassId(typeConstructorData.id)
+       ^c.nameResolver.getClassId(typeConstructorData.id)
     }.let {
         supertypeIds ->
         //empty supertype list if single supertype is Any
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
index fd066cb..58e99e4 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt
@@ -75,18 +75,18 @@
             header.isCompatiblePackageFacadeKind() -> {
                 val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
                 val context = components.createContext(packageData.getNameResolver(), packageFqName)
-                createPackageFacadeStub(packageData.getPackageProto(), packageFqName, context)
+               ^createPackageFacadeStub(packageData.getPackageProto(), packageFqName, context)
             }
             header.isCompatibleClassKind() -> {
                 if (header.classKind != JvmAnnotationNames.KotlinClass.Kind.CLASS) return null
                 val classData = JvmProtoBufUtil.readClassDataFrom(annotationData)
                 val context = components.createContext(classData.getNameResolver(), packageFqName)
-                createTopLevelClassStub(classId, classData.getClassProto(), context)
+               ^createTopLevelClassStub(classId, classData.getClassProto(), context)
             }
             header.isCompatibleFileFacadeKind() -> {
                 val packageData = JvmProtoBufUtil.readPackageDataFrom(annotationData)
                 val context = components.createContext(packageData.getNameResolver(), packageFqName)
-                createFileFacadeStub(packageData.getPackageProto(), classId.asSingleFqName(), context)
+               ^createFileFacadeStub(packageData.getPackageProto(), classId.asSingleFqName(), context)
             }
             else -> throw IllegalStateException("Should have processed " + file.getPath() + " with header $header")
         }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
index 1103005..dc31967 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt
@@ -49,7 +49,7 @@
 
         val annotations = c.components.annotationLoader.loadTypeAnnotations(type, c.nameResolver).filterNot {
             val isTopLevelClass = !it.isNestedClass()
-            isTopLevelClass && it.asSingleFqName() in JvmAnnotationNames.ANNOTATIONS_COPIED_TO_TYPES
+           ^isTopLevelClass && it.asSingleFqName() in JvmAnnotationNames.ANNOTATIONS_COPIED_TO_TYPES
         }
 
         val effectiveParent =
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
index f26df58..4aea2d1 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt
@@ -75,7 +75,7 @@
         classHeader.isCompatibleMultifileClassKind() -> {
             val partClasses = findMultifileClassParts(classFile, kotlinClass)
             val partMembers = partClasses.flatMap { partClass -> resolver.resolveDeclarationsInFacade(partClass.classId.asSingleFqName()) }
-            buildDecompiledText(packageFqName, partMembers)
+           ^buildDecompiledText(packageFqName, partMembers)
         }
         else ->
             throw UnsupportedOperationException("Unknown header kind: ${classHeader.kind} ${classHeader.isCompatibleAbiVersion}")
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDeserializerForDecompiler.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDeserializerForDecompiler.kt
index f529aa0..67c59b0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDeserializerForDecompiler.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/KotlinJavaScriptDeserializerForDecompiler.kt
@@ -38,7 +38,7 @@
         val stringsFileName = KotlinJavascriptSerializedResourcePaths.getStringTableFilePath(directoryPackageFqName)
         val stringsFile = moduleDirectory.findFileByRelativePath(stringsFileName)
         assert(stringsFile != null) { "strings file not found: $stringsFileName" }
-        NameResolver.read(ByteArrayInputStream(stringsFile!!.contentsToByteArray(false)))
+       ^NameResolver.read(ByteArrayInputStream(stringsFile!!.contentsToByteArray(false)))
     }
 
     private val metaFileFinder = DirectoryBasedKotlinJavaScriptMetaFileFinder(packageDirectory, directoryPackageFqName, nameResolver)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
index f5e7a28..157bf82 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt
@@ -103,7 +103,7 @@
 
                 with(refExpr.getParentOfTypeAndBranch<JetBinaryExpressionWithTypeRHS>(){ getRight() }) {
                     val opType = this?.getOperationReference()?.getReferencedNameElementType()
-                    opType == JetTokens.AS_KEYWORD || opType == JetTokens.AS_SAFE || opType == JetTokens.COLON
+                   ^opType == JetTokens.AS_KEYWORD || opType == JetTokens.AS_SAFE || opType == JetTokens.COLON
                 } ->
                     CLASS_CAST_TO
 
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
index 21bdc38..8388245 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt
@@ -44,7 +44,7 @@
         calls: Collection<ResolvedCall<*>> ->
             // TODO: compareBy(comparator, selector) in stdlib
             val comparator = comparator<ResolvedCall<*>> { c1, c2 -> MemberComparator.INSTANCE.compare(c1.getResultingDescriptor(), c2.getResultingDescriptor()) }
-            calls
+           ^calls
                 .sortBy(comparator)
                 .joinToString("") { "<li>" + renderResolvedCall(it) + "</li>" }
     }
@@ -67,7 +67,7 @@
 
     public val HTML_RENDER_RETURN_TYPE: Renderer<CallableMemberDescriptor> = Renderer {
         val returnType = it.getReturnType()!!
-        DescriptorRenderer.HTML.renderType(returnType)
+       ^DescriptorRenderer.HTML.renderType(returnType)
     }
 
     public val HTML_COMPACT_WITH_MODIFIERS: DescriptorRenderer = DescriptorRenderer.HTML.withOptions {
@@ -83,7 +83,7 @@
             .sortBy(MemberComparator.INSTANCE)
             .joinToString("") { "<li>" + HTML_COMPACT_WITH_MODIFIERS.render(it) + "</li>\n" }
 
-        "The following declarations have the same JVM signature (<code>${data.signature.name}${data.signature.desc}</code>):<br/>\n<ul>\n$conflicts</ul>"
+       ^"The following declarations have the same JVM signature (<code>${data.signature.name}${data.signature.desc}</code>):<br/>\n<ul>\n$conflicts</ul>"
     }
 
     public val HTML_THROWABLE: Renderer<Throwable> = Renderer {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
index 5648430..0bef192 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt
@@ -64,7 +64,7 @@
                         val range = intention.applicabilityRange(targetElement)?.let { range ->
                             val elementRange = targetElement.getTextRange()
                             assert(range in elementRange) { "Wrong applicabilityRange() result for $intention - should be within element's range" }
-                            range.shiftRight(-elementRange.getStartOffset())
+                           ^range.shiftRight(-elementRange.getStartOffset())
                         }
 
                         if (range != null && additionalChecker(targetElement)) {
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
index acb40ac..81a85be 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt
@@ -272,7 +272,7 @@
             is JetImportList -> {
                 val scope = resolveSession.getFileScopeProvider().getFileScope(resolveElement.getContainingJetFile())
                 scope.forceResolveAllImports()
-                resolveSession.getTrace()
+               ^resolveSession.getTrace()
             }
 
             is JetAnnotationEntry -> annotationAdditionalResolve(resolveSession, resolveElement)
@@ -432,7 +432,7 @@
 
         val bodyResolveContext = BodyResolveContextForLazy(TopDownAnalysisMode.LocalDeclarations, { declaration ->
             assert(declaration.getParent() == jetProperty) { "Must be called only for property accessors, but called for $declaration" }
-            resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(declaration)
+           ^resolveSession.getDeclarationScopeProvider().getResolutionScopeForDeclaration(declaration)
         })
 
         bodyResolver.resolvePropertyAccessors(bodyResolveContext, jetProperty, descriptor)
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
index 2ce7e0d..483dcf8 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt
@@ -37,7 +37,7 @@
         is PsiClass -> element.getQualifiedName()?.let { FqName(it) }
         is PsiMember -> (element : PsiMember).getName()?.let { name ->
             val prefix = element.getContainingClass()?.getQualifiedName()
-            FqName(if (prefix != null) "$prefix.$name" else name)
+           ^FqName(if (prefix != null) "$prefix.$name" else name)
         }
         is JetNamedDeclaration -> element.getFqName()
         else -> null
@@ -56,7 +56,7 @@
     val psiFactory = JetPsiFactory(this)
     val fqNameBase = (getParent() as? JetCallExpression)?.let { parent ->
         val callCopy = parent.copy() as JetCallExpression
-        callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText()
+       ^callCopy.getCalleeExpression()!!.replace(psiFactory.createSimpleName(shortName)).getParent()!!.getText()
     } ?: shortName
 
     val text = if (!fqName.isOneSegmentFQN()) "${fqName.parent().asString()}.$fqNameBase" else fqNameBase
@@ -65,7 +65,7 @@
     return when (elementToReplace) {
         is JetUserType -> {
             val typeText = "$text${elementToReplace.getTypeArgumentList()?.getText() ?: ""}"
-            elementToReplace.replace(psiFactory.createType(typeText).getTypeElement()!!)
+           ^elementToReplace.replace(psiFactory.createType(typeText).getTypeElement()!!)
         }
         else -> elementToReplace.replace(psiFactory.createExpression(text))
     } as JetElement
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
index e8d9613..5fc2d49 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt
@@ -34,7 +34,7 @@
             registerMultiProvider(javaClass<JetNameReferenceExpression>()) {
                 if (it.getReferencedNameElementType() != JetTokens.IDENTIFIER) return@registerMultiProvider emptyArray()
 
-                when (it.readWriteAccess(useResolveForReadWrite = false)) {
+               ^when (it.readWriteAccess(useResolveForReadWrite = false)) {
                     ReferenceAccess.READ -> arrayOf(SyntheticPropertyAccessorReference.Getter(it))
                     ReferenceAccess.WRITE -> arrayOf(SyntheticPropertyAccessorReference.Setter(it))
                     ReferenceAccess.READ_WRITE -> arrayOf(SyntheticPropertyAccessorReference.Getter(it), SyntheticPropertyAccessorReference.Setter(it))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
index 0d78c23..51c0bf0 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt
@@ -64,7 +64,7 @@
 
         val words = runReadAction {
             val classNameForCompanionObject = unwrappedElement.getClassNameForCompanionObject()
-            unwrappedElement.getSpecialNamesToSearch() +
+           ^unwrappedElement.getSpecialNamesToSearch() +
                 (if (classNameForCompanionObject != null) listOf(classNameForCompanionObject) else emptyList())
         }
 
@@ -142,7 +142,7 @@
             return referenceService.getReferences(element, PsiReferenceService.Hints.NO_HINTS).all { ref ->
                 ProgressManager.checkCanceled()
 
-                when {
+               ^when {
                     !filter(ref) -> true
                     !ReferenceRange.containsOffsetInElement(ref, offsetInElement) -> true
                     !ref.isReferenceToTarget(unwrappedElement) -> true
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
index e5a28fa..365b42e 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt
@@ -62,7 +62,7 @@
             .filterIsInstance<JetDeclaration>()
             .any {
                 val usageDescriptor = declarationToDescriptor(it)
-                usageDescriptor != null && checker(usageDescriptor, targetDescriptor)
+               ^usageDescriptor != null && checker(usageDescriptor, targetDescriptor)
             }
 }
 
@@ -85,7 +85,7 @@
         return declaration == jetClassOrObject || (declaration is JetConstructor<*> && declaration.getContainingClassOrObject() == jetClassOrObject)
     }
 
-    checkJavaUsage() || checkKotlinUsage()
+   ^checkJavaUsage() || checkKotlinUsage()
 }
 
 private fun JetElement.getConstructorCallDescriptor(): DeclarationDescriptor? {
@@ -145,7 +145,7 @@
 ): Boolean {
     return HierarchySearchRequest(klass, scope, false).searchInheritors().all {
         val unwrapped = it.unwrapped
-        if (unwrapped is JetClass) {
+       ^if (unwrapped is JetClass) {
             processClassDelegationCallsToSpecifiedConstructor(unwrapped, descriptor, process)
         } else
             true
@@ -186,7 +186,7 @@
                         usageDescriptor.getExtensionReceiverParameter()?.getType()?.getConstructor()?.getDeclarationDescriptor()
                 val containingDescriptor = targetDescriptor.getContainingDeclaration()
 
-                containingDescriptor == receiverDescriptor
+               ^containingDescriptor == receiverDescriptor
                 || (containingDescriptor is ClassDescriptor
                     && receiverDescriptor is ClassDescriptor
                     && DescriptorUtils.isSubclass(containingDescriptor, receiverDescriptor))
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
index b86c021..87fa99d 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt
@@ -69,7 +69,7 @@
                 JetExactPackagesIndex.getInstance().getKey(), packageFqName.asString(), project, searchScope, javaClass<JetFile>()
         ) {
             result = true
-            false
+           ^false
         }
         return result
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
index e3bdcd4..7d778c2 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt
@@ -51,9 +51,9 @@
             is JetOperationExpression -> {
                 val operation = expression.getOperationReference().getReferencedNameElementType()
                 val precedenceNumber = precedence[operation]
-                if (precedenceNumber == null) {
+               ^if (precedenceNumber == null) {
                     LOG.error("No precedence for operation: " + operation)
-                    precedence.size()
+                   ^precedence.size()
                 }
                 else precedenceNumber
             }
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
index fd97eac..1eb20b3 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt
@@ -89,7 +89,7 @@
                     val range = TextRange(rangeMarker.getStartOffset(), rangeMarker.getEndOffset())
 
                     val elementRange = element.getTextRange()!!
-                    when {
+                   ^when {
                         range.contains(elementRange) -> FilterResult.PROCESS
 
                         range.intersects(elementRange) -> {
@@ -97,9 +97,9 @@
                             val calleeExpression = ((element as? JetDotQualifiedExpression)
                                     ?.getSelectorExpression() as? JetCallExpression)
                                     ?.getCalleeExpression()
-                            if (calleeExpression != null) {
+                           ^if (calleeExpression != null) {
                                 val rangeWithoutParenthesis = TextRange(elementRange.getStartOffset(), calleeExpression.getTextRange()!!.getEndOffset())
-                                if (range.contains(rangeWithoutParenthesis)) FilterResult.PROCESS else FilterResult.GO_INSIDE
+                               ^if (range.contains(rangeWithoutParenthesis)) FilterResult.PROCESS else FilterResult.GO_INSIDE
                             }
                             else {
                                 FilterResult.GO_INSIDE
diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt
index cb405fa..8a91788 100644
--- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt
+++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt
@@ -54,7 +54,7 @@
             DataIndexer<FqName, Void, FileContent> {
                 try {
                     val fqName = f(it.getFile())
-                    if (fqName != null) {
+                   ^if (fqName != null) {
                         Collections.singletonMap<FqName, Void>(fqName, null)
                     }
                     else {
@@ -63,7 +63,7 @@
                 }
                 catch (e: Throwable) {
                     LOG.warn("Error while indexing file " + it.getFileName(), e)
-                    emptyMap()
+                   ^emptyMap()
                 }
             }
 }
@@ -80,7 +80,7 @@
 
     private val INDEXER = indexer() { file ->
         val kotlinClass = KotlinBinaryClassCache.getKotlinBinaryClass(file)
-        if (kotlinClass != null && kotlinClass.getClassHeader().isCompatibleAbiVersion) kotlinClass.getClassId().asSingleFqName() else null
+       ^if (kotlinClass != null && kotlinClass.getClassHeader().isCompatibleAbiVersion) kotlinClass.getClassId().asSingleFqName() else null
     }
 }
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
index 3d35aff..77b47fa 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt
@@ -184,7 +184,7 @@
         if (parameters.isAutoPopup) {
             collector.addLookupElementPostProcessor { lookupElement ->
                 lookupElement.putUserData(LookupCancelWatcher.AUTO_POPUP_AT, position.startOffset)
-                lookupElement
+               ^lookupElement
             }
         }
 
@@ -203,7 +203,7 @@
             collector.addLookupElementPostProcessor { lookupElement ->
                 lookupElement.putUserData(KotlinCompletionCharFilter.SUPPRESS_ITEM_SELECTION_BY_CHARS_ON_TYPING, Unit)
                 lookupElement.putUserData(KotlinCompletionCharFilter.HIDE_LOOKUP_ON_COLON, Unit)
-                lookupElement
+               ^lookupElement
             }
 
             parameterNameAndTypeCompletion.addFromParametersInFile(position, resolutionFacade, isVisibleFilter)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
index 61f32b6..9dca745 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt
@@ -125,7 +125,7 @@
     protected val descriptorNameFilter: (Name) -> Boolean = run {
         val nameFilter = prefixMatcher.asNameFilter()
         val getOrSetPrefix = listOf("get", "set").firstOrNull { prefix.startsWith(it) }
-        if (getOrSetPrefix != null)
+       ^if (getOrSetPrefix != null)
             nameFilter or prefixMatcher.cloneWithPrefix(prefix.removePrefix(getOrSetPrefix).decapitalizeSmart()).asNameFilter()
         else
             nameFilter
@@ -154,7 +154,7 @@
 
             receiverTypes = receiversData.receivers.flatMap { receiverValue ->
                 val dataFlowValue = DataFlowValueFactory.createDataFlowValue(receiverValue, bindingContext, moduleDescriptor)
-                if (dataFlowValue.isPredictable) { // we don't include smart cast receiver types for "unpredictable" receiver value to mark members grayed
+               ^if (dataFlowValue.isPredictable) { // we don't include smart cast receiver types for "unpredictable" receiver value to mark members grayed
                     resolutionFacade.frontendService<SmartCastManager>()
                             .getSmartCastVariantsWithLessSpecificExcluded(receiverValue, bindingContext, moduleDescriptor, dataFlowInfo)
                 }
@@ -175,7 +175,7 @@
             } ?: emptyList()
         }
 
-        LookupElementFactory(resolutionFacade, receiverTypes, contextType, inDescriptor, InsertHandlerProvider { expectedInfos }, contextVariablesProvider)
+       ^LookupElementFactory(resolutionFacade, receiverTypes, contextType, inDescriptor, InsertHandlerProvider { expectedInfos }, contextVariablesProvider)
     }
 
     // LookupElementsCollector instantiation is deferred because virtual call to createSorter uses data from derived classes
@@ -230,7 +230,7 @@
             collector.addLookupElementPostProcessor { lookupElement ->
                 // we should put data into the original element because of DecoratorCompletionStatistician
                 lookupElement.putUserDataDeep(STATISTICS_INFO_CONTEXT_KEY, statisticsContext)
-                lookupElement
+               ^lookupElement
             }
         }
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
index 227a470..758f1b9 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt
@@ -134,7 +134,7 @@
     }
     else {
         val identifier = name.getIdentifier()
-        if (getPrefix().startsWith("$")) { // we need properties from scope for backing field completion
+       ^if (getPrefix().startsWith("$")) { // we need properties from scope for backing field completion
             prefixMatches("$" + identifier)
         }
         else {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
index c2305b7..1c37313 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt
@@ -300,12 +300,12 @@
         else {
             val namedArgumentCandidates = if (!isFunctionLiteralArgument && descriptor.hasStableParameterNames()) {
                 val usedParameters = argumentToParameter.filter { it.key != argument }.map { it.value }.toSet()
-                descriptor.valueParameters.filter { it !in usedParameters }
+               ^descriptor.valueParameters.filter { it !in usedParameters }
             }
             else {
                 emptyList()
             }
-            ArgumentPositionData.Positional(descriptor, argumentIndex, isFunctionLiteralArgument, namedArgumentCandidates)
+           ^ArgumentPositionData.Positional(descriptor, argumentIndex, isFunctionLiteralArgument, namedArgumentCandidates)
         }
 
         if (parameter == null) {
@@ -428,7 +428,7 @@
             ifExpression.getElse() -> {
                 val ifExpectedInfo = calculate(ifExpression)
                 val thenType = ifExpression.getThen()?.let { bindingContext.getType(it) }
-                if (thenType != null && !thenType.isError())
+               ^if (thenType != null && !thenType.isError())
                     ifExpectedInfo.filter { it.matchingSubstitutor(thenType) != null }
                 else
                     ifExpectedInfo
@@ -474,7 +474,7 @@
                     .filter { KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(it.type) }
                     .map {
                         val returnType = KotlinBuiltIns.getReturnTypeFromFunctionType(it.type)
-                        ExpectedInfo(FuzzyType(returnType, it.freeParameters), null, Tail.RBRACE)
+                       ^ExpectedInfo(FuzzyType(returnType, it.freeParameters), null, Tail.RBRACE)
                     }
         }
         else {
@@ -531,14 +531,14 @@
         return when (descriptor) {
             is SimpleFunctionDescriptor -> {
                 val expectedType = if (expectType) descriptor.returnType else null
-                ExpectedInfo.createForReturnValue(expectedType, descriptor)
+               ^ExpectedInfo.createForReturnValue(expectedType, descriptor)
             }
 
             is PropertyGetterDescriptor -> {
                 if (descriptor !is PropertyGetterDescriptor) return null
                 val property = descriptor.getCorrespondingProperty()
                 val expectedType = if (expectType) property.type else null
-                ExpectedInfo.createForReturnValue(expectedType, property)
+               ^ExpectedInfo.createForReturnValue(expectedType, property)
             }
 
             else -> null
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
index a8ad6cd..17f3cab 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/InsertHandlerProvider.kt
@@ -33,7 +33,7 @@
             is FunctionDescriptor -> {
                 val needTypeArguments = needTypeArguments(descriptor)
                 val parameters = descriptor.valueParameters
-                when (parameters.size()) {
+               ^when (parameters.size()) {
                     0 -> KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = false)
 
                     1 -> {
@@ -45,7 +45,7 @@
                                 return KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = false, lambdaInfo = GenerateLambdaInfo(parameterType, false))
                             }
                         }
-                        KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = true)
+                       ^KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = true)
                     }
 
                     else -> KotlinFunctionInsertHandler(needTypeArguments, inputValueArguments = true)
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
index b4e5a0b..afa8447 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KeywordCompletion.kt
@@ -176,7 +176,7 @@
             val file = psiFactory.createFile(prefixText + keywordTokenType.getValue() + postfix)
             val elementAt = file.findElementAt(prefixText.length())!!
 
-            when {
+           ^when {
                 !elementAt.getNode()!!.getElementType().matchesKeyword(keywordTokenType) -> false
 
                 elementAt.getNonStrictParentOfType<PsiErrorElement>() != null -> false
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
index 6ada567..92c31e4 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionCharFilter.kt
@@ -79,7 +79,7 @@
                         return Result.HIDE_LOOKUP
                     }
                 }
-                Result.SELECT_ITEM_AND_FINISH_LOOKUP
+               ^Result.SELECT_ITEM_AND_FINISH_LOOKUP
             }
 
             '{' -> {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
index 8361e34..a066214 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/KotlinCompletionContributor.kt
@@ -311,7 +311,7 @@
             val c = chars.charAt(i)
             if (c == '\n') return true
             if (!Character.isWhitespace(c)) return false
-            i++
+           ^i++
         }
         return true
     }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
index cf1f7cf..e6f3949 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/SmartCastCalculator.kt
@@ -85,7 +85,7 @@
             val receiverId = DataFlowValueFactory.createDataFlowValue(receiver, receiverType, bindingContext, containingDeclarationOrModule).id
             dataFlowValueToEntity = { value ->
                 val id = value.id
-                if (id is Pair<*, *> && id.first == receiverId) id.second as? VariableDescriptor else null
+               ^if (id is Pair<*, *> && id.first == receiverId) id.second as? VariableDescriptor else null
             }
         }
         else {
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Weighers.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Weighers.kt
index 2a25074..ab61202 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Weighers.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/Weighers.kt
@@ -112,7 +112,7 @@
 
             is DeclarationLookupObject -> {
                 val descriptor = o.descriptor
-                when (descriptor) {
+               ^when (descriptor) {
                     is VariableDescriptor, is FunctionDescriptor -> Weight.callable
                     is ClassDescriptor -> if (descriptor.kind == ClassKind.ENUM_ENTRY) Weight.enumMember else Weight.default
                     else -> Weight.default
@@ -235,7 +235,7 @@
         val (fuzzyTypes, name) = when (o) {
             is DeclarationLookupObject -> {
                 val descriptor = o.descriptor ?: return NO_MATCH_WEIGHT
-                descriptor.fuzzyTypesForSmartCompletion(smartCastCalculator) to descriptor.name
+               ^descriptor.fuzzyTypesForSmartCompletion(smartCastCalculator) to descriptor.name
             }
 
             is ThisItemLookupObject -> smartCastCalculator.types(o.receiverParameter).map { FuzzyType(it, emptyList()) } to null
@@ -250,7 +250,7 @@
 
         val nameSimilarity = if (name != null) {
             val matchingInfos = classified.filter { it.second != ExpectedInfoClassification.noMatch }.map { it.first }
-            calcNameSimilarity(name.asString(), matchingInfos)
+           ^calcNameSimilarity(name.asString(), matchingInfos)
         }
         else {
             0
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/handlerUtils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/handlerUtils.kt
index 6d3810d..731bef7 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/handlerUtils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/handlers/handlerUtils.kt
@@ -29,10 +29,10 @@
 }
 
 fun CharSequence.skipSpaces(index: Int): Int
-        = (index..length() - 1).firstOrNull { val c = this[it]; c != ' ' && c != '\t' } ?: this.length()
+        = (index..length() - 1).firstOrNull { val c = this[it];^c != ' ' && c != '\t' } ?: this.length()
 
 fun CharSequence.skipSpacesAndLineBreaks(index: Int): Int
-        = (index..length() - 1).firstOrNull { val c = this[it]; c != ' ' && c != '\t' && c != '\n' && c != '\r' } ?: this.length()
+        = (index..length() - 1).firstOrNull { val c = this[it];^c != ' ' && c != '\t' && c != '\n' && c != '\r' } ?: this.length()
 
 fun CharSequence.isCharAt(offset: Int, c: Char) = offset < length() && charAt(offset) == c
 
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
index 2228bf0..f5501a3 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt
@@ -256,7 +256,7 @@
                 else
                     infos
             }
-            count++
+           ^count++
         }
         //TODO: we could always give higher priority to results with outer call expected type used
     }
diff --git a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
index 96313d6..8f68176 100644
--- a/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
+++ b/idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/smart/Utils.kt
@@ -239,7 +239,7 @@
     val extensionReceiverType = function.getExtensionReceiverParameter()?.getType()
     val memberReceiverType = if (function is ConstructorDescriptor) {
         val classDescriptor = function.getContainingDeclaration()
-        if (classDescriptor.isInner()) {
+       ^if (classDescriptor.isInner()) {
             (classDescriptor.getContainingDeclaration() as? ClassifierDescriptor)?.getDefaultType()
         }
         else {
@@ -277,7 +277,7 @@
             element = element.assignSmartCompletionPriority(SmartCompletionItemPriority.IT)
         }
 
-        element
+       ^element
     }
 }
 
diff --git a/idea/idea-completion/testData/basic/common/NoLocalsDeclaredAhead.kt b/idea/idea-completion/testData/basic/common/NoLocalsDeclaredAhead.kt
index 54b08b5..c22fd6a 100644
--- a/idea/idea-completion/testData/basic/common/NoLocalsDeclaredAhead.kt
+++ b/idea/idea-completion/testData/basic/common/NoLocalsDeclaredAhead.kt
@@ -2,7 +2,7 @@
     val v = {
         <caret>
         val hello = 1
-        hello
+       ^hello
     }
 }
 // ABSENT: hello
\ No newline at end of file
diff --git a/idea/idea-completion/testData/handlers/charFilter/FunctionLiteralParameter3.kt b/idea/idea-completion/testData/handlers/charFilter/FunctionLiteralParameter3.kt
index 62b20d5..a60c9df 100644
--- a/idea/idea-completion/testData/handlers/charFilter/FunctionLiteralParameter3.kt
+++ b/idea/idea-completion/testData/handlers/charFilter/FunctionLiteralParameter3.kt
@@ -1,6 +1,6 @@
 fun bar() {
     val handler = { p<caret>
-        foo()
+       ^foo()
     }
 }
 
diff --git a/idea/idea-completion/testData/handlers/smart/IfValueInBlock.kt b/idea/idea-completion/testData/handlers/smart/IfValueInBlock.kt
index e7e48f8..3b88e15 100644
--- a/idea/idea-completion/testData/handlers/smart/IfValueInBlock.kt
+++ b/idea/idea-completion/testData/handlers/smart/IfValueInBlock.kt
@@ -5,7 +5,7 @@
             "abc"
         else {
             println()
-            <caret>
+            <^caret>
     })
 }
 
diff --git a/idea/idea-completion/testData/smart/ifValue/InBlock1.kt b/idea/idea-completion/testData/smart/ifValue/InBlock1.kt
index 825b9b9..30d1a30 100644
--- a/idea/idea-completion/testData/smart/ifValue/InBlock1.kt
+++ b/idea/idea-completion/testData/smart/ifValue/InBlock1.kt
@@ -4,7 +4,7 @@
 fun bar(b: Boolean, s: String, c: Char){
     foo(if (b) {
         println()
-        <caret>
+        <^caret>
     })
 }
 
diff --git a/idea/idea-completion/testData/smart/ifValue/InBlock2.kt b/idea/idea-completion/testData/smart/ifValue/InBlock2.kt
index 6cff230..afcfd57 100644
--- a/idea/idea-completion/testData/smart/ifValue/InBlock2.kt
+++ b/idea/idea-completion/testData/smart/ifValue/InBlock2.kt
@@ -6,7 +6,7 @@
             "abc"
         else {
             println()
-            <caret>
+            <^caret>
     })
 }
 
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt
index 408520f..f502c1f 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileJvmBasicCompletionTest.kt
@@ -26,7 +26,7 @@
         AstAccessControl.testWithControlledAccessToAst(shouldFail, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
             testCompletion(getFile().getText(), JvmPlatform, { invocationCount ->
                 complete(invocationCount)
-                myItems
+               ^myItems
             }, 0)
         })
     }
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileSmartCompletionTest.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileSmartCompletionTest.kt
index f101a7e..dad4671 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileSmartCompletionTest.kt
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/AbstractMultiFileSmartCompletionTest.kt
@@ -31,7 +31,7 @@
         AstAccessControl.testWithControlledAccessToAst(false, getFile().getVirtualFile(), getProject(), getTestRootDisposable(), {
             testCompletion(getFile().getText(), JvmPlatform, { invocationCount ->
                 complete(invocationCount)
-                myItems
+               ^myItems
             }, 1)
         })
     }
diff --git a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionHandlerTestBase.kt b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionHandlerTestBase.kt
index fee8cfb..65fd7df 100644
--- a/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionHandlerTestBase.kt
+++ b/idea/idea-completion/tests/org/jetbrains/kotlin/idea/completion/test/handlers/CompletionHandlerTestBase.kt
@@ -75,7 +75,7 @@
 
                 val textOk = if (itemText != null) {
                     val itemItemText = presentation.getItemText()
-                    itemItemText != null && itemItemText == itemText
+                   ^itemItemText != null && itemItemText == itemText
                 }
                 else {
                     true
@@ -84,7 +84,7 @@
                 if (textOk) {
                     val tailOk = if (tailText != null) {
                         val itemTailText = presentation.getTailText()
-                        itemTailText != null && itemTailText == tailText
+                       ^itemTailText != null && itemTailText == tailText
                     }
                     else {
                         true
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
index 9746e4f..172bfcc 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinIndicesHelper.kt
@@ -62,7 +62,7 @@
         if (it.isAnnotatedAsHidden()) return@filter false
         if (!visibilityFilter(it)) return@filter false
         if (applyExcludeSettings && isExcludedFromAutoImport(it)) return@filter false
-        true
+       ^true
     }
 
     public fun getTopLevelCallablesByName(name: String): Collection<CallableDescriptor> {
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
index 0c184a5..a22a035 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/KotlinNameSuggester.kt
@@ -128,7 +128,7 @@
                 val candidate = if (i > 0) name + i else name
                 if (validator(candidate)) return candidate
             }
-            i++
+           ^i++
         }
     }
 
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
index b1f36b5..2a3175f 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/overrideImplement/OverrideImplementMembersHandler.kt
@@ -80,7 +80,7 @@
         }
         else {
             val chooser = showOverrideImplementChooser(project, members.toTypedArray()) ?: return
-            chooser.selectedElements ?: return
+           ^chooser.selectedElements ?: return
         }
         if (selectedElements.isEmpty()) return
 
@@ -244,7 +244,7 @@
                     if (descriptor is FunctionDescriptor) {
                         val paramTexts = descriptor.valueParameters.map {
                             val renderedName = it.escapedName()
-                            if (it.varargElementType != null) "*$renderedName" else renderedName
+                           ^if (it.varargElementType != null) "*$renderedName" else renderedName
                         }
                         paramTexts.joinTo(this, prefix="(", postfix=")")
                     }
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
index 7682de8..1ca6d73 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiClassToDescriptor.kt
@@ -33,7 +33,7 @@
     return if (psiClass is KotlinLightClass && psiClass !is KotlinLightClassForDecompiledDeclaration) {
         val origin = psiClass.getOrigin () ?: return null
         val declaration = declarationTranslator(origin) ?: return null
-        resolveToDescriptor(declaration)
+       ^resolveToDescriptor(declaration)
     }
     else {
         this.getFrontendService(psiClass, javaClass<JavaDescriptorResolver>()).resolveClass(JavaClassImpl(psiClass))
diff --git a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
index 5577fad..6273f8c 100644
--- a/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
+++ b/idea/idea-core/src/org/jetbrains/kotlin/idea/core/psiModificationUtils.kt
@@ -107,7 +107,7 @@
     val rBrace = getRBrace()
     val anchor = if (rBrace == null) {
         val lastChild = getLastChild()
-        if (lastChild !is PsiWhiteSpace) addAfter(JetPsiFactory(this).createNewLine(), lastChild)!! else lastChild
+       ^if (lastChild !is PsiWhiteSpace) addAfter(JetPsiFactory(this).createNewLine(), lastChild)!! else lastChild
     }
     else {
         rBrace.getPrevSibling()!!
diff --git a/idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptLibraryManager.kt b/idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptLibraryManager.kt
index 99852c0..4bb8819 100644
--- a/idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptLibraryManager.kt
+++ b/idea/idea-js/src/org/jetbrains/kotlin/idea/js/KotlinJavaScriptLibraryManager.kt
@@ -143,7 +143,7 @@
                         srcRootUrls.addAll(library.getFiles(OrderRootType.SOURCES).map { it.url })
                     }
                 }
-                true
+               ^true
             }
 
             val filesToRefresh = update(rootFiles, addToMapIfAbsent = true)
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
index 9a19e40..2361923 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/AstAccessControl.kt
@@ -61,7 +61,7 @@
             }
             else {
                 val text = VfsUtilCore.loadText(file)
-                !InTextDirectivesUtils.isDirectiveDefined(text, ALLOW_AST_ACCESS_DIRECTIVE)
+               ^!InTextDirectivesUtils.isDirectiveDefined(text, ALLOW_AST_ACCESS_DIRECTIVE)
             }
         }
         manager.setAssertOnFileLoadingFilter(filter, disposable)
diff --git a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinMultiFileTestCase.kt b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinMultiFileTestCase.kt
index 9a4cbd4..2977ec3 100644
--- a/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinMultiFileTestCase.kt
+++ b/idea/idea-test-framework/src/org/jetbrains/kotlin/idea/test/KotlinMultiFileTestCase.kt
@@ -34,7 +34,7 @@
                 doc.setText(text.toString())
             }
 
-            offset
+           ^offset
         }
 
         PsiDocumentManager.getInstance(myProject).commitAllDocuments()
diff --git a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
index 8bfc213..1ba7767 100644
--- a/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
+++ b/idea/kotlin-android-plugin/src/org/jetbrains/kotlin/android/KotlinOutputParserHelper.kt
@@ -136,7 +136,7 @@
     init {
         isNewAndroidPlugin = try {
             Class.forName("com.android.ide.common.blame.Message")
-            true
+           ^true
         }
         catch (e: ClassNotFoundException) {
             false
@@ -151,12 +151,12 @@
         if (!isNewAndroidPlugin) {
             val messageClass = Class.forName("$packagePrefix.GradleMessage")
             val messageKindClass = Class.forName("$packagePrefix.GradleMessage\$Kind")
-            messageClass.getConstructor(messageKindClass, String::class.java)
+           ^messageClass.getConstructor(messageKindClass, String::class.java)
         }
         else {
             val messageClass = Class.forName("$packagePrefix.Message")
             val messageKindClass = Class.forName("$packagePrefix.Message\$Kind")
-            messageClass.getConstructor(
+           ^messageClass.getConstructor(
                     messageKindClass,
                     String::class.java,
                     String::class.java,
@@ -168,7 +168,7 @@
         if (!isNewAndroidPlugin) {
             val messageClass = Class.forName("$packagePrefix.GradleMessage")
             val messageKindClass = Class.forName("$packagePrefix.GradleMessage\$Kind")
-            messageClass.getConstructor(
+           ^messageClass.getConstructor(
                     messageKindClass,
                     String::class.java, String::class.java,
                     Int::class.java, Int::class.java)
@@ -178,7 +178,7 @@
             val messageKindClass = Class.forName("$packagePrefix.Message\$Kind")
             val sourceFilePositionClass = Class.forName("$packagePrefix.SourceFilePosition")
             val sourceFilePositionArrayClass = Class.forName("[L$packagePrefix.SourceFilePosition;")
-            messageClass.getConstructor(
+           ^messageClass.getConstructor(
                     messageKindClass,
                     String::class.java,
                     sourceFilePositionClass,
@@ -190,19 +190,19 @@
         assert(isNewAndroidPlugin) { "This property should be used only for New Android Plugin" }
         val sourcePositionClass = Class.forName("$packagePrefix.SourcePosition")
         val sourceFilePositionClass = Class.forName("$packagePrefix.SourceFilePosition")
-        sourceFilePositionClass.getConstructor(File::class.java, sourcePositionClass)
+       ^sourceFilePositionClass.getConstructor(File::class.java, sourcePositionClass)
     }
 
     private val sourcePositionConstructor: Constructor<*> by lazy {
         assert(isNewAndroidPlugin) { "This property should be used only for New Android Plugin" }
         val sourcePositionClass = Class.forName("$packagePrefix.SourcePosition")
-        sourcePositionClass.getConstructor(Int::class.java, Int::class.java, Int::class.java)
+       ^sourcePositionClass.getConstructor(Int::class.java, Int::class.java, Int::class.java)
     }
 
     private val sourcePositionVarargArg: Any by lazy {
         assert(isNewAndroidPlugin) { "This property should be used only for New Android Plugin" }
         val sourceFilePositionClass = Class.forName("$packagePrefix.SourceFilePosition")
-        RArray.newInstance(sourceFilePositionClass, 0)
+       ^RArray.newInstance(sourceFilePositionClass, 0)
     }
 
     private fun loadSeverityEnums() {
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
index 9781d1d..ad8a035 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/JavaToKotlinAction.kt
@@ -151,7 +151,7 @@
         while (true) {
             val fileName = javaFile.getNameWithoutExtension() + (if (i > 0) i else "") + ".kt"
             if (!ioFile.resolveSibling(fileName).exists()) return fileName
-            i++
+           ^i++
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
index 0503494..26d93b6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/ShowExpressionTypeAction.kt
@@ -46,7 +46,7 @@
             val startOffset = editor.getSelectionModel().getSelectionStart()
             val endOffset = editor.getSelectionModel().getSelectionEnd()
             val expression = CodeInsightUtilCore.findElementInRange<JetExpression>(psiFile, startOffset, endOffset, javaClass<JetExpression>(), JetLanguage.INSTANCE) ?: return
-            typeByExpression(expression)
+           ^typeByExpression(expression)
         }
         else {
             val offset = editor.getCaretModel().getOffset()
@@ -57,7 +57,7 @@
                                .firstOrNull { it.second != null } ?: return
             val (expression, type) = pair
             editor.getSelectionModel().setSelection(expression.startOffset, expression.endOffset)
-            type
+           ^type
         }
 
         if (type != null) {
diff --git a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
index 2d79366..d163dad 100644
--- a/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/actions/internal/CheckPartialBodyResolveAction.kt
@@ -193,7 +193,7 @@
 
             is JetContainerNode -> { //TODO - not quite correct
                 val pparent = parent.getParent() as? JetExpression
-                pparent != null && isValueNeeded(pparent)
+               ^pparent != null && isValueNeeded(pparent)
             }
 
             is JetDeclarationWithBody -> {
diff --git a/idea/src/org/jetbrains/kotlin/idea/caches/FileAttributeServiceImpl.kt b/idea/src/org/jetbrains/kotlin/idea/caches/FileAttributeServiceImpl.kt
index 40a8572..bf169c7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/caches/FileAttributeServiceImpl.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/caches/FileAttributeServiceImpl.kt
@@ -49,7 +49,7 @@
             val timeStamp = DataInputOutputUtil.readTIME(it)
             val intValue = DataInputOutputUtil.readINT(it)
 
-            if (file.timeStamp == timeStamp) {
+           ^if (file.timeStamp == timeStamp) {
                 CachedAttributeData(deserializeEnumValue(intValue, klass), timeStamp)
             }
             else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
index aaf4449..2325397 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinCopyPasteReferenceProcessor.kt
@@ -211,7 +211,7 @@
         val fileResolutionScope = file.getResolutionFacade().getFileTopLevelScope(file)
         return referenceData.map {
             val reference = findReference(it, file, blockStart)
-            if (reference != null)
+           ^if (reference != null)
                 createReferenceToRestoreData(reference, it, file, fileResolutionScope)
             else
                 null
diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinReferenceTransferableData.kt b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinReferenceTransferableData.kt
index 7fc093e..bfea136 100644
--- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinReferenceTransferableData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/KotlinReferenceTransferableData.kt
@@ -101,7 +101,7 @@
         public val dataFlavor: DataFlavor? by lazy {
             try {
                 val dataClass = javaClass<KotlinReferenceData>()
-                DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=" + dataClass.getName(),
+               ^DataFlavor(DataFlavor.javaJVMLocalObjectMimeType + ";class=" + dataClass.getName(),
                            "KotlinReferenceData",
                            dataClass.getClassLoader())
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
index b80953e..d4e8e81 100644
--- a/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/conversion/copy/ConvertJavaCopyPastePostProcessor.kt
@@ -229,7 +229,7 @@
         while (true) {
             val name = "dummy$i"
             if (convertedCode.indexOf(name) < 0) return name
-            i++
+           ^i++
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
index 251b9de..3985082 100644
--- a/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/coverage/KotlinCoverageExtension.kt
@@ -109,7 +109,7 @@
             runReadAction {
                 val outputRoot = findOutputRoot(srcFile)
                 val existingClassFiles = getClassesGeneratedFromFile(outputRoot, srcFile)
-                existingClassFiles.mapTo(classFiles) { File(it.getPath()) }
+               ^existingClassFiles.mapTo(classFiles) { File(it.getPath()) }
             }
             return true
         }
@@ -127,7 +127,7 @@
             LOG.debug("Classfiles: [${existingClassFiles.map { it.getName() }.join()}]")
             return existingClassFiles.map {
                 val relativePath = VfsUtilCore.getRelativePath(it, outputRoot!!)!!
-                StringUtil.trimEnd(relativePath, ".class").replace("/", ".")
+               ^StringUtil.trimEnd(relativePath, ".class").replace("/", ".")
             }
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
index b49107f..ddb0cd7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt
@@ -239,7 +239,7 @@
                 val file = element.getContainingFile() as JetFile
                 val isInLibrary = LibraryUtil.findLibraryEntry(file.getVirtualFile(), file.getProject()) != null
                 val typeMapper = if (!isInLibrary) prepareTypeMapper(file) else createTypeMapperForLibraryFile(element, file)
-                getInternalClassNameForElement(element, typeMapper, file, isInLibrary).className
+               ^getInternalClassNameForElement(element, typeMapper, file, isInLibrary).className
             }
         }
     }
@@ -252,7 +252,7 @@
             value = CachedValuesManager.getManager(file.getProject()).createCachedValue<JetTypeMapper>(
                     {
                         val typeMapper = createTypeMapper(file)
-                        CachedValueProvider.Result<JetTypeMapper>(typeMapper, PsiModificationTracker.MODIFICATION_COUNT)
+                       ^CachedValueProvider.Result<JetTypeMapper>(typeMapper, PsiModificationTracker.MODIFICATION_COUNT)
                     }, false)
 
             myTypeMappers.put(key, value)
@@ -475,7 +475,7 @@
                     }
                 }
             }
-            result
+           ^result
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
index 15d8e16..4ce3a22 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/KotlinEditorTextProvider.kt
@@ -76,7 +76,7 @@
                 is JetSuperExpression,
                 is JetReferenceExpression -> {
                     val pparent = parent.getParent()
-                    when (pparent) {
+                   ^when (pparent) {
                         is JetQualifiedExpression -> pparent
                         else -> parent
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/PositionManagerLibraryClassFileSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/PositionManagerLibraryClassFileSearcher.kt
index a5f1b29..37e3c48 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/PositionManagerLibraryClassFileSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/PositionManagerLibraryClassFileSearcher.kt
@@ -66,7 +66,7 @@
         is PropertyDescriptor -> packageDescriptor.memberScope.getProperties(descriptor.name, NoLookupLocation.FROM_IDE)
         else -> {
             reportError(topLevelDeclaration, descriptor)
-            listOf()
+           ^listOf()
         }
     }
 
@@ -111,7 +111,7 @@
         FilenameIndex.getVirtualFilesByName(project, it, scope).asSequence()
             }.map {
                 val packageFqName = file.getPackageFqName()
-                if (packageFqName.isRoot()) {
+               ^if (packageFqName.isRoot()) {
                     it.getNameWithoutExtension()
                 } else {
                     "${packageFqName.asString()}.${it.getNameWithoutExtension()}"
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
index 278a96c..2d60896 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpoint.kt
@@ -75,7 +75,7 @@
 
         return runReadAction {
             val field = getField()
-            field != null && field.isValid()
+           ^field != null && field.isValid()
         }
     }
 
@@ -195,7 +195,7 @@
                 descriptor = bindingContext.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, descriptor)
             }
 
-            if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor as PropertyDescriptor)!!) {
+           ^if (bindingContext.get(BindingContext.BACKING_FIELD_REQUIRED, descriptor as PropertyDescriptor)!!) {
                 BreakpointType.FIELD
             }
             else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
index 1b397e6..273e90fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/breakpoints/KotlinFieldBreakpointType.kt
@@ -95,7 +95,7 @@
                     }
                     is KotlinLightClassForExplicitDeclaration -> {
                         val jetClass = psiClass.getOrigin()
-                        createBreakpointIfPropertyExists(jetClass, jetClass.getContainingJetFile(), className, fieldName)
+                       ^createBreakpointIfPropertyExists(jetClass, jetClass.getContainingJetFile(), className, fieldName)
                     }
                     else -> null
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
index 0eb8291..9c8b4c4b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt
@@ -100,7 +100,7 @@
 
             val debuggerContext = DebuggerManagerEx.getInstanceEx(project).context
             val debuggerSession = debuggerContext.debuggerSession
-            if (debuggerSession == null) {
+           ^if (debuggerSession == null) {
                 null
             }
             else {
@@ -121,7 +121,7 @@
                     if (semaphore.waitFor(20)) break
                 }
 
-                nameRef.get()
+               ^nameRef.get()
             }
         })
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
index bdcfc29..1c49080 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt
@@ -135,7 +135,7 @@
             val compiledData = KotlinEvaluateExpressionCache.getOrCreateCompiledData(codeFragment, sourcePosition, context) {
                 fragment, position ->
                 isCompiledDataFromCache = false
-                extractAndCompile(fragment, position, context)
+               ^extractAndCompile(fragment, position, context)
             }
             val result = runEval4j(context, compiledData)
 
@@ -325,7 +325,7 @@
                     }
                     parameters.add(paramName, param.getParameterType(true), valuesForLabels[paramName])
                 }
-                parameters
+               ^parameters
             }
         }
 
@@ -395,7 +395,7 @@
 
                 KotlinCodegenFacade.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION)
 
-                state.factory
+               ^state.factory
             }
         }
 
@@ -443,9 +443,9 @@
                     throw EvaluateExceptionUtil.createEvaluateException(DefaultErrorMessages.render(it))
                 }
 
-                if (analyzeInlineFunctions) {
+               ^if (analyzeInlineFunctions) {
                     val (newBindingContext, files) = DebuggerUtils.analyzeInlinedFunctions(resolutionFacade, bindingContext, this, false)
-                    ExtendedAnalysisResult(newBindingContext, analysisResult.moduleDescriptor, files)
+                   ^ExtendedAnalysisResult(newBindingContext, analysisResult.moduleDescriptor, files)
                 }
                 else {
                     ExtendedAnalysisResult(bindingContext, analysisResult.moduleDescriptor, Collections.singletonList(this))
@@ -530,7 +530,7 @@
 
     return runReadAction {
         val classes = JavaPsiFacade.getInstance(project).findClasses(jvmName.asString(), GlobalSearchScope.allScope(project))
-        if (classes.isEmpty()) null
+       ^if (classes.isEmpty()) null
         else {
             classes.first().getJavaClassDescriptor()
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
index e720b1b..6b1702f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt
@@ -68,7 +68,7 @@
         val evaluator = DebuggerInvocationUtil.commitAndRunReadAction<ExpressionEvaluator>(project, EvaluatingComputable {
                 val codeFragment = JetPsiFactory(myElement.getProject()).createExpressionCodeFragment(
                         myElement.getText(), myElement.getContainingFile().getContext())
-                KotlinEvaluationBuilder.build(codeFragment, ContextUtil.getSourcePosition(evaluationContext))
+               ^KotlinEvaluationBuilder.build(codeFragment, ContextUtil.getSourcePosition(evaluationContext))
         })
 
         val value = evaluator.evaluate(evaluationContext)
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilingEvaluator.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilingEvaluator.kt
index e2c554f..8f18383 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilingEvaluator.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/compilingEvaluator.kt
@@ -78,7 +78,7 @@
         val inputStream = this.javaClass.getClassLoader().getResourceAsStream(name.replace('.', '/') + ".class")
                           ?: throw EvaluateException("Couldn't find $name class in current class loader")
 
-        try {
+       ^try {
             inputStream.readBytes()
         }
         finally {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
index ee6bc15..705cc3e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/extractFunctionForDebuggerUtil.kt
@@ -65,7 +65,7 @@
                 ErrorMessage.DECLARATIONS_ARE_USED_OUTSIDE -> "Cannot perform an action for this expression"
                 ErrorMessage.MULTIPLE_OUTPUT -> throw AssertionError("Unexpected error: $errorMessage")
             }
-            errorMessage.additionalInfo?.let { "$message: ${it.joinToString(", ")}" } ?: message
+           ^errorMessage.additionalInfo?.let { "$message: ${it.joinToString(", ")}" } ?: message
         }.joinToString(", ")
     }
 
@@ -192,16 +192,16 @@
             val fakeFunction = psiFactory.createFunction("fun _debug_fun_() {}")
             contextElement.add(psiFactory.createNewLine())
             val newFakeFun = contextElement.add(fakeFunction) as JetNamedFunction
-            newFakeFun.getBodyExpression()!!.getLastChild()
+           ^newFakeFun.getBodyExpression()!!.getLastChild()
         }
         contextElement is JetProperty && !contextElement.isLocal() -> {
             val delegateExpressionOrInitializer = contextElement.getDelegateExpressionOrInitializer()
-            if (delegateExpressionOrInitializer != null) {
+           ^if (delegateExpressionOrInitializer != null) {
                 wrapInRunFun(delegateExpressionOrInitializer)
             }
             else {
                 val getter = contextElement.getGetter()!!
-                if (!getter.hasBlockBody()) {
+               ^if (!getter.hasBlockBody()) {
                     wrapInRunFun(getter.getBodyExpression()!!)
                 }
                 else {
@@ -211,19 +211,19 @@
         }
         contextElement is JetPrimaryConstructor -> {
             val classOrObject = contextElement.getContainingClassOrObject()
-            insertNewInitializer(classOrObject.getOrCreateBody())
+           ^insertNewInitializer(classOrObject.getOrCreateBody())
         }
         contextElement is JetClassOrObject -> {
             insertNewInitializer(contextElement.getBody()!!)
         }
         contextElement is JetFunctionLiteral -> {
             val block = contextElement.getBodyExpression()!!
-            block.getStatements().firstOrNull() ?: block.getLastChild()
+           ^block.getStatements().firstOrNull() ?: block.getLastChild()
         }
         contextElement is JetDeclarationWithBody && !contextElement.hasBody()-> {
             val block = psiFactory.createBlock("")
             val newBlock = contextElement.add(block) as JetBlockExpression
-            newBlock.getRBrace()
+           ^newBlock.getRBrace()
         }
         contextElement is JetDeclarationWithBody && !contextElement.hasBlockBody()-> {
             wrapInRunFun(contextElement.getBodyExpression()!!)
@@ -231,14 +231,14 @@
         contextElement is JetDeclarationWithBody && contextElement.hasBlockBody()-> {
             val block = contextElement.getBodyExpression() as JetBlockExpression
             val last = block.getStatements().lastOrNull()
-            if (last is JetReturnExpression)
+           ^if (last is JetReturnExpression)
                 last
             else
                 block.getRBrace()
         }
         contextElement is JetWhenEntry -> {
             val entryExpression = contextElement.getExpression()
-            if (entryExpression is JetBlockExpression) {
+           ^if (entryExpression is JetBlockExpression) {
                 entryExpression.getStatements().firstOrNull() ?: entryExpression.getLastChild()
             }
             else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
index 06198dc..1fa1d96 100644
--- a/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/debugger/stepping/KotlinSteppingCommandProvider.kt
@@ -124,7 +124,7 @@
             }
 
             val inlinedArgument = getInlineArgumentIfAny(file, offset)
-            inlinedArgument != null && inlinedArgument.textRange.contains(offset)
+           ^inlinedArgument != null && inlinedArgument.textRange.contains(offset)
         }
     }
 
@@ -228,7 +228,7 @@
             if (elementAt != null) {
                 topMostElement = CodeInsightUtils.getTopmostElementAtOffset(elementAt, startOffset)
             }
-            startOffset++
+           ^startOffset++
         }
 
         if (topMostElement == null) return emptyList()
@@ -242,7 +242,7 @@
                 .filterIsInstance<JetFunction>()
                 .filter {
                     val context = it.analyze(BodyResolveMode.PARTIAL)
-                    InlineUtil.isInlinedArgument(it, context, false)
+                   ^InlineUtil.isInlinedArgument(it, context, false)
                 }
     }
 }
\ No newline at end of file
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
index 8fd420a..f3b35bb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/KotlinEnterHandler.kt
@@ -111,7 +111,7 @@
                     doc.insertString(stringTemplate.endOffset, ")")
                     doc.insertString(stringTemplate.startOffset, "(")
                     caretOffset++
-                    caretAdvance++
+                   ^caretAdvance++
                 }
                 doc.insertString(caretOffset, "\" + \"")
                 caretOffsetRef.set(caretOffset + 3)
diff --git a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
index 6442f7d..48bc2cf 100644
--- a/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/editor/fixers/KotlinFunctionDeclarationBodyFixer.kt
@@ -45,7 +45,7 @@
 
         if (psiElement.getText()?.last() == ';') {
             doc.deleteString(endOffset - 1, endOffset)
-            endOffset--
+           ^endOffset--
         }
 
         doc.insertString(endOffset, "{}")
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
index ce6c508..3056f72 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/JetElementDescriptionProvider.kt
@@ -73,12 +73,12 @@
                             descriptor.getName().asString()
                         }
 
-                "$kind ${CommonRefactoringUtil.htmlEmphasize(desc)}"
+               ^"$kind ${CommonRefactoringUtil.htmlEmphasize(desc)}"
             }
             is HighlightUsagesDescriptionLocation -> {
                 val kind = elementKind() ?: return null
                 val descriptor = targetDescriptor() ?: return null
-                "$kind ${descriptor.getName().asString()}"
+               ^"$kind ${descriptor.getName().asString()}"
             }
             else -> null
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
index 55f3a3e..3453325 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/KotlinFindUsagesHandlerFactory.kt
@@ -126,7 +126,7 @@
 
             1 -> {
                 val target = declarations.single().unwrapped ?: return FindUsagesHandler.NULL_HANDLER
-                if (target is JetNamedDeclaration) {
+               ^if (target is JetNamedDeclaration) {
                     KotlinFindMemberUsagesHandler.getInstance(target, factory = this)
                 }
                 else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
index b21d5e9..58c273f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindClassUsagesHandler.kt
@@ -112,7 +112,7 @@
         if (kotlinOptions.searchConstructorUsages) {
             val result = runReadAction {
                 val constructors = classOrObject.toLightClass()?.getConstructors() ?: PsiMethod.EMPTY_ARRAY
-                constructors.filterIsInstance<KotlinLightMethod>().all { constructor ->
+               ^constructors.filterIsInstance<KotlinLightMethod>().all { constructor ->
                     constructor.processDelegationCallConstructorUsages(constructor.getUseScope()) {
                         it.getCalleeExpression()?.mainReference?.let { referenceProcessor.process(it) } ?: false
                     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
index 4c112d3..88c7260 100644
--- a/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/findUsages/handlers/KotlinFindMemberUsagesHandler.kt
@@ -102,7 +102,7 @@
 
                 return FilteredQuery(result) {
                     val access = detector.getReferenceAccess(element, it)
-                    when (access) {
+                   ^when (access) {
                         ReadWriteAccessDetector.Access.Read -> kotlinOptions.isReadAccess
                         ReadWriteAccessDetector.Access.Write -> kotlinOptions.isWriteAccess
                         ReadWriteAccessDetector.Access.ReadWrite -> true
diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
index 3d0d69e..7026cb8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/formatter/KotlinSpacingBuilder.kt
@@ -84,7 +84,7 @@
         fun emptyLinesIfLineBreakInLeft(emptyLines: Int, numberOfLineFeedsOtherwise: Int = 1, numSpacesOtherwise: Int = 0) {
             newRule { parent: ASTBlock, left: ASTBlock, right: ASTBlock ->
                 val dependentSpacingRule = DependentSpacingRule(Trigger.HAS_LINE_FEEDS).registerData(Anchor.MIN_LINE_FEEDS, emptyLines + 1)
-                LineFeedDependantSpacing(
+               ^LineFeedDependantSpacing(
                         numSpacesOtherwise, numSpacesOtherwise,
                         minimumLineFeeds = numberOfLineFeedsOtherwise,
                         keepLineBreaks = codeStyleSettings.KEEP_LINE_BREAKS,
diff --git a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
index c2312e6..73eb59b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/formatter/kotlinSpacingRules.kt
@@ -153,7 +153,7 @@
             custom {
                 inPosition(right = PRIMARY_CONSTRUCTOR).customRule { p, l, r ->
                     val spacesCount = if (r.getNode().findLeafElementAt(0)?.getElementType() != LPAR) 1 else 0
-                    Spacing.createSpacing(spacesCount, spacesCount, 0, true, 0)
+                   ^Spacing.createSpacing(spacesCount, spacesCount, 0, true, 0)
                 }
             }
 
@@ -227,7 +227,7 @@
                         } else null
 
                         val removeLineBreaks = leftBlock != null && afterBlockFilter(right.getNode()?.getTreeParent()!!, leftBlock)
-                        Spacing.createSpacing(1, 1, 0, !removeLineBreaks, 0)
+                       ^Spacing.createSpacing(1, 1, 0, !removeLineBreaks, 0)
                     }
                 }
             }
@@ -325,7 +325,7 @@
                     }
                 }
 
-                Spacing.createSpacing(numSpaces, numSpaces, 0, settings.KEEP_LINE_BREAKS, settings.KEEP_BLANK_LINES_IN_CODE)
+               ^Spacing.createSpacing(numSpaces, numSpaces, 0, settings.KEEP_LINE_BREAKS, settings.KEEP_BLANK_LINES_IN_CODE)
             }
 
             inPosition(parent = CLASS_BODY, right = RBRACE).lineBreakIfLineBreakInParent(numSpacesOtherwise = 1)
diff --git a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
index c4d6921..0bc8605 100644
--- a/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/highlighter/markers/SuperDeclarationMarker.kt
@@ -57,7 +57,7 @@
             val memberKind = if (it is PropertyAccessorDescriptor || it is PropertyDescriptor) "property" else "function"
 
             val isBaseAbstract = it.getModality() == Modality.ABSTRACT
-            "${if (!isAbstract && isBaseAbstract) "Implements" else "Overrides"} $memberKind in '${renderer.render(declaration)}'"
+           ^"${if (!isAbstract && isBaseAbstract) "Implements" else "Overrides"} $memberKind in '${renderer.render(declaration)}'"
         }
 
         return containingStrings.sort().join(separator = "<br/>")
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
index 7e92abf..a6079fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/ConflictingExtensionPropertyInspection.kt
@@ -168,7 +168,7 @@
                 object : IntentionWrapper(MarkHiddenAndDeprecatedAction(property), property.containingFile), LowPriorityAction {}
             else
                 null
-            listOf(fix1, fix2).filterNotNull().toTypedArray()
+           ^listOf(fix1, fix2).filterNotNull().toTypedArray()
         }
         else {
             emptyArray()
@@ -193,7 +193,7 @@
                             override fun run(indicator: ProgressIndicator) {
                                 val importsToDelete = runReadAction {
                                     val searchScope = JetSourceFilterScope.kotlinSources(GlobalSearchScope.projectScope(project), project)
-                                    ReferencesSearch.search(declaration, searchScope)
+                                   ^ReferencesSearch.search(declaration, searchScope)
                                             .filterIsInstance<JetSimpleNameReference>()
                                             .map { ref -> ref.expression.getStrictParentOfType<JetImportDirective>() }
                                             .filterNotNull()
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
index 3b377a8..7f3c8ba 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedImportInspection.kt
@@ -180,7 +180,7 @@
         DaemonCodeAnalyzerEx.processHighlights(document, project, HighlightSeverity.ERROR, 0, document.textLength, Processor { highlightInfo ->
             if (!importsRange.containsRange(highlightInfo.startOffset, highlightInfo.endOffset)) {
                 hasErrors = true
-                false
+               ^false
             }
             else {
                 true
diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
index 313feaa..664b8b9 100644
--- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
@@ -171,7 +171,7 @@
 
                 val (inspectionTarget, textRange) = if (isCompanionObject && declaration.getNameIdentifier() == null) {
                     val objectKeyword = (declaration as JetObjectDeclaration).getObjectKeyword()
-                    Pair(declaration, TextRange(0, objectKeyword.getStartOffsetInParent() + objectKeyword.getTextLength()))
+                   ^Pair(declaration, TextRange(0, objectKeyword.getStartOffsetInParent() + objectKeyword.getTextLength()))
                 } else {
                     Pair(declaration.getNameIdentifier()!!, null)
                 }
@@ -198,7 +198,7 @@
             val findClassUsagesHandler = KotlinFindClassUsagesHandler(classOrObject, KotlinFindUsagesHandlerFactory(classOrObject.getProject()))
             findClassUsagesHandler.processUsagesInText(
                     classOrObject,
-                    { hasTextUsages = true; false },
+                    { hasTextUsages = true;^false },
                     GlobalSearchScope.projectScope(classOrObject.getProject())
             )
         }
@@ -247,7 +247,7 @@
     private fun hasReferences(declaration: JetNamedDeclaration, useScope: SearchScope): Boolean {
         return !ReferencesSearch.search(declaration, useScope).forEach(Processor {
             assert(it != null, { "Found reference is null, was looking for: " + declaration.getElementTextWithContext() })
-            declaration.isAncestor(it.getElement()) ||
+           ^declaration.isAncestor(it.getElement()) ||
             it.element.parent is JetValueArgumentName ||
             it.element.getParentOfType<JetImportDirective>(false) != null
         })
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
index 274bf52..f54f07a 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToBlockBodyIntention.kt
@@ -71,7 +71,7 @@
                     if (!declaration.hasDeclaredReturnType() && !KotlinBuiltIns.isUnit(returnType)) {
                         declaration.setType(returnType)
                     }
-                    generateBody(!KotlinBuiltIns.isUnit(returnType) && !KotlinBuiltIns.isNothing(returnType))
+                   ^generateBody(!KotlinBuiltIns.isUnit(returnType) && !KotlinBuiltIns.isNothing(returnType))
                 }
 
                 is JetPropertyAccessor -> generateBody(declaration.isGetter())
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
index 39d7650..1d73f30 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ConvertToStringTemplateIntention.kt
@@ -90,18 +90,18 @@
             is JetConstantExpression -> {
                 val bindingContext = expression.analyze()
                 val constant = ConstantExpressionEvaluator.getConstant(expression, bindingContext)
-                constant?.getValue(bindingContext.getType(expression)!!).toString()
+               ^constant?.getValue(bindingContext.getType(expression)!!).toString()
             }
 
             is JetStringTemplateExpression -> {
                 val base = if (expressionText.startsWith("\"\"\"") && expressionText.endsWith("\"\"\"")) {
                     val unquoted = expressionText.substring(3, expressionText.length() - 3)
-                    StringUtil.escapeStringCharacters(unquoted)
+                   ^StringUtil.escapeStringCharacters(unquoted)
                 }
                 else {
                     StringUtil.unquoteString(expressionText)
                 }
-                if (forceBraces && base.endsWith('$')) {
+               ^if (forceBraces && base.endsWith('$')) {
                     base.dropLast(1) + "\\$"
                 }
                 else {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
index 250e130..1d50e63 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/DeprecatedCallableAddReplaceWithIntention.kt
@@ -129,7 +129,7 @@
 
             is JetProperty -> {
                 if (isVar()) return null //TODO
-                getGetter()?.replacementExpressionFromBody()
+               ^getGetter()?.replacementExpressionFromBody()
             }
 
             else -> null
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
index 4786561..5bc4475 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/MoveLambdaOutsideParenthesesIntention.kt
@@ -45,7 +45,7 @@
             // if there are functions among candidates but none of them have last function parameter then not show the intention
             if (candidates.isNotEmpty() && candidates.none {
                 val lastParameter = it.getValueParameters().lastOrNull()
-                lastParameter != null && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(lastParameter.getType())
+               ^lastParameter != null && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(lastParameter.getType())
             }) {
                 return false
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
index a20ef0a..0945ccb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/ReplaceWithOperatorAssignmentIntention.kt
@@ -63,7 +63,7 @@
 
             expressionLeft is JetBinaryExpression -> {
                 val sameCommutativeOperation = expressionLeft.getOperationToken() == operationToken && isCommutative(operationToken)
-                isPrimitiveOperation && sameCommutativeOperation && checkExpressionRepeat(variableExpression, expressionLeft)
+               ^isPrimitiveOperation && sameCommutativeOperation && checkExpressionRepeat(variableExpression, expressionLeft)
             }
 
             else -> {
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
index 1fcb460..8ca56b8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SimplifyBooleanWithConstantsIntention.kt
@@ -103,7 +103,7 @@
 
                         else -> {
                             val opText = expression.getOperationReference().getText()
-                            psiFactory.createExpressionByPattern("$0 $opText $1", simpleLeft, simpleRight)
+                           ^psiFactory.createExpressionByPattern("$0 $opText $1", simpleLeft, simpleRight)
                         }
                     }
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
index 86eaf71..7248a92 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/SplitIfIntention.kt
@@ -64,7 +64,7 @@
             JetTokens.OROR -> {
                 val container = ifExpression.getParent()
 
-                if (container is JetBlockExpression && elseBranch == null && thenBranch.lastBlockStatementOrThis().isExitStatement()) { // special case
+               ^if (container is JetBlockExpression && elseBranch == null && thenBranch.lastBlockStatementOrThis().isExitStatement()) { // special case
                     val secondIf = container.addAfter(innerIf, ifExpression)
                     container.addAfter(psiFactory.createNewLine(), ifExpression)
                     val firstIf = ifExpression.replace(psiFactory.createIf(leftExpression, thenBranch))
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
index 4e8e6e5..75d8593 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/branchedTransformationUtils.kt
@@ -80,7 +80,7 @@
         is JetBinaryExpression -> {
             val lhs = getLeft()
             val op = getOperationToken()
-            when (op) {
+           ^when (op) {
                 JetTokens.IN_KEYWORD, JetTokens.NOT_IN -> lhs
                 JetTokens.EQEQ -> lhs as? JetSimpleNameExpression ?: getRight()
                 else -> null
diff --git a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
index 37d02ed..5545ab1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/intentions/branchedTransformations/intentions/MergeWhenIntention.kt
@@ -93,7 +93,7 @@
                 val expression = block.appendElement(element)
                 block.addBefore(psiFactory.createNewLine(), expression)
             }
-            block
+           ^block
         }
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/internal/makeBackup/CreateIncrementalCompilationBackup.kt b/idea/src/org/jetbrains/kotlin/idea/internal/makeBackup/CreateIncrementalCompilationBackup.kt
index 799e2a7..f56d6cd 100644
--- a/idea/src/org/jetbrains/kotlin/idea/internal/makeBackup/CreateIncrementalCompilationBackup.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/internal/makeBackup/CreateIncrementalCompilationBackup.kt
@@ -139,11 +139,11 @@
                             files.add(Pair(it, FileUtil.getRelativePath(dir, it)!!))
                             totalBytes += it.length()
                         }
-                        true
+                       ^true
                     },
                     /*directoryFilter*/ {
                         val name = it!!.getName()
-                        name != ".git" && name != "out"
+                       ^name != ".git" && name != "out"
                     }
             )
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaDocCommentConverter.kt b/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaDocCommentConverter.kt
index 557a4b9..7fafd84 100644
--- a/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaDocCommentConverter.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/j2k/IdeaDocCommentConverter.kt
@@ -76,7 +76,7 @@
         "code", "literal" -> {
             val text = tag.getDataElements().map { it.getText() }.join("")
             val escaped = StringUtil.escapeXml(text.trimStart())
-            if (tag.getName() == "code") "<code>$escaped</code>" else escaped
+           ^if (tag.getName() == "code") "<code>$escaped</code>" else escaped
         }
 
         "link", "linkplain" -> {
@@ -84,7 +84,7 @@
             val labelText = tag.getDataElements().firstOrNull { it is PsiDocToken }?.getText() ?: ""
             val kdocLink = convertJavadocLink(valueElement?.getText())
             val linkText = if (labelText.isEmpty()) kdocLink else StringUtil.escapeXml(labelText)
-            "<a docref=\"$kdocLink\">$linkText</a>"
+           ^"<a docref=\"$kdocLink\">$linkText</a>"
         }
 
         else -> tag.getText()
@@ -185,16 +185,16 @@
                 if (tag.getAttributeValue("docref") != null) {
                     val docRef = tag.getAttributeValue("docref")
                     val innerText = tag.getValue().getText()
-                    if (docRef == innerText) MarkdownSpan("[", "]") else MarkdownSpan("[", "][$docRef]")
+                   ^if (docRef == innerText) MarkdownSpan("[", "]") else MarkdownSpan("[", "][$docRef]")
                 }
                 else {
                     MarkdownSpan("[", "](${tag.getAttributeValue("href")})")
                 }
             }
 
-            "ul" -> { currentListType = ListType.Unordered; MarkdownSpan.Empty }
+            "ul" -> { currentListType = ListType.Unordered;^MarkdownSpan.Empty }
 
-            "ol" -> { currentListType = ListType.Ordered; MarkdownSpan.Empty }
+            "ol" -> { currentListType = ListType.Ordered;^MarkdownSpan.Empty }
 
             "li" -> if (currentListType == ListType.Unordered) MarkdownSpan.prefix(" * ") else MarkdownSpan.prefix(" 1. ")
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
index c6630bd..4121fce 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddFunctionParametersFix.kt
@@ -54,11 +54,11 @@
 
         val callableDescription = if (isConstructor()) {
             val className = functionDescriptor.containingDeclaration.name.asString()
-            "constructor '$className'"
+           ^"constructor '$className'"
         }
         else {
             val functionName = functionDescriptor.name.asString()
-            "function '$functionName'"
+           ^"function '$functionName'"
         }
 
         return if (hasTypeMismatches)
@@ -132,7 +132,7 @@
     private fun hasOtherUsages(function: PsiElement): Boolean {
         return ReferencesSearch.search(function).any {
             val call = it.element.getParentOfType<JetCallElement>(false)
-            call != null && callElement != call
+           ^call != null && callElement != call
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
index 0ec16a1..b86a9f3 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AddGenericUpperBoundFix.kt
@@ -66,11 +66,11 @@
             return when (diagnostic.factory) {
                 Errors.UPPER_BOUND_VIOLATED -> {
                     val upperBoundViolated = Errors.UPPER_BOUND_VIOLATED.cast(diagnostic)
-                    createAction(upperBoundViolated.b, upperBoundViolated.a).singletonOrEmptyList()
+                   ^createAction(upperBoundViolated.b, upperBoundViolated.a).singletonOrEmptyList()
                 }
                 Errors.TYPE_INFERENCE_UPPER_BOUND_VIOLATED -> {
                     val inferenceData = Errors.TYPE_INFERENCE_UPPER_BOUND_VIOLATED.cast(diagnostic).a
-                    createActionsByInferenceData(inferenceData)
+                   ^createActionsByInferenceData(inferenceData)
                 }
                 else -> emptyList()
             }
@@ -96,7 +96,7 @@
                 val argument = resultingSubstitutor.substitute(typeParameterDescriptor.defaultType, Variance.INVARIANT)
                                ?: return@factory null
 
-                createAction(argument, upperBound)
+               ^createAction(argument, upperBound)
             }.filterNotNull()
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
index 1634d9c..22a09a1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/AutoImportFix.kt
@@ -57,7 +57,7 @@
             {
                 val descriptors = computeSuggestions(element)
                 anySuggestionFound = !descriptors.isEmpty()
-                descriptors
+               ^descriptors
             },
             { PsiModificationTracker.SERVICE.getInstance(element.getProject()).getModificationCount() })
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
index b53caab..33b020d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/RemoveModifierFix.kt
@@ -38,7 +38,7 @@
 
     private val text = run {
         val modifierText = modifier.value
-        when {
+       ^when {
             isRedundant ->
                 "Remove redundant '$modifierText' modifier"
             modifier === JetTokens.ABSTRACT_KEYWORD || modifier === JetTokens.OPEN_KEYWORD ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
index 488285d..001498d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/ReplaceObsoleteLabelSyntaxFix.kt
@@ -50,7 +50,7 @@
             if (!(diagnostic.getPsiElement().getNonStrictParentOfType<JetAnnotationEntry>()?.looksLikeObsoleteLabelWithReferencesInCode()
                 ?: false)) return@factory null
 
-            JetWholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<JetAnnotatedExpression, JetAnnotationEntry>(
+           ^JetWholeProjectForEachElementOfTypeFix.createForMultiTaskOnElement<JetAnnotatedExpression, JetAnnotationEntry>(
                     tasksFactory = { collectTasks(it) },
                     tasksProcessor ={ it.forEach { ann -> replaceWithLabel(ann) } },
                     name = "Update obsolete label syntax in whole project"
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFactory.kt
index 58cb0e5..b13fcde 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/CreateFromUsageFactory.kt
@@ -73,7 +73,7 @@
                 if (cachedData == null) {
                     cachedData = Ref(createQuickFixData(element, currentDiagnostic))
                 }
-                cachedData!!.get()
+               ^cachedData!!.get()
             }.filter { it.isAvailable(project, null, file) }
         }
         finally {
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
index afb692d..c6a297f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt
@@ -187,7 +187,7 @@
                 newTypes.add(EqWrapper(KotlinBuiltIns.getInstance().getAnyType()))
             }
 
-            newTypes.map { TypeCandidate(it._type, scope) }.reverse()
+           ^newTypes.map { TypeCandidate(it._type, scope) }.reverse()
         }
     }
 
@@ -298,7 +298,7 @@
                         .map {
                             val typeCandidates = computeTypeCandidates(it)
                             assert (typeCandidates.size() == 1) { "Ambiguous type candidates for type parameter $it: $typeCandidates" }
-                            typeCandidates.first().theType
+                           ^typeCandidates.first().theType
                         }
                         .subtract(substitutionMap.keySet())
                 fakeFunction = createFakeFunctionDescriptor(scope, typeArgumentsForFakeFunction.size())
@@ -356,7 +356,7 @@
             ) {
                 receiverClassDescriptor.getTypeConstructor().getParameters().forEach { addClassifierDescriptor(it) }
                 changeLockLevel(WritableScope.LockLevel.READING)
-                this
+               ^this
             }
 
             val projections = receiverClassDescriptor.getTypeConstructor().getParameters()
@@ -467,7 +467,7 @@
                             containingElement is JetClass && containingElement.isInterface() && !config.isExtension -> ""
                             else -> "{}"
                         }
-                        if (callableInfo.kind == CallableKind.FUNCTION) {
+                       ^if (callableInfo.kind == CallableKind.FUNCTION) {
                             psiFactory.createFunction("${modifiers}fun<> $header $body")
                         }
                         else {
@@ -481,11 +481,11 @@
                                 else -> "{\n\n}"
                             }
                             val safeName = name.quoteIfNeeded()
-                            when (kind) {
+                           ^when (kind) {
                                 ClassKind.ENUM_ENTRY -> {
                                     if (!(targetParent is JetClass && targetParent.isEnum())) throw AssertionError("Enum class expected: ${targetParent.getText()}")
                                     val hasParameters = targetParent.getPrimaryConstructorParameters().isNotEmpty()
-                                    psiFactory.createEnumEntry("$safeName${if (hasParameters) "()" else " "}")
+                                   ^psiFactory.createEnumEntry("$safeName${if (hasParameters) "()" else " "}")
                                 }
                                 else -> {
                                     val openMod = if (open) "open " else ""
@@ -494,7 +494,7 @@
                                         ClassKind.PLAIN_CLASS, ClassKind.INTERFACE -> "<>"
                                         else -> ""
                                     }
-                                    psiFactory.createDeclaration<JetClassOrObject>(
+                                   ^psiFactory.createDeclaration<JetClassOrObject>(
                                             "$openMod$innerMod${kind.keyword} $safeName$typeParamList$paramList$returnTypeString $classBody"
                                     )
                                 }
@@ -503,7 +503,7 @@
                     }
                     CallableKind.PROPERTY -> {
                         val valVar = if ((callableInfo as PropertyInfo).writable) "var" else "val"
-                        psiFactory.createProperty("$modifiers$valVar<> $header")
+                       ^psiFactory.createProperty("$modifiers$valVar<> $header")
                     }
                 }
 
@@ -562,7 +562,7 @@
                                 }
                             }
                         }
-                        addNextToOriginalElementContainer(insertToBlock || declaration is JetProperty)
+                       ^addNextToOriginalElementContainer(insertToBlock || declaration is JetProperty)
                     }
 
                     containingElement is JetFile -> containingElement.add(declaration) as JetNamedDeclaration
@@ -571,7 +571,7 @@
                         if (declaration is JetSecondaryConstructor) {
                             val wrappingClass = psiFactory.createClass("class ${containingElement.getName()} {\n}")
                             addDeclarationToClassOrObject(wrappingClass, declaration)
-                            (jetFileToEdit.add(wrappingClass) as JetClass).getDeclarations().first() as JetNamedDeclaration
+                           ^(jetFileToEdit.add(wrappingClass) as JetClass).getDeclarations().first() as JetNamedDeclaration
                         }
                         else {
                             jetFileToEdit.add(declaration) as JetNamedDeclaration
@@ -604,7 +604,7 @@
                         classBody.getRBrace() ?: classBody.getLastChild()!!,
                         javaClass<PsiWhiteSpace>()
                 )
-                classBody.addAfter(declaration, anchor) as JetNamedDeclaration
+               ^classBody.addAfter(declaration, anchor) as JetNamedDeclaration
             }
             else classBody.addAfter(declaration, classBody.getLBrace()!!) as JetNamedDeclaration
         }
@@ -694,7 +694,7 @@
             properties.setProperty(FileTemplate.ATTRIBUTE_RETURN_TYPE, if (skipReturnType) "Unit" else func.getTypeReference()!!.getText())
             receiverClassDescriptor?.let {
                 properties.setProperty(FileTemplate.ATTRIBUTE_CLASS_NAME, DescriptorUtils.getFqName(it).asString())
-                properties.setProperty(FileTemplate.ATTRIBUTE_SIMPLE_CLASS_NAME, it.getName().asString())
+               ^properties.setProperty(FileTemplate.ATTRIBUTE_SIMPLE_CLASS_NAME, it.getName().asString())
             }
             if (callableInfo.name.isNotEmpty()) {
                 properties.setProperty(ATTRIBUTE_FUNCTION_NAME, callableInfo.name)
@@ -719,7 +719,7 @@
             val oldTypeArgumentList = callElement.getTypeArgumentList() ?: return
             val renderedTypeArgs = typeParameters.map { typeParameter ->
                 val type = substitutions.first { it.byType.getConstructor().getDeclarationDescriptor() == typeParameter }.forType
-                IdeDescriptorRenderers.SOURCE_CODE.renderType(type)
+               ^IdeDescriptorRenderers.SOURCE_CODE.renderType(type)
             }
             if (renderedTypeArgs.isEmpty()) {
                 oldTypeArgumentList.delete()
@@ -853,7 +853,7 @@
                     is JetNamedFunction, is JetProperty -> {
                         val klass = psiFactory.createClass("class Foo {}")
                         klass.getBody()!!.add(declaration)
-                        (declaration.replace(klass) as JetClass).getBody()!!.getDeclarations().first()
+                       ^(declaration.replace(klass) as JetClass).getBody()!!.getDeclarations().first()
                     }
                     else -> declaration
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
index 34c5950..396c4d0 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/templateExpressions.kt
@@ -113,7 +113,7 @@
                 typeCandidates.map {
                     val descriptor = it.theType.getConstructor().getDeclarationDescriptor() as ClassDescriptor
                     val text = it.renderedType!! + if (descriptor.getKind() == ClassKind.INTERFACE) "" else "()"
-                    LookupElementBuilder.create(it, text)
+                   ^LookupElementBuilder.create(it, text)
                 }.toTypedArray()
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
index 036e407..e82be8e 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/typeUtils.kt
@@ -67,7 +67,7 @@
 private fun getTypeParameterNamesNotInScope(typeParameters: Collection<TypeParameterDescriptor>, scope: JetScope): List<TypeParameterDescriptor> {
     return typeParameters.filter { typeParameter ->
         val classifier = scope.getClassifier(typeParameter.name, NoLookupLocation.FROM_IDE)
-        classifier == null || classifier != typeParameter
+       ^classifier == null || classifier != typeParameter
     }
 }
 
@@ -124,17 +124,17 @@
         this is JetTypeConstraint -> {
             // expression itself is a type assertion
             val constraint = this
-            arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
+           ^arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
         }
         parent is JetTypeConstraint -> {
             // expression is on the left side of a type assertion
             val constraint = parent
-            arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
+           ^arrayOf(context[BindingContext.TYPE, constraint.getBoundTypeReference()]!!)
         }
         this is JetMultiDeclarationEntry -> {
             // expression is on the lhs of a multi-declaration
             val typeRef = getTypeReference()
-            if (typeRef != null) {
+           ^if (typeRef != null) {
                 // and has a specified type
                 arrayOf(context[BindingContext.TYPE, typeRef]!!)
             }
@@ -146,7 +146,7 @@
         this is JetParameter -> {
             // expression is a parameter (e.g. declared in a for-loop)
             val typeRef = getTypeReference()
-            if (typeRef != null) {
+           ^if (typeRef != null) {
                 // and has a specified type
                 arrayOf(context[BindingContext.TYPE, typeRef]!!)
             }
@@ -159,7 +159,7 @@
             // the expression is the RHS of a variable assignment with a specified type
             val variable = parent
             val typeRef = variable.getTypeReference()
-            if (typeRef != null) {
+           ^if (typeRef != null) {
                 // and has a specified type
                 arrayOf(context[BindingContext.TYPE, typeRef]!!)
             }
@@ -176,7 +176,7 @@
             val receiverType = (variableDescriptor.getExtensionReceiverParameter() ?: variableDescriptor.getDispatchReceiverParameter())?.getType()
                                ?: module.builtIns.getNullableNothingType()
             val typeArguments = listOf(TypeProjectionImpl(receiverType), TypeProjectionImpl(variableDescriptor.getType()))
-            arrayOf(TypeUtils.substituteProjectionsForParameters(delegateClass, typeArguments))
+           ^arrayOf(TypeUtils.substituteProjectionsForParameters(delegateClass, typeArguments))
         }
         parent is JetStringTemplateEntryWithExpression && parent.getExpression() == this -> {
             arrayOf(module.builtIns.getStringType())
@@ -231,7 +231,7 @@
     else {
         val newArguments = getArguments().zip(getConstructor().getParameters()).map { pair ->
             val (projection, typeParameter) = pair
-            TypeProjectionImpl(Variance.INVARIANT, projection.getType().substitute(substitution, typeParameter.getVariance()))
+           ^TypeProjectionImpl(Variance.INVARIANT, projection.getType().substitute(substitution, typeParameter.getVariance()))
         }
         return JetTypeImpl.create(getAnnotations(), getConstructor(), isMarkedNullable(), newArguments, getMemberScope())
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
index 579927e..039703f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromCallActionFactory.kt
@@ -66,7 +66,7 @@
         return when (diagnostic.factory) {
             in Errors.UNRESOLVED_REFERENCE_DIAGNOSTICS, Errors.EXPRESSION_EXPECTED_PACKAGE_FOUND -> {
                 val parent = diagElement.parent
-                if (parent is JetCallExpression && parent.calleeExpression == diagElement) parent else diagElement
+               ^if (parent is JetCallExpression && parent.calleeExpression == diagElement) parent else diagElement
             }
 
             Errors.NO_VALUE_FOR_PARAMETER,
@@ -96,7 +96,7 @@
                     val containers = with(element.getQualifiedExpressionForSelectorOrThis().getExtractionContainers()) {
                         if (element is JetCallExpression) this else filter { it is JetClassBody || it is JetFile }
                     }
-                    if (containers.isNotEmpty()) containers else return null
+                   ^if (containers.isNotEmpty()) containers else return null
                 }
                 else Collections.emptyList()
 
@@ -113,7 +113,7 @@
                 val classifier = receiver.classifier as? JavaClassDescriptor ?: return null
                 val javaClass = DescriptorToSourceUtilsIde.getAnyDeclaration(project, classifier) as? PsiClass
                 if (javaClass == null || !javaClass.canRefactor()) return null
-                TypeInfo.StaticContextRequired(TypeInfo(classifier.defaultType, Variance.IN_VARIANCE))
+               ^TypeInfo.StaticContextRequired(TypeInfo(classifier.defaultType, Variance.IN_VARIANCE))
             }
             else -> TypeInfo(receiver.type, Variance.IN_VARIANCE)
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
index 885ae23..5d6fd40 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt
@@ -76,7 +76,7 @@
                 CallableKind.SECONDARY_CONSTRUCTOR -> "secondary constructor"
                 else -> throw AssertionError("Unexpected callable info: $it")
             }
-            if (it.name.isNotEmpty()) "$kind '${it.name}'" else kind
+           ^if (it.name.isNotEmpty()) "$kind '${it.name}'" else kind
         }
 
         return StringBuilder {
@@ -111,7 +111,7 @@
         return receiverTypeCandidates.any {
             val declaration = getDeclarationIfApplicable(project, it)
             val insertToJavaInterface = declaration is PsiClass && declaration.isInterface
-            when {
+           ^when {
                 !isExtension && propertyInfo != null && insertToJavaInterface && (!receiverInfo.staticContextRequired || propertyInfo.writable) ->
                     false
                 isFunction && insertToJavaInterface && receiverInfo.staticContextRequired ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
index aa4f4c0..4c9279f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableMemberFromUsageFactory.kt
@@ -38,7 +38,7 @@
         val delegateFactory = {
             val data = quickFixDataFactory(originalElementPointer).orEmpty()
             val originalElement = originalElementPointer.element
-            if (data.isNotEmpty() && originalElement != null) quickFixFactory(originalElement, data) else NullQuickFix
+           ^if (data.isNotEmpty() && originalElement != null) quickFixFactory(originalElement, data) else NullQuickFix
         }
         return if (lowPriority) LowPriorityQuickFixWithDelegateFactory(delegateFactory) else QuickFixWithDelegateFactory(delegateFactory)
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
index 7b2e3c6..719525c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateConstructorFromDelegationCallActionFactory.kt
@@ -53,7 +53,7 @@
         else {
             val superClassDescriptor =
                     DescriptorUtils.getSuperclassDescriptors(classDescriptor).singleOrNull { it.kind == ClassKind.CLASS } ?: return null
-            DescriptorToSourceUtilsIde.getAnyDeclaration(project, superClassDescriptor) ?: return null
+           ^DescriptorToSourceUtilsIde.getAnyDeclaration(project, superClassDescriptor) ?: return null
         }
         if (!(targetClass.canRefactor() && (targetClass is JetClass || targetClass is PsiClass))) return null
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
index 6336ecd..c35254f 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateSetFunctionActionFactory.kt
@@ -59,7 +59,7 @@
 
                 val context = assignmentExpr.analyze()
                 val rhsType = assignmentExpr.getResolvedCall(context)?.resultingDescriptor?.returnType
-                TypeInfo(if (rhsType == null || ErrorUtils.containsErrorType(rhsType)) builtIns.anyType else rhsType, Variance.IN_VARIANCE)
+               ^TypeInfo(if (rhsType == null || ErrorUtils.containsErrorType(rhsType)) builtIns.anyType else rhsType, Variance.IN_VARIANCE)
             }
             else -> return null
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
index affd376..c656ea1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromTypeReferenceActionFactory.kt
@@ -46,7 +46,7 @@
             interfaceExpected -> Collections.singletonList(ClassKind.INTERFACE)
             else -> ClassKind.values().filter {
                 val noTypeArguments = element.typeArgumentsAsTypes.isEmpty()
-                when (it) {
+               ^when (it) {
                     ClassKind.OBJECT -> noTypeArguments && isQualifier
                     ClassKind.ANNOTATION_CLASS -> noTypeArguments && !isQualifier
                     ClassKind.ENUM_ENTRY -> false
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
index 5c33b67..9a0b6d7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createClass/CreateClassFromUsageFactory.kt
@@ -37,7 +37,7 @@
             QuickFixWithDelegateFactory {
                 val currentElement = originalElementPointer.element
                 val data = quickFixDataFactory(originalElementPointer)
-                if (currentElement != null && data != null) {
+               ^if (currentElement != null && data != null) {
                     CreateClassFromUsageFix(originalElement, data.copy(kind = classKind))
                 } else NullQuickFix
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
index 8c3945a..ce9bb9c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createVariable/CreateParameterByRefActionFactory.kt
@@ -88,11 +88,11 @@
                                         it is JetClassInitializer -> it.parent?.parent as? JetClass
                                         it is JetDelegationSpecifier -> {
                                             val klass = it.getStrictParentOfType<JetClass>()
-                                            if (klass != null && !klass.isInterface() && klass !is JetEnumEntry) klass else null
+                                           ^if (klass != null && !klass.isInterface() && klass !is JetEnumEntry) klass else null
                                         }
                                         it is JetClassBody -> {
                                             val klass = it.parent as? JetClass
-                                            when {
+                                           ^when {
                                                 klass is JetEnumEntry -> chooseContainingClass(klass)
                                                 klass != null && klass.isInterface() -> null
                                                 else -> klass
@@ -132,7 +132,7 @@
 
                 is FunctionDescriptor -> {
                     val function = functionDescriptor.source.getPsi() as? JetFunction
-                    function?.let { context[BindingContext.RESOLUTION_SCOPE, it.bodyExpression] }
+                   ^function?.let { context[BindingContext.RESOLUTION_SCOPE, it.bodyExpression] }
                 }
 
                 else -> null
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
index d6d0a08..cb4cb67 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/CallableUsageReplacementStrategy.kt
@@ -210,7 +210,7 @@
         val type = resolvedCall.typeArguments[typeParameter]!!
         val typeElement = if (explicitTypeArgs != null) { // we use explicit type arguments if available to avoid shortening
             val _typeElement = explicitTypeArgs[index].typeReference?.typeElement ?: continue
-            _typeElement.marked(USER_CODE_KEY)
+           ^_typeElement.marked(USER_CODE_KEY)
         }
         else {
             factory.createType(IdeDescriptorRenderers.SOURCE_CODE.renderType(type)).typeElement!!
@@ -386,7 +386,7 @@
         }
         else {
             val thisReceiver = (element as? JetQualifiedExpression)?.receiverExpression as? JetThisExpression
-            if (thisReceiver != null && thisReceiver[USER_CODE_KEY]) // don't remove explicit 'this' coming from user's code
+           ^if (thisReceiver != null && thisReceiver[USER_CODE_KEY]) // don't remove explicit 'this' coming from user's code
                 ShortenReferences.FilterResult.GO_INSIDE
             else
                 ShortenReferences.FilterResult.PROCESS
@@ -671,12 +671,12 @@
 
         expression = if (!isNameUsed("it")) {
             replaceUsages(Name.identifier("it"))
-            psiFactory.createExpressionByPattern("$0${dot}let { $1 }", value, expression)
+           ^psiFactory.createExpressionByPattern("$0${dot}let { $1 }", value, expression)
         }
         else {
             val name = suggestName { !isNameUsed(it) }
             replaceUsages(name)
-            psiFactory.createExpressionByPattern("$0${dot}let { $1 -> $2 }", value, name, expression)
+           ^psiFactory.createExpressionByPattern("$0${dot}let { $1 -> $2 }", value, name, expression)
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
index 40e8a85..8180dfe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ClassUsageReplacementStrategy.kt
@@ -37,7 +37,7 @@
             is JetUserType -> {
                 return {
                     val replaced = parent.replaced(replacement)
-                    ShortenReferences.DEFAULT.process(replaced)
+                   ^ShortenReferences.DEFAULT.process(replaced)
                 } //TODO: type arguments and type arguments of outer class are lost
             }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
index d654aba..b59c6fc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/DeprecatedSymbolUsageInWholeProjectFix.kt
@@ -68,7 +68,7 @@
                     override fun run(indicator: ProgressIndicator) {
                         val usages = runReadAction {
                             val searchScope = JetSourceFilterScope.kotlinSources(GlobalSearchScope.projectScope(project), project)
-                            ReferencesSearch.search(psiElement, searchScope)
+                           ^ReferencesSearch.search(psiElement, searchScope)
                                     .filterIsInstance<JetSimpleNameReference>()
                                     .map { ref -> ref.expression }
                         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
index 772fddd..d578efe 100644
--- a/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/replaceWith/ReplaceWithAnnotationAnalyzer.kt
@@ -231,7 +231,7 @@
         return when (descriptor) {
             is PackageFragmentDescriptor -> {
                 val moduleDescriptor = descriptor.containingDeclaration
-                getResolutionScope(moduleDescriptor.getPackage(descriptor.fqName), ownerDescriptor, additionalScopes)
+               ^getResolutionScope(moduleDescriptor.getPackage(descriptor.fqName), ownerDescriptor, additionalScopes)
             }
 
             is PackageViewDescriptor ->
@@ -239,17 +239,17 @@
 
             is ClassDescriptor -> {
                 val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
-                ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, { outerScope }).scopeForMemberDeclarationResolution()
+               ^ClassResolutionScopesSupport(descriptor, LockBasedStorageManager.NO_LOCKS, { outerScope }).scopeForMemberDeclarationResolution()
             }
 
             is FunctionDescriptor -> {
                 val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
-                FunctionDescriptorUtil.getFunctionInnerScope(outerScope, descriptor, RedeclarationHandler.DO_NOTHING)
+               ^FunctionDescriptorUtil.getFunctionInnerScope(outerScope, descriptor, RedeclarationHandler.DO_NOTHING)
             }
 
             is PropertyDescriptor -> {
                 val outerScope = getResolutionScope(descriptor.containingDeclaration, ownerDescriptor, additionalScopes) ?: return null
-                JetScopeUtils.getPropertyDeclarationInnerScope(descriptor, outerScope, RedeclarationHandler.DO_NOTHING)
+               ^JetScopeUtils.getPropertyDeclarationInnerScope(descriptor, outerScope, RedeclarationHandler.DO_NOTHING)
             }
 
             else -> return null // something local, should not work with ReplaceWith
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
index d4ef633..505e9fb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/CallableRefactoring.kt
@@ -179,7 +179,7 @@
     val baseCallables = descriptorsForChange.map { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }.filterNotNull()
     return baseCallables + baseCallables.flatMap { it.toLightMethods() }.flatMapTo(HashSet<PsiElement>()) { psiMethod ->
         val overrides = OverridingMethodsSearch.search(psiMethod).findAll()
-        overrides.map { method -> method.namedUnwrappedElement ?: method}
+       ^overrides.map { method -> method.namedUnwrappedElement ?: method}
     }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
index 4166799..bec6282 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeInfo.kt
@@ -78,12 +78,12 @@
         val parameters = methodDescriptor.baseDescriptor.getValueParameters()
         parameters.indices.forEach { i -> map[parameters.get(i).getName().asString()] = i }
 
-        map
+       ^map
     }
 
     public val isParameterSetOrOrderChanged: Boolean by lazy {
         val signatureParameters = getNonReceiverParameters()
-        methodDescriptor.receiver != receiverParameterInfo ||
+       ^methodDescriptor.receiver != receiverParameterInfo ||
         signatureParameters.size() != methodDescriptor.getParametersCount() ||
         signatureParameters.indices.any { i -> signatureParameters[i].getOldIndex() != i }
     }
@@ -170,7 +170,7 @@
                             return
                     }
 
-                    result.add(usageInfo)
+                   ^result.add(usageInfo)
                 }
             }
 
@@ -319,7 +319,7 @@
                     else -> -1
                 }
 
-                ParameterInfoImpl(javaOldIndex, info.getName(), type, info.defaultValueForCall?.getText() ?: "")
+               ^ParameterInfoImpl(javaOldIndex, info.getName(), type, info.defaultValueForCall?.getText() ?: "")
             }
         }
 
@@ -357,12 +357,12 @@
             javaChangeInfos = (filterLightMethods(originalPsiMethods) zip filterLightMethods(method.toLightMethods())).map {
                 val (originalPsiMethod, currentPsiMethod) = it
 
-                when (method) {
+               ^when (method) {
                     is JetFunction, is JetClassOrObject ->
                         createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, false)
                     is JetProperty, is JetParameter -> {
                         val accessorName = originalPsiMethod.getName()
-                        when {
+                       ^when {
                             accessorName.startsWith(JvmAbi.GETTER_PREFIX) ->
                                 createJavaChangeInfoForFunctionOrGetter(originalPsiMethod, currentPsiMethod, true)
                             accessorName.startsWith(JvmAbi.SETTER_PREFIX) ->
@@ -415,13 +415,13 @@
                     else -> null
                 }
 
-        with(JetParameterInfo(callableDescriptor = functionDescriptor,
+       ^with(JetParameterInfo(callableDescriptor = functionDescriptor,
                               originalIndex = oldIndex,
                               name = info.getName(),
                               type = if (oldIndex >= 0) originalParameterDescriptors[oldIndex].getType() else currentType,
                               defaultValueForCall = defaultValueExpr)) {
             currentTypeText = IdeDescriptorRenderers.SOURCE_CODE_FOR_TYPE_ARGUMENTS.renderType(currentType)
-            this
+           ^this
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
index ac7f66b..52f9e59 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignature.kt
@@ -99,7 +99,7 @@
                     return
                 }
 
-                ChangeSignatureProcessor(project, getPreviewInfoForJavaMethod(descriptor).second)
+               ^ChangeSignatureProcessor(project, getPreviewInfoForJavaMethod(descriptor).second)
             }
             else -> throw AssertionError("Unexpected declaration: ${baseDeclaration.getElementTextWithContext()}")
         }
@@ -124,7 +124,7 @@
                 }
 
                 val (preview, javaChangeInfo) = getPreviewInfoForJavaMethod(descriptor)
-                object: JavaChangeSignatureDialog(project, JavaMethodDescriptor(preview), false, null) {
+               ^object: JavaChangeSignatureDialog(project, JavaMethodDescriptor(preview), false, null) {
                     override fun createRefactoringProcessor(): BaseRefactoringProcessor? {
                         val processor = super.createRefactoringProcessor()
                         (processor as? ChangeSignatureProcessor)?.getChangeInfo()?.updateMethod(javaChangeInfo.getMethod())
@@ -148,7 +148,7 @@
         val dummyFileText = with(StringBuilder()) {
             contextFile.getPackageDirective()?.let { append(it.getText()).append("\n") }
             append("class Dummy {\n").append(ktSignature).append("{}\n}")
-            toString()
+           ^toString()
         }
         val dummyFile = LightVirtualFile("dummy.kt", JetFileType.INSTANCE, dummyFileText).toPsiFile(project) as JetFile
         val dummyDeclaration = (dummyFile.getDeclarations().first() as JetClass).getBody()!!.getDeclarations().first()
@@ -164,7 +164,7 @@
         val params = (preview.getParameterList().getParameters() zip ktChangeInfo.getNewParameters()).map {
             val (param, paramInfo) = it
             // Keep original default value for proper update of Kotlin usages
-            KotlinAwareJavaParameterInfoImpl(paramInfo.getOldIndex(), param.getName()!!, param.getType(), paramInfo.defaultValueForCall)
+           ^KotlinAwareJavaParameterInfoImpl(paramInfo.getOldIndex(), param.getName()!!, param.getType(), paramInfo.defaultValueForCall)
         }.toTypedArray()
 
         return preview to JavaChangeInfoImpl(visibility,
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
index e1b0a10..6df15ff 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt
@@ -62,7 +62,7 @@
         parameters = baseDescriptor.getValueParameters()
                 .mapTo(receiver?.let{ arrayListOf(it) } ?: arrayListOf()) { parameterDescriptor ->
                     val jetParameter = valueParameters?.get(parameterDescriptor.getIndex())
-                    JetParameterInfo(
+                   ^JetParameterInfo(
                             callableDescriptor = baseDescriptor,
                             originalIndex = parameterDescriptor.getIndex(),
                             name = parameterDescriptor.getName().asString(),
@@ -81,7 +81,7 @@
         val validator = bodyScope?.let { bodyScope ->
             CollectingNameValidator(paramNames) {
                 val name = Name.identifier(it)
-                bodyScope.getLocalVariable(name) == null && bodyScope.getProperties(name, NoLookupLocation.FROM_IDE).isEmpty()
+               ^bodyScope.getLocalVariable(name) == null && bodyScope.getProperties(name, NoLookupLocation.FROM_IDE).isEmpty()
             }
         } ?: CollectingNameValidator(paramNames)
         val receiverType = baseDescriptor.getExtensionReceiverParameter()?.getType() ?: return null
@@ -96,7 +96,7 @@
         descriptorsForSignatureChange.map {
             val declaration = DescriptorToSourceUtilsIde.getAnyDeclaration(baseDeclaration.getProject(), it)
             assert(declaration != null) { "No declaration found for " + baseDescriptor }
-            JetCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
+           ^JetCallableDefinitionUsage<PsiElement>(declaration!!, it, null, null)
         }
     }
 
@@ -108,14 +108,14 @@
         primaryCallables + primaryCallables.flatMapTo(HashSet<UsageInfo>()) { primaryFunction ->
             val primaryDeclaration = primaryFunction.getDeclaration() as? JetCallableDeclaration
             val lightMethods = primaryDeclaration?.toLightMethods() ?: Collections.emptyList()
-            lightMethods.flatMap { baseMethod ->
+           ^lightMethods.flatMap { baseMethod ->
                 OverridingMethodsSearch
                         .search(baseMethod)
                         .map { overridingMethod ->
                             if (overridingMethod is KotlinLightMethod) {
                                 val overridingDeclaration = overridingMethod.namedUnwrappedElement as JetNamedDeclaration
                                 val overridingDescriptor = overridingDeclaration.resolveToDescriptor() as CallableDescriptor
-                                JetCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
+                               ^JetCallableDefinitionUsage<PsiElement>(overridingDeclaration, overridingDescriptor, primaryFunction, null)
                             }
                             else OverriderUsageInfo(overridingMethod, baseMethod, true, true, true)
                         }.filterNotNullTo(HashSet<UsageInfo>())
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
index 811b31f..451eaf8 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt
@@ -107,7 +107,7 @@
                                                                    javaClass<JetConstructorDelegationCall>())
             val calleeExpr = call?.let {
                 val callee = it.getCalleeExpression()
-                (callee as? JetConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
+               ^(callee as? JetConstructorCalleeExpression)?.getConstructorReferenceExpression() ?: callee
             } ?: element.getStrictParentOfType<JetSimpleNameExpression>()
 
             if (calleeExpr is JetSimpleNameExpression || calleeExpr is JetConstructorDelegationReferenceExpression) {
@@ -181,7 +181,7 @@
                         return null
                     }
 
-                    descriptor
+                   ^descriptor
                 }
 
                 is PropertyDescriptor, is ValueParameterDescriptor -> descriptor as CallableDescriptor
@@ -189,7 +189,7 @@
                 else -> {
                     val message = RefactoringBundle.getCannotRefactorMessage(JetRefactoringBundle.message("error.wrong.caret.position.function.or.constructor.name"))
                     CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
-                    null
+                   ^null
                 }
             }
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt
index 8d2d073..ed38778c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureProcessor.kt
@@ -50,7 +50,7 @@
         val allUsages = ArrayList<UsageInfo>()
         getChangeInfo().getOrCreateJavaChangeInfos(true)?.let { javaChangeInfos ->
             val javaProcessor = JavaChangeSignatureUsageProcessor()
-            javaChangeInfos.mapTo(allUsages) {
+           ^javaChangeInfos.mapTo(allUsages) {
                 KotlinWrapperForJavaUsageInfos(it, javaProcessor.findUsages(it), getChangeInfo().getMethod())
             }
         }
@@ -95,7 +95,7 @@
             val element2 = u2.getElement()
             val rank1 = if (element1 != null) element1.getTextOffset() else -1
             val rank2 = if (element2 != null) element2.getTextOffset() else -1
-            rank2 - rank1 // Reverse order
+           ^rank2 - rank1 // Reverse order
         }
         refUsages.set(usageArray)
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
index cb7c607..f7d927c 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetParameterInfo.kt
@@ -119,7 +119,7 @@
                             }
                     )
 
-                    map
+                   ^map
                 }
                 else {
                     emptyMap()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
index 983be43..388d7bc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/changeSignatureUtils.kt
@@ -48,7 +48,7 @@
             .asSequence()
             .filter {
                 val usage = (it as? JavaMethodKotlinUsageWithDelegate<*>)?.delegateUsage ?: it
-                usage is KotlinCallerUsage
+               ^usage is KotlinCallerUsage
                 || usage is DeferredJavaMethodKotlinCallerUsage
                 || usage is CallerUsageInfo
                 || (usage is OverriderUsageInfo && !usage.isOriginalOverrider())
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
index 02eb0db..d9e3adc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangePropertySignatureDialog.kt
@@ -120,7 +120,7 @@
                 updateReceiverUI()
             }
 
-            getPanel()
+           ^getPanel()
         }
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
index 17bdca7..ae2b314 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/ui/JetChangeSignatureDialog.kt
@@ -240,7 +240,7 @@
                     panel.add(component)
                     add(panel)
                     IJSwingUtilities.adjustComponentsOnMac(label, component)
-                    column++
+                   ^column++
                 }
             }
 
@@ -303,7 +303,7 @@
             override fun getFocusableComponents(): Array<JComponent> {
                 return Array(components.size()) {
                     val component = components.get(it)
-                    (component as? EditorTextField)?.getFocusTarget() ?: component
+                   ^(component as? EditorTextField)?.getFocusTarget() ?: component
                 }
             }
         }
@@ -420,7 +420,7 @@
                     parameterInfo.defaultValueForCall = codeFragment.getContentElement()
                 }
 
-                parameterInfo
+               ^parameterInfo
             }
 
             val returnTypeText = if (returnTypeCodeFragment != null) returnTypeCodeFragment.getText().trim() else ""
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
index cc55146..752ff8b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/usages/JetPropertyCallUsage.kt
@@ -58,7 +58,7 @@
         val replacingElement = newReceiver?.let {
             val psiFactory = JetPsiFactory(getProject())
             val receiver = it.defaultValueForCall ?: psiFactory.createExpression("_")
-            psiFactory.createExpressionByPattern("$0.$1", receiver, element)
+           ^psiFactory.createExpressionByPattern("$0.$1", receiver, element)
         } ?: element
 
         elementToReplace.replace(replacingElement)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
index 84ba61a..2ee189b 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractableCodeDescriptor.kt
@@ -215,7 +215,7 @@
                 return TypeUtils.substituteParameters(boxingClass, outputValueTypes)
             }
 
-            getType()
+           ^getType()
         }
 
         override val boxingRequired: Boolean = outputValues.size() > 1
@@ -242,7 +242,7 @@
                 1 -> Collections.singletonMap(outputValues.first(), boxedText)
                 else -> {
                     var i = 0
-                    ContainerUtil.newMapFromKeys(outputValues.iterator()) { "$boxedText.${selectors[i++]}" }
+                   ^ContainerUtil.newMapFromKeys(outputValues.iterator()) { "$boxedText.${selectors[i++]}" }
                 }
             }
         }
@@ -288,7 +288,7 @@
 
     val jumpOutputValue: Jump? = with(outputValues.filterIsInstance<Jump>()) {
         val jumpCount = size()
-        when {
+       ^when {
             isEmpty() ->
                 null
             outputValues.size() > jumpCount || jumpCount > 1 ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
index bc553b4..d71bd58 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt
@@ -100,7 +100,7 @@
             else -> {
                 val from = originalElements.first().getTextRange()!!.getStartOffset()
                 val to = originalElements.last().getTextRange()!!.getEndOffset()
-                TextRange(from, to)
+               ^TextRange(from, to)
             }
         }
     }
@@ -143,7 +143,7 @@
         val originalStartOffset = originalStartOffset
         val context = bindingContext
 
-        if (originalStartOffset != null && context != null) {
+       ^if (originalStartOffset != null && context != null) {
             val resultMap = HashMap<Int, ResolveResult>()
 
             val visitor = object: JetTreeVisitorVoid() {
@@ -170,7 +170,7 @@
             }
             getExpressions().forEach { it.accept(visitor) }
 
-            resultMap
+           ^resultMap
         }
         else Collections.emptyMap<Int, ResolveResult>()
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/duplicateUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/duplicateUtil.kt
index 5c24362..b53f3ee 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/duplicateUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/duplicateUtil.kt
@@ -58,7 +58,7 @@
         }
         editor.getScrollingModel().scrollTo(editor.offsetToLogicalPosition(startOffset), ScrollType.MAKE_VISIBLE)
 
-        it
+       ^it
     }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
index c21ce08..96a8799 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractableAnalysisUtil.kt
@@ -133,7 +133,7 @@
                     doTraversal(it.body.getEnterInstruction())
             }
 
-            true
+           ^true
         }
     }
 
@@ -350,7 +350,7 @@
 
     outDeclarations.mapTo(outputValues) {
         val descriptor = bindingContext[BindingContext.DECLARATION_TO_DESCRIPTOR, it] as? CallableDescriptor
-        Initializer(it as JetProperty, descriptor?.getReturnType() ?: DEFAULT_PARAMETER_TYPE)
+       ^Initializer(it as JetProperty, descriptor?.getReturnType() ?: DEFAULT_PARAMETER_TYPE)
     }
     outParameters.mapTo(outputValues) { ParameterUpdate(it, modifiedVarDescriptors[it.originalDescriptor]!!) }
 
@@ -365,7 +365,7 @@
                              + outDeclarations.map { it.renderForMessage(bindingContext)!! }).sort()
                     return controlFlow to ErrorMessage.MULTIPLE_OUTPUT.addAdditionalInfo(outValuesStr)
                 }
-                OutputValueBoxer::AsList
+               ^OutputValueBoxer::AsList
             }
 
             else -> controlFlow.boxerFactory
@@ -455,7 +455,7 @@
             DescriptorToSourceUtils.descriptorToDeclaration(it)
         } as? JetTypeParameter
 
-        extractable && (typeParameter != null || typeToCheck.isResolvableInScope(targetScope, false))
+       ^extractable && (typeParameter != null || typeToCheck.isResolvableInScope(targetScope, false))
     }
 }
 
@@ -472,13 +472,13 @@
             DescriptorToSourceUtils.descriptorToDeclaration(it)
         } as? JetTypeParameter
 
-        when {
+       ^when {
             typeToCheck.isResolvableInScope(targetScope, true) ->
                 extractable
 
             typeParameter != null -> {
                 typeParameters.add(TypeParameter(typeParameter, typeParameter.collectRelevantConstraints()))
-                extractable
+               ^extractable
             }
 
             options.allowSpecialClassNames && typeToCheck.isSpecial() ->
@@ -489,7 +489,7 @@
 
             else -> {
                 nonDenotableTypes.add(typeToCheck)
-                false
+               ^false
             }
         }
     }
@@ -530,7 +530,7 @@
 
     private val defaultType: JetType by lazy {
         writable = false
-        if (defaultTypes.isNotEmpty()) {
+       ^if (defaultTypes.isNotEmpty()) {
             TypeIntersector.intersectTypes(originalDescriptor.builtIns, JetTypeChecker.DEFAULT, defaultTypes)!!
         }
         else originalType
@@ -543,7 +543,7 @@
 
         val typeSet = if (defaultType.isFlexible()) {
             val bounds = defaultType.getCapability(javaClass<Flexibility>())!!
-            LinkedHashSet<JetType>().apply {
+           ^LinkedHashSet<JetType>().apply {
                 if (typePredicate(bounds.upperBound)) add(bounds.upperBound)
                 if (typePredicate(bounds.lowerBound)) add(bounds.lowerBound)
             }
@@ -560,7 +560,7 @@
             typeSet.add(superType)
         }
 
-        typeSet.toList()
+       ^typeSet.toList()
     }
 
     override fun getParameterTypeCandidates(allowSpecialClassNames: Boolean): List<JetType> {
@@ -618,7 +618,7 @@
         return when {
                    extractFunctionRef -> {
                        originalDescriptor as FunctionDescriptor
-                       KotlinBuiltIns.getInstance().getFunctionType(Annotations.EMPTY,
+                      ^KotlinBuiltIns.getInstance().getFunctionType(Annotations.EMPTY,
                                                                     originalDescriptor.getExtensionReceiverParameter()?.getType(),
                                                                     originalDescriptor.getValueParameters().map { it.getType() },
                                                                     originalDescriptor.getReturnType() ?: DEFAULT_RETURN_TYPE)
@@ -635,10 +635,10 @@
                        val typeByDataFlowInfo = if (useSmartCastsIfPossible) {
                            bindingContext[BindingContext.EXPRESSION_TYPE_INFO, calleeExpression]?.dataFlowInfo?.let { dataFlowInfo ->
                                val possibleTypes = dataFlowInfo.getPossibleTypes(DataFlowValueFactory.createDataFlowValue(receiverToExtract))
-                               if (possibleTypes.isNotEmpty()) CommonSupertypes.commonSupertype(possibleTypes) else null
+                              ^if (possibleTypes.isNotEmpty()) CommonSupertypes.commonSupertype(possibleTypes) else null
                            }
                        } else null
-                       typeByDataFlowInfo ?: receiverToExtract.getType()
+                      ^typeByDataFlowInfo ?: receiverToExtract.getType()
                    }
                    receiverToExtract.exists() -> receiverToExtract.getType()
                    else -> null
@@ -715,7 +715,7 @@
                     receiverToExtract is ExpressionReceiver -> {
                         val receiverExpression = receiverToExtract.getExpression()
                         // If p.q has a smart-cast, then extract entire qualified expression
-                        if (refInfo.smartCast != null) receiverExpression.getParent() as JetExpression else receiverExpression
+                       ^if (refInfo.smartCast != null) receiverExpression.getParent() as JetExpression else receiverExpression
                     }
                     receiverToExtract.exists() && refInfo.smartCast == null -> null
                     else -> (originalRef.getParent() as? JetThisExpression) ?: originalRef
@@ -727,14 +727,14 @@
                     var argumentText =
                             if (hasThisReceiver && extractThis) {
                                 val label = if (descriptorToExtract is ClassDescriptor) "@${descriptorToExtract.getName().asString()}" else ""
-                                "this$label"
+                               ^"this$label"
                             }
                             else {
                                 val argumentExpr = (thisExpr ?: ref).getQualifiedExpressionForSelectorOrThis()
-                                if (argumentExpr is JetOperationReferenceExpression) {
+                               ^if (argumentExpr is JetOperationReferenceExpression) {
                                     val nameElement = argumentExpr.getReferencedNameElement()
                                     val nameElementType = nameElement.node.elementType
-                                    (nameElementType as? JetToken)?.let {
+                                   ^(nameElementType as? JetToken)?.let {
                                         OperatorConventions.getNameForOperationSymbol(it)?.asString()
                                     } ?: nameElement.getText()
                                 }
@@ -748,7 +748,7 @@
 
                     val originalType = suggestParameterType(extractFunctionRef, originalDescriptor, parameterExpression, receiverToExtract, resolvedCall, false)
 
-                    MutableParameter(argumentText, descriptorToExtract, extractThis, targetScope, originalType, refInfo.possibleTypes)
+                   ^MutableParameter(argumentText, descriptorToExtract, extractThis, targetScope, originalType, refInfo.possibleTypes)
                 }
 
                 if (!extractThis) {
@@ -799,7 +799,7 @@
                 currentName = KotlinNameSuggester.suggestNamesByType(getParameterType(options.allowSpecialClassNames), varNameValidator, "p").first()
             }
             mirrorVarName = if (descriptorToExtract in modifiedVarDescriptors) KotlinNameSuggester.suggestNameByName(name, varNameValidator) else null
-            info.parameters.add(this)
+           ^info.parameters.add(this)
         }
     }
 
@@ -977,9 +977,9 @@
                 property.getGetter()?.getBodyExpression()?.let { return it }
                 property.getInitializer()?.let { return it }
                 // We assume lazy property here with delegate expression 'by Delegates.lazy { body }'
-                property.getDelegateExpression()?.let {
+               ^property.getDelegateExpression()?.let {
                     val call = it.getCalleeExpressionIfAny()?.getParent() as? JetCallExpression
-                    call?.getFunctionLiteralArguments()?.singleOrNull()?.getFunctionLiteral()?.getBodyExpression()
+                   ^call?.getFunctionLiteralArguments()?.singleOrNull()?.getFunctionLiteral()?.getBodyExpression()
                 }
             }
         } ?: throw AssertionError("Couldn't get block body for this declaration: ${getElementTextWithContext()}")
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
index 17ac0c8..4dff9f7 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/extractorUtil.kt
@@ -74,7 +74,7 @@
                 descriptor.typeParameters.map {
                     val typeParameter = it.originalDeclaration
                     val bound = typeParameter.extendsBound
-                    typeParameter.name + (bound?.let { " : " + it.text } ?: "")
+                   ^typeParameter.name + (bound?.let { " : " + it.text } ?: "")
                 }
         )
 
@@ -86,7 +86,7 @@
             val receiverType = it.getParameterType(descriptor.extractionData.options.allowSpecialClassNames)
             val receiverTypeAsString = receiverType.typeAsString()
             val isFunctionType = KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(receiverType)
-            builder.receiver(if (isFunctionType) "($receiverTypeAsString)" else receiverTypeAsString)
+           ^builder.receiver(if (isFunctionType) "($receiverTypeAsString)" else receiverTypeAsString)
         }
 
         builder.name(if (descriptor.name == "" && generatorOptions.allowDummyName) "myFun" else descriptor.name)
@@ -117,7 +117,7 @@
             }
         }
 
-        builder.asString()
+       ^builder.asString()
     }
 }
 
@@ -211,7 +211,7 @@
             .filter { !(it.range.getTextRange() intersects originalTextRange) }
             .map { match ->
                 val controlFlow = getControlFlowIfMatched(match)
-                controlFlow?.let { DuplicateInfo(match.range, it, unifierParameters.map { match.result.substitution[it]!!.getText()!! }) }
+               ^controlFlow?.let { DuplicateInfo(match.range, it, unifierParameters.map { match.result.substitution[it]!!.getText()!! }) }
             }
             .filterNotNull()
             .toList()
@@ -300,7 +300,7 @@
                 val resultVal = KotlinNameSuggester.suggestNamesByType(extractableDescriptor.returnType, varNameValidator, null).first()
                 block.addBefore(psiFactory.createDeclaration("val $resultVal = $callText"), anchorInBlock)
                 block.addBefore(newLine, anchorInBlock)
-                controlFlow.outputValueBoxer.getUnboxingExpressions(resultVal)
+               ^controlFlow.outputValueBoxer.getUnboxingExpressions(resultVal)
             }
 
     val copiedDeclarations = HashMap<JetDeclaration, JetDeclaration>()
@@ -321,12 +321,12 @@
                 val exprText = if (outputValue.callSiteReturn) {
                     val firstReturn = outputValue.originalExpressions.filterIsInstance<JetReturnExpression>().firstOrNull()
                     val label = firstReturn?.getTargetLabel()?.getText() ?: ""
-                    "return$label $callText"
+                   ^"return$label $callText"
                 }
                 else {
                     callText
                 }
-                Collections.singletonList(psiFactory.createExpression(exprText))
+               ^Collections.singletonList(psiFactory.createExpression(exprText))
             }
 
             is ParameterUpdate ->
@@ -355,7 +355,7 @@
             is Initializer -> {
                 val newProperty = copiedDeclarations[outputValue.initializedDeclaration] as JetProperty
                 newProperty.setInitializer(psiFactory.createExpression(callText))
-                Collections.emptyList()
+               ^Collections.emptyList()
             }
 
             else -> throw IllegalArgumentException("Unknown output value: $outputValue")
@@ -431,7 +431,7 @@
 
         val newResultExpression = descriptor.controlFlow.defaultOutputValue?.let {
             val boxedExpression = originalExpression.replaced(replacingExpression).getReturnedExpression()!!
-            descriptor.controlFlow.outputValueBoxer.extractExpressionByValue(boxedExpression, it)
+           ^descriptor.controlFlow.outputValueBoxer.extractExpressionByValue(boxedExpression, it)
         }
         if (newResultExpression == null) {
             throw AssertionError("Can' replace '${originalExpression.getText()}' with '${replacingExpression.getText()}'")
@@ -447,7 +447,7 @@
                                            file: PsiFile): List<T> {
         return originalExpressions.map { originalExpression ->
             val offsetInBody = originalExpression.getTextRange()!!.getStartOffset() - descriptor.extractionData.originalStartOffset!!
-            file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType(originalExpression.javaClass)
+           ^file.findElementAt(bodyOffset + offsetInBody)?.getNonStrictParentOfType(originalExpression.javaClass)
             ?: throw AssertionError("Couldn't find expression at $offsetInBody in '${body.getText()}'")
         }
     }
@@ -516,7 +516,7 @@
             for (param in descriptor.parameters) {
                 param.mirrorVarName?.let { varName ->
                     body.addBefore(psiFactory.createProperty(varName, null, true, param.name), firstExpression)
-                    body.addBefore(psiFactory.createNewLine(), firstExpression)
+                   ^body.addBefore(psiFactory.createNewLine(), firstExpression)
                 }
             }
         }
@@ -532,7 +532,7 @@
                     val resultVal = KotlinNameSuggester.suggestNamesByType(defaultValue.valueType, varNameValidator, null).first()
                     val newDecl = body.addBefore(psiFactory.createDeclaration("val $resultVal = ${lastExpression!!.getText()}"), lastExpression) as JetProperty
                     body.addBefore(psiFactory.createNewLine(), lastExpression)
-                    psiFactory.createExpression(resultVal) to newDecl.getInitializer()!!
+                   ^psiFactory.createExpression(resultVal) to newDecl.getInitializer()!!
                 }
                 else {
                     lastExpression to null
@@ -575,17 +575,17 @@
         return with(descriptor.extractionData) {
             val targetContainer = anchor.getParent()!!
             val emptyLines = psiFactory.createWhiteSpace("\n\n")
-            if (insertBefore) {
+           ^if (insertBefore) {
                 val declarationInFile = targetContainer.addBefore(declaration, anchor) as JetNamedDeclaration
                 targetContainer.addBefore(emptyLines, anchor)
 
-                declarationInFile
+               ^declarationInFile
             }
             else {
                 val declarationInFile = targetContainer.addAfter(declaration, anchor) as JetNamedDeclaration
                 targetContainer.addAfter(emptyLines, anchor)
 
-                declarationInFile
+               ^declarationInFile
             }
         }
     }
@@ -605,7 +605,7 @@
 
         // Ascend to the level of targetSibling
         val targetParent = targetSibling.getParent()
-        marginalCandidate.parentsWithSelf.first { it.getParent() == targetParent }
+       ^marginalCandidate.parentsWithSelf.first { it.getParent() == targetParent }
     }
 
     val shouldInsert = !(generatorOptions.inTempFile || generatorOptions.target == ExtractionTarget.FAKE_LAMBDALIKE_FUNCTION)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
index c5060da..38913d6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinInplaceParameterIntroducer.kt
@@ -71,7 +71,7 @@
             override val textAttributes: TextAttributes = with(TextAttributes()) {
                 setEffectType(EffectType.ROUNDED_BOX)
                 setEffectColor(JBColor.RED)
-                this
+               ^this
             }
         },
 
@@ -79,7 +79,7 @@
             override val textAttributes: TextAttributes = with(TextAttributes()) {
                 setEffectType(EffectType.STRIKEOUT)
                 setEffectColor(Color.BLACK)
-                this
+               ^this
             }
         };
 
@@ -138,7 +138,7 @@
                         val modifier = if (valVar != JetValVar.None) "${valVar.name} " else ""
                         val defaultValue = if (withDefaultValue) " = ${newArgumentValue.getText()}" else ""
 
-                        "$modifier$parameterName: $parameterType$defaultValue"
+                       ^"$modifier$parameterName: $parameterType$defaultValue"
                     }
                     else parameter.getText()
 
@@ -208,7 +208,7 @@
                 val parameterList = callable.getValueParameterList()
                                     ?: (callable as JetClass).createPrimaryConstructorParameterListIfAbsent()
                 val parameter = JetPsiFactory(myProject).createParameter("$newParameterName: $newParameterTypeText")
-                parameterList.addParameter(parameter)
+               ^parameterList.addParameter(parameter)
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
index ee5fece..740c626 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceParameter/KotlinIntroduceParameterHandler.kt
@@ -94,7 +94,7 @@
                         false
                 }
             }
-            if (occurrencesToReplace.all {
+           ^if (occurrencesToReplace.all {
                 PsiTreeUtil.findCommonParent(it.elements)?.parentsWithSelf?.any(modifierIsUnnecessary) ?: false
             }) JetValVar.None else JetValVar.Val
         }
@@ -182,7 +182,7 @@
                         .firstOrNull { isObjectOrNonInnerClass(it.first) }
                         ?.second
 
-                (if (stopAt != null) parent.parents.takeWhile { it != stopAt } else parents)
+               ^(if (stopAt != null) parent.parents.takeWhile { it != stopAt } else parents)
                         .filter {
                             ((it is JetClass && !it.isInterface() && it !is JetEnumEntry) || it is JetNamedFunction || it is JetSecondaryConstructor) &&
                             ((it as JetNamedDeclaration).getValueParameterList() != null || it.getNameIdentifier() != null)
@@ -250,11 +250,11 @@
                 .match(body, JetPsiUnifier.DEFAULT)
                 .filterNot {
                     val textRange = it.range.getTextRange()
-                    forbiddenRanges.any { it.intersects(textRange) }
+                   ^forbiddenRanges.any { it.intersects(textRange) }
                 }
                 .map {
                     val matchedElement = it.range.elements.singleOrNull()
-                    when (matchedElement) {
+                   ^when (matchedElement) {
                         is JetExpression -> matchedElement
                         is JetStringTemplateEntryWithExpression -> matchedElement.getExpression()
                         else -> null
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
index 78140cc..78367ce 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceProperty/KotlinInplacePropertyIntroducer.kt
@@ -100,7 +100,7 @@
 
                             setSelectedIndex(availableTargets.indexOf(currentTarget))
 
-                            this
+                           ^this
                         }
 
                         val propertyKindLabel = JLabel("Introduce as: ")
@@ -111,7 +111,7 @@
                         panel.add(propertyKindLabel)
                         panel.add(propertyKindComboBox)
 
-                        panel
+                       ^panel
                     }
             )
         }
@@ -146,7 +146,7 @@
                         replaceAllCheckBox.setSelected(replaceAll)
                         replaceAllCheckBox.setMnemonic('R')
                         replaceAllCheckBox.addActionListener { replaceAll = replaceAllCheckBox.isSelected() }
-                        replaceAllCheckBox
+                       ^replaceAllCheckBox
                     }
             )
         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
index f7f2625..47a0acc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/introduceVariable/KotlinVariableInplaceIntroducer.kt
@@ -73,7 +73,7 @@
 
                         val psiFactory = JetPsiFactory(myProject)
                         val keyword = if (varCheckBox.isSelected()) psiFactory.createVarKeyword() else psiFactory.createValKeyword()
-                        addedVariable.getValOrVarKeyword().replace(keyword)
+                       ^addedVariable.getValOrVarKeyword().replace(keyword)
                     }
                 }
                 addComponent(varCheckBox)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
index 6bae03e..f84dcf6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt
@@ -183,7 +183,7 @@
                 is JetClassInitializer -> enclosingDeclaration.getBody()
                 else -> null
             }
-            if (targetContainer is JetBlockExpression) Collections.singletonList(targetContainer) else Collections.emptyList()
+           ^if (targetContainer is JetBlockExpression) Collections.singletonList(targetContainer) else Collections.emptyList()
         }
     }
 }
@@ -251,7 +251,7 @@
             }
         })
 
-        createPopup()
+       ^createPopup()
     }
 }
 
@@ -328,7 +328,7 @@
         is JetClassInitializer -> enclosingDeclaration.getBody()
         is JetClass -> {
             val delegationSpecifierList = enclosingDeclaration.getDelegationSpecifierList()
-            if (delegationSpecifierList.isAncestor(this)) this else null
+           ^if (delegationSpecifierList.isAncestor(this)) this else null
         }
         else -> null
     }
@@ -401,7 +401,7 @@
             toPsi,
             {
                 onSelect(it)
-                true
+               ^true
             }
     ).showInBestPositionFor(editor)
 }
@@ -504,7 +504,7 @@
     val newParams = template.getParameterList().getParameters().map {
         val param = factory.createParameter(it.getName()!!, it.getType())
         copyModifierListItems(it.getModifierList()!!, param.getModifierList()!!)
-        param
+       ^param
     }
     ChangeSignatureUtil.synchronizeList(
             targetParamList,
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
index 03f1598..5c51016 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/memberInfo/KotlinMemberInfoStorage.kt
@@ -84,7 +84,7 @@
                 .map {
                     val type = context[BindingContext.TYPE, it.typeReference]
                     val classDescriptor = type?.constructor?.declarationDescriptor as? ClassDescriptor
-                    classDescriptor?.source?.getPsi() as? JetClass
+                   ^classDescriptor?.source?.getPsi() as? JetClass
                 }
                 .filter { it != null && it.isInterface() }
                 .mapTo(temp) { KotlinMemberInfo(it!!, true) }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
index 4ab4c53..5083157 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/MoveJavaInnerClassKotlinUsagesHandler.kt
@@ -55,7 +55,7 @@
         else {
             innerCall.getFunctionLiteralArguments().firstOrNull()?.let { lambdaArg ->
                 val anchor = PsiTreeUtil.skipSiblingsBackward(lambdaArg, javaClass<PsiWhiteSpace>())
-                innerCall.addAfter(psiFactory.createCallArguments("(${outerCall.getText()})"), anchor)
+               ^innerCall.addAfter(psiFactory.createCallArguments("(${outerCall.getText()})"), anchor)
             }
         }
     }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
index 455312e..03e67b1 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveFilesOrDirectories/MoveKotlinFileHandler.kt
@@ -76,7 +76,7 @@
 
             else -> DeferredJetFileKotlinMoveTarget(project, newPackageName.toSafe()) {
                 MoveFilesOrDirectoriesUtil.doMoveFile(psiFile, newParent)
-                newParent?.findFile(psiFile.name) as? JetFile
+               ^newParent?.findFile(psiFile.name) as? JetFile
             }
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
index 0e32fc8..ea366c2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/move/moveTopLevelDeclarations/MoveKotlinTopLevelDeclarationsProcessor.kt
@@ -144,7 +144,7 @@
 
                 MoveClassHandler.EP_NAME.getExtensions().forEach { handler -> handler.preprocessUsages(results) }
 
-                results
+               ^results
             }
         }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
index 56a618a..34b3124 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpData.kt
@@ -72,7 +72,7 @@
             substitution[subClassTypeParameter.typeConstructor] = TypeProjectionImpl(superClassTypeParameter.defaultType)
         }
 
-        TypeSubstitutor.create(substitution)
+       ^TypeSubstitutor.create(substitution)
     }
 
     val isInterfaceTarget: Boolean = targetClassDescriptor.kind == ClassKind.INTERFACE
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
index 9a03be1..c468ed6 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHandler.kt
@@ -78,7 +78,7 @@
                 .map {
                     val descriptor = it.constructor.declarationDescriptor
                     val declaration = descriptor?.let { DescriptorToSourceUtilsIde.getAnyDeclaration(project, it) }
-                    if ((declaration is JetClass || declaration is PsiClass)
+                   ^if ((declaration is JetClass || declaration is PsiClass)
                         && declaration.canRefactor()) declaration as PsiNamedElement else null
                 }
                 .filterNotNull()
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
index 98f0413..d68bcac 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelper.kt
@@ -146,7 +146,7 @@
         val elementsToRemove = LinkedHashSet<JetElement>()
         val commonInitializer = sourceConstructors.fold(null as JetExpression?) { commonInitializer, constructor ->
             val body = (constructor as? JetSecondaryConstructor)?.bodyExpression
-            getCommonInitializer(commonInitializer, body, propertyDescriptor, elementsToRemove)
+           ^getCommonInitializer(commonInitializer, body, propertyDescriptor, elementsToRemove)
         }
         if (commonInitializer == null) {
             elementsToRemove.clear()
@@ -180,7 +180,7 @@
                 .filterIsInstance<JetProperty>()
                 .filter {
                     val descriptor = memberDescriptors[it] as? PropertyDescriptor
-                    descriptor != null && data.sourceClassContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] ?: false
+                   ^descriptor != null && data.sourceClassContext[BindingContext.BACKING_FIELD_REQUIRED, descriptor] ?: false
                 }
     }
 
@@ -212,7 +212,7 @@
                     }
             )
         }
-        result
+       ^result
     }
 
     private val targetConstructorToPropertyInitializerInfoMap = LinkedHashMap<JetElement, Map<JetProperty, InitializerInfo>>().let { result ->
@@ -234,7 +234,7 @@
             propertyToInitializerInfo.keySet().removeAll(unmovableProperties)
             result[targetConstructor] = propertyToInitializerInfo
         }
-        result
+       ^result
     }
 
     private var dummyField: PsiField? = null
@@ -383,7 +383,7 @@
                 val newField = createJavaField(member, data.targetClass)
                 newField.typeElement?.replace(elementFactory.createTypeElement(newType))
                 member.delete()
-                newField
+               ^newField
             }
             is JetNamedFunction -> {
                 val newReturnType = substitutor.substitute(lightMethod.returnType)
@@ -407,7 +407,7 @@
                 if (!data.isInterfaceTarget && !data.targetClass.hasModifierProperty(PsiModifier.ABSTRACT)) {
                     data.targetClass.modifierList?.setModifierProperty(PsiModifier.ABSTRACT, true)
                 }
-                newMethod
+               ^newMethod
             }
             else -> return
         }
@@ -586,7 +586,7 @@
 
                 info.initializer?.let {
                     val body = constructorElement.getConstructorBodyBlock()
-                    body?.addAfter(it, body.statements.lastOrNull() ?: body.lBrace!!)
+                   ^body?.addAfter(it, body.statements.lastOrNull() ?: body.lBrace!!)
                 }
                 info.elementsToRemove.forEach { it.delete() }
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
index 0bccd04..32544cb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/KotlinPullUpHelperFactory.kt
@@ -88,7 +88,7 @@
             if (!(it is JetClass && it.isInner())) {
                 psiClass.modifierList!!.setModifierProperty(PsiModifier.STATIC, true)
             }
-            psiClass
+           ^psiClass
         }
         return outerPsiClasses
                 .drop(1)
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
index 5093f5b..377a371 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/markingUtils.kt
@@ -134,7 +134,7 @@
                     expression.newFqName?.let {
                         expression.newFqName = null
 
-                        expression.mainReference.bindToFqName(it)
+                       ^expression.mainReference.bindToFqName(it)
                     }
                 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
index 1dfb2157c..2ede765 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pullUp/pullUpUtils.kt
@@ -43,7 +43,7 @@
             if (targetClass.isInterface) return false
             if (hasModifier(JetTokens.OPEN_KEYWORD) || hasModifier(JetTokens.ABSTRACT_KEYWORD)) return false
             if (accessors.isNotEmpty() || delegateExpression != null) return false
-            true
+           ^true
         }
         is JetNamedFunction -> true
         else -> false
@@ -96,7 +96,7 @@
             .filterIsInstance<JetDelegatorToSuperClass>()
             .firstOrNull {
                 val referencedType = context[BindingContext.TYPE, it.typeReference]
-                referencedType?.constructor?.declarationDescriptor == descriptor
+               ^referencedType?.constructor?.declarationDescriptor == descriptor
             }
 }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
index 30b1daa..5c75f65 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/pushDown/KotlinPushDownProcessor.kt
@@ -138,7 +138,7 @@
                         targetClassDescriptor.findCallableMemberBySignature(it as CallableMemberDescriptor)
                     }
                     val targetMember = targetMemberDescriptor?.source?.getPsi() as? JetCallableDeclaration
-                    targetMember?.apply {
+                   ^targetMember?.apply {
                         if (memberDescriptor.modality != Modality.ABSTRACT && memberInfo.isToAbstract) {
                             addModifierWithSpace(JetTokens.OVERRIDE_KEYWORD)
                         }
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
index e249cb8..4549f6d 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinClassProcessor.kt
@@ -88,11 +88,11 @@
                 }
 
                 // Cancel rename
-                null
+               ^null
             }
             else {
                 assert(false) { "Should not be suggested to rename element of type " + element.javaClass + " " + element }
-                null
+               ^null
             }
 
         is JetConstructor<*> ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
index 8f4b71d..85ea7eb 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/rename/RenameKotlinPropertyProcessor.kt
@@ -119,7 +119,7 @@
 
         val refKindUsages = usages.toList().groupBy { usage: UsageInfo ->
             val refElement = usage.getReference()?.resolve()
-            if (refElement is PsiMethod) {
+           ^if (refElement is PsiMethod) {
                 when (refElement.getName()) {
                     oldGetterName -> UsageKind.GETTER_USAGE
                     oldSetterName -> UsageKind.SETTER_USAGE
diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
index 58ca85a..c0d9709 100644
--- a/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/safeDelete/KotlinSafeDeleteProcessor.kt
@@ -173,14 +173,14 @@
             is JetClassOrObject -> {
                 element.toLightClass()?.let { klass ->
                     findDelegationCallUsages(klass)
-                    findUsagesByJavaProcessor(klass, false)
+                   ^findUsagesByJavaProcessor(klass, false)
                 }
             }
 
             is JetSecondaryConstructor -> {
                 element.getRepresentativeLightMethod()?.let { method ->
                     findDelegationCallUsages(method)
-                    findUsagesByJavaProcessor(method, false)
+                   ^findUsagesByJavaProcessor(method, false)
                 }
             }
 
@@ -207,7 +207,7 @@
 
             is JetTypeParameter -> {
                 findTypeParameterUsages(element)
-                findUsagesByJavaProcessor(element)
+               ^findUsagesByJavaProcessor(element)
             }
 
             is JetParameter ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
index a1c568c..51f3763 100644
--- a/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/run/KotlinRunConfigurationProducer.kt
@@ -103,7 +103,7 @@
             is JetClassOrObject -> {
                 if (container is JetObjectDeclaration && container.isCompanion()) {
                     val containerClass = container.getParentOfType<JetClass>(true)
-                    containerClass?.getFqName()
+                   ^containerClass?.getFqName()
                 } else {
                     container.getFqName()
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
index 761907d..7fcac15 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinAnnotatedElementsSearcher.kt
@@ -46,11 +46,11 @@
             when (declaration) {
                 is JetClass -> {
                     val lightClass = LightClassUtil.getPsiClass(declaration)
-                    consumer.process(lightClass)
+                   ^consumer.process(lightClass)
                 }
                 is JetNamedFunction, is JetSecondaryConstructor -> {
                     val wrappedMethod = LightClassUtil.getLightClassMethod(declaration as JetFunction)
-                    consumer.process(wrappedMethod)
+                   ^consumer.process(wrappedMethod)
                 }
                 else -> true
             }
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
index d4c59cd..6fa0787 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinClassesWithAnnotatedMembersSearcher.kt
@@ -36,9 +36,9 @@
         val processed = hashSetOf<JetClassOrObject>()
         return KotlinAnnotatedElementsSearcher.processAnnotatedMembers(queryParameters.annotationClass, queryParameters.scope) { declaration ->
             val jetClass = declaration.getNonStrictParentOfType<JetClassOrObject>()
-            if (jetClass != null && processed.add(jetClass)) {
+           ^if (jetClass != null && processed.add(jetClass)) {
                 val lightClass = LightClassUtil.getPsiClass(jetClass)
-                if (lightClass != null) consumer.process(lightClass) else true
+               ^if (lightClass != null) consumer.process(lightClass) else true
             }
             else
                 true
diff --git a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
index 836b04b..c83a2bc 100644
--- a/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinOverridingMethodsWithGenericsSearcher.kt
@@ -55,7 +55,7 @@
                 findOverridingMethod(inheritor, declaration)
             }
 
-            found == null || (consumer.process(found) && p.isCheckDeep)
+           ^found == null || (consumer.process(found) && p.isCheckDeep)
         })
     }
 
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt b/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
index 73ed93f..0f08036 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/ImportInsertHelperImpl.kt
@@ -194,7 +194,7 @@
 
             val importsFromPackage = imports.count {
                 val path = it.getImportPath()
-                path != null && !path.isAllUnder() && !path.hasAlias() && path.fqnPart().parent() == packageFqName
+               ^path != null && !path.isAllUnder() && !path.hasAlias() && path.fqnPart().parent() == packageFqName
             }
             return importsFromPackage + 1 >= codeStyleSettings.NAME_COUNT_TO_USE_STAR_IMPORT
         }
@@ -210,9 +210,9 @@
                     .filter { it.isAllUnder () }
                     .map {
                         val importPath = it.getImportPath()
-                        if (importPath != null) {
+                       ^if (importPath != null) {
                             val fqName = importPath.fqnPart()
-                            getMemberScope(fqName, moduleDescriptor)
+                           ^getMemberScope(fqName, moduleDescriptor)
                         }
                         else {
                             null
@@ -390,7 +390,7 @@
                             .reverse()
                             .firstOrNull {
                                 val directivePath = it.getImportPath()
-                                directivePath != null && ImportPathComparator.compare(directivePath, importPath) <= 0
+                               ^directivePath != null && ImportPathComparator.compare(directivePath, importPath) <= 0
                             }
                     return importList.addAfter(newDirective, insertAfter) as JetImportDirective
                 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/projectStructureUtil.kt b/idea/src/org/jetbrains/kotlin/idea/util/projectStructureUtil.kt
index 58f436e..51649c2 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/projectStructureUtil.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/projectStructureUtil.kt
@@ -30,7 +30,7 @@
     forEachLibrary { library ->
         if (predicate(library!!)) {
             lib = library
-            false
+           ^false
         }
         else {
             true
diff --git a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
index d0b0fca..bdf5673 100644
--- a/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/util/psi/patternMatching/JetPsiUnifier.kt
@@ -227,7 +227,7 @@
 
                 return (args1.asSequence() zip args2.asSequence()).fold(MATCHED) { s, p ->
                     val (arg1, arg2) = p
-                    s and when {
+                   ^s and when {
                         arg1 == arg2 -> MATCHED
                         arg1 == null || arg2 == null -> UNMATCHED
                         else -> (arg1.getArguments().asSequence() zip arg2.getArguments().asSequence()).fold(MATCHED) { s, p ->
@@ -298,7 +298,7 @@
                 rc1.isSafeCall() != rc2.isSafeCall() -> UNMATCHED
                 else -> {
                     val s = checkTypeArguments()
-                    if (s != MATCHED) s else checkArguments()
+                   ^if (s != MATCHED) s else checkArguments()
                 }
             }
         }
@@ -339,7 +339,7 @@
                     val call1 = e1.getCall(e1.bindingContext)
                     val call2 = e2.getCall(e2.bindingContext)
 
-                    when {
+                   ^when {
                         call1 != null && call2 != null ->
                             if (matchCalls(call1, call2)) null else UNMATCHED
 
@@ -465,7 +465,7 @@
                 val (entry1, entry2) = p
                 val rc1 = entry1.bindingContext[BindingContext.COMPONENT_RESOLVED_CALL, entry1]
                 val rc2 = entry2.bindingContext[BindingContext.COMPONENT_RESOLVED_CALL, entry2]
-                when {
+               ^when {
                     rc1 == null && rc2 == null -> true
                     rc1 != null && rc2 != null -> matchResolvedCalls(rc1, rc2) == MATCHED
                     else -> false
@@ -634,7 +634,7 @@
             if ((sortedMembers1.size() != sortedMembers2.size())) return UNMATCHED
             if (sortedMembers1.zip(sortedMembers2).any {
                 val (d1, d2) = it
-                (matchDeclarations(d1.first, d2.first, d1.second, d2.second) ?: doUnify(d1.first, d2.first)) == UNMATCHED
+               ^(matchDeclarations(d1.first, d2.first, d1.second, d2.second) ?: doUnify(d1.first, d2.first)) == UNMATCHED
             }) return UNMATCHED
 
             return doUnify(
@@ -802,14 +802,14 @@
                     return when {
                         existingArgument == null -> {
                             substitution[parameter] = targetElementUnwrapped
-                            MATCHED
+                           ^MATCHED
                         }
                         else -> {
                             checkEquivalence = true
                             val status = doUnify(existingArgument, targetElementUnwrapped)
                             checkEquivalence = false
 
-                            status
+                           ^status
                         }
                     }
                 }
@@ -860,7 +860,7 @@
     public fun unify(target: JetPsiRange, pattern: JetPsiRange): UnificationResult {
         return with(Context(target, pattern)) {
             val status = doUnify(target, pattern)
-            when {
+           ^when {
                 substitution.size() != descriptorToParameter.size() ->
                     Unmatched
                 status == MATCHED ->
diff --git a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinAbiVersionIndex.kt b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinAbiVersionIndex.kt
index 702ef35..1717571 100644
--- a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinAbiVersionIndex.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinAbiVersionIndex.kt
@@ -83,6 +83,6 @@
             version = AbiVersionUtil.INVALID_VERSION
         }
 
-        if (version != null) mapOf(version!! to null) else mapOf()
+       ^if (version != null) mapOf(version!! to null) else mapOf()
     }
 }
diff --git a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinJavaScriptAbiVersionIndex.kt b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinJavaScriptAbiVersionIndex.kt
index 6fada6f..c88f672 100644
--- a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinJavaScriptAbiVersionIndex.kt
+++ b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinJavaScriptAbiVersionIndex.kt
@@ -56,6 +56,6 @@
             }
         }
 
-        result
+       ^result
     }
 }