[JVM] Replace open functions in FastAnalyzer with constructor args

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

@@ -20,6 +20,8 @@ abstract class FastAnalyzer<V : Value, F : Frame<V>>(
     private val method: MethodNode,
     private val interpreter: Interpreter<V>,
     private val pruneExceptionEdges: Boolean,
+    private val useFastComputeExceptionHandlers: Boolean,
+    private val useFastMergeControlFlowEdge: Boolean,
     private val newFrame: (Int, Int) -> F
 ) {
     private val nInsns = method.instructions.size()
@@ -139,11 +141,9 @@ abstract class FastAnalyzer<V : Value, F : Frame<V>>(
             throw AssertionError("Subroutines are deprecated since Java 6")
     }
 
-    protected open fun useFastComputeExceptionHandlers(): Boolean = false
-
     private fun computeExceptionHandlers(m: MethodNode) {
         for (tcb in m.tryCatchBlocks) {
-            if (useFastComputeExceptionHandlers()) computeExceptionHandlerFast(tcb) else computeExceptionHandlersForEachInsn(tcb)
+            if (useFastComputeExceptionHandlers) computeExceptionHandlerFast(tcb) else computeExceptionHandlersForEachInsn(tcb)
         }
     }
 
@@ -209,8 +209,6 @@ abstract class FastAnalyzer<V : Value, F : Frame<V>>(
         }
     }
 
-    protected open fun useFastMergeControlFlowEdge(): Boolean = false
-
     /**
      * Updates frame at the index [dest] with its old value if provided and previous control flow node frame [frame].
      * Reuses old frame when possible and when [canReuse] is true.
@@ -231,7 +229,7 @@ abstract class FastAnalyzer<V : Value, F : Frame<V>>(
                 oldFrame.init(frame)
                 true
             }
-            !useFastMergeControlFlowEdge() ->
+            !useFastMergeControlFlowEdge ->
                 try {
                     oldFrame.merge(frame, interpreter)
                 } catch (e: AnalyzerException) {

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

@@ -45,4 +45,9 @@ class FastMethodAnalyzer<V : Value>
     interpreter: Interpreter<V>,
     pruneExceptionEdges: Boolean = false,
     newFrame: (Int, Int) -> Frame<V> = { nLocals, nStack -> Frame<V>(nLocals, nStack) }
-) : FastAnalyzer<V, Frame<V>>(owner, method, interpreter, pruneExceptionEdges, newFrame)
+) : FastAnalyzer<V, Frame<V>>(
+    owner, method, interpreter, pruneExceptionEdges,
+    useFastComputeExceptionHandlers = false,
+    useFastMergeControlFlowEdge = false,
+    newFrame
+)

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

@@ -46,9 +46,11 @@ internal open class FastStackAnalyzer<V : Value, F : Frame<V>>(
     method: MethodNode,
     interpreter: Interpreter<V>,
     newFrame: (Int, Int) -> F
-) : FastAnalyzer<V, F>(owner, method, interpreter, pruneExceptionEdges = false, newFrame) {
-
+) : FastAnalyzer<V, F>(
+    owner, method, interpreter,
+    pruneExceptionEdges = false,
     // Don't have to visit the same exception handler multiple times - we care only about stack state at TCB start.
-    override fun useFastComputeExceptionHandlers(): Boolean = true
-    override fun useFastMergeControlFlowEdge(): Boolean = true
-}
+    useFastComputeExceptionHandlers = true,
+    useFastMergeControlFlowEdge = true,
+    newFrame
+)

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

@@ -46,8 +46,7 @@ internal class FixStackAnalyzer(
         owner, method, FixStackInterpreter(), { nLocals, nStack -> FixStackFrame(nLocals, nStack) }
     ) {
         override fun visitControlFlowEdge(insnNode: AbstractInsnNode, successor: Int): Boolean {
-            if (!skipBreakContinueGotoEdges) return true
-            return !(insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
+            return !(skipBreakContinueGotoEdges && insnNode is JumpInsnNode && context.breakContinueGotoNodes.contains(insnNode))
         }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/optimization/temporaryVals/FastStoreLoadAnalyzer.kt

@@ -67,4 +67,10 @@ class FastStoreLoadAnalyzer<V : Value>(
     method: MethodNode,
     interpreter: Interpreter<V>,
     newFrame: (Int, Int) -> StoreLoadFrame<V> = { nLocals, _ -> StoreLoadFrame(nLocals) }
-) : FastAnalyzer<V, StoreLoadFrame<V>>(owner, method, interpreter, pruneExceptionEdges = false, newFrame)
+) : FastAnalyzer<V, StoreLoadFrame<V>>(
+    owner, method, interpreter,
+    pruneExceptionEdges = false,
+    useFastComputeExceptionHandlers = false,
+    useFastMergeControlFlowEdge = false,
+    newFrame
+)