[experiment] Insert '^' before result expressions

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/CodegenUtilKt.kt

@@ -58,14 +58,14 @@ public object CodegenUtilKt {
                             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()
             }
     }
 }

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

@@ -39,7 +39,7 @@ open public class AbstractAccessorForFunctionDescriptor(
             copy.addUpperBound(upperBound)
         }
         copy.setInitialized()
-        copy
+       ^copy
     }
 
     protected fun copyValueParameters(descriptor: FunctionDescriptor): List<ValueParameterDescriptor> =

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

@@ -79,7 +79,7 @@ public class MultifileClassCodegen(
         if (singleSourceFile != null) {
             classBuilder.visitSource(singleSourceFile.name, null)
         }
-        classBuilder
+       ^classBuilder
     }
 
     public fun generate(errorHandler: CompilationErrorHandler) {

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

@@ -116,7 +116,7 @@ public class PropertyReferenceCodegen(
             val getter = target.getGetter() ?: run {
                 val defaultGetter = DescriptorFactory.createDefaultGetter(target, Annotations.EMPTY)
                 defaultGetter.initialize(target.getType())
-                defaultGetter
+               ^defaultGetter
             }
 
             val method = typeMapper.mapSignature(getter).getAsmMethod()

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

@@ -53,6 +53,6 @@ private fun List<PackageParts>.addCompiledParts(state: GenerationState): List<Pa
                 val (packageFqName, packageParts) = it
                 val newPackageParts = PackageParts(packageFqName)
                 packageParts.forEach { newPackageParts.parts.addAll(it.parts) }
-                newPackageParts
+               ^newPackageParts
             }
 }

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

@@ -67,7 +67,7 @@ public abstract class CoveringTryCatchNodeProcessor(parameterSize: Int) {
                     result = instructionIndex(t1.endLabel) - instructionIndex(t2.endLabel)
                 }
             }
-            result
+           ^result
         }
 
         Collections.sort<TryCatchBlockNodeInfo>(intervals, comp)
@@ -197,12 +197,12 @@ public class LocalVarNodeWrapper(val node: LocalVariableNode) : Interval, Splitt
         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(

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

@@ -33,7 +33,7 @@ public class SMAPBuilder(val source: String,
     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()) {

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

@@ -36,7 +36,7 @@ class SMAPAndMethodNode(val node: MethodNode, val classSMAP: SMAP) {
             }
             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();

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

@@ -63,12 +63,12 @@ class TryCatchBlockNodeInfo(val node: TryCatchBlockNode, val onlyCopyNotProcess:
         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,

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

@@ -40,12 +40,12 @@ public fun FunctionDescriptor.getClassFilePath(cache: IncrementalCache): String
         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)
         }
     }
 }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/LabelNormalizationMethodTransformer.kt

@@ -100,7 +100,7 @@ public class LabelNormalizationMethodTransformer : MethodTransformer() {
                 val newTcb = TryCatchBlockNode(getNew(oldTcb.start), getNew(oldTcb.end), getNew(oldTcb.handler), oldTcb.type)
                 newTcb.visibleTypeAnnotations = oldTcb.visibleTypeAnnotations
                 newTcb.invisibleTypeAnnotations = oldTcb.invisibleTypeAnnotations
-                newTcb
+               ^newTcb
             }
         }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/fixStack/AnalyzeTryCatchBlocks.kt

@@ -56,7 +56,7 @@ internal fun insertTryCatchBlocksMarkers(methodNode: MethodNode) {
 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)

compiler/frontend.java/src/org/jetbrains/kotlin/fileClasses/JvmFileClassUtil.kt

@@ -124,6 +124,6 @@ public val JetFile.javaFileFacadeFqName: FqName
             val facadeFqName =
                     if (isCompiled) packageFqName.child(Name.identifier(virtualFile.nameWithoutExtension))
                     else JvmFileClassUtil.getFileClassInfoNoResolve(this).facadeClassFqName
-            CachedValueProvider.Result(facadeFqName, this)
+           ^CachedValueProvider.Result(facadeFqName, this)
         }
     }

compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt

@@ -115,7 +115,7 @@ public fun createContainerForTopDownAnalyzerForJvm(
 }.let {
     it.javaAnalysisInit()
 
-    ContainerForTopDownAnalyzerForJvm(it)
+   ^ContainerForTopDownAnalyzerForJvm(it)
 }
 
 private fun StorageComponentContainer.javaAnalysisInit() {

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaPackageImpl.kt

@@ -30,7 +30,7 @@ public class JavaPackageImpl(psiPackage: PsiPackage, private val scope: GlobalSe
     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)
     }

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/VirtualFileKotlinClass.kt

@@ -73,7 +73,7 @@ public class VirtualFileKotlinClass private constructor(
                 catch (e: Throwable) {
                     LOG.warn(renderFileReadingErrorMessage(file))
                 }
-                null
+               ^null
             }
         }
 

compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/incremental/IncrementalPackageFragmentProvider.kt

@@ -111,20 +111,20 @@ public class IncrementalPackageFragmentProvider(
                                     }
                                     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>()
                     )

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/JvmAnalyzerFacade.kt

@@ -62,7 +62,7 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmPlatformParameters>() {
 
         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,

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/ReflectionAPICallChecker.kt

@@ -42,7 +42,7 @@ class ReflectionAPICallChecker(private val module: ModuleDescriptor, storageMana
 
     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) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/jvmSignature/KotlinToJvmSignatureMapper.kt

@@ -30,6 +30,6 @@ fun erasedSignaturesEqualIgnoringReturnTypes(subFunction: JvmMethodSignature, su
 
     return subParams.zip(superParams).all {
         p -> val (subParam, superParam) = p
-        subParam.getAsmType() == superParam.getAsmType()
+       ^subParam.getAsmType() == superParam.getAsmType()
     }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt

@@ -130,7 +130,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp
             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
         }
 

compiler/frontend/src/org/jetbrains/kotlin/analyzer/AnalyzerFacade.kt

@@ -184,7 +184,7 @@ public abstract class AnalyzerFacade<in P : PlatformAnalysisParameters> {
                 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)

compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariableDataCollector.kt

@@ -68,7 +68,7 @@ public class PseudocodeVariableDataCollector(
             val lexicalScope = lexicalScopeVariableInfo.declaredIn[variable]
             // '-1' for variables declared outside this pseudocode
             val depth = lexicalScope?.depth ?: -1
-            depth <= toDepth
+           ^depth <= toDepth
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/cfg/UnreachableCode.kt

@@ -103,7 +103,7 @@ class UnreachableCodeImpl(
             currentTextRange, element ->
 
             val elementRange = element.getTextRange()!!
-            if (currentTextRange == null) {
+           ^if (currentTextRange == null) {
                 elementRange
             }
             else if (currentTextRange.getEndOffset() == elementRange.getStartOffset()) {
@@ -111,7 +111,7 @@ class UnreachableCodeImpl(
             }
             else {
                 result.add(currentTextRange)
-                elementRange
+               ^elementRange
             }
         }
         if (lastRange != null) {

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt

@@ -192,7 +192,7 @@ public fun getExpectedTypePredicate(value: PseudoValue, bindingContext: BindingC
                                 else ->
                                     parameter.getType()
                             }
-                            addSubtypesOf(expectedType)
+                           ^addSubtypesOf(expectedType)
                         }
                     }
                 }

compiler/frontend/src/org/jetbrains/kotlin/descriptors/annotations/AnnotationSplitter.kt

@@ -104,7 +104,7 @@ public class AnnotationSplitter(
 
             other.add(annotationWithTarget)
         }
-        map to AnnotationsImpl.create(other)
+       ^map to AnnotationsImpl.create(other)
     }
 
     public fun getOtherAnnotations(): Annotations = LazySplitAnnotations(storageManager, null)
@@ -119,7 +119,7 @@ public class AnnotationSplitter(
         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

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -60,7 +60,7 @@ public object Renderers {
                      + "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 object Renderers {
     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 object Renderers {
     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 @@ public object Renderers {
             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()) {

compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt

@@ -118,7 +118,7 @@ abstract public class JetClassOrObject :
             val typeReference = entry.getTypeReference()
             val userType = typeReference?.getStubOrPsiChild(JetStubElementTypes.USER_TYPE)
 
-            name == userType?.getReferencedName()
+           ^name == userType?.getReferencedName()
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/psi/JetPrimaryConstructor.kt

@@ -66,7 +66,7 @@ public class JetPrimaryConstructor : JetConstructor<JetPrimaryConstructor> {
         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()
         }
     }
 }

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

compiler/frontend/src/org/jetbrains/kotlin/psi/TypeRefHelpers.kt

@@ -68,7 +68,7 @@ fun JetCallableDeclaration.setReceiverTypeReference(typeRef: JetTypeReference?):
                     val anchor = getNameIdentifier()
                     val newTypeRef = addBefore(typeRef, anchor) as JetTypeReference
                     addAfter(JetPsiFactory(getProject()).createDot(), newTypeRef)
-                    newTypeRef
+                   ^newTypeRef
                 }
         if (needParentheses) {
             val argList = JetPsiFactory(getProject()).createCallArguments("()")

compiler/frontend/src/org/jetbrains/kotlin/psi/createByPattern.kt

@@ -96,7 +96,7 @@ public fun <TElement : JetElement> createByPattern(pattern: String, vararg args:
     @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 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
                         check(endIndex > i, "empty placeholder text")
                         val text = pattern.substring(i, endIndex)
                         i = endIndex + 1
-                        text
+                       ^text
                     }
 
                     append(placeholderText)
@@ -232,7 +232,7 @@ private fun processPattern(pattern: String, args: List<Any>): PatternData {
             else {
                 append(c)
             }
-            i++
+           ^i++
         }
     }.toString()
 

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/PsiChildRange.kt

@@ -37,7 +37,7 @@ public data class PsiChildRange(public val first: PsiElement?, public val last:
         }
         else {
             val afterLast = last!!.getNextSibling()
-            first.siblings().takeWhile { it != afterLast }
+           ^first.siblings().takeWhile { it != afterLast }
         }
         return sequence.iterator()
     }

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/jetPsiUtil.kt

@@ -68,7 +68,7 @@ public fun JetSimpleNameExpression.getQualifiedElement(): JetElement {
 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 @@ public fun JetElement.getQualifiedElementSelector(): JetElement? {
         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

compiler/frontend/src/org/jetbrains/kotlin/psi/psiUtil/psiUtils.kt

@@ -258,7 +258,7 @@ public fun PsiFile.elementsInRange(range: TextRange): List<PsiElement> {
                 .parentsWithSelf
                 .first {
                     val parent = it.getParent()
-                    it is PsiFile || parent.getTextRange() !in currentRange
+                   ^it is PsiFile || parent.getTextRange() !in currentRange
                 }
         result.add(element)
 

compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinStubBaseImpl.kt

@@ -58,11 +58,11 @@ public open class KotlinStubBaseImpl<T : JetElementImplStub<*>>(parent: StubElem
         return try {
             val value = property.invoke(this)
             val name = getPropertyName(property)
-            "$name=$value"
+           ^"$name=$value"
         }
         catch (e: Exception) {
             LOGGER.error(e)
-            null
+           ^null
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt

@@ -54,7 +54,7 @@ private fun CallableDescriptor.isPlatformStaticIn(predicate: (DeclarationDescrip
         when (this) {
             is PropertyAccessorDescriptor -> {
                 val propertyDescriptor = getCorrespondingProperty()
-                predicate(propertyDescriptor.getContainingDeclaration()) &&
+               ^predicate(propertyDescriptor.getContainingDeclaration()) &&
                 (hasPlatformStaticAnnotation() || propertyDescriptor.hasPlatformStaticAnnotation())
             }
             else -> predicate(getContainingDeclaration()) && hasPlatformStaticAnnotation()
@@ -77,7 +77,7 @@ public fun KotlinBuiltIns.buildMigrationAnnotationDescriptors(): List<Annotation
                 /* nullable = */false, /* arguments = */emptyList()
         )
 
-        AnnotationDescriptorImpl(
+       ^AnnotationDescriptorImpl(
                 type,
                 emptyMap(), SourceElement.NO_SOURCE
         )

compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorEquivalenceForOverrides.kt

@@ -80,7 +80,7 @@ object DescriptorEquivalenceForOverrides {
 
             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

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -122,7 +122,7 @@ class FunctionDescriptorResolver(
         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 {

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.kt

@@ -57,7 +57,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
             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 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
 
         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 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
                     } 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 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
                 else -> null
             }
             storageResult(trace, qualifierPart.expression, listOfNotNull(nextDescriptor), shouldBeVisibleFrom, inImport)
-            nextDescriptor
+           ^nextDescriptor
         }
     }
 
@@ -312,7 +312,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
                 return Pair(packageDescriptor, prefixSize)
             }
             fqName = fqName.parent()
-            prefixSize--
+           ^prefixSize--
         }
         return Pair(getPackage(FqName.ROOT), 0)
     }
@@ -330,7 +330,7 @@ public class QualifiedExpressionResolver(val symbolUsageValidator: SymbolUsageVa
                 "Containing Declaration must be not null for package with fqName: ${currentView.fqName}, " +
                 "path: ${path.joinToString()}, packageView fqName: ${packageView.fqName}"
             }
-            parentView!!
+           ^parentView!!
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeBinding.kt

@@ -78,7 +78,7 @@ private class ExplicitTypeBinding(
         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 @@ private class NoTypeElementBinding<out P : PsiElement>(
         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())

compiler/frontend/src/org/jetbrains/kotlin/resolve/TypeResolver.kt

@@ -278,11 +278,11 @@ public class TypeResolver(
 
             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 @@ public class TypeResolver(
                         }
                     }
                 }
-                TypeProjectionImpl(kind, type)
+               ^TypeProjectionImpl(kind, type)
             }
 
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/callableReferences/CallableReferencesResolutionUtils.kt

@@ -155,7 +155,7 @@ public fun resolveCallableReferenceTarget(
     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 @@ private fun createReflectionTypeForCallableDescriptor(
             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")

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallCompleter.kt

@@ -159,7 +159,7 @@ public class CallCompleter(
             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 @@ public class CallCompleter(
             updateSystemIfSuccessful {
                 system ->
                 system.addSupertypeConstraint(builtIns.getUnitType(), returnType, EXPECTED_TYPE_POSITION.position())
-                system.getStatus().isSuccessful()
+               ^system.getStatus().isSuccessful()
             }
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CandidateResolver.kt

@@ -181,9 +181,9 @@ public class CandidateResolver(
         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 @@ public class CandidateResolver(
     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 @@ public class CandidateResolver(
             "Shouldn't happen because of TaskPrioritizer: $candidateDescriptor"
         }
 
-        SUCCESS
+       ^SUCCESS
     }
 
     private fun checkOuterClassMemberIsAccessible(context: CallCandidateResolutionContext<*>): Boolean {
@@ -282,7 +282,7 @@ public class CandidateResolver(
             && !KotlinBuiltIns.isExtensionFunctionType(candidateCall.getDispatchReceiver().getType())
         ) {
             tracing.freeFunctionCalledAsExtension(trace)
-            OTHER_ERROR
+           ^OTHER_ERROR
         } else {
             SUCCESS
         }
@@ -399,7 +399,7 @@ public class CandidateResolver(
 
         val erasedReceiverType = getErasedReceiverType(receiverParameterDescriptor, candidateDescriptor)
 
-        if (!smartCastManager.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, this)) {
+       ^if (!smartCastManager.isSubTypeBySmartCastIgnoringNullability(receiverArgument, erasedReceiverType, this)) {
             RECEIVER_TYPE_ERROR
         } else {
             SUCCESS

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt

@@ -209,7 +209,7 @@ class GenericCandidateResolver(
                     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)
                     }
                 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/TaskPrioritizer.kt

@@ -200,7 +200,7 @@ public class TaskPrioritizer(
                             c.context.call
                     )
                 }
-                members
+               ^members
             }
         }
     }
@@ -221,7 +221,7 @@ public class TaskPrioritizer(
                 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 @@ public class TaskPrioritizer(
         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 @@ public class TaskPrioritizer(
             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)
             }
         }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt

@@ -49,7 +49,7 @@ fun createSynthesizedInvokes(functions: Collection<FunctionDescriptor>): Collect
                     true
             )
             fakeOverride.addOverriddenDescriptor(synthesizedSuperFun)
-            fakeOverride
+           ^fakeOverride
         }
 
         result.add(synthesized.substitute(TypeSubstitutor.create(invoke.getDispatchReceiverParameter()!!.getType()))!!)

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/callUtil.kt

@@ -53,7 +53,7 @@ public fun <D : CallableDescriptor> ResolvedCall<D>.hasTypeMismatchErrorOnParame
 
     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
     }
 }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -766,7 +766,7 @@ private fun createCompileTimeConstantForEquals(result: Any?, operationReference:
             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()}")
         }

compiler/frontend/src/org/jetbrains/kotlin/resolve/diagnostics/MutableDiagnosticsWithSuppression.kt

@@ -34,7 +34,7 @@ public class MutableDiagnosticsWithSuppression(
     //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()!!

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/LazyImportScope.kt

@@ -58,7 +58,7 @@ class AliasImportsIndexed(allImports: Collection<JetImportDirective>) : IndexedI
             builder.put(importedName, directive)
         }
 
-        builder.build()
+       ^builder.build()
     }
 
     override fun importsForName(name: Name) = nameToDirectives.get(name)
@@ -92,13 +92,13 @@ class LazyImportResolver(
 
             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 @@ class LazyImportResolver(
                         PlatformTypesMappedToKotlinChecker.checkPlatformTypesMappedToKotlin(moduleDescriptor, traceForImportResolve, directive, descriptors)
 
                         importResolveStatus = ImportResolveStatus(directiveImportScope, descriptors)
-                        directiveImportScope
+                       ^directiveImportScope
                     }
                     finally {
                         directiveUnderResolve = null
@@ -200,7 +200,7 @@ class LazyImportResolver(
                 descriptors = descriptors.concat(descriptorsForImport)
             }
 
-            descriptors ?: emptySet<D>()
+           ^descriptors ?: emptySet<D>()
         }
     }
 
@@ -233,7 +233,7 @@ class LazyImportScope(
     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 @@ class LazyImportScope(
                     descriptors.addAll(importResolver.getImportScope(directive).getDescriptors(kindFilter, nameFilter))
                 }
             }
-            descriptors
+           ^descriptors
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/AbstractPsiBasedDeclarationProvider.kt

@@ -66,7 +66,7 @@ public abstract class AbstractPsiBasedDeclarationProvider(storageManager: Storag
     private val index = storageManager.createLazyValue<Index> {
         val index = Index()
         doCreateIndex(index)
-        index
+       ^index
     }
 
     protected abstract fun doCreateIndex(index: Index)

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/declarations/CliDeclarationProviderFactoryService.kt

@@ -34,7 +34,7 @@ public class CliDeclarationProviderFactoryService(private val sourceFiles: Colle
         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)

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/ClassResolutionScopesSupport.kt

@@ -44,7 +44,7 @@ class ClassResolutionScopesSupport(
             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 @@ class ClassResolutionScopesSupport(
     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 @@ class ClassResolutionScopesSupport(
         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 ->

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyAnnotations.kt

@@ -62,7 +62,7 @@ public class LazyAnnotations(
 
         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 @@ public class LazyAnnotations(
                 .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 @@ public class LazyAnnotations(
                 .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 @@ public class LazyAnnotationDescriptor(
         @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<*>>

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -256,7 +256,7 @@ public open class LazyClassMemberScope(
 
             result.addAll(functions)
 
-            n++
+           ^n++
         }
         result.addAll(getFunctions(Name.identifier("copy"), location))
     }
@@ -303,7 +303,7 @@ public open class LazyClassMemberScope(
                     thisDescriptor.getScopeForClassHeaderResolution(), thisDescriptor, constructor, trace
             )
             setDeferredReturnType(descriptor)
-            descriptor
+           ^descriptor
         }
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptClassMemberScope.kt

@@ -40,7 +40,7 @@ public class LazyScriptClassMemberScope protected constructor(
 
     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> {

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt

@@ -85,7 +85,7 @@ public class LazyScriptDescriptor(
                     scriptBodyResolver.resolveScriptReturnType(jetScript, this, resolveSession.getTrace())
                 }
         )
-        result
+       ^result
     }
 
     override fun getScriptCodeDescriptor() = scriptCodeDescriptor()

compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/utils/ScopeUtils.kt

@@ -48,7 +48,7 @@ public fun LexicalScope.getImplicitReceiversHierarchy(): List<ReceiverParameterD
         if (it is MemberScopeToFileScopeAdapter) {
             jetScopeRefactoringHack = it.memberScope
         }
-        it.implicitReceiver
+       ^it.implicitReceiver
     }
 
     return if (jetScopeRefactoringHack != null) {

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt

@@ -206,7 +206,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express
                 && !JetTypeChecker.DEFAULT.isSubtypeOf(type, expectedReturnType)) {
                 context.trace.report(EXPECTED_RETURN_TYPE_MISMATCH.on(it, expectedReturnType))
             }
-            type
+           ^type
         }
 
         val expectedType = declaredReturnType ?: (expectedReturnType ?: NO_EXPECTED_TYPE)

compiler/serialization/src/org/jetbrains/kotlin/serialization/AnnotationSerializer.kt

@@ -44,7 +44,7 @@ public class AnnotationSerializer() {
                 addArgument(argument)
             }
 
-            build()
+           ^build()
         }
     }
 
@@ -128,6 +128,6 @@ public class AnnotationSerializer() {
             }
         }, Unit)
 
-        this
+       ^this
     }
 }

idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt

@@ -49,7 +49,7 @@ public class ShadowedDeclarationsFilter(
 
     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> {

idea/ide-common/src/org/jetbrains/kotlin/idea/util/extensionsUtils.kt

@@ -109,7 +109,7 @@ public fun CallableDescriptor.substituteExtensionIfCallable(
                 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 @@ public fun ReceiverValue.getThisReceiverOwner(bindingContext: BindingContext): D
     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()

idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt

@@ -61,7 +61,7 @@ public fun JetScope.getImplicitReceiversWithInstanceToExpression(): Map<Receiver
         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

idea/ide-common/src/org/jetbrains/kotlin/resolve/lazy/PartialBodyResolveFilter.kt

@@ -94,7 +94,7 @@ class PartialBodyResolveFilter(
             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 @@ class PartialBodyResolveFilter(
                 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 @@ class PartialBodyResolveFilter(
 
                 is JetContainerNode -> { //TODO - not quite correct
                     val pparent = parent.getParent() as? JetExpression
-                    pparent != null && isValueNeeded(pparent)
+                   ^pparent != null && isValueNeeded(pparent)
                 }
 
                 is JetDeclarationWithBody -> {

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

@@ -77,7 +77,7 @@ public class CodeFragmentAnalyzer(
                            if (parent is JetWhenEntry || parent is JetIfExpression || parent is JetBlockExpression) return this
                            if (parent is JetExpression) return parent
                        }
-                       null
+                      ^null
                    }
                } ?: this
     }

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

@@ -233,7 +233,7 @@ public class IDELightClassGenerationSupport(private val project: Project) : Ligh
         return groupedByFqNameAndModuleInfo.flatMap {
             val (key, files) = it
             val (fqName, moduleInfo) = key
-            createLightClassForFileFacade(fqName, files, moduleInfo)
+           ^createLightClassForFileFacade(fqName, files, moduleInfo)
         }
     }
 

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

@@ -49,11 +49,11 @@ private fun orderEntryToModuleInfo(project: Project, orderEntry: OrderEntry, pro
         }
         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 @@ fun ideaModelDependencies(module: Module, productionOnly: Boolean): List<IdeaMod
     dependencyEnumerator.forEach {
         orderEntry ->
         result.addAll(orderEntryToModuleInfo(module.getProject(), orderEntry!!, productionOnly))
-        true
+       ^true
     }
     return result.toList()
 }

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

@@ -87,7 +87,7 @@ private fun JavaDescriptorResolver.getContainingScope(member: JavaMember): JetSc
 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<*> ->

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

@@ -29,7 +29,7 @@ public object JsProjectDetector {
     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))
         }
     }
 }

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

@@ -96,7 +96,7 @@ public class KotlinCacheService(val project: Project) {
         return when {
             syntheticFileModule is ModuleSourceInfo -> {
                 val dependentModules = syntheticFileModule.getDependentModules()
-                ProjectResolutionFacade(project) {
+               ^ProjectResolutionFacade(project) {
                     globalResolveSessionProvider(
                             project,
                             targetPlatform,
@@ -126,7 +126,7 @@ public class KotlinCacheService(val project: Project) {
                 // 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,

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

@@ -44,7 +44,7 @@ public class LibraryDependenciesCache(private val project: Project) {
         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

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

@@ -58,7 +58,7 @@ fun createModuleResolverProvider(
         val jvmPlatformParameters = JvmPlatformParameters {
             javaClass: JavaClass ->
             val psiClass = (javaClass as JavaClassImpl).getPsi()
-            psiClass.getModuleInfo()
+           ^psiClass.getModuleInfo()
         }
 
         val resolverForProject = analyzerFacade.setupResolverForProject(

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

@@ -61,7 +61,7 @@ private class ProjectResolutionFacade(
                         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 @@ private class ProjectResolutionFacade(
             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 })

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

@@ -85,6 +85,6 @@ private fun getModuleIndex(project: Project): ModuleIndex {
                 }
             }
         }
-        CachedValueProvider.Result(index, ProjectRootModificationTracker.getInstance(project))
+       ^CachedValueProvider.Result(index, ProjectRootModificationTracker.getInstance(project))
     }!!
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/codeInsight/shorten/shortenWaitingSet.kt

@@ -76,7 +76,7 @@ public fun performDelayedShortening(project: Project) {
         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())
     }
 }
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/configuration/ModuleTypeCache.kt

@@ -42,7 +42,7 @@ class ModuleTypeCacheManager private constructor(project: Project) {
             {
                 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

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/kotlinFileViewProviders.kt

@@ -39,7 +39,7 @@ abstract class KotlinClassFileViewProvider(
 
         (psiFile as? PsiFileImpl)?.markInvalidated()
 
-        text
+       ^text
     }
 
     override fun createFile(project: Project, file: VirtualFile, fileType: FileType): PsiFile? {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt

@@ -58,7 +58,7 @@ private class ClassClsStubBuilder(
         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

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/KotlinClsStubBuilder.kt

@@ -75,18 +75,18 @@ public open class KotlinClsStubBuilder : ClsStubBuilder() {
             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")
         }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt

@@ -49,7 +49,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) {
 
         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 =

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

@@ -75,7 +75,7 @@ public fun buildDecompiledText(
         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}")

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

@@ -38,7 +38,7 @@ public class KotlinJavaScriptDeserializerForDecompiler(
         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)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt

@@ -103,7 +103,7 @@ public object UsageTypeUtils {
 
                 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
 

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/IdeRenderers.kt

@@ -44,7 +44,7 @@ public object IdeRenderers {
         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 object IdeRenderers {
 
     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 @@ public object IdeRenderers {
             .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 {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/IntentionBasedInspection.kt

@@ -64,7 +64,7 @@ public abstract class IntentionBasedInspection<TElement : JetElement>(
                         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)) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/ResolveElementCache.kt

@@ -272,7 +272,7 @@ public class ResolveElementCache(
             is JetImportList -> {
                 val scope = resolveSession.getFileScopeProvider().getFileScope(resolveElement.getContainingJetFile())
                 scope.forceResolveAllImports()
-                resolveSession.getTrace()
+               ^resolveSession.getTrace()
             }
 
             is JetAnnotationEntry -> annotationAdditionalResolve(resolveSession, resolveElement)
@@ -432,7 +432,7 @@ public class ResolveElementCache(
 
         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)

idea/idea-analysis/src/org/jetbrains/kotlin/idea/refactoring/fqName/fqNameUtil.kt

@@ -37,7 +37,7 @@ public fun PsiElement.getKotlinFqName(): FqName? {
         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 @@ fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement {
     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 @@ fun JetSimpleNameExpression.changeQualifiedName(fqName: FqName): JetElement {
     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

idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/JetReferenceContributor.kt

@@ -34,7 +34,7 @@ public class JetReferenceContributor() : PsiReferenceContributor() {
             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))

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/ideaExtensions/KotlinReferencesSearcher.kt

@@ -64,7 +64,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
 
         val words = runReadAction {
             val classNameForCompanionObject = unwrappedElement.getClassNameForCompanionObject()
-            unwrappedElement.getSpecialNamesToSearch() +
+           ^unwrappedElement.getSpecialNamesToSearch() +
                 (if (classNameForCompanionObject != null) listOf(classNameForCompanionObject) else emptyList())
         }
 
@@ -142,7 +142,7 @@ public class KotlinReferencesSearcher : QueryExecutorBase<PsiReference, Referenc
             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

idea/idea-analysis/src/org/jetbrains/kotlin/idea/search/usagesSearch/utils.kt

@@ -62,7 +62,7 @@ fun PsiReference.checkUsageVsOriginalDescriptor(
             .filterIsInstance<JetDeclaration>()
             .any {
                 val usageDescriptor = declarationToDescriptor(it)
-                usageDescriptor != null && checker(usageDescriptor, targetDescriptor)
+               ^usageDescriptor != null && checker(usageDescriptor, targetDescriptor)
             }
 }
 
@@ -85,7 +85,7 @@ fun PsiReference.isConstructorUsage(jetClassOrObject: JetClassOrObject): Boolean
         return declaration == jetClassOrObject || (declaration is JetConstructor<*> && declaration.getContainingClassOrObject() == jetClassOrObject)
     }
 
-    checkJavaUsage() || checkKotlinUsage()
+   ^checkJavaUsage() || checkKotlinUsage()
 }
 
 private fun JetElement.getConstructorCallDescriptor(): DeclarationDescriptor? {
@@ -145,7 +145,7 @@ private fun processInheritorsDelegatingCallToSpecifiedConstructor(
 ): 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 @@ fun PsiReference.isExtensionOfDeclarationClassUsage(declaration: JetNamedDeclara
                         usageDescriptor.getExtensionReceiverParameter()?.getType()?.getConstructor()?.getDeclarationDescriptor()
                 val containingDescriptor = targetDescriptor.getContainingDeclaration()
 
-                containingDescriptor == receiverDescriptor
+               ^containingDescriptor == receiverDescriptor
                 || (containingDescriptor is ClassDescriptor
                     && receiverDescriptor is ClassDescriptor
                     && DescriptorUtils.isSubclass(containingDescriptor, receiverDescriptor))

idea/idea-analysis/src/org/jetbrains/kotlin/idea/stubindex/PackageIndexUtil.kt

@@ -69,7 +69,7 @@ public object PackageIndexUtil {
                 JetExactPackagesIndex.getInstance().getKey(), packageFqName.asString(), project, searchScope, javaClass<JetFile>()
         ) {
             result = true
-            false
+           ^false
         }
         return result
     }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/JetPsiPrecedences.kt

@@ -51,9 +51,9 @@ public object JetPsiPrecedences {
             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
             }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/util/ShortenReferences.kt

@@ -89,7 +89,7 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
                     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 @@ public class ShortenReferences(val options: (JetElement) -> Options = { Options.
                             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

idea/idea-analysis/src/org/jetbrains/kotlin/idea/vfilefinder/fileIndexes.kt

@@ -54,7 +54,7 @@ abstract class KotlinFileIndexBase<T>(private val classOfIndex: Class<T>) : Scal
             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 @@ abstract class KotlinFileIndexBase<T>(private val classOfIndex: Class<T>) : Scal
                 }
                 catch (e: Throwable) {
                     LOG.warn("Error while indexing file " + it.getFileName(), e)
-                    emptyMap()
+                   ^emptyMap()
                 }
             }
 }
@@ -80,7 +80,7 @@ public object KotlinClassFileIndex : KotlinFileIndexBase<KotlinClassFileIndex>(j
 
     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
     }
 }
 

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/BasicCompletionSession.kt

@@ -184,7 +184,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
         if (parameters.isAutoPopup) {
             collector.addLookupElementPostProcessor { lookupElement ->
                 lookupElement.putUserData(LookupCancelWatcher.AUTO_POPUP_AT, position.startOffset)
-                lookupElement
+               ^lookupElement
             }
         }
 
@@ -203,7 +203,7 @@ class BasicCompletionSession(configuration: CompletionSessionConfiguration,
             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)

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionSession.kt

@@ -125,7 +125,7 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
     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 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
 
             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 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
             } ?: 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 @@ abstract class CompletionSession(protected val configuration: CompletionSessionC
             collector.addLookupElementPostProcessor { lookupElement ->
                 // we should put data into the original element because of DecoratorCompletionStatistician
                 lookupElement.putUserDataDeep(STATISTICS_INFO_CONTEXT_KEY, statisticsContext)
-                lookupElement
+               ^lookupElement
             }
         }
 

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/CompletionUtils.kt

@@ -134,7 +134,7 @@ fun PrefixMatcher.asNameFilter() = { name: Name ->
     }
     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 {

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt

@@ -300,12 +300,12 @@ class ExpectedInfos(
         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 @@ class ExpectedInfos(
             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 @@ class ExpectedInfos(
                     .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 @@ class ExpectedInfos(
         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