JS: fix inline cycle reporting

js/js.inliner/src/org/jetbrains/kotlin/js/inline/InlinerCycleReporter.kt

@@ -57,7 +57,15 @@ class InlinerCycleReporter(
     }
 
     fun processInlineFunction(definition: FunctionWithWrapper, call: JsInvocation?, doProcess: () -> Unit) {
+        val function = definition.function
 
+        if (call != null) {
+            currentNamedFunction?.let {
+                inlineCallInfos.add(JsCallInfo(call, it))
+            }
+        }
+
+        try {
             when (functionVisitingState[definition.function]) {
                 VisitedState.IN_PROCESS -> {
                     reportInlineCycle(call, definition.function)
@@ -66,32 +74,19 @@ class InlinerCycleReporter(
                 VisitedState.PROCESSED -> return
             }
 
-        val function = definition.function
-
             functionVisitingState[function] = VisitedState.IN_PROCESS
 
-        val result = withFunction(function, doProcess)
+            withFunction(function, doProcess)
 
             functionVisitingState[function] = VisitedState.PROCESSED
 
-        return result
+        } finally {
-    }
-
-
-    fun <T> inlineCall(call: JsInvocation, doInline: () -> T): T {
-        currentNamedFunction?.let {
-            inlineCallInfos.add(JsCallInfo(call, it))
-        }
-
-        val result = doInline()
-
             if (!inlineCallInfos.isEmpty()) {
                 if (inlineCallInfos.last.call == call) {
                     inlineCallInfos.removeLast()
                 }
             }
-
+        }
-        return result
     }
 
     private fun reportInlineCycle(call: JsInvocation?, calledFunction: JsFunction) {

js/js.inliner/src/org/jetbrains/kotlin/js/inline/JsInliner.kt

@@ -60,8 +60,6 @@ class JsInliner(
     fun inline(scope: InliningScope, call: JsInvocation, currentStatement: JsStatement?): InlineableResult {
         val definition = functionContext.getFunctionDefinition(call, scope)
 
-        return cycleReporter.inlineCall(call) {
-
         val function = scope.importFunctionDefinition(definition)
 
         val inliningContext = InliningContext(currentStatement)
@@ -74,7 +72,6 @@ class JsInliner(
         // TODO shouldn't we process the resultExpression qualifier along with the lambda inlining?
         resultExpression?.synthetic = true
 
-            InlineableResult(JsBlock(inliningContext.previousStatements + inlineableBody), resultExpression)
+        return InlineableResult(JsBlock(inliningContext.previousStatements + inlineableBody), resultExpression)
-        }
     }
 }

js/js.inliner/src/org/jetbrains/kotlin/js/inline/context/FunctionContext.kt

@@ -39,6 +39,7 @@ class FunctionContext(
 
     fun scopeForFragment(fragment: JsProgramFragment) = if (fragment in newFragments) {
         inliningScopeCache.computeIfAbsent(fragment) {
+            loadFragment(fragment)
             ProgramFragmentInliningScope(fragment)
         }
     } else null
@@ -75,8 +76,7 @@ class FunctionContext(
      */
     private fun getFunctionDefinitionImpl(call: JsInvocation, scope: InliningScope): InlineFunctionDefinition? {
         // Ensure we have the local function information
-        // TODO is this necessary?
+        assert(scope.fragment in inliningScopeCache)
-        loadFragment(scope.fragment)
 
         return lookUpFunctionDirect(call) ?: lookUpFunctionIndirect(call, scope) ?: lookUpFunctionExternal(call, scope.fragment)
     }