From 1c75a5f64243add6339af8ba8c1dd91f11500a65 Mon Sep 17 00:00:00 2001 From: Alexey Sedunov Date: Thu, 26 Jun 2014 20:16:08 +0400 Subject: [PATCH] Pseudocode: Generate instructions for superclass constructor calls. Consume value of delegate expression in the by-clause --- .../jet/lang/cfg/JetControlFlowBuilder.java | 2 +- .../cfg/JetControlFlowBuilderAdapter.java | 4 +- .../jet/lang/cfg/JetControlFlowProcessor.java | 51 +++++++++++----- .../JetControlFlowInstructionsGenerator.java | 4 +- ...eferenceToPropertyInitializer.instructions | 12 ++-- .../referenceToPropertyInitializer.values | 11 ++-- .../delegationByExpression.instructions | 60 +++++++++++++++++++ .../delegationByExpression.kt | 5 ++ .../delegationByExpression.values | 24 ++++++++ .../delegationBySuperCall.instructions | 46 ++++++++++++++ .../delegationBySuperCall.kt | 3 + .../delegationBySuperCall.values | 19 ++++++ .../local/ObjectExpression.instructions | 11 ++-- .../local/ObjectExpression.values | 13 ++-- .../deadCode/deadCodeInLocalDeclarations.kt | 4 +- .../jet/cfg/ControlFlowTestGenerated.java | 10 ++++ .../jet/cfg/PseudoValueTestGenerated.java | 17 ++++-- 17 files changed, 248 insertions(+), 48 deletions(-) create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.values create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt create mode 100644 compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java index 7dfde451583..9da324d252b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java @@ -134,7 +134,7 @@ public interface JetControlFlowBuilder { @NotNull CallInstruction call( - @NotNull JetExpression expression, + @NotNull JetElement valueElement, @NotNull ResolvedCall resolvedCall, @NotNull Map receiverValues, @NotNull Map arguments diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java index 24bf65414f8..09479f38cb5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java @@ -96,12 +96,12 @@ public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuil @NotNull @Override public CallInstruction call( - @NotNull JetExpression expression, + @NotNull JetElement valueElement, @NotNull ResolvedCall resolvedCall, @NotNull Map receiverValues, @NotNull Map arguments ) { - return getDelegateBuilder().call(expression, resolvedCall, receiverValues, arguments); + return getDelegateBuilder().call(valueElement, resolvedCall, receiverValues, arguments); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java index 5b6d68037a5..35f0ac227bc 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java @@ -21,6 +21,7 @@ import com.intellij.psi.PsiElement; import com.intellij.psi.tree.IElementType; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.SmartFMap; +import com.intellij.util.containers.ContainerUtil; import kotlin.Function0; import kotlin.Function1; import kotlin.KotlinPackage; @@ -1348,15 +1349,35 @@ public class JetControlFlowProcessor { @Override public void visitDelegationToSuperCallSpecifier(@NotNull JetDelegatorToSuperCall call) { - List valueArguments = call.getValueArguments(); - for (ValueArgument valueArgument : valueArguments) { - generateInstructions(valueArgument.getArgumentExpression()); + if (!generateCall(call)) { + List arguments = KotlinPackage.map( + call.getValueArguments(), + new Function1() { + @Override + public JetExpression invoke(ValueArgument valueArgument) { + return valueArgument.getArgumentExpression(); + } + } + ); + + for (JetExpression argument : arguments) { + generateInstructions(argument); + } + createNonSyntheticValue(call, arguments); } } @Override public void visitDelegationByExpressionSpecifier(@NotNull JetDelegatorByExpressionSpecifier specifier) { generateInstructions(specifier.getDelegateExpression()); + + List arguments = ContainerUtil.createMaybeSingletonList(builder.getBoundValue(specifier.getDelegateExpression())); + TypePredicate expectedTypePredicate = + PseudocodePackage.getSubtypesPredicate(trace.get(BindingContext.TYPE, specifier.getTypeReference())); + if (expectedTypePredicate == null) { + expectedTypePredicate = AllTypes.instance$; + } + builder.magic(specifier, specifier, arguments, PseudocodePackage.expectedTypeFor(expectedTypePredicate, arguments), false); } @Override @@ -1373,24 +1394,24 @@ public class JetControlFlowProcessor { builder.unsupported(element); } - private boolean generateCall(@Nullable JetExpression callExpression) { - if (callExpression == null) return false; - return checkAndGenerateCall(callExpression, getResolvedCall(callExpression, trace.getBindingContext())); + private boolean generateCall(@Nullable JetElement callElement) { + if (callElement == null) return false; + return checkAndGenerateCall(callElement, getResolvedCall(callElement, trace.getBindingContext())); } - private boolean checkAndGenerateCall(@NotNull JetExpression callExpression, @Nullable ResolvedCall resolvedCall) { + private boolean checkAndGenerateCall(@NotNull JetElement callElement, @Nullable ResolvedCall resolvedCall) { if (resolvedCall == null) { - builder.compilationError(callExpression, "No resolved call"); + builder.compilationError(callElement, "No resolved call"); return false; } - generateCall(callExpression, resolvedCall); + generateCall(callElement, resolvedCall); return true; } @NotNull - private InstructionWithValue generateCall(@NotNull JetExpression callExpression, @NotNull ResolvedCall resolvedCall) { + private InstructionWithValue generateCall(@NotNull JetElement callElement, @NotNull ResolvedCall resolvedCall) { if (resolvedCall instanceof VariableAsFunctionResolvedCall) { VariableAsFunctionResolvedCall variableAsFunctionResolvedCall = (VariableAsFunctionResolvedCall) resolvedCall; - return generateCall(callExpression, variableAsFunctionResolvedCall.getFunctionCall()); + return generateCall(callElement, variableAsFunctionResolvedCall.getFunctionCall()); } CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor(); @@ -1406,15 +1427,15 @@ public class JetControlFlowProcessor { if (resultingDescriptor instanceof VariableDescriptor) { // If a callee of the call is just a variable (without 'invoke'), 'read variable' is generated. // todo : process arguments for such a case (KT-5387) - JetExpression calleeExpression = PsiUtilPackage.getCalleeExpressionIfAny(callExpression); + JetExpression calleeExpression = PsiUtilPackage.getCalleeExpressionIfAny(callElement); assert calleeExpression != null - : "No callee for " + callExpression.getText(); + : "Variable-based call without callee expression: " + callElement.getText(); assert parameterValues.isEmpty() - : "Variable-based call with non-empty argument list: " + callExpression.getText(); + : "Variable-based call with non-empty argument list: " + callElement.getText(); return builder.readVariable(calleeExpression, resolvedCall, receivers); } mark(resolvedCall.getCall().getCallElement()); - return builder.call(callExpression, resolvedCall, receivers, parameterValues); + return builder.call(callElement, resolvedCall, receivers, parameterValues); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java index 1b0c2d2d643..abb207f00c1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java @@ -460,14 +460,14 @@ public class JetControlFlowInstructionsGenerator extends JetControlFlowBuilderAd @NotNull @Override public CallInstruction call( - @NotNull JetExpression expression, + @NotNull JetElement valueElement, @NotNull ResolvedCall resolvedCall, @NotNull Map receiverValues, @NotNull Map arguments ) { JetType returnType = resolvedCall.getResultingDescriptor().getReturnType(); CallInstruction instruction = CallInstruction.object$.create( - expression, + valueElement, getCurrentScope(), resolvedCall, receiverValues, diff --git a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions index 35a29ba7825..401c51e492b 100644 --- a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions +++ b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions @@ -83,16 +83,18 @@ L0: mark(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) INIT: in: {obj=D} out: {obj=D} magic(obj) -> r(obj|) -> + mark(A(obj)) + call(A(obj), |) -> 2 mark({ val x = obj }) v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D} - magic(obj) -> INIT: in: {obj=D, x=D} out: {obj=D, x=D} - r(obj|) -> - w(x|) INIT: in: {obj=D, x=D} out: {obj=D, x=ID} + magic(obj) -> INIT: in: {obj=D, x=D} out: {obj=D, x=D} + r(obj|) -> + w(x|) INIT: in: {obj=D, x=D} out: {obj=D, x=ID} 1 jmp?(L2) INIT: in: {obj=D} out: {obj=D} d(fun foo() { val y = obj }) USE: in: {obj=READ} out: {obj=READ} L2: - r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> - w(obj|) INIT: in: {obj=D} out: {obj=ID} + r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> + w(obj|) INIT: in: {obj=D} out: {obj=ID} L1: INIT: in: {obj=ID} out: {obj=ID} error: diff --git a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values index 782422b3f7c..99694f22423 100644 --- a/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values +++ b/compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values @@ -41,10 +41,11 @@ class TestObjectLiteral { } --------------------- : TestObjectLiteral NEW: magic(obj) -> - : TestObjectLiteral NEW: magic(obj) -> -obj : * NEW: r(obj|) -> -obj : {<: A} NEW: r(obj|) -> -object: A(obj) { { val x = obj } fun foo() { val y = obj } } : {<: A} NEW: r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> + : TestObjectLiteral NEW: magic(obj) -> +obj : {<: A} NEW: r(obj|) -> +A(obj) : * NEW: call(A(obj), |) -> +obj : {<: A} NEW: r(obj|) -> +object: A(obj) { { val x = obj } fun foo() { val y = obj } } : {<: A} NEW: r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> ===================== == foo == fun foo() { @@ -63,4 +64,4 @@ class TestOther { x : Int NEW: r(x|) -> 1 : Int NEW: r(1) -> x + 1 : Int NEW: call(x + 1, plus|, ) -> -===================== \ No newline at end of file +===================== diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions new file mode 100644 index 00000000000..b4235d97823 --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions @@ -0,0 +1,60 @@ +== T == +trait T +--------------------- +L0: + 1 +L1: + NEXT:[] +error: + PREV:[] +sink: + PREV:[, ] +===================== +== A == +class A(a: Int, b: Int): T +--------------------- +L0: + 1 + v(a: Int) + magic(a: Int) -> + w(a|) + v(b: Int) + magic(b: Int) -> + w(b|) + unsupported(DELEGATOR_SUPER_CLASS : T) +L1: + NEXT:[] +error: + PREV:[] +sink: + PREV:[, ] +===================== +== B == +class B(a: Int, b: Int): T by A(a + b, a - b) +--------------------- +L0: + 1 + v(a: Int) + magic(a: Int) -> + w(a|) + v(b: Int) + magic(b: Int) -> + w(b|) + r(a) -> + r(b) -> + mark(a + b) + call(a + b, plus|, ) -> + r(a) -> + r(b) -> + mark(a - b) + call(a - b, minus|, ) -> + mark(A(a + b, a - b)) + call(A(a + b, a - b), |, ) -> + magic(T by A(a + b, a - b)|) -> +L1: + NEXT:[] +error: + PREV:[] +sink: + PREV:[, ] +===================== diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt new file mode 100644 index 00000000000..8071281842b --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt @@ -0,0 +1,5 @@ +trait T + +class A(a: Int, b: Int): T + +class B(a: Int, b: Int): T by A(a + b, a - b) \ No newline at end of file diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.values b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.values new file mode 100644 index 00000000000..fae9948bfbf --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.values @@ -0,0 +1,24 @@ +== T == +trait T +--------------------- +===================== +== A == +class A(a: Int, b: Int): T +--------------------- + : Int NEW: magic(a: Int) -> + : Int NEW: magic(b: Int) -> +===================== +== B == +class B(a: Int, b: Int): T by A(a + b, a - b) +--------------------- + : Int NEW: magic(a: Int) -> + : Int NEW: magic(b: Int) -> +a : Int NEW: r(a) -> +b : Int NEW: r(b) -> +a + b : Int NEW: call(a + b, plus|, ) -> +a : Int NEW: r(a) -> +b : Int NEW: r(b) -> +a - b : Int NEW: call(a - b, minus|, ) -> +A(a + b, a - b) : {<: T} NEW: call(A(a + b, a - b), |, ) -> +T by A(a + b, a - b) : * NEW: magic(T by A(a + b, a - b)|) -> +===================== diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions new file mode 100644 index 00000000000..e2eda1d5a49 --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions @@ -0,0 +1,46 @@ +== A == +open class A(a: Int, b: Int) +--------------------- +L0: + 1 + v(a: Int) + magic(a: Int) -> + w(a|) + v(b: Int) + magic(b: Int) -> + w(b|) +L1: + NEXT:[] +error: + PREV:[] +sink: + PREV:[, ] +===================== +== B == +class B(a: Int, b: Int): A(a + b, a - b) +--------------------- +L0: + 1 + v(a: Int) + magic(a: Int) -> + w(a|) + v(b: Int) + magic(b: Int) -> + w(b|) + r(a) -> + r(b) -> + mark(a + b) + call(a + b, plus|, ) -> + r(a) -> + r(b) -> + mark(a - b) + call(a - b, minus|, ) -> + mark(A(a + b, a - b)) + call(A(a + b, a - b), |, ) -> +L1: + NEXT:[] +error: + PREV:[] +sink: + PREV:[, ] +===================== diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt new file mode 100644 index 00000000000..c5f90e45154 --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt @@ -0,0 +1,3 @@ +open class A(a: Int, b: Int) + +class B(a: Int, b: Int): A(a + b, a - b) \ No newline at end of file diff --git a/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values new file mode 100644 index 00000000000..dfcb5253064 --- /dev/null +++ b/compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values @@ -0,0 +1,19 @@ +== A == +open class A(a: Int, b: Int) +--------------------- + : Int NEW: magic(a: Int) -> + : Int NEW: magic(b: Int) -> +===================== +== B == +class B(a: Int, b: Int): A(a + b, a - b) +--------------------- + : Int NEW: magic(a: Int) -> + : Int NEW: magic(b: Int) -> +a : Int NEW: r(a) -> +b : Int NEW: r(b) -> +a + b : Int NEW: call(a + b, plus|, ) -> +a : Int NEW: r(a) -> +b : Int NEW: r(b) -> +a - b : Int NEW: call(a - b, minus|, ) -> +A(a + b, a - b) : * NEW: call(A(a + b, a - b), |, ) -> +===================== diff --git a/compiler/testData/cfg/declarations/local/ObjectExpression.instructions b/compiler/testData/cfg/declarations/local/ObjectExpression.instructions index 6ba8e240dc6..c8d728b6dd9 100644 --- a/compiler/testData/cfg/declarations/local/ObjectExpression.instructions +++ b/compiler/testData/cfg/declarations/local/ObjectExpression.instructions @@ -67,13 +67,14 @@ L0: v(val o = object : A by b {}) mark(object : A by b {}) r(b) -> - r(object : A by b {}) -> - w(o|) + magic(A by b|) -> + r(object : A by b {}) -> + w(o|) mark(o.foo()) - r(o) -> + r(o) -> mark(foo()) - call(foo(), foo|) -> - ret(*|) L1 + call(foo(), foo|) -> + ret(*|) L1 L1: 1 NEXT:[] error: diff --git a/compiler/testData/cfg/declarations/local/ObjectExpression.values b/compiler/testData/cfg/declarations/local/ObjectExpression.values index d2296f974c6..c1b74b0bdf5 100644 --- a/compiler/testData/cfg/declarations/local/ObjectExpression.values +++ b/compiler/testData/cfg/declarations/local/ObjectExpression.values @@ -26,9 +26,10 @@ fun foo(b: B) : Int { } --------------------- : B NEW: magic(b: B) -> -b : * NEW: r(b) -> -object : A by b {} : NEW: r(object : A by b {}) -> -o : {<: A} NEW: r(o) -> -foo() : Int NEW: call(foo(), foo|) -> -o.foo() : Int COPY -===================== \ No newline at end of file +b : {<: A} NEW: r(b) -> +A by b : * NEW: magic(A by b|) -> +object : A by b {} : NEW: r(object : A by b {}) -> +o : {<: A} NEW: r(o) -> +foo() : Int NEW: call(foo(), foo|) -> +o.foo() : Int COPY +===================== diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt index db437307072..f6da886eb8e 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt @@ -21,7 +21,7 @@ fun testObjectExpression1() { } fun testClassDeclaration() { - class C : Foo(todo()) {} + class C : Foo(todo()) {} bar() } @@ -33,4 +33,4 @@ fun testFunctionDefaultArgument() { open class Foo(i: Int) {} fun todo() = throw Exception() -fun bar() {} +fun bar() {} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java b/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java index b4f0f972387..f9b2a86710b 100644 --- a/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java @@ -223,6 +223,16 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest { doTest("compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.kt"); } + @TestMetadata("delegationByExpression.kt") + public void testDelegationByExpression() throws Exception { + doTest("compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt"); + } + + @TestMetadata("delegationBySuperCall.kt") + public void testDelegationBySuperCall() throws Exception { + doTest("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt"); + } + } @TestMetadata("compiler/testData/cfg/declarations/functionLiterals") diff --git a/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java b/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java index f530d7e7c02..73fbabab54c 100644 --- a/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java +++ b/compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java @@ -16,17 +16,14 @@ package org.jetbrains.jet.cfg; -import junit.framework.Assert; import junit.framework.Test; import junit.framework.TestSuite; - -import java.io.File; -import java.util.regex.Pattern; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.test.InnerTestClasses; import org.jetbrains.jet.test.TestMetadata; -import org.jetbrains.jet.cfg.AbstractPseudoValueTest; +import java.io.File; +import java.util.regex.Pattern; /** This class is generated by {@link org.jetbrains.jet.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ @SuppressWarnings("all") @@ -225,6 +222,16 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest { doTest("compiler/testData/cfg/declarations/classesAndObjects/AnonymousInitializers.kt"); } + @TestMetadata("delegationByExpression.kt") + public void testDelegationByExpression() throws Exception { + doTest("compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt"); + } + + @TestMetadata("delegationBySuperCall.kt") + public void testDelegationBySuperCall() throws Exception { + doTest("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt"); + } + } @TestMetadata("compiler/testData/cfg/declarations/functionLiterals")