Remove obsolete -X compiler arguments for JVM backend

-Xno-exception-on-explicit-equals-for-boxed-null
-Xstrict-java-nullability-assertions
-Xuse-old-spilled-var-type-analysis
-Xpolymorphic-signature

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineCodegen.kt

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializationBindings.METHOD_FOR_FUNCTION
 import org.jetbrains.kotlin.codegen.serialization.JvmSerializerExtension
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor
@@ -526,7 +525,6 @@ class CoroutineCodegenForLambda private constructor(
                         reportSuspensionPointInsideMonitor = { reportSuspensionPointInsideMonitor(element, state, it) },
                         lineNumber = CodegenUtil.getLineNumberForElement(element, false) ?: 0,
                         sourceFile = element.containingKtFile.name,
-                        useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS),
                         initialVarsCountByType = varsCountByType
                     )
                     val maybeWithForInline = if (forInline)

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/CoroutineTransformerMethodVisitor.kt

@@ -59,8 +59,6 @@ class CoroutineTransformerMethodVisitor(
     private val internalNameForDispatchReceiver: String? = null,
     // JVM_IR backend generates $completion, while old backend does not
     private val putContinuationParameterToLvt: Boolean = true,
-    // New SourceInterpreter-less analyser can be somewhat unstable, disable it
-    private val useOldSpilledVarTypeAnalysis: Boolean = false,
     // Parameters of suspend lambda are put to the same fields as spilled variables
     private val initialVarsCountByType: Map<Type, Int> = emptyMap()
 ) : TransformationMethodVisitor(delegate, access, name, desc, signature, exceptions) {
@@ -583,9 +581,7 @@ class CoroutineTransformerMethodVisitor(
 
     private fun spillVariables(suspensionPoints: List<SuspensionPoint>, methodNode: MethodNode): List<List<SpilledVariableAndField>> {
         val instructions = methodNode.instructions
-        val frames =
-            if (useOldSpilledVarTypeAnalysis) performRefinedTypeAnalysis(methodNode, containingClassInternalName)
-            else performSpilledVariableFieldTypesAnalysis(methodNode, containingClassInternalName)
+        val frames = performSpilledVariableFieldTypesAnalysis(methodNode, containingClassInternalName)
 
         fun AbstractInsnNode.index() = instructions.indexOf(this)
 

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/SuspendFunctionGenerationStrategy.kt

@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.codegen.inline.addFakeContinuationConstructorCallMar
 import org.jetbrains.kotlin.codegen.inline.coroutines.FOR_INLINE_SUFFIX
 import org.jetbrains.kotlin.codegen.inline.preprocessSuspendMarkers
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.config.languageVersionSettings
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
@@ -96,7 +95,6 @@ class SuspendFunctionGenerationStrategy(
             internalNameForDispatchReceiver = (originalSuspendDescriptor.containingDeclaration as? ClassDescriptor)?.let {
                 if (it.isInlineClass()) state.typeMapper.mapType(it).internalName else null
             } ?: containingClassInternalNameOrNull(),
-            useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
         )
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/coroutines/refinedIntTypesAnalysis.kt

@@ -1,221 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.codegen.coroutines
-
-import org.jetbrains.kotlin.codegen.optimization.common.*
-import org.jetbrains.kotlin.codegen.optimization.fixStack.peek
-import org.jetbrains.kotlin.codegen.optimization.fixStack.top
-import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.org.objectweb.asm.Opcodes
-import org.jetbrains.org.objectweb.asm.Type
-import org.jetbrains.org.objectweb.asm.tree.*
-import org.jetbrains.org.objectweb.asm.tree.analysis.BasicValue
-import org.jetbrains.org.objectweb.asm.tree.analysis.Frame
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceInterpreter
-import org.jetbrains.org.objectweb.asm.tree.analysis.SourceValue
-import java.util.*
-
-// BasicValue interpreter from ASM does not distinct 'int' types from other int-like types like 'byte' or 'boolean',
-// neither do HotSpot and JVM spec.
-// But it seems like Dalvik does not follow it, and spilling boolean value into an 'int' field fails with VerifyError on Android 4,
-// so this function calculates refined frames' markup.
-// Note that type of some values is only possible to determine by their usages (e.g. ICONST_1, BALOAD both may push boolean or byte on stack)
-internal fun performRefinedTypeAnalysis(methodNode: MethodNode, thisName: String): Array<out Frame<out BasicValue>?> {
-    val insnList = methodNode.instructions
-    val basicFrames = MethodTransformer.analyze(thisName, methodNode, OptimizationBasicInterpreter())
-    val sourceValueFrames = MethodTransformer.analyze(thisName, methodNode, MySourceInterpreter())
-
-    val expectedTypeAndSourcesByInsnIndex: Array<Pair<Type, List<SourceValue>>?> = arrayOfNulls(insnList.size())
-
-    fun AbstractInsnNode.index() = insnList.indexOf(this)
-
-    fun saveExpectedType(value: SourceValue?, expectedType: Type) {
-        if (value == null) return
-        if (expectedType.sort !in REFINED_INT_SORTS) return
-
-        for (insn in value.insns) {
-            // If source is something like ICONST_0, ignore it
-            if (!insn.isIntLoad()) continue
-            val index = insnList.indexOf(insn)
-
-            checkUpdatedExpectedType(expectedTypeAndSourcesByInsnIndex[index]?.first, expectedType)
-
-            expectedTypeAndSourcesByInsnIndex[index] =
-                Pair(expectedType,
-                     expectedTypeAndSourcesByInsnIndex[index]?.second.orEmpty() + value)
-        }
-    }
-
-    fun saveExpectedTypeForArrayStore(insn: AbstractInsnNode, sourceValueFrame: Frame<SourceValue>) {
-        val arrayStoreType =
-                when (insn.opcode) {
-                    Opcodes.BASTORE -> Type.BYTE_TYPE
-                    Opcodes.CASTORE -> Type.CHAR_TYPE
-                    Opcodes.SASTORE -> Type.SHORT_TYPE
-                    else -> return
-                }
-
-        val insnIndex = insnList.indexOf(insn)
-
-        val arrayArg = basicFrames[insnIndex].peek(2)
-        // may be different from 'arrayStoreType' in case of boolean arrays (BASTORE opcode is also used for them)
-        val expectedType =
-                if (arrayArg?.type?.sort == Type.ARRAY)
-                    arrayArg.type.elementType
-                else
-                    arrayStoreType
-
-        saveExpectedType(sourceValueFrame.top(), expectedType)
-    }
-
-    fun saveExpectedTypeForFieldOrMethod(insn: AbstractInsnNode, sourceValueFrame: Frame<SourceValue>) {
-        when (insn.opcode) {
-            Opcodes.PUTFIELD, Opcodes.PUTSTATIC ->
-                saveExpectedType(sourceValueFrame.top(), Type.getType((insn as FieldInsnNode).desc))
-
-            Opcodes.INVOKESTATIC, Opcodes.INVOKEVIRTUAL, Opcodes.INVOKEINTERFACE, Opcodes.INVOKESPECIAL -> {
-                val argumentTypes = Type.getArgumentTypes((insn as MethodInsnNode).desc)
-                argumentTypes.withIndex().forEach {
-                    val (argIndex, type) = it
-                    saveExpectedType(sourceValueFrame.peek(argumentTypes.size - argIndex - 1), type)
-                }
-            }
-        }
-    }
-
-    fun saveExpectedTypeForVarStore(insn: AbstractInsnNode, sourceValueFrame: Frame<SourceValue>) {
-        if (insn.isIntStore()) {
-            val varIndex = (insn as VarInsnNode).`var`
-            // Considering next insn is important because variable initializer is emitted just before
-            // the beginning of variable
-            val nextInsn = InsnSequence(insn.next, insnList.last).firstOrNull(AbstractInsnNode::isMeaningful)
-
-            val variableNode =
-                    methodNode.findContainingVariableFromTable(insn, varIndex)
-                    ?: methodNode.findContainingVariableFromTable(nextInsn ?: return, varIndex)
-                    ?: return
-
-            saveExpectedType(sourceValueFrame.top(), Type.getType(variableNode.desc))
-        }
-    }
-
-    for ((insnIndex, insn) in insnList.toArray().withIndex()) {
-         assert(insn.opcode != Opcodes.IRETURN) {
-            "Coroutine body must not contain IRETURN instructions because 'doResume' is always void"
-        }
-
-        val sourceValueFrame = sourceValueFrames[insnIndex] ?: continue
-
-        saveExpectedTypeForArrayStore(insn, sourceValueFrame)
-        saveExpectedTypeForFieldOrMethod(insn, sourceValueFrame)
-        saveExpectedTypeForVarStore(insn, sourceValueFrame)
-    }
-
-    val refinedVarFrames = analyze(methodNode, object : BackwardAnalysisInterpreter<VarExpectedTypeFrame> {
-        override fun newFrame(maxLocals: Int): VarExpectedTypeFrame = VarExpectedTypeFrame(maxLocals)
-
-        override fun def(frame: VarExpectedTypeFrame, insn: AbstractInsnNode) {
-            if (insn.isIntStore()) {
-                frame.expectedTypeByVarIndex[(insn as VarInsnNode).`var`] = null
-            }
-        }
-
-        override fun use(frame: VarExpectedTypeFrame, insn: AbstractInsnNode) {
-            val (expectedType, sources) = expectedTypeAndSourcesByInsnIndex[insn.index()] ?: return
-
-            sources.flatMap(SourceValue::insns).forEach { insnNode ->
-                if (insnNode.isIntLoad()) {
-                    frame.updateExpectedType((insnNode as VarInsnNode).`var`, expectedType)
-                }
-            }
-        }
-    })
-
-    return Array(basicFrames.size) {
-        insnIndex ->
-        val current = Frame(basicFrames[insnIndex] ?: return@Array null)
-
-        refinedVarFrames[insnIndex].expectedTypeByVarIndex.withIndex().filter { it.value != null }.forEach {
-            assert(current.getLocal(it.index)?.type?.sort in ALL_INT_SORTS) {
-                "int type expected, but ${current.getLocal(it.index)?.type} was found in basic frames"
-            }
-
-            current.setLocal(it.index, StrictBasicValue(it.value))
-        }
-
-        current
-    }
-}
-
-private fun AbstractInsnNode.isIntLoad() = opcode == Opcodes.ILOAD
-private fun AbstractInsnNode.isIntStore() = opcode == Opcodes.ISTORE
-
-private fun checkUpdatedExpectedType(was: Type?, new: Type) {
-    assert(was == null || was == new) {
-        "Conflicting expected types: $was/$new"
-    }
-}
-
-private class MySourceInterpreter : SourceInterpreter(Opcodes.API_VERSION) {
-    override fun copyOperation(insn: AbstractInsnNode, value: SourceValue) =
-            when {
-                insn.isStoreOperation() || insn.isLoadOperation() -> SourceValue(value.size, insn)
-                // For DUP* instructions return the same value (effectively ignore DUP's)
-                else -> value
-            }
-}
-
-private val REFINED_INT_SORTS = setOf(Type.BOOLEAN, Type.CHAR, Type.BYTE, Type.SHORT)
-private val ALL_INT_SORTS = REFINED_INT_SORTS + Type.INT
-
-private fun MethodNode.findContainingVariableFromTable(insn: AbstractInsnNode, varIndex: Int): LocalVariableNode? {
-    val insnIndex = instructions.indexOf(insn)
-    return localVariables.firstOrNull {
-        it.index == varIndex && it.rangeContainsInsn(insnIndex, instructions)
-    }
-}
-
-private fun LocalVariableNode.rangeContainsInsn(insnIndex: Int, insnList: InsnList) =
-        insnList.indexOf(start) < insnIndex && insnIndex < insnList.indexOf(end)
-
-private class VarExpectedTypeFrame(maxLocals: Int) : VarFrame<VarExpectedTypeFrame> {
-    val expectedTypeByVarIndex = arrayOfNulls<Type>(maxLocals)
-
-    override fun mergeFrom(other: VarExpectedTypeFrame) {
-        assert(expectedTypeByVarIndex.size == other.expectedTypeByVarIndex.size) {
-            "Other VarExpectedTypeFrame has different size: ${expectedTypeByVarIndex.size} / ${other.expectedTypeByVarIndex.size}"
-        }
-
-        for ((varIndex, type) in other.expectedTypeByVarIndex.withIndex()) {
-            updateExpectedType(varIndex, type ?: continue)
-        }
-    }
-
-    fun updateExpectedType(varIndex: Int, new: Type) {
-        val was = expectedTypeByVarIndex[varIndex]
-        // Widening to int is always allowed
-        if (new == Type.INT_TYPE) return
-
-        checkUpdatedExpectedType(was, new)
-
-        expectedTypeByVarIndex[varIndex] = new
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other == null || other::class.java != this::class.java) return false
-
-        other as VarExpectedTypeFrame
-
-        if (!Arrays.equals(expectedTypeByVarIndex, other.expectedTypeByVarIndex)) return false
-
-        return true
-    }
-
-    override fun hashCode(): Int {
-        return Arrays.hashCode(expectedTypeByVarIndex)
-    }
-}

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/coroutines/CoroutineTransformer.kt

@@ -11,7 +11,6 @@ import org.jetbrains.kotlin.codegen.coroutines.*
 import org.jetbrains.kotlin.codegen.inline.*
 import org.jetbrains.kotlin.codegen.optimization.common.asSequence
 import org.jetbrains.kotlin.codegen.optimization.transformer.MethodTransformer
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin
 import org.jetbrains.org.objectweb.asm.MethodVisitor
@@ -92,7 +91,6 @@ class CoroutineTransformer(
                 // TODO: this linenumbers might not be correct and since they are used only for step-over, check them.
                 lineNumber = inliningContext.callSiteInfo.lineNumber,
                 sourceFile = inliningContext.callSiteInfo.file?.name ?: "",
-                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
             )
 
             if (generateForInline)
@@ -127,7 +125,6 @@ class CoroutineTransformer(
                 needDispatchReceiver = true,
                 internalNameForDispatchReceiver = classBuilder.thisName,
                 putContinuationParameterToLvt = !state.isIrBackend,
-                useOldSpilledVarTypeAnalysis = state.configuration.getBoolean(JVMConfigurationKeys.USE_OLD_SPILLED_VAR_TYPE_ANALYSIS)
             )
 
             if (generateForInline)

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/Equals.kt

@@ -18,25 +18,12 @@ package org.jetbrains.kotlin.codegen.intrinsics
 
 import org.jetbrains.kotlin.codegen.Callable
 import org.jetbrains.kotlin.codegen.CallableMethod
-import org.jetbrains.kotlin.codegen.DescriptorAsmUtil
 import org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE
 import org.jetbrains.org.objectweb.asm.Type
 
 internal val equalsMethodDescriptor: String =
         Type.getMethodDescriptor(Type.BOOLEAN_TYPE, Type.getType(Any::class.java));
 
-class Equals : IntrinsicMethod() {
-    override fun toCallable(method: CallableMethod): Callable =
-            createBinaryIntrinsicCallable(
-                    method.returnType,
-                    OBJECT_TYPE,
-                    nullOrObject(method.dispatchReceiverType),
-                    nullOrObject(method.extensionReceiverType)
-            ) {
-                DescriptorAsmUtil.genAreEqualCall(it)
-            }
-}
-
 class EqualsThrowingNpeForNullReceiver(private val lhsType: Type) : IntrinsicMethod() {
     override fun toCallable(method: CallableMethod): Callable =
             createBinaryIntrinsicCallable(

compiler/backend/src/org/jetbrains/kotlin/codegen/intrinsics/IntrinsicMethods.java

@@ -53,7 +53,6 @@ public class IntrinsicMethods {
     private static final IntrinsicMethod DEC = new Increment(-1);
 
     private static final IntrinsicMethod ARRAY_SIZE = new ArraySize();
-    private static final Equals EQUALS = new Equals();
     private static final IteratorNext ITERATOR_NEXT = new IteratorNext();
     private static final ArraySet ARRAY_SET = new ArraySet();
     private static final ArrayGet ARRAY_GET = new ArrayGet();
@@ -65,10 +64,10 @@ public class IntrinsicMethods {
     private final IntrinsicsMap intrinsicsMap = new IntrinsicsMap();
 
     public IntrinsicMethods(JvmTarget jvmTarget) {
-        this(jvmTarget, false, true);
+        this(jvmTarget, false);
     }
 
-    public IntrinsicMethods(JvmTarget jvmTarget, boolean canReplaceStdlibRuntimeApiBehavior, boolean shouldThrowNpeOnExplicitEqualsForBoxedNull) {
+    public IntrinsicMethods(JvmTarget jvmTarget, boolean canReplaceStdlibRuntimeApiBehavior) {
         intrinsicsMap.registerIntrinsic(KOTLIN_JVM, RECEIVER_PARAMETER_FQ_NAME, "javaClass", -1, JavaClassProperty.INSTANCE);
         intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "java", -1, new KClassJavaProperty());
         intrinsicsMap.registerIntrinsic(KOTLIN_JVM, StandardNames.FqNames.kClass, "javaObjectType", -1, new KClassJavaObjectTypeProperty());
@@ -108,16 +107,8 @@ public class IntrinsicMethods {
         IntrinsicMethod hashCode = new HashCode(jvmTarget);
         for (PrimitiveType type : PrimitiveType.values()) {
             FqName typeFqName = type.getTypeFqName();
-            IntrinsicMethod equalsMethod;
-            if (shouldThrowNpeOnExplicitEqualsForBoxedNull) {
-                Type wrapperType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(JvmPrimitiveType.get(type).getWrapperFqName());
-                equalsMethod = new EqualsThrowingNpeForNullReceiver(wrapperType);
-            }
-            else {
-                equalsMethod = EQUALS;
-            }
-
-            declareIntrinsicFunction(typeFqName, "equals", 1, equalsMethod);
+            Type wrapperType = AsmUtil.asmTypeByFqNameWithoutInnerClasses(JvmPrimitiveType.get(type).getWrapperFqName());
+            declareIntrinsicFunction(typeFqName, "equals", 1, new EqualsThrowingNpeForNullReceiver(wrapperType));
             declareIntrinsicFunction(typeFqName, "hashCode", 0, hashCode);
             declareIntrinsicFunction(typeFqName, "toString", 0, TO_STRING);
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -248,11 +248,7 @@ class GenerationState private constructor(
         isIrBackend
     )
     val canReplaceStdlibRuntimeApiBehavior = languageVersionSettings.apiVersion <= ApiVersion.parse(KotlinVersion.CURRENT.toString())!!
-    val intrinsics: IntrinsicMethods = run {
-        val shouldUseConsistentEquals = languageVersionSettings.supportsFeature(LanguageFeature.ThrowNpeOnExplicitEqualsForBoxedNull) &&
-                !configuration.getBoolean(JVMConfigurationKeys.NO_EXCEPTION_ON_EXPLICIT_EQUALS_FOR_BOXED_NULL)
-        IntrinsicMethods(target, canReplaceStdlibRuntimeApiBehavior, shouldUseConsistentEquals)
-    }
+    val intrinsics: IntrinsicMethods = IntrinsicMethods(target, canReplaceStdlibRuntimeApiBehavior)
     val generateOptimizedCallableReferenceSuperClasses =
         languageVersionSettings.apiVersion >= ApiVersion.KOTLIN_1_4 &&
                 !configuration.getBoolean(JVMConfigurationKeys.NO_OPTIMIZED_CALLABLE_REFERENCES)