Report error on indirect inline cycles

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

@@ -0,0 +1,52 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.codegen
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.codegen.state.GenerationState
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.diagnostics.DiagnosticSink
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
+
+public class InlineCycleReporter(val diagnostics: DiagnosticSink) {
+
+    val processingFunctions = linkedMapOf<PsiElement, CallableDescriptor>()
+
+    public fun enterIntoInlining(call: ResolvedCall<*>?): Boolean {
+        //null call for default method inlining
+        if (call != null) {
+            val callElement = call.getCall().getCallElement()
+            if (processingFunctions.contains(callElement)) {
+                val cycle = processingFunctions.asSequence().dropWhile { it.getKey() != callElement }
+                cycle.forEach {
+                    diagnostics.report(Errors.INLINE_CALL_CYCLE.on(it.getKey(), it.getValue()))
+                }
+                return false
+            }
+            processingFunctions.put(callElement, call.getResultingDescriptor().getOriginal())
+        }
+        return true
+    }
+
+    public fun exitFromInliningOf(call: ResolvedCall<*>?) {
+        if (call != null) {
+            val callElement = call.getCall().getCallElement()
+            processingFunctions.remove(callElement)
+        }
+    }
+}

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

@@ -127,6 +127,10 @@ public class InlineCodegen extends CallGenerator {
     @Override
     public void genCallInner(@NotNull Callable callableMethod, @Nullable ResolvedCall<?> resolvedCall, boolean callDefault, @NotNull ExpressionCodegen codegen) {
         SMAPAndMethodNode nodeAndSmap = null;
+        if (!state.getInlineCycleReporter().enterIntoInlining(resolvedCall)) {
+            generateStub(resolvedCall, codegen);
+            return;
+        }
 
         try {
             nodeAndSmap = createMethodNode(callDefault);
@@ -144,8 +148,16 @@ public class InlineCodegen extends CallGenerator {
                                        (generateNodeText ? ("\ncause: " + InlineCodegenUtil.getNodeText(nodeAndSmap != null ? nodeAndSmap.getNode(): null)) : ""),
                                        e, callElement);
         }
+        finally {
+            state.getInlineCycleReporter().exitFromInliningOf(resolvedCall);
+        }
+    }
 
-
+    protected void generateStub(@Nullable ResolvedCall<?> resolvedCall, @NotNull ExpressionCodegen codegen) {
+        leaveTemps();
+        assert resolvedCall != null;
+        String message = "Call is part of inline cycle: " + resolvedCall.getCall().getCallElement().getText();
+        AsmUtil.genThrow(codegen.v, "java/lang/UnsupportedOperationException", message);
     }
 
     private void endCall(@NotNull InlineResult result) {

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

@@ -97,6 +97,9 @@ public class GenerationState {
     @NotNull
     private final SamWrapperClasses samWrapperClasses = new SamWrapperClasses(this);
 
+    @NotNull
+    private final InlineCycleReporter inlineCycleReporter;
+
     @NotNull
     private final MappingsClassesForWhenByEnum mappingsClassesForWhenByEnum = new MappingsClassesForWhenByEnum(this);
 
@@ -194,6 +197,7 @@ public class GenerationState {
 
         this.reflectionTypes = new ReflectionTypes(module);
         this.runtimeTypes = new JvmRuntimeTypes(reflectionTypes);
+        this.inlineCycleReporter = new InlineCycleReporter(diagnostics);
     }
 
     @NotNull
@@ -246,6 +250,11 @@ public class GenerationState {
         return samWrapperClasses;
     }
 
+    @NotNull
+    public InlineCycleReporter getInlineCycleReporter() {
+        return inlineCycleReporter;
+    }
+
     @NotNull
     public MappingsClassesForWhenByEnum getMappingsClassesForWhenByEnum() {
         return mappingsClassesForWhenByEnum;