Temporary rename of properties starting with "is" and used from java code (will revert back after changing accessor naming policy)

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

@@ -24,7 +24,7 @@ import org.jetbrains.kotlin.psi.JetFile
 public class CodegenFileClassesProvider(private val packageFacadesAsMultifileClasses: Boolean) : JvmFileClassesProvider {
     override public fun getFileClassInfo(file: JetFile): JvmFileClassInfo {
         val fileClassInfo = JvmFileClassUtil.getFileClassInfoNoResolve(file)
-        if (packageFacadesAsMultifileClasses && !fileClassInfo.isMultifileClass) {
+        if (packageFacadesAsMultifileClasses && !fileClassInfo.TEMP_isMultifileClass) {
             return JvmFileClassUtil.getMultifilePackageFacadePartInfo(file)
         }
         else {

compiler/backend/src/org/jetbrains/kotlin/codegen/KotlinCodegenFacade.java

@@ -71,12 +71,12 @@ public class KotlinCodegenFacade {
 
             JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
 
-            if (fileClassInfo.getIsMultifileClass()) {
+            if (fileClassInfo.getTEMP_isMultifileClass()) {
                 filesInMultifileClasses.putValue(fileClassInfo.getFacadeClassFqName(), file);
             }
 
             if (state.getPackageFacadesAsMultifileClasses()) {
-                if (!fileClassInfo.getIsMultifileClass()) {
+                if (!fileClassInfo.getTEMP_isMultifileClass()) {
                     filesInMultifileClasses.putValue(PackageClassUtils.getPackageClassFqName(file.getPackageFqName()), file);
                 }
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/PackageCodegen.java

@@ -305,7 +305,7 @@ public class PackageCodegen {
     private ClassBuilder generateFile(@NotNull JetFile file, @NotNull Map<CallableMemberDescriptor, Runnable> generateCallableMemberTasks) {
         JvmFileClassInfo fileClassInfo = state.getFileClassesProvider().getFileClassInfo(file);
 
-        if (fileClassInfo.getIsMultifileClass()) {
+        if (fileClassInfo.getTEMP_isMultifileClass()) {
             Type fileFacadeType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(fileClassInfo.getFacadeClassFqName());
             addDelegateToFileClassMemberTasks(file, generateCallableMemberTasks, fileFacadeType);
             return null;

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.inline
 import com.google.common.collect.LinkedListMultimap
 import java.util.ArrayList
 import com.intellij.util.containers.Stack
-import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
+import org.jetbrains.kotlin.codegen.optimization.common.TEMP_isMeaningful
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.*
 import java.util.Comparator
@@ -157,7 +157,7 @@ class IntervalMetaInfo<T : SplittableInterval<T>> {
 private fun Interval.isMeaningless(): Boolean {
     val start = this.startLabel
     var end: AbstractInsnNode = this.endLabel
-    while (end != start && !end.isMeaningful) {
+    while (end != start && !end.TEMP_isMeaningful) {
         end = end.getPrevious()
     }
     return start == end

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InternalFinallyBlockInliner.java

@@ -522,7 +522,7 @@ public class InternalFinallyBlockInliner extends CoveringTryCatchNodeProcessor {
     @Nullable
     private static AbstractInsnNode getNextMeaningful(@NotNull AbstractInsnNode node) {
         AbstractInsnNode result = node.getNext();
-        while (result != null && !CommonPackage.getIsMeaningful(result)) {
+        while (result != null && !CommonPackage.getTEMP_isMeaningful(result)) {
             result = result.getNext();
         }
         return result;

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

@@ -19,7 +19,7 @@ package org.jetbrains.kotlin.codegen.optimization
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
 import org.jetbrains.kotlin.codegen.optimization.common.OptimizationBasicInterpreter
-import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
+import org.jetbrains.kotlin.codegen.optimization.common.TEMP_isMeaningful
 
 public class DeadCodeEliminationMethodTransformer : MethodTransformer() {
     override fun transform(internalClassName: String, methodNode: MethodNode) {
@@ -31,7 +31,7 @@ public class DeadCodeEliminationMethodTransformer : MethodTransformer() {
         // by try/catch blocks or local variables table
         // We remove unneeded ones further after all optimizations by calling CommonPackage.prepareForEmitting(methodNode)
         insnsArray.zip(frames).filter {
-            it.second == null && it.first.isMeaningful
+            it.second == null && it.first.TEMP_isMeaningful
         }.forEach { insnList.remove(it.first) }
     }
 }

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

@@ -22,7 +22,7 @@ import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
 import org.jetbrains.org.objectweb.asm.tree.LabelNode
 import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.JumpInsnNode
-import org.jetbrains.kotlin.codegen.optimization.common.isMeaningful
+import org.jetbrains.kotlin.codegen.optimization.common.TEMP_isMeaningful
 
 public class RedundantGotoMethodTransformer : MethodTransformer() {
     /**
@@ -34,7 +34,7 @@ public class RedundantGotoMethodTransformer : MethodTransformer() {
 
         val currentLabels = hashSetOf<LabelNode>()
         for (insn in insns.reverse()) {
-            if (insn.isMeaningful) {
+            if (insn.TEMP_isMeaningful) {
                 if (insn.getOpcode() == Opcodes.GOTO && (insn as JumpInsnNode).label in currentLabels) {
                     insnsToRemove.add(insn)
                 }

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/common/Util.kt

@@ -17,14 +17,11 @@
 package org.jetbrains.kotlin.codegen.optimization.common
 
 import org.jetbrains.org.objectweb.asm.tree.AbstractInsnNode
-import org.jetbrains.org.objectweb.asm.Opcodes
 import org.jetbrains.org.objectweb.asm.tree.InsnList
-import org.jetbrains.org.objectweb.asm.tree.LabelNode
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 import org.jetbrains.org.objectweb.asm.tree.MethodNode
+import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
 
-val AbstractInsnNode.isMeaningful : Boolean get() =
+val AbstractInsnNode.TEMP_isMeaningful: Boolean get() =
     when (this.getType()) {
         AbstractInsnNode.LABEL, AbstractInsnNode.LINE, AbstractInsnNode.FRAME -> false
         else -> true
@@ -49,21 +46,21 @@ public class InsnSequence(val from: AbstractInsnNode, val to: AbstractInsnNode?)
 fun MethodNode.prepareForEmitting() {
     tryCatchBlocks = tryCatchBlocks.filter { tcb ->
         InsnSequence(tcb.start, tcb.end).any { insn ->
-            insn.isMeaningful
+            insn.TEMP_isMeaningful
         }
     }
 
     // local variables with live ranges starting after last meaningful instruction lead to VerifyError
     localVariables = localVariables.filter { lv ->
         InsnSequence(lv.start, lv.end).any { insn ->
-            insn.isMeaningful
+            insn.TEMP_isMeaningful
         }
     }
 
     // We should remove linenumbers after last meaningful instruction
     // because they point to index of non-existing instruction and it leads to VerifyError
     var current = instructions.getLast()
-    while (!current.isMeaningful) {
+    while (!current.TEMP_isMeaningful) {
         val prev = current.getPrevious()
 
         if (current.getType() == AbstractInsnNode.LINE) {