Introduce typeRef for FirExpression

This helps both body resolve & conversion to IR
2019-03-21 11:29:08 +03:00
parent adeeeeee48
commit aa6ba1cd4a
29 changed files with 205 additions and 24 deletions
@@ -100,13 +100,13 @@ open class FirBodyResolveTransformer(val session: FirSession, val implicitTypeOn
                )
            }
            FirOperation.AS -> {
-                bindingContext[resolved] = resolved.typeRef
+                bindingContext[resolved] = resolved.conversionTypeRef
            }
            FirOperation.SAFE_AS -> {
                bindingContext[resolved] =
-                    resolved.typeRef.withReplacedConeType(
+                    resolved.conversionTypeRef.withReplacedConeType(
                        session,
-                        resolved.typeRef.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE)
+                        resolved.conversionTypeRef.coneTypeUnsafe().withNullability(ConeNullability.NULLABLE)
                    )
            }
            else -> error("Unknown type operator")
@@ -618,7 +618,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
        print(" ")
        print(typeOperatorCall.operation.operator)
        print(" ")
-        typeOperatorCall.typeRef.accept(this)
+        typeOperatorCall.conversionTypeRef.accept(this)
        print(")")
    }

@@ -853,7 +853,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
        print(operatorCall.operation.operator)
        if (operatorCall is FirTypeOperatorCall) {
            print("/")
-            operatorCall.typeRef.accept(this)
+            operatorCall.conversionTypeRef.accept(this)
        }
        visitCall(operatorCall)
    }
@@ -882,7 +882,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
        classReferenceExpression.annotations.renderAnnotations()
        print("<getClass>")
        print("(")
-        classReferenceExpression.typeRef.accept(this)
+        classReferenceExpression.classTypeRef.accept(this)
        print(")")
    }

@@ -25,6 +25,7 @@ interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, F
            parameter.accept(visitor, data)
        }
        body?.accept(visitor, data)
-        // Don't call super<FirExpression>.acceptChildren (annotations are already processed)
+        typeRef.accept(visitor, data)
+        // Don't call super<FirExpression>.acceptChildren (annotations & typeRef are already processed)
    }
 }
@@ -19,6 +19,7 @@ interface FirEnumEntry : @VisitedSupertype FirRegularClass, FirCall {
        for (argument in arguments) {
            argument.accept(visitor, data)
        }
+        typeRef.accept(visitor, data)
        super<FirRegularClass>.acceptChildren(visitor, data)
    }
 }
@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer

 class FirAnonymousFunctionImpl(
@@ -20,9 +21,16 @@ class FirAnonymousFunctionImpl(
    override var returnTypeRef: FirTypeRef,
    override var receiverTypeRef: FirTypeRef?
 ) : FirAbstractFunction(session, psi), FirAnonymousFunction, FirModifiableFunction {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
    override var label: FirLabel? = null

+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
        returnTypeRef = returnTypeRef.transformSingle(transformer, data)
        receiverTypeRef = receiverTypeRef?.transformSingle(transformer, data)
        label = label?.transformSingle(transformer, data)
@@ -11,7 +11,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousObject
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor

@@ -19,15 +21,22 @@ class FirAnonymousObjectImpl(
    session: FirSession,
    psi: PsiElement?
 ) : FirAbstractAnnotatedDeclaration(session, psi), FirAnonymousObject, FirModifiableClass {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
    override val superTypeRefs = mutableListOf<FirTypeRef>()

    override val declarations = mutableListOf<FirDeclaration>()

+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
        return super<FirAnonymousObject>.accept(visitor, data)
    }

    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
        superTypeRefs.transformInplace(transformer, data)
        declarations.transformInplace(transformer, data)

@@ -11,8 +11,14 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name

 class FirEnumEntryImpl(
@@ -35,5 +41,18 @@ class FirEnumEntryImpl(
    isData = false,
    isInline = false
 ), FirEnumEntry {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
    override val arguments = mutableListOf<FirExpression>()
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClass {
+        typeRef = typeRef.transformSingle(transformer, data)
+        arguments.transformInplace(transformer, data)
+
+        return super<FirClassImpl>.transformChildren(transformer, data)
+    }
 }
@@ -17,7 +17,7 @@ class FirErrorLoop(
    session: FirSession,
    psi: PsiElement?,
    override val reason: String
-) : FirAbstractElement(session, psi), FirErrorExpression, FirLoop {
+) : FirAbstractElement(session, psi), FirErrorStatement, FirLoop {
    override val annotations: List<FirAnnotationCall> = listOf()

    override val condition: FirExpression = FirErrorExpressionImpl(session, psi, reason)
@@ -25,7 +25,7 @@ class FirErrorLoop(
    override val block: FirBlock = FirEmptyExpressionBlock(session)

    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
-        return super<FirErrorExpression>.accept(visitor, data)
+        return super<FirErrorStatement>.accept(visitor, data)
    }

    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
@@ -22,6 +22,7 @@ interface FirArraySetCall : @VisitedSupertype FirCall, FirAssignment {
            index.accept(visitor, data)
        }
        acceptAnnotations(visitor, data)
+        typeRef.accept(visitor, data)
        super<FirAssignment>.acceptChildren(visitor, data)
    }
 }
@@ -17,6 +17,7 @@ interface FirBlock : FirExpression {
        for (statement in statements) {
            statement.accept(visitor, data)
        }
+        typeRef.accept(visitor, data)
        super.acceptChildren(visitor, data)
    }
 }
@@ -9,7 +9,7 @@ import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor

 interface FirClassReferenceExpression : FirExpression {
-    val typeRef: FirTypeRef
+    val classTypeRef: FirTypeRef

    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
        visitor.visitClassReferenceExpression(this, data)
@@ -0,0 +1,15 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirErrorStatement : FirStatement {
+    val reason: String
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitErrorStatement(this, data)
+}
@@ -7,11 +7,21 @@ package org.jetbrains.kotlin.fir.expressions

 import org.jetbrains.kotlin.fir.FirResolvedCallableReference
 import org.jetbrains.kotlin.fir.symbols.ConeCallableSymbol
+import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.visitors.FirVisitor

 interface FirExpression : FirStatement {
+    val typeRef: FirTypeRef
+
+    fun replaceTypeRef(newTypeRef: FirTypeRef)
+
    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
        visitor.visitExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super.acceptChildren(visitor, data)
+        typeRef.accept(visitor, data)
+    }
 }

 fun FirExpression.toResolvedCallableReference(): FirResolvedCallableReference? {
@@ -23,6 +23,7 @@ interface FirFunctionCall : @VisitedSupertype FirCall, FirQualifiedAccess, FirTy
        for (typeArgument in typeArguments) {
            typeArgument.accept(visitor, data)
        }
+        typeRef.accept(visitor, data)
        super<FirQualifiedAccess>.acceptChildren(visitor, data)
    }
 }
@@ -14,5 +14,6 @@ interface FirQualifiedAccessExpression : @VisitedSupertype FirQualifiedAccess, F

    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
        super<FirQualifiedAccess>.acceptChildren(visitor, data)
+        typeRef.accept(visitor, data)
    }
 }
@@ -12,13 +12,13 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 interface FirTypeOperatorCall : FirOperatorCall {
    val argument: FirExpression get() = arguments.first()

-    val typeRef: FirTypeRef
+    val conversionTypeRef: FirTypeRef

    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
        visitor.visitTypeOperatorCall(this, data)

    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        typeRef.accept(visitor, data)
+        conversionTypeRef.accept(visitor, data)
        super.acceptChildren(visitor, data)
    }
 }
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.expressions.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractBlock(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedElement(session, psi), FirBlock {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+    }
+}
@@ -6,10 +6,28 @@
 package org.jetbrains.kotlin.fir.expressions.impl

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer

 abstract class FirAbstractExpression(
    session: FirSession,
    psi: PsiElement?
-) : FirAbstractStatement(session, psi), FirExpression
+) : FirAbstractStatement(session, psi), FirExpression {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractStatement>.transformChildren(transformer, data)
+    }
+}
@@ -13,6 +13,9 @@ import org.jetbrains.kotlin.fir.expressions.FirArraySetCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirOperation
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor

@@ -22,12 +25,19 @@ class FirArraySetCallImpl(
    value: FirExpression,
    operation: FirOperation
 ) : FirAbstractAssignment(session, psi, value, operation, false), FirArraySetCall {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
    override val indexes = mutableListOf<FirExpression>()

    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
        super<FirArraySetCall>.accept(visitor, data)

    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
        indexes.transformInplace(transformer, data)

        return super<FirAbstractAssignment>.transformChildren(transformer, data)
@@ -16,11 +16,11 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirBlockImpl(
    session: FirSession,
    psi: PsiElement?
-) : FirAbstractAnnotatedElement(session, psi), FirBlock {
+) : FirAbstractBlock(session, psi), FirBlock {
    override val statements = mutableListOf<FirStatement>()

    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
        statements.transformInplace(transformer, data)
-        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+        return super<FirAbstractBlock>.transformChildren(transformer, data)
    }
 }
@@ -6,10 +6,27 @@
 package org.jetbrains.kotlin.fir.expressions.impl

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer

 class FirCallableReferenceAccessImpl(
    session: FirSession,
    psi: PsiElement?
-) : FirAbstractQualifiedAccess(session, psi), FirCallableReferenceAccess
+) : FirAbstractQualifiedAccess(session, psi), FirCallableReferenceAccess {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+    }
+}
@@ -16,10 +16,10 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirClassReferenceExpressionImpl(
    session: FirSession,
    psi: PsiElement?,
-    override var typeRef: FirTypeRef
+    override var classTypeRef: FirTypeRef
 ) : FirAbstractExpression(session, psi), FirClassReferenceExpression {
    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        classTypeRef = classTypeRef.transformSingle(transformer, data)
        return super<FirAbstractExpression>.transformChildren(transformer, data)
    }
 }
@@ -10,6 +10,6 @@ import org.jetbrains.kotlin.fir.expressions.FirBlock

 class FirEmptyExpressionBlock(
    session: FirSession
-) : FirAbstractAnnotatedElement(session, null), FirBlock {
+) : FirAbstractBlock(session, null), FirBlock {
    override val statements = listOf()
 }
@@ -6,11 +6,28 @@
 package org.jetbrains.kotlin.fir.expressions.impl

 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.impl.FirImplicitTypeRefImpl
+import org.jetbrains.kotlin.fir.visitors.FirTransformer

 class FirQualifiedAccessExpressionImpl(
    session: FirSession,
    psi: PsiElement?,
    safe: Boolean = false
-) : FirAbstractQualifiedAccess(session, psi, safe), FirQualifiedAccessExpression
+) : FirAbstractQualifiedAccess(session, psi, safe), FirQualifiedAccessExpression {
+    override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(session, null)
+
+    override fun replaceTypeRef(newTypeRef: FirTypeRef) {
+        typeRef = newTypeRef
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeRef = typeRef.transformSingle(transformer, data)
+
+        return super<FirAbstractQualifiedAccess>.transformChildren(transformer, data)
+    }
+}
@@ -15,12 +15,12 @@ import org.jetbrains.kotlin.fir.visitors.FirTransformer
 class FirSingleExpressionBlock(
    session: FirSession,
    private var statement: FirStatement
-) : FirAbstractAnnotatedElement(session, statement.psi), FirBlock {
+) : FirAbstractBlock(session, statement.psi), FirBlock {
    override val statements
        get() = listOf(statement)

    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
        statement = statement.transformSingle(transformer, data)
-        return super<FirAbstractAnnotatedElement>.transformChildren(transformer, data)
+        return super<FirAbstractBlock>.transformChildren(transformer, data)
    }
 }
@@ -18,10 +18,10 @@ class FirTypeOperatorCallImpl(
    session: FirSession,
    psi: PsiElement?,
    override val operation: FirOperation,
-    override var typeRef: FirTypeRef
+    override var conversionTypeRef: FirTypeRef
 ) : FirAbstractCall(session, psi), FirTypeOperatorCall {
    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        typeRef = typeRef.transformSingle(transformer, data)
+        conversionTypeRef = conversionTypeRef.transformSingle(transformer, data)
        return super<FirAbstractCall>.transformChildren(transformer, data)
    }
 }
@@ -180,6 +180,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformClass(modifiableClass, data)
    }

+    open fun transformErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirStatement> {
+        return transformStatement(errorStatement, data)
+    }
+
    open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult<FirStatement> {
        return transformStatement(expression, data)
    }
@@ -504,6 +508,10 @@ abstract class FirTransformer<in D> : FirVisitor<CompositeTransformResult<FirEle
        return transformErrorExpression(errorExpression, data)
    }

+    final override fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): CompositeTransformResult<FirElement> {
+        return transformErrorStatement(errorStatement, data)
+    }
+
    final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: D): CompositeTransformResult<FirElement> {
        return transformErrorTypeRef(errorTypeRef, data)
    }
@@ -180,6 +180,10 @@ abstract class FirVisitor<out R, in D> {
        return visitClass(modifiableClass, data)
    }

+    open fun visitErrorStatement(errorStatement: FirErrorStatement, data: D): R {
+        return visitStatement(errorStatement, data)
+    }
+
    open fun visitExpression(expression: FirExpression, data: D): R {
        return visitStatement(expression, data)
    }
@@ -180,6 +180,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitClass(modifiableClass, null)
    }

+    open fun visitErrorStatement(errorStatement: FirErrorStatement) {
+        visitStatement(errorStatement, null)
+    }
+
    open fun visitExpression(expression: FirExpression) {
        visitStatement(expression, null)
    }
@@ -504,6 +508,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitErrorExpression(errorExpression)
    }

+    final override fun visitErrorStatement(errorStatement: FirErrorStatement, data: Nothing?) {
+        visitErrorStatement(errorStatement)
+    }
+
    final override fun visitErrorTypeRef(errorTypeRef: FirErrorTypeRef, data: Nothing?) {
        visitErrorTypeRef(errorTypeRef)
    }