azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Pseudocode: Generate instructions for superclass constructor calls. Consume value of delegate expression in the by-clause

Browse Source
This commit is contained in:
Alexey Sedunov
2014-06-26 20:16:08 +04:00
parent 523beab902
commit 1c75a5f642
17 changed files with 248 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilder.java
+1 -1
View File
@@ -134,7 +134,7 @@ public interface JetControlFlowBuilder {
@NotNull
CallInstruction call(
@NotNull JetExpression expression,
@NotNull JetElement valueElement,
@NotNull ResolvedCall<?> resolvedCall,
@NotNull Map<PseudoValue, ReceiverValue> receiverValues,
@NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowBuilderAdapter.java
+2 -2
View File
@@ -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<PseudoValue, ReceiverValue> receiverValues,
@NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
) {
return getDelegateBuilder().call(expression, resolvedCall, receiverValues, arguments);
return getDelegateBuilder().call(valueElement, resolvedCall, receiverValues, arguments);
}
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetControlFlowProcessor.java
+36 -15
View File
@@ -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<? extends ValueArgument> valueArguments = call.getValueArguments();
for (ValueArgument valueArgument : valueArguments) {
generateInstructions(valueArgument.getArgumentExpression());
if (!generateCall(call)) {
List<JetExpression> arguments = KotlinPackage.map(
call.getValueArguments(),
new Function1<ValueArgument, JetExpression>() {
@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<PseudoValue> 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
compiler/frontend/src/org/jetbrains/jet/lang/cfg/pseudocode/JetControlFlowInstructionsGenerator.java
+2 -2
View File
@@ -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<PseudoValue, ReceiverValue> receiverValues,
@NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
) {
JetType returnType = resolvedCall.getResultingDescriptor().getReturnType();
CallInstruction instruction = CallInstruction.object$.create(
expression,
valueElement,
getCurrentScope(),
resolvedCall,
receiverValues,
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.instructions
+7 -5
View File
@@ -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) -> <v0>
r(obj|<v0>) -> <v1>
mark(A(obj))
call(A(obj), <init>|<v1>) -> <v2>
2 mark({ val x = obj })
v(val x = obj) INIT: in: {obj=D} out: {obj=D, x=D}
magic(obj) -> <v2> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
r(obj|<v2>) -> <v3>
w(x|<v3>) INIT: in: {obj=D, x=D} out: {obj=D, x=ID}
magic(obj) -> <v3> INIT: in: {obj=D, x=D} out: {obj=D, x=D}
r(obj|<v3>) -> <v4>
w(x|<v4>) 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 } }) -> <v4>
w(obj|<v4>) INIT: in: {obj=D} out: {obj=ID}
r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v5>
w(obj|<v5>) INIT: in: {obj=D} out: {obj=ID}
L1:
<END> INIT: in: {obj=ID} out: {obj=ID}
error:
compiler/testData/cfg-variables/bugs/referenceToPropertyInitializer.values
+6 -5
View File
@@ -41,10 +41,11 @@ class TestObjectLiteral {
}
---------------------
<v0>: TestObjectLiteral NEW: magic(obj) -> <v0>
<v2>: TestObjectLiteral NEW: magic(obj) -> <v2>
obj <v1>: * NEW: r(obj|<v0>) -> <v1>
obj <v3>: {<: A} NEW: r(obj|<v2>) -> <v3>
object: A(obj) { { val x = obj } fun foo() { val y = obj } } <v4>: {<: A} NEW: r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v4>
<v3>: TestObjectLiteral NEW: magic(obj) -> <v3>
obj <v1>: {<: A} NEW: r(obj|<v0>) -> <v1>
A(obj) <v2>: * NEW: call(A(obj), <init>|<v1>) -> <v2>
obj <v4>: {<: A} NEW: r(obj|<v3>) -> <v4>
object: A(obj) { { val x = obj } fun foo() { val y = obj } } <v5>: {<: A} NEW: r(object: A(obj) { { val x = obj } fun foo() { val y = obj } }) -> <v5>
=====================
== foo ==
fun foo() {
@@ -63,4 +64,4 @@ class TestOther {
x <v1>: Int NEW: r(x|<v0>) -> <v1>
1 <v2>: Int NEW: r(1) -> <v2>
x + 1 <v3>: Int NEW: call(x + 1, plus|<v1>, <v2>) -> <v3>
=====================
=====================
compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.instructions
+60
View File
@@ -0,0 +1,60 @@
== T ==
trait T
---------------------
L0:
1 <START>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== A ==
class A(a: Int, b: Int): T
---------------------
L0:
1 <START>
v(a: Int)
magic(a: Int) -> <v0>
w(a|<v0>)
v(b: Int)
magic(b: Int) -> <v1>
w(b|<v1>)
unsupported(DELEGATOR_SUPER_CLASS : T)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== B ==
class B(a: Int, b: Int): T by A(a + b, a - b)
---------------------
L0:
1 <START>
v(a: Int)
magic(a: Int) -> <v0>
w(a|<v0>)
v(b: Int)
magic(b: Int) -> <v1>
w(b|<v1>)
r(a) -> <v2>
r(b) -> <v3>
mark(a + b)
call(a + b, plus|<v2>, <v3>) -> <v4>
r(a) -> <v5>
r(b) -> <v6>
mark(a - b)
call(a - b, minus|<v5>, <v6>) -> <v7>
mark(A(a + b, a - b))
call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
magic(T by A(a + b, a - b)|<v8>) -> <v9>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.kt
+5
View File
@@ -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)
compiler/testData/cfg/declarations/classesAndObjects/delegationByExpression.values
+24
View File
@@ -0,0 +1,24 @@
== T ==
trait T
---------------------
=====================
== A ==
class A(a: Int, b: Int): T
---------------------
<v0>: Int NEW: magic(a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1>
=====================
== B ==
class B(a: Int, b: Int): T by A(a + b, a - b)
---------------------
<v0>: Int NEW: magic(a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
b <v3>: Int NEW: r(b) -> <v3>
a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4>
a <v5>: Int NEW: r(a) -> <v5>
b <v6>: Int NEW: r(b) -> <v6>
a - b <v7>: Int NEW: call(a - b, minus|<v5>, <v6>) -> <v7>
A(a + b, a - b) <v8>: {<: T} NEW: call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
T by A(a + b, a - b) <v9>: * NEW: magic(T by A(a + b, a - b)|<v8>) -> <v9>
=====================
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.instructions
+46
View File
@@ -0,0 +1,46 @@
== A ==
open class A(a: Int, b: Int)
---------------------
L0:
1 <START>
v(a: Int)
magic(a: Int) -> <v0>
w(a|<v0>)
v(b: Int)
magic(b: Int) -> <v1>
w(b|<v1>)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== B ==
class B(a: Int, b: Int): A(a + b, a - b)
---------------------
L0:
1 <START>
v(a: Int)
magic(a: Int) -> <v0>
w(a|<v0>)
v(b: Int)
magic(b: Int) -> <v1>
w(b|<v1>)
r(a) -> <v2>
r(b) -> <v3>
mark(a + b)
call(a + b, plus|<v2>, <v3>) -> <v4>
r(a) -> <v5>
r(b) -> <v6>
mark(a - b)
call(a - b, minus|<v5>, <v6>) -> <v7>
mark(A(a + b, a - b))
call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt
+3
View File
@@ -0,0 +1,3 @@
open class A(a: Int, b: Int)
class B(a: Int, b: Int): A(a + b, a - b)
compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.values
+19
View File
@@ -0,0 +1,19 @@
== A ==
open class A(a: Int, b: Int)
---------------------
<v0>: Int NEW: magic(a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1>
=====================
== B ==
class B(a: Int, b: Int): A(a + b, a - b)
---------------------
<v0>: Int NEW: magic(a: Int) -> <v0>
<v1>: Int NEW: magic(b: Int) -> <v1>
a <v2>: Int NEW: r(a) -> <v2>
b <v3>: Int NEW: r(b) -> <v3>
a + b <v4>: Int NEW: call(a + b, plus|<v2>, <v3>) -> <v4>
a <v5>: Int NEW: r(a) -> <v5>
b <v6>: Int NEW: r(b) -> <v6>
a - b <v7>: Int NEW: call(a - b, minus|<v5>, <v6>) -> <v7>
A(a + b, a - b) <v8>: * NEW: call(A(a + b, a - b), <init>|<v4>, <v7>) -> <v8>
=====================
compiler/testData/cfg/declarations/local/ObjectExpression.instructions
+6 -5
View File
@@ -67,13 +67,14 @@ L0:
v(val o = object : A by b {})
mark(object : A by b {})
r(b) -> <v1>
r(object : A by b {}) -> <v2>
w(o|<v2>)
magic(A by b|<v1>) -> <v2>
r(object : A by b {}) -> <v3>
w(o|<v3>)
mark(o.foo())
r(o) -> <v3>
r(o) -> <v4>
mark(foo())
call(foo(), foo|<v3>) -> <v4>
ret(*|<v4>) L1
call(foo(), foo|<v4>) -> <v5>
ret(*|<v5>) L1
L1:
1 <END> NEXT:[<SINK>]
error:
compiler/testData/cfg/declarations/local/ObjectExpression.values
+7 -6
View File
@@ -26,9 +26,10 @@ fun foo(b: B) : Int {
}
---------------------
<v0>: B NEW: magic(b: B) -> <v0>
b <v1>: * NEW: r(b) -> <v1>
object : A by b {} <v2>: <no name provided> NEW: r(object : A by b {}) -> <v2>
o <v3>: {<: A} NEW: r(o) -> <v3>
foo() <v4>: Int NEW: call(foo(), foo|<v3>) -> <v4>
o.foo() <v4>: Int COPY
=====================
b <v1>: {<: A} NEW: r(b) -> <v1>
A by b <v2>: * NEW: magic(A by b|<v1>) -> <v2>
object : A by b {} <v3>: <no name provided> NEW: r(object : A by b {}) -> <v3>
o <v4>: {<: A} NEW: r(o) -> <v4>
foo() <v5>: Int NEW: call(foo(), foo|<v4>) -> <v5>
o.foo() <v5>: Int COPY
=====================
compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/deadCodeInLocalDeclarations.kt
+2 -2
View File
@@ -21,7 +21,7 @@ fun testObjectExpression1() {
}
fun testClassDeclaration() {
class C : Foo(todo()) {}
class C : <!UNREACHABLE_CODE!>Foo(<!>todo()<!UNREACHABLE_CODE!>)<!> {}
<!UNREACHABLE_CODE!>bar()<!>
}
@@ -33,4 +33,4 @@ fun testFunctionDefaultArgument() {
open class Foo(i: Int) {}
fun todo() = throw Exception()
fun bar() {}
fun bar() {}
compiler/tests/org/jetbrains/jet/cfg/ControlFlowTestGenerated.java
+10
View File
@@ -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")
compiler/tests/org/jetbrains/jet/cfg/PseudoValueTestGenerated.java
+12 -5
View File
@@ -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")