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

CFA: No more UNRESOLVED_CALL for object / enum entry qualifiers

Browse Source 
(cherry picked from commit 4b09de8)
This commit is contained in:
Mikhail Glukhikh
2016-08-04 15:05:11 +03:00
committed by Mikhail Glukhikh
parent 962c2e5dd2
commit b7ed68db05
17 changed files with 504 additions and 30 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowBuilder.kt
+2
View File
@@ -129,6 +129,8 @@ interface ControlFlowBuilder {
operation: PredefinedOperation,
inputValues: List<PseudoValue>): OperationInstruction
fun read(element: KtElement, target: AccessTarget, receiverValues: Map<PseudoValue, ReceiverValue>): ReadValueInstruction
fun write(
assignment: KtElement,
lValue: KtElement,
compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowBuilderAdapter.kt
+3
View File
@@ -176,6 +176,9 @@ abstract class ControlFlowBuilderAdapter : ControlFlowBuilder {
delegateBuilder.returnNoValue(returnExpression, subroutine)
}
override fun read(element: KtElement, target: AccessTarget, receiverValues: Map<PseudoValue, ReceiverValue>) =
delegateBuilder.read(element, target, receiverValues)
override fun write(
assignment: KtElement,
lValue: KtElement,
compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowProcessor.kt
+23 -6
View File
@@ -48,12 +48,11 @@ import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall
import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind
import org.jetbrains.kotlin.resolve.calls.tower.getFakeDescriptorForObject
import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.resolve.scopes.receivers.TransientReceiver
import org.jetbrains.kotlin.types.expressions.DoubleColonLHS
import org.jetbrains.kotlin.resolve.scopes.receivers.*
import org.jetbrains.kotlin.types.expressions.OperatorConventions
import java.util.*
@@ -266,8 +265,14 @@ class ControlFlowProcessor(private val trace: BindingTrace) {
if (resolvedCall is VariableAsFunctionResolvedCall) {
generateCall(resolvedCall.variableCall)
}
else if (!generateCall(expression) && expression.parent !is KtCallExpression) {
createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, generateAndGetReceiverIfAny(expression))
else {
if (resolvedCall == null) {
val qualifier = trace.bindingContext[BindingContext.QUALIFIER, expression]
if (qualifier != null && generateQualifier(expression, qualifier)) return
}
if (!generateCall(expression) && expression.parent !is KtCallExpression) {
createNonSyntheticValue(expression, MagicKind.UNRESOLVED_CALL, generateAndGetReceiverIfAny(expression))
}
}
}
@@ -1366,6 +1371,18 @@ class ControlFlowProcessor(private val trace: BindingTrace) {
createNonSyntheticValue(element, MagicKind.UNSUPPORTED_ELEMENT)
}
private fun generateQualifier(expression: KtExpression, qualifier: Qualifier): Boolean {
val qualifierDescriptor = qualifier.descriptor
if (qualifierDescriptor is ClassDescriptor) {
getFakeDescriptorForObject(qualifierDescriptor)?.let {
mark(expression)
builder.read(expression, AccessTarget.Declaration(it), emptyMap())
return true
}
}
return false
}
private fun generateCall(callElement: KtElement): Boolean {
return checkAndGenerateCall(callElement.getResolvedCall(trace.bindingContext))
}
compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/ControlFlowInstructionsGenerator.kt
+22 -22
View File
@@ -331,21 +331,19 @@ class ControlFlowInstructionsGenerator : ControlFlowBuilderAdapter() {
labelCount = pseudocode.repeatPart(startLabel, finishLabel, labelCount)
}
override fun loadConstant(expression: KtExpression, constant: CompileTimeConstant<*>?): InstructionWithValue {
return read(expression)
}
override fun loadConstant(expression: KtExpression, constant: CompileTimeConstant<*>?) = read(expression)
override fun createAnonymousObject(expression: KtObjectLiteralExpression): InstructionWithValue {
return read(expression)
}
override fun createAnonymousObject(expression: KtObjectLiteralExpression) = read(expression)
override fun createLambda(expression: KtFunction): InstructionWithValue {
return read(if (expression is KtFunctionLiteral) expression.getParent() as KtLambdaExpression else expression)
}
override fun createLambda(expression: KtFunction) =
read(if (expression is KtFunctionLiteral) expression.getParent() as KtLambdaExpression else expression)
override fun loadStringTemplate(expression: KtStringTemplateExpression, inputValues: List<PseudoValue>): InstructionWithValue {
return if (inputValues.isEmpty()) read(expression) else magic(expression, expression, inputValues, MagicKind.STRING_TEMPLATE)
}
override fun loadStringTemplate(
expression: KtStringTemplateExpression,
inputValues: List<PseudoValue>
): InstructionWithValue =
if (inputValues.isEmpty()) read(expression)
else magic(expression, expression, inputValues, MagicKind.STRING_TEMPLATE)
override fun magic(
instructionElement: KtElement,
@@ -367,9 +365,8 @@ class ControlFlowInstructionsGenerator : ControlFlowBuilderAdapter() {
override fun readVariable(
expression: KtExpression,
resolvedCall: ResolvedCall<*>,
receiverValues: Map<PseudoValue, ReceiverValue>): ReadValueInstruction {
return read(expression, resolvedCall, receiverValues)
}
receiverValues: Map<PseudoValue, ReceiverValue>
) = read(expression, resolvedCall, receiverValues)
override fun call(
valueElement: KtElement,
@@ -404,16 +401,19 @@ class ControlFlowInstructionsGenerator : ControlFlowBuilderAdapter() {
}
}
override fun read(
element: KtElement,
target: AccessTarget,
receiverValues: Map<PseudoValue, ReceiverValue>
) = ReadValueInstruction(element, currentScope, target, receiverValues, valueFactory).apply {
add(this)
}
private fun read(
expression: KtExpression,
resolvedCall: ResolvedCall<*>? = null,
receiverValues: Map<PseudoValue, ReceiverValue> = emptyMap<PseudoValue, ReceiverValue>()): ReadValueInstruction {
val accessTarget = if (resolvedCall != null) AccessTarget.Call(resolvedCall) else AccessTarget.BlackBox
val instruction = ReadValueInstruction(
expression, currentScope, accessTarget, receiverValues, valueFactory)
add(instruction)
return instruction
}
receiverValues: Map<PseudoValue, ReceiverValue> = emptyMap<PseudoValue, ReceiverValue>()
) = read(expression, if (resolvedCall != null) AccessTarget.Call(resolvedCall) else AccessTarget.BlackBox, receiverValues)
}
private class TryFinallyBlockInfo(private val finallyBlock: GenerationTrigger) : BlockInfo() {
compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/tower/TowerLevels.kt
+1 -1
View File
@@ -268,7 +268,7 @@ private fun ResolutionScope.getContributedObjectVariables(name: Name, location:
return listOfNotNull(objectDescriptor)
}
private fun getFakeDescriptorForObject(classifier: ClassifierDescriptor?): FakeCallableDescriptorForObject? =
fun getFakeDescriptorForObject(classifier: ClassifierDescriptor?): FakeCallableDescriptorForObject? =
when (classifier) {
is TypeAliasDescriptor ->
getFakeDescriptorForObject(classifier.classDescriptor)
compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.instructions
Vendored
+79
View File
@@ -0,0 +1,79 @@
== O ==
object O {
val y = 1
}
---------------------
L0:
1 <START>
v(val y = 1)
r(1) -> <v0>
w(y|<v0>)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== E ==
enum class E(val x: Int) {
E1(0)
}
---------------------
L0:
1 <START>
v(val x: Int)
magic[FAKE_INITIALIZER](val x: Int) -> <v0>
w(x|<v0>)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== C ==
class C {
companion object {
val z = 2
}
}
---------------------
L0:
1 <START>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== foo ==
fun foo() = E1.x + O.y + C.z
---------------------
L0:
1 <START>
mark(E1.x)
mark(E1)
r(E1) -> <v0>
r(x|<v0>) -> <v1>
mark(O.y)
mark(O)
r(O) -> <v2>
r(y|<v2>) -> <v3>
mark(E1.x + O.y)
call(E1.x + O.y, plus|<v1>, <v3>) -> <v4>
mark(C.z)
mark(C)
r(C, Companion) -> <v5>
r(z|<v5>) -> <v6>
mark(E1.x + O.y + C.z)
call(E1.x + O.y + C.z, plus|<v4>, <v6>) -> <v7>
ret(*|<v7>) L1
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.kt
Vendored
+17
View File
@@ -0,0 +1,17 @@
import E.E1
object O {
val y = 1
}
enum class E(val x: Int) {
E1(0)
}
class C {
companion object {
val z = 2
}
}
fun foo() = E1.x + O.y + C.z
compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.values
Vendored
+37
View File
@@ -0,0 +1,37 @@
== O ==
object O {
val y = 1
}
---------------------
1 <v0>: Int NEW: r(1) -> <v0>
=====================
== E ==
enum class E(val x: Int) {
E1(0)
}
---------------------
<v0>: Int NEW: magic[FAKE_INITIALIZER](val x: Int) -> <v0>
=====================
== C ==
class C {
companion object {
val z = 2
}
}
---------------------
=====================
== foo ==
fun foo() = E1.x + O.y + C.z
---------------------
E1 <v0>: E NEW: r(E1) -> <v0>
x <v1>: Int NEW: r(x|<v0>) -> <v1>
E1.x <v1>: Int COPY
O <v2>: O NEW: r(O) -> <v2>
y <v3>: Int NEW: r(y|<v2>) -> <v3>
O.y <v3>: Int COPY
E1.x + O.y <v4>: Int NEW: call(E1.x + O.y, plus|<v1>, <v3>) -> <v4>
C <v5>: C.Companion NEW: r(C, Companion) -> <v5>
z <v6>: Int NEW: r(z|<v5>) -> <v6>
C.z <v6>: Int COPY
E1.x + O.y + C.z <v7>: Int NEW: call(E1.x + O.y + C.z, plus|<v4>, <v6>) -> <v7>
=====================
compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.instructions
Vendored
+171
View File
@@ -0,0 +1,171 @@
== A ==
class A {
companion object
}
---------------------
L0:
1 <START>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== B ==
object B {
val A.Companion.foo: X get() = X
}
---------------------
L0:
1 <START>
v(val A.Companion.foo: X get() = X)
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== X ==
object X
---------------------
L0:
1 <START>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== C ==
object C {
operator fun X.invoke() = println("Hello!")
}
---------------------
L0:
1 <START>
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== invoke ==
operator fun X.invoke() = println("Hello!")
---------------------
L0:
1 <START>
mark("Hello!")
r("Hello!") -> <v0>
mark(println("Hello!"))
magic[UNRESOLVED_CALL](println("Hello!")|<v0>, !<v1>) -> <v2>
ret(*|<v2>) L1
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== with ==
inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
---------------------
L0:
1 <START>
v(receiver: T)
magic[FAKE_INITIALIZER](receiver: T) -> <v0>
w(receiver|<v0>)
v(block: T.() -> R)
magic[FAKE_INITIALIZER](block: T.() -> R) -> <v1>
w(block|<v1>)
mark(receiver.block())
r(block) -> <v2>
r(receiver) -> <v3>
mark(block())
call(block(), invoke|<v2>, <v3>) -> <v4>
ret(*|<v4>) L1
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
== use ==
fun use() = with(C) {
with(B) {
A.foo()
}
}
---------------------
L0:
1 <START>
r(C) -> <v0>
mark({ with(B) { A.foo() } })
jmp?(L2) NEXT:[r({ with(B) { A.foo() } }) -> <v1>, d({ with(B) { A.foo() } })]
d({ with(B) { A.foo() } }) NEXT:[<SINK>]
L2 [after local declaration]:
r({ with(B) { A.foo() } }) -> <v1> PREV:[jmp?(L2)]
mark(with(C) { with(B) { A.foo() } })
call(with(C) { with(B) { A.foo() } }, with|<v0>, <v1>) -> <v2>
ret(*|<v2>) L1
L1:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>, d({ with(B) { A.foo() } })]
=====================
== anonymous_0 ==
{
with(B) {
A.foo()
}
}
---------------------
L3:
2 <START>
3 mark(with(B) { A.foo() })
r(B) -> <v0>
mark({ A.foo() })
jmp?(L5) NEXT:[r({ A.foo() }) -> <v1>, d({ A.foo() })]
d({ A.foo() }) NEXT:[<SINK>]
L5 [after local declaration]:
r({ A.foo() }) -> <v1> PREV:[jmp?(L5)]
mark(with(B) { A.foo() })
call(with(B) { A.foo() }, with|<v0>, <v1>) -> <v2>
2 ret(*|<v2>) L4
L4:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>, d({ A.foo() })]
=====================
== anonymous_1 ==
{
A.foo()
}
---------------------
L6:
4 <START>
5 mark(A.foo())
mark(A.foo())
magic[IMPLICIT_RECEIVER](foo) -> <v0>
mark(A)
r(A, Companion) -> <v1>
r(foo|<v0>, <v1>) -> <v2>
magic[IMPLICIT_RECEIVER](foo()) -> <v3>
mark(foo())
call(foo(), invoke|<v2>, <v3>) -> <v4>
4 ret(*|<v4>) L7
L7:
<END> NEXT:[<SINK>]
error:
<ERROR> PREV:[]
sink:
<SINK> PREV:[<ERROR>, <END>]
=====================
compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.kt
Vendored
+21
View File
@@ -0,0 +1,21 @@
class A {
companion object
}
object B {
val A.Companion.foo: X get() = X
}
object X
object C {
operator fun X.invoke() = println("Hello!")
}
inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
fun use() = with(C) {
with(B) {
A.foo()
}
}
compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.values
Vendored
+75
View File
@@ -0,0 +1,75 @@
== A ==
class A {
companion object
}
---------------------
=====================
== B ==
object B {
val A.Companion.foo: X get() = X
}
---------------------
=====================
== X ==
object X
---------------------
=====================
== C ==
object C {
operator fun X.invoke() = println("Hello!")
}
---------------------
=====================
== invoke ==
operator fun X.invoke() = println("Hello!")
---------------------
println !<v1>: *
"Hello!" <v0>: * NEW: r("Hello!") -> <v0>
println("Hello!") <v2>: {<: [ERROR : Error function type]} NEW: magic[UNRESOLVED_CALL](println("Hello!")|<v0>, !<v1>) -> <v2>
=====================
== with ==
inline fun <T, R> with(receiver: T, block: T.() -> R): R = receiver.block()
---------------------
<v0>: {<: T} NEW: magic[FAKE_INITIALIZER](receiver: T) -> <v0>
<v1>: {<: T.() -> R} NEW: magic[FAKE_INITIALIZER](block: T.() -> R) -> <v1>
receiver <v3>: {<: T} NEW: r(receiver) -> <v3>
block <v2>: {<: (T) -> R} NEW: r(block) -> <v2>
block() <v4>: {<: R} NEW: call(block(), invoke|<v2>, <v3>) -> <v4>
receiver.block() <v4>: {<: R} COPY
=====================
== use ==
fun use() = with(C) {
with(B) {
A.foo()
}
}
---------------------
C <v0>: C NEW: r(C) -> <v0>
{ with(B) { A.foo() } } <v1>: {<: C.() -> ???} NEW: r({ with(B) { A.foo() } }) -> <v1>
with(C) { with(B) { A.foo() } } <v2>: {<: [ERROR : Error function type]} NEW: call(with(C) { with(B) { A.foo() } }, with|<v0>, <v1>) -> <v2>
=====================
== anonymous_0 ==
{
with(B) {
A.foo()
}
}
---------------------
B <v0>: B NEW: r(B) -> <v0>
{ A.foo() } <v1>: {<: B.() -> ???} NEW: r({ A.foo() }) -> <v1>
with(B) { A.foo() } <v2>: {<: ???} NEW: call(with(B) { A.foo() }, with|<v0>, <v1>) -> <v2>
with(B) { A.foo() } <v2>: {<: ???} COPY
=====================
== anonymous_1 ==
{
A.foo()
}
---------------------
<v0>: B NEW: magic[IMPLICIT_RECEIVER](foo) -> <v0>
<v3>: C NEW: magic[IMPLICIT_RECEIVER](foo()) -> <v3>
A <v1>: A.Companion NEW: r(A, Companion) -> <v1>
foo <v2>: X NEW: r(foo|<v0>, <v1>) -> <v2>
foo() <v4>: {<: [ERROR : Error function type]} NEW: call(foo(), invoke|<v2>, <v3>) -> <v4>
A.foo() <v4>: {<: [ERROR : Error function type]} COPY
A.foo() <v4>: {<: [ERROR : Error function type]} COPY
=====================
compiler/testData/cfg/declarations/functions/typeParameter.values
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ fun <T> foo() {
}
---------------------
T <v0>: * NEW: magic[UNRESOLVED_CALL](T) -> <v0>
{ T } <v0>: * COPY
{ T } <v0>: * COPY
=====================
compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.kt
Vendored
+9
View File
@@ -0,0 +1,9 @@
// FILE: Owner.java
public class Owner {
public static final String name = "Owner";
}
// FILE: Use.kt
val x = Owner.name
compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.txt
Vendored
+13
View File
@@ -0,0 +1,13 @@
package
public val x: kotlin.String = "Owner"
public open class Owner {
public constructor Owner()
public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
// Static members
public const final val name: kotlin.String = "Owner"
}
compiler/tests/org/jetbrains/kotlin/cfg/ControlFlowTestGenerated.java
+12
View File
@@ -374,6 +374,18 @@ public class ControlFlowTestGenerated extends AbstractControlFlowTest {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt");
doTest(fileName);
}
@TestMetadata("ObjectEnumQualifiers.kt")
public void testObjectEnumQualifiers() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.kt");
doTest(fileName);
}
@TestMetadata("QualifierReceiverWithOthers.kt")
public void testQualifierReceiverWithOthers() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.kt");
doTest(fileName);
}
}
@TestMetadata("compiler/testData/cfg/declarations/functionLiterals")
compiler/tests/org/jetbrains/kotlin/cfg/PseudoValueTestGenerated.java
+12
View File
@@ -376,6 +376,18 @@ public class PseudoValueTestGenerated extends AbstractPseudoValueTest {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/delegationBySuperCall.kt");
doTest(fileName);
}
@TestMetadata("ObjectEnumQualifiers.kt")
public void testObjectEnumQualifiers() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/ObjectEnumQualifiers.kt");
doTest(fileName);
}
@TestMetadata("QualifierReceiverWithOthers.kt")
public void testQualifierReceiverWithOthers() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/cfg/declarations/classesAndObjects/QualifierReceiverWithOthers.kt");
doTest(fileName);
}
}
@TestMetadata("compiler/testData/cfg/declarations/functionLiterals")
compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java
+6
View File
@@ -13959,6 +13959,12 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest {
doTest(fileName);
}
@TestMetadata("JavaQualifier.kt")
public void testJavaQualifier() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/JavaQualifier.kt");
doTest(fileName);
}
@TestMetadata("PackageVsClass.kt")
public void testPackageVsClass() throws Exception {
String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/qualifiedExpression/PackageVsClass.kt");