Raw FIR: implement expression trees & conversions from PSI

Testing: total kotlin test controls no stubs in FIR in non-stub-mode
#KT-29002 Fixed

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractElement.kt

@@ -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
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+
+abstract class FirAbstractElement(
+    final override val session: FirSession,
+    final override val psi: PsiElement?
+) : FirElement

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirAbstractTarget.kt

@@ -0,0 +1,16 @@
+/*
+ * 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
+
+abstract class FirAbstractTarget<E : FirTargetElement>(
+    override val labelName: String?
+) : FirTarget<E> {
+    override lateinit var labeledElement: E
+
+    override fun bind(element: E) {
+        labeledElement = element
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirFunctionTarget.kt

@@ -0,0 +1,12 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+
+class FirFunctionTarget(
+    labelName: String?
+) : FirAbstractTarget<FirFunction>(labelName)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirLabel.kt

@@ -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
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirLabel : FirElement {
+    val name: String
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitLabel(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirLabeledElement.kt

@@ -0,0 +1,21 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+// Target element which may have label
+interface FirLabeledElement : FirTargetElement {
+    val label: FirLabel? get() = null
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitLabeledElement(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        label?.accept(visitor, data)
+    }
+
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirLoopTarget.kt

@@ -0,0 +1,12 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.expressions.FirLoop
+
+class FirLoopTarget(
+    labelName: String?
+) : FirAbstractTarget<FirLoop>(labelName)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirNamedReference.kt

@@ -0,0 +1,16 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import org.jetbrains.kotlin.name.Name
+
+interface FirNamedReference : FirReference {
+    val name: Name
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitNamedReference(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirReference.kt

@@ -0,0 +1,13 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirReference : FirElement {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitReference(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.impl.*
 import org.jetbrains.kotlin.fir.symbols.ConeClassLikeSymbol
 import org.jetbrains.kotlin.fir.symbols.ConeSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirTypeParameterSymbol
@@ -141,7 +142,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         if (memberDeclaration is FirCallableMember && memberDeclaration.isOverride) {
             print("override ")
         }
-        if (memberDeclaration is FirClass) {
+        if (memberDeclaration is FirRegularClass) {
             if (memberDeclaration.isInner) {
                 print("inner ")
             }
@@ -193,35 +194,62 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
     override fun visitDeclaration(declaration: FirDeclaration) {
         print(
             when (declaration) {
-                is FirClass -> declaration.classKind.name.toLowerCase().replace("_", " ")
+                is FirRegularClass -> declaration.classKind.name.toLowerCase().replace("_", " ")
                 is FirTypeAlias -> "typealias"
                 is FirNamedFunction -> "function"
                 is FirProperty -> "property"
+                is FirVariable -> if (declaration.isVal) "val" else "var"
                 else -> "unknown"
             }
         )
     }
 
     override fun visitEnumEntry(enumEntry: FirEnumEntry) {
-        visitClass(enumEntry)
+        visitRegularClass(enumEntry)
     }
 
-    override fun visitClass(klass: FirClass) {
-        visitMemberDeclaration(klass)
-        if (klass.superTypes.isNotEmpty()) {
-            print(" : ")
-            klass.superTypes.renderSeparated()
-        }
+    private fun FirDeclarationContainer.renderDeclarations() {
         println(" {")
         pushIndent()
-        for (declaration in klass.declarations) {
-            declaration.accept(this)
+        for (declaration in declarations) {
+            declaration.accept(this@FirRenderer)
             println()
         }
         popIndent()
         println("}")
     }
 
+    override fun visitRegularClass(regularClass: FirRegularClass) {
+        visitMemberDeclaration(regularClass)
+        if (regularClass.superTypes.isNotEmpty()) {
+            print(" : ")
+            regularClass.superTypes.renderSeparated()
+        }
+        regularClass.renderDeclarations()
+    }
+
+    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject) {
+        anonymousObject.annotations.renderAnnotations()
+        print("object : ")
+        anonymousObject.superTypes.renderSeparated()
+        anonymousObject.renderDeclarations()
+    }
+
+    override fun visitVariable(variable: FirVariable) {
+        variable.annotations.renderAnnotations()
+        visitNamedDeclaration(variable)
+        print(": ")
+        variable.returnType.accept(this)
+        variable.initializer?.let {
+            print(" = ")
+            it.accept(this)
+        }
+        variable.delegate?.let {
+            print("by ")
+            it.accept(this)
+        }
+    }
+
     override fun visitProperty(property: FirProperty) {
         visitCallableMember(property)
         property.initializer?.let {
@@ -276,6 +304,26 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         propertyAccessor.body?.accept(this)
     }
 
+    override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction) {
+        anonymousFunction.annotations.renderAnnotations()
+        val label = anonymousFunction.label
+        if (label != null) {
+            print("${label.name}@")
+        }
+        print("function ")
+        val receiverType = anonymousFunction.receiverType
+        if (receiverType != null) {
+            print(" ")
+            receiverType.accept(this)
+            print(".")
+        }
+        print("<anonymous>")
+        anonymousFunction.valueParameters.renderParameters()
+        print(": ")
+        anonymousFunction.returnType.accept(this)
+        anonymousFunction.body?.accept(this)
+    }
+
     override fun visitFunction(function: FirFunction) {
         function.valueParameters.renderParameters()
         visitDeclarationWithBody(function)
@@ -291,10 +339,10 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         declarationWithBody.body?.accept(this)
     }
 
-    override fun visitBody(body: FirBody) {
+    override fun visitBlock(block: FirBlock) {
         println(" {")
         pushIndent()
-        for (statement in body.statements) {
+        for (statement in block.statements) {
             statement.accept(this)
             println()
         }
@@ -348,10 +396,6 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         }
     }
 
-    override fun visitVariable(variable: FirVariable) {
-        visitDeclaration(variable)
-    }
-
     override fun visitImport(import: FirImport) {
         visitElement(import)
     }
@@ -360,11 +404,128 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         visitElement(statement)
     }
 
+    override fun visitReturnExpression(returnExpression: FirReturnExpression) {
+        returnExpression.annotations.renderAnnotations()
+        print("return")
+        val target = returnExpression.target
+        val labeledElement = target.labeledElement
+        if (labeledElement is FirNamedFunction) {
+            print("@@@${labeledElement.name}")
+        } else {
+            val labelName = target.labelName
+            if (labelName != null) {
+                if (labeledElement is FirAnonymousFunction) {
+                    print("@@")
+                }
+                print("@$labelName")
+            }
+        }
+        print(" ")
+        returnExpression.result.accept(this)
+    }
+
+    override fun visitWhenBranch(whenBranch: FirWhenBranch) {
+        val condition = whenBranch.condition
+        if (condition is FirElseIfTrueCondition) {
+            print("else")
+        } else {
+            condition.accept(this)
+        }
+        print(" -> ")
+        whenBranch.result.accept(this)
+    }
+
+    override fun visitWhenExpression(whenExpression: FirWhenExpression) {
+        whenExpression.annotations.renderAnnotations()
+        print("when (")
+        val subjectVariable = whenExpression.subjectVariable
+        if (subjectVariable != null) {
+            subjectVariable.accept(this)
+        } else {
+            whenExpression.subject?.accept(this)
+        }
+        println(") {")
+        pushIndent()
+        for (branch in whenExpression.branches) {
+            branch.accept(this)
+        }
+        popIndent()
+        println("}")
+    }
+
+    override fun visitTryExpression(tryExpression: FirTryExpression) {
+        tryExpression.annotations.renderAnnotations()
+        print("try")
+        tryExpression.tryBlock.accept(this)
+        for (catchClause in tryExpression.catches) {
+            print("catch (")
+            catchClause.parameter.accept(this)
+            print(")")
+            catchClause.block.accept(this)
+        }
+        val finallyBlock = tryExpression.finallyBlock ?: return
+        print("finally")
+        finallyBlock.accept(this)
+    }
+
+    override fun visitDoWhileLoop(doWhileLoop: FirDoWhileLoop) {
+        val label = doWhileLoop.label
+        if (label != null) {
+            print("${label.name}@")
+        }
+        print("do")
+        doWhileLoop.block.accept(this)
+        print("while(")
+        doWhileLoop.condition.accept(this)
+        print(")")
+    }
+
+    override fun visitWhileLoop(whileLoop: FirWhileLoop) {
+        val label = whileLoop.label
+        if (label != null) {
+            print("${label.name}@")
+        }
+        print("while(")
+        whileLoop.condition.accept(this)
+        print(")")
+        whileLoop.block.accept(this)
+    }
+
+    private fun visitLoopJump(jump: FirJump<FirLoop>) {
+        val target = jump.target
+        val labeledElement = target.labeledElement
+        print("@@@[")
+        labeledElement.condition.accept(this)
+        print("] ")
+    }
+
+    override fun visitBreakExpression(breakExpression: FirBreakExpression) {
+        breakExpression.annotations.renderAnnotations()
+        print("break")
+        visitLoopJump(breakExpression)
+    }
+
+    override fun visitContinueExpression(continueExpression: FirContinueExpression) {
+        continueExpression.annotations.renderAnnotations()
+        print("continue")
+        visitLoopJump(continueExpression)
+    }
+
     override fun visitExpression(expression: FirExpression) {
-        print("STUB")
+        expression.annotations.renderAnnotations()
+        print(
+            when (expression) {
+                is FirExpressionStub -> "STUB"
+                is FirUnitExpression -> "Unit"
+                is FirWhenSubjectExpression -> "\$subj\$"
+                is FirElseIfTrueCondition -> "else"
+                else -> "??? ${expression.javaClass}"
+            }
+        )
     }
 
     override fun <T> visitConstExpression(constExpression: FirConstExpression<T>) {
+        constExpression.annotations.renderAnnotations()
         print("${constExpression.kind}(${constExpression.value})")
     }
 
@@ -406,7 +567,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
     }
 
     override fun visitDelegatedType(delegatedType: FirDelegatedType) {
-        delegatedType.accept(this)
+        delegatedType.type.accept(this)
         print(" by ")
         delegatedType.delegate?.accept(this)
     }
@@ -460,7 +621,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
                 val sb = StringBuilder()
                 sb.append(symbol.classId.asString())
                 if (typeArguments.isNotEmpty()) {
-                    sb.append(typeArguments.joinToString(prefix = "<", postfix = ">") { it ->
+                    sb.append(typeArguments.joinToString(prefix = "<", postfix = ">") {
                         when (it) {
                             StarProjection -> "*"
                             is ConeKotlinTypeProjectionIn -> "in ${it.type.asString()}"
@@ -530,4 +691,130 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() {
         print("*")
     }
 
+    override fun visitNamedReference(namedReference: FirNamedReference) {
+        print("${namedReference.name}#")
+    }
+
+    override fun visitThisReference(thisReference: FirThisReference) {
+        print("this")
+        val labelName = thisReference.labelName
+        if (labelName != null) {
+            print("@$labelName")
+        } else {
+            print("#")
+        }
+    }
+
+    override fun visitSuperReference(superReference: FirSuperReference) {
+        print("super<")
+        superReference.superType.accept(this)
+        print(">")
+    }
+
+    override fun visitAccess(access: FirAccess) {
+        val explicitReceiver = access.explicitReceiver
+        if (explicitReceiver != null) {
+            explicitReceiver.accept(this)
+            if (access.safe) {
+                print("?.")
+            } else {
+                print(".")
+            }
+        }
+    }
+
+    override fun visitCallableReferenceAccess(callableReferenceAccess: FirCallableReferenceAccess) {
+        callableReferenceAccess.annotations.renderAnnotations()
+        callableReferenceAccess.explicitReceiver?.accept(this)
+        print("::")
+        callableReferenceAccess.calleeReference.accept(this)
+    }
+
+    override fun visitAccessExpression(accessExpression: FirAccessExpression) {
+        accessExpression.annotations.renderAnnotations()
+        visitAccess(accessExpression)
+        accessExpression.calleeReference.accept(this)
+    }
+
+    override fun visitAssignment(assignment: FirAssignment) {
+        print(assignment.operation.operator)
+        print(" ")
+        assignment.value.accept(this)
+    }
+
+    override fun visitPropertyAssignment(propertyAssignment: FirPropertyAssignment) {
+        propertyAssignment.annotations.renderAnnotations()
+        visitAccess(propertyAssignment)
+        propertyAssignment.calleeReference.accept(this)
+        print(" ")
+        visitAssignment(propertyAssignment)
+    }
+
+    override fun visitArraySetCall(arraySetCall: FirArraySetCall) {
+        arraySetCall.annotations.renderAnnotations()
+        visitAccess(arraySetCall)
+        arraySetCall.calleeReference.accept(this)
+        print("[")
+        arraySetCall.arguments.renderSeparated()
+        print("] ")
+        visitAssignment(arraySetCall)
+    }
+
+    override fun visitFunctionCall(functionCall: FirFunctionCall) {
+        functionCall.annotations.renderAnnotations()
+        visitAccess(functionCall)
+        functionCall.calleeReference.accept(this)
+        if (functionCall.typeArguments.isNotEmpty()) {
+            print("<")
+            functionCall.typeArguments.renderSeparated()
+            print(">")
+        }
+        visitCall(functionCall)
+    }
+
+    override fun visitOperatorCall(operatorCall: FirOperatorCall) {
+        operatorCall.annotations.renderAnnotations()
+        print(operatorCall.operation.operator)
+        if (operatorCall is FirTypeOperatorCall) {
+            print("/")
+            operatorCall.type.accept(this)
+        }
+        visitCall(operatorCall)
+    }
+
+    override fun visitArrayGetCall(arrayGetCall: FirArrayGetCall) {
+        arrayGetCall.annotations.renderAnnotations()
+        arrayGetCall.array.accept(this)
+        print("[")
+        arrayGetCall.arguments.renderSeparated()
+        print("]")
+    }
+
+    override fun visitComponentCall(componentCall: FirComponentCall) {
+        componentCall.annotations.renderAnnotations()
+        print("component${componentCall.componentIndex}")
+        visitCall(componentCall)
+    }
+
+    override fun visitGetClassCall(getClassCall: FirGetClassCall) {
+        getClassCall.annotations.renderAnnotations()
+        print("<getClass>")
+        visitCall(getClassCall)
+    }
+
+    override fun visitArrayOfCall(arrayOfCall: FirArrayOfCall) {
+        arrayOfCall.annotations.renderAnnotations()
+        print("<implicitArrayOf>")
+        visitCall(arrayOfCall)
+    }
+
+    override fun visitThrowExpression(throwExpression: FirThrowExpression) {
+        throwExpression.annotations.renderAnnotations()
+        print("throw ")
+        throwExpression.exception.accept(this)
+    }
+
+    override fun visitErrorExpression(errorExpression: FirErrorExpression) {
+        print("ERROR_EXPR(${errorExpression.reason})")
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSuperReference.kt

@@ -0,0 +1,20 @@
+/*
+ * 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
+
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirSuperReference : FirReference {
+    val superType: FirType
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitSuperReference(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        superType.accept(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirTarget.kt

@@ -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
+
+// Reference to some label
+interface FirTarget<E : FirTargetElement> {
+    val labelName: String?
+
+    val labeledElement: E
+
+    fun bind(element: E)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirTargetElement.kt

@@ -0,0 +1,9 @@
+/*
+ * 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
+
+// Any target of return / break / continue (some targets may have labels, some never have them)
+interface FirTargetElement : FirElement

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirThisReference.kt

@@ -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
+
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirThisReference : FirReference {
+    val labelName: String?
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitThisReference(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousFunction.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.declarations
+
+import org.jetbrains.kotlin.fir.FirLabeledElement
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirAnonymousFunction : @VisitedSupertype FirFunction, FirExpression, FirTypedDeclaration, FirLabeledElement {
+    val receiverType: FirType?
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitAnonymousFunction(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirTypedDeclaration>.acceptChildren(visitor, data)
+        super<FirLabeledElement>.acceptChildren(visitor, data)
+        receiverType?.accept(visitor, data)
+        for (parameter in valueParameters) {
+            parameter.accept(visitor, data)
+        }
+        body?.accept(visitor, data)
+        // Don't call super<FirExpression>.acceptChildren (annotations are already processed)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousObject.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.declarations
+
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirAnonymousObject : @VisitedSupertype FirClass, FirExpression {
+    override val classKind: ClassKind
+        get() = ClassKind.OBJECT
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitAnonymousObject(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirClass>.acceptChildren(visitor, data)
+        super<FirExpression>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt

@@ -1,41 +1,26 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * 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.declarations
 
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.BaseTransformedType
-import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-// May be all containers should be properties and not base classes
-// About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end
-@BaseTransformedType
-interface FirClass : FirDeclarationContainer, FirMemberDeclaration, FirSymbolOwner<FirClass> {
+interface FirClass : FirDeclarationContainer, FirStatement, FirAnnotationContainer {
     // including delegated types
     val superTypes: List<FirType>
 
     val classKind: ClassKind
 
-    val isInner: Boolean get() = status.isInner
-
-    val isCompanion: Boolean get() = status.isCompanion
-
-    val isData: Boolean get() = status.isData
-
-    val isInline: Boolean get() = status.isInline
-
-    override val symbol: FirClassSymbol
-
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitClass(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
-        super.acceptChildren(visitor, data)
         for (superType in superTypes) {
             superType.accept(visitor, data)
         }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationWithBody.kt

@@ -5,11 +5,11 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 interface FirDeclarationWithBody : FirDeclaration {
-    val body: FirBody?
+    val body: FirBlock?
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitDeclarationWithBody(this, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirCall
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirEnumEntry : @VisitedSupertype FirClass, FirCall {
+interface FirEnumEntry : @VisitedSupertype FirRegularClass, FirCall {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitEnumEntry(this, data)
 
@@ -19,6 +19,6 @@ interface FirEnumEntry : @VisitedSupertype FirClass, FirCall {
         for (argument in arguments) {
             argument.accept(visitor, data)
         }
-        super<FirClass>.acceptChildren(visitor, data)
+        super<FirRegularClass>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorDeclaration.kt

@@ -9,6 +9,8 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // Is it necessary?
 interface FirErrorDeclaration : FirDeclaration {
+    val reason: String
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitErrorDeclaration(this, data)
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt

@@ -5,11 +5,14 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import org.jetbrains.kotlin.fir.FirTargetElement
+import org.jetbrains.kotlin.fir.VisitedSupertype
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.expressions.FirStatement
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 // May be should inherit FirTypeParameterContainer
-interface FirFunction : FirDeclarationWithBody, FirAnnotationContainer {
+interface FirFunction : @VisitedSupertype FirDeclarationWithBody, FirAnnotationContainer, FirTargetElement, FirStatement {
     val valueParameters: List<FirValueParameter>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
@@ -20,6 +23,6 @@ interface FirFunction : FirDeclarationWithBody, FirAnnotationContainer {
         for (parameter in valueParameters) {
             parameter.accept(visitor, data)
         }
-        super.acceptChildren(visitor, data)
+        super<FirDeclarationWithBody>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt

@@ -23,8 +23,6 @@ interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMember, Fir
 
     val setter: FirPropertyAccessor
 
-    val delegate: FirExpression?
-
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitProperty(this, data)
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirRegularClass.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2000-2018 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.declarations
+
+import org.jetbrains.kotlin.fir.BaseTransformedType
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.symbols.FirSymbolOwner
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+// May be all containers should be properties and not base classes
+// About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end
+@BaseTransformedType
+interface FirRegularClass : FirClass, @VisitedSupertype FirMemberDeclaration, FirSymbolOwner<FirRegularClass> {
+    val isInner: Boolean get() = status.isInner
+
+    val isCompanion: Boolean get() = status.isCompanion
+
+    val isData: Boolean get() = status.isData
+
+    val isInline: Boolean get() = status.isInline
+
+    override val symbol: FirClassSymbol
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitRegularClass(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirMemberDeclaration>.acceptChildren(visitor, data)
+        super<FirClass>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt

@@ -8,12 +8,9 @@ package org.jetbrains.kotlin.fir.declarations.impl
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.expressions.impl.FirAbstractAnnotatedElement
 
 abstract class FirAbstractAnnotatedDeclaration(
-    final override val session: FirSession,
-    final override val psi: PsiElement?
-) : FirAnnotationContainer, FirDeclaration {
-    final override val annotations = mutableListOf<FirAnnotationCall>()
-}
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedElement(session, psi), FirDeclaration

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractFunction.kt

@@ -10,21 +10,23 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 abstract class FirAbstractFunction(
     session: FirSession,
-    psi: PsiElement?,
-    final override val body: FirBody?
+    psi: PsiElement?
 ) : FirAbstractAnnotatedDeclaration(session, psi), FirFunction {
     final override val valueParameters = mutableListOf<FirValueParameter>()
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        annotations.transformInplace(transformer, data)
-        valueParameters.transformInplace(transformer, data)
+    final override var body: FirBlock? = null
 
-        return this
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        valueParameters.transformInplace(transformer, data)
+        body = body?.transformSingle(transformer, data)
+
+        return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractNamedAnnotatedDeclaration.kt

@@ -6,21 +6,12 @@
 package org.jetbrains.kotlin.fir.declarations.impl
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration
-import org.jetbrains.kotlin.fir.transformInplace
-import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
 
 abstract class FirAbstractNamedAnnotatedDeclaration(
     session: FirSession,
     psi: PsiElement?,
     final override val name: Name
-) : FirAbstractAnnotatedDeclaration(session, psi), FirNamedDeclaration {
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        annotations.transformInplace(transformer, data)
-
-        return this
-    }
-}
+) : FirAbstractAnnotatedDeclaration(session, psi), FirNamedDeclaration

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousFunctionImpl.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.declarations.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirLabel
+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.FirType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirAnonymousFunctionImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override var returnType: FirType,
+    override var receiverType: FirType?
+) : FirAbstractFunction(session, psi), FirAnonymousFunction, FirModifiableFunction {
+    override var label: FirLabel? = null
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        returnType = returnType.transformSingle(transformer, data)
+        receiverType = receiverType?.transformSingle(transformer, data)
+        label = label?.transformSingle(transformer, data)
+        return super<FirAbstractFunction>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt

@@ -6,12 +6,20 @@
 package org.jetbrains.kotlin.fir.declarations.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 class FirAnonymousInitializerImpl(
     override val session: FirSession,
     override val psi: PsiElement?,
-    override val body: FirBody?
-) : FirAnonymousInitializer
+    override var body: FirBlock?
+) : FirAnonymousInitializer {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        body = body?.transformSingle(transformer, data)
+        return this
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousObjectImpl.kt

@@ -0,0 +1,36 @@
+/*
+ * 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.declarations.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirElement
+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.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+class FirAnonymousObjectImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedDeclaration(session, psi), FirAnonymousObject, FirModifiableClass {
+    override val superTypes = mutableListOf<FirType>()
+
+    override val declarations = mutableListOf<FirDeclaration>()
+
+    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 {
+        superTypes.transformInplace(transformer, data)
+        declarations.transformInplace(transformer, data)
+
+        return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.transformInplace
@@ -32,7 +32,7 @@ open class FirClassImpl(
     isCompanion: Boolean,
     isData: Boolean,
     isInline: Boolean
-) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality, isExpect, isActual), FirClass {
+) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality, isExpect, isActual), FirRegularClass, FirModifiableClass {
 
     init {
         symbol.bind(this)
@@ -47,9 +47,9 @@ open class FirClassImpl(
     override val declarations = mutableListOf<FirDeclaration>()
 
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirClass {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirRegularClass {
         superTypes.transformInplace(transformer, data)
-        val result = super<FirAbstractMemberDeclaration>.transformChildren(transformer, data) as FirClass
+        val result = super<FirAbstractMemberDeclaration>.transformChildren(transformer, data) as FirRegularClass
 
         // Transform declarations in last turn
         declarations.transformInplace(transformer, data)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt

@@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
@@ -27,17 +27,19 @@ open class FirConstructorImpl(
     isExpect: Boolean,
     isActual: Boolean,
     delegatedSelfType: FirType,
-    final override var delegatedConstructor: FirDelegatedConstructorCall?,
-    override val body: FirBody?
+    final override var delegatedConstructor: FirDelegatedConstructorCall?
 ) : FirAbstractCallableMember(
     session, psi, NAME, visibility, Modality.FINAL,
     isExpect, isActual, isOverride = false, receiverType = null, returnType = delegatedSelfType
 ), FirConstructor {
     override val valueParameters = mutableListOf<FirValueParameter>()
 
+    override var body: FirBlock? = null
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         valueParameters.transformInplace(transformer, data)
         delegatedConstructor?.transformSingle(transformer, data)
+        body = body?.transformSingle(transformer, data)
 
         return super<FirAbstractCallableMember>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt

@@ -7,14 +7,13 @@ package org.jetbrains.kotlin.fir.declarations.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirType
@@ -31,7 +30,7 @@ abstract class FirDefaultPropertyAccessor(
         session, visibility, Modality.FINAL
     )
 
-    final override val body: FirBody? =
+    final override val body: FirBlock? =
         null
 
     final override val annotations: List<FirAnnotationCall>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunction.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.declarations.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirErrorDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+class FirErrorFunction(
+    session: FirSession,
+    psi: PsiElement?,
+    override val reason: String
+) : FirAbstractElement(session, psi), FirErrorDeclaration, FirFunction {
+    override val annotations: List<FirAnnotationCall>
+        get() = emptyList()
+
+    override val valueParameters: List<FirValueParameter>
+        get() = emptyList()
+
+    override val body: FirBlock?
+        get() = null
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        super<FirFunction>.accept(visitor, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirErrorLoop.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.declarations.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
+import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+class FirErrorLoop(
+    session: FirSession,
+    psi: PsiElement?,
+    override val reason: String
+) : FirAbstractElement(session, psi), FirErrorExpression, FirLoop {
+    override val annotations: List<FirAnnotationCall> = listOf()
+
+    override val condition: FirExpression = FirErrorExpressionImpl(session, psi, reason)
+
+    override val block: FirBlock = FirEmptyExpressionBlock(session)
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
+        return super<FirErrorExpression>.accept(visitor, data)
+    }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirLoop>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt

@@ -26,9 +26,8 @@ class FirFileImpl(
     override val declarations = mutableListOf<FirDeclaration>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
-        annotations.transformInplace(transformer, data)
         imports.transformInplace(transformer, data)
         declarations.transformInplace(transformer, data)
-        return this
+        return super<FirAbstractAnnotatedDeclaration>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt

@@ -12,8 +12,9 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirNamedFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.name.Name
@@ -34,12 +35,11 @@ class FirMemberFunctionImpl(
     isExternal: Boolean,
     isSuspend: Boolean,
     receiverType: FirType?,
-    returnType: FirType,
-    override val body: FirBody?
+    returnType: FirType
 ) : FirAbstractCallableMember(
     session, psi, name, visibility, modality,
     isExpect, isActual, isOverride, receiverType, returnType
-), FirNamedFunction {
+), FirNamedFunction, FirModifiableFunction {
     init {
         status.isOperator = isOperator
         status.isInfix = isInfix
@@ -51,8 +51,11 @@ class FirMemberFunctionImpl(
 
     override val valueParameters = mutableListOf<FirValueParameter>()
 
+    override var body: FirBlock? = null
+
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         valueParameters.transformInplace(transformer, data)
+        body = body?.transformSingle(transformer, data)
 
         return super<FirAbstractCallableMember>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt

@@ -32,10 +32,10 @@ class FirMemberPropertyImpl(
     receiverType: FirType?,
     returnType: FirType,
     override val isVar: Boolean,
-    override val initializer: FirExpression?,
+    override var initializer: FirExpression?,
     override var getter: FirPropertyAccessor,
     override var setter: FirPropertyAccessor,
-    override val delegate: FirExpression?
+    override var delegate: FirExpression?
 ) : FirAbstractCallableMember(
     session, psi, name, visibility, modality, isExpect, isActual, isOverride, receiverType, returnType
 ), FirProperty {
@@ -47,6 +47,8 @@ class FirMemberPropertyImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         getter = getter.transformSingle(transformer, data)
         setter = setter.transformSingle(transformer, data)
+        initializer = initializer?.transformSingle(transformer, data)
+        delegate = delegate?.transformSingle(transformer, data)
 
         return super<FirAbstractCallableMember>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableClass.kt

@@ -0,0 +1,16 @@
+/*
+ * 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.declarations.impl
+
+import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.types.FirType
+
+interface FirModifiableClass : FirClass {
+    override val superTypes: MutableList<FirType>
+
+    override val declarations: MutableList<FirDeclaration>
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirModifiableFunction.kt

@@ -0,0 +1,16 @@
+/*
+ * 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.declarations.impl
+
+import org.jetbrains.kotlin.fir.declarations.FirFunction
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+
+interface FirModifiableFunction : FirFunction {
+    override var body: FirBlock?
+
+    override val valueParameters: MutableList<FirValueParameter>
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt

@@ -19,4 +19,4 @@ class FirPrimaryConstructorImpl(
     isActual: Boolean,
     delegatedSelfType: FirType,
     delegatedConstructor: FirDelegatedConstructorCall?
-) : FirConstructorImpl(session, psi, visibility, isExpect, isActual, delegatedSelfType, delegatedConstructor, body = null)
+) : FirConstructorImpl(session, psi, visibility, isExpect, isActual, delegatedSelfType, delegatedConstructor)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor
-import org.jetbrains.kotlin.fir.expressions.FirBody
+import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.transformSingle
 import org.jetbrains.kotlin.fir.types.FirType
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
@@ -21,9 +21,8 @@ class FirPropertyAccessorImpl(
     psi: PsiElement?,
     override val isGetter: Boolean,
     visibility: Visibility,
-    override var returnType: FirType,
-    body: FirBody?
-) : FirAbstractFunction(session, psi, body), FirPropertyAccessor {
+    override var returnType: FirType
+) : FirAbstractFunction(session, psi), FirPropertyAccessor {
     override var status = FirDeclarationStatusImpl(
         session, visibility, Modality.FINAL
     )

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt

@@ -20,13 +20,14 @@ class FirValueParameterImpl(
     psi: PsiElement?,
     name: Name,
     override var returnType: FirType,
-    override val defaultValue: FirExpression?,
+    override var defaultValue: FirExpression?,
     override val isCrossinline: Boolean,
     override val isNoinline: Boolean,
     override val isVararg: Boolean
 ) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter {
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         returnType = returnType.transformSingle(transformer, data)
+        defaultValue = defaultValue?.transformSingle(transformer, data)
 
         return super<FirAbstractNamedAnnotatedDeclaration>.transformChildren(transformer, data)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirVariableImpl.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.declarations.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.expressions.FirVariable
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.name.Name
+
+class FirVariableImpl(
+    session: FirSession,
+    psiElement: PsiElement?,
+    name: Name,
+    override var returnType: FirType,
+    override val isVar: Boolean,
+    override var initializer: FirExpression?,
+    override var delegate: FirExpression? = null
+) : FirAbstractNamedAnnotatedDeclaration(session, psiElement, name), FirVariable {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        returnType = returnType.transformSingle(transformer, data)
+        initializer = initializer?.transformSingle(transformer, data)
+        delegate = delegate?.transformSingle(transformer, data)
+
+        return super<FirAbstractNamedAnnotatedDeclaration>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAccess.kt

@@ -0,0 +1,26 @@
+/*
+ * 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.FirReference
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirAccess : FirStatement {
+    val calleeReference: FirReference
+
+    val safe: Boolean get() = false
+
+    val explicitReceiver: FirExpression? get() = null
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitAccess(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        calleeReference.accept(visitor, data)
+        explicitReceiver?.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAccessExpression.kt

@@ -0,0 +1,18 @@
+/*
+ * 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.VisitedSupertype
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirAccessExpression : @VisitedSupertype FirAccess, FirExpression {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitAccessExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirAccess>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayGetCall.kt

@@ -0,0 +1,20 @@
+/*
+ * 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 FirArrayGetCall : FirCall {
+    val array: FirExpression
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitArrayGetCall(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        array.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArrayOfCall.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirArrayOfCall : FirCall {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitArrayOfCall(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArraySetCall.kt

@@ -0,0 +1,19 @@
+/*
+ * 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.VisitedSupertype
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirArraySetCall : @VisitedSupertype FirCall, FirAssignment {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitArraySetCall(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        super<FirCall>.acceptChildren(visitor, data)
+        super<FirAssignment>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAssignment.kt

@@ -0,0 +1,22 @@
+/*
+ * 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 FirAssignment : FirAccess {
+    val value: FirExpression
+
+    val operation: FirOperation
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitAssignment(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        value.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBlock.kt

@@ -7,13 +7,11 @@ package org.jetbrains.kotlin.fir.expressions
 
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
-// Should we have FirBlockBody / FirExpressionBody?
-// Is it FirExpression or just FirElement?
-interface FirBody : FirExpression {
+interface FirBlock : FirExpression {
     val statements: List<FirStatement>
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
-        visitor.visitBody(this, data)
+        visitor.visitBlock(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         for (statement in statements) {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBreakExpression.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirBreakExpression : FirJump<FirLoop> {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitBreakExpression(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCallableReferenceAccess.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirCallableReferenceAccess : FirAccessExpression {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitCallableReferenceAccess(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCatch.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.FirElement
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirCatch : FirElement {
+    val parameter: FirValueParameter
+
+    val block: FirBlock
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitCatch(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        parameter.accept(visitor, data)
+        block.accept(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt

@@ -0,0 +1,16 @@
+/*
+ * 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 FirComponentCall : FirCall {
+    // Starting from 1, not from 0
+    val componentIndex: Int
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitComponentCall(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirContinueExpression.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirContinueExpression : FirJump<FirLoop> {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitContinueExpression(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDoWhileLoop.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirDoWhileLoop : FirLoop {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitDoWhileLoop(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt

@@ -5,6 +5,12 @@
 
 package org.jetbrains.kotlin.fir.expressions
 
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
 interface FirErrorExpression : FirExpression {
     val reason: String
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R {
+        return visitor.visitErrorExpression(this, data)
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.FirNamedReference
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirFunctionCall : @VisitedSupertype FirCall, FirAccess, FirTypeProjectionContainer {
+    override val calleeReference: FirNamedReference
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitFunctionCall(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        for (argument in arguments) {
+            argument.accept(visitor, data)
+        }
+        for (typeArgument in typeArguments) {
+            typeArgument.accept(visitor, data)
+        }
+        super<FirAccess>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirGetClassCall.kt

@@ -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 FirGetClassCall : FirCall {
+    val argument: FirExpression get() = arguments.first()
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitGetClassCall(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirJump.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.FirTarget
+import org.jetbrains.kotlin.fir.FirTargetElement
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirJump<E : FirTargetElement> : FirExpression {
+    val target: FirTarget<E>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitJump(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirLoop.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.FirLabeledElement
+import org.jetbrains.kotlin.fir.VisitedSupertype
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirLoop : @VisitedSupertype FirStatement, FirLabeledElement, FirAnnotationContainer {
+    val condition: FirExpression
+
+    val block: FirBlock
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitLoop(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        condition.accept(visitor, data)
+        block.accept(visitor, data)
+        super<FirLabeledElement>.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperation.kt

@@ -0,0 +1,44 @@
+/*
+ * 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
+
+enum class FirOperation(val operator: String = "???") {
+    // Binary
+    RANGE(".."),
+    EQ("=="),
+    NOT_EQ("!="),
+    IDENTITY("==="),
+    NOT_IDENTITY("!=="),
+    LT("<"),
+    GT(">"),
+    LT_EQ("<="),
+    GT_EQ(">="),
+    AND("&&"),
+    OR("||"),
+    IN("in"),
+    NOT_IN("!in"),
+
+    ASSIGN("="),
+    PLUS_ASSIGN("+="),
+    MINUS_ASSIGN("-="),
+    TIMES_ASSIGN("*="),
+    DIV_ASSIGN("/="),
+    REM_ASSIGN("%="),
+
+    // Unary
+    EXCL("!"),
+    // Type
+    IS("is"),
+    NOT_IS("!is"),
+    AS("as"),
+    SAFE_AS("as?"),
+    // All non-standard operations (infix calls)
+    OTHER;
+
+    companion object {
+        val ASSIGNMENTS = setOf(ASSIGN, PLUS_ASSIGN, MINUS_ASSIGN, TIMES_ASSIGN, DIV_ASSIGN, REM_ASSIGN)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirOperatorCall.kt

@@ -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 FirOperatorCall : FirCall {
+    val operation: FirOperation
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitOperatorCall(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirPropertyAssignment.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirPropertyAssignment : FirAssignment {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitPropertyAssignment(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirReturnExpression.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.declarations.FirFunction
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirReturnExpression : FirJump<FirFunction> {
+    val result: FirExpression
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitReturnExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        result.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStatement.kt

@@ -10,7 +10,11 @@ import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
 
 @BaseTransformedType
-interface FirStatement : FirElement {
+interface FirStatement : FirElement, FirAnnotationContainer {
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitStatement(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        acceptAnnotations(visitor, data)
+    }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirThrowExpression.kt

@@ -0,0 +1,20 @@
+/*
+ * 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 FirThrowExpression : FirExpression {
+    val exception: FirExpression
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitThrowExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        exception.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTryExpression.kt

@@ -0,0 +1,26 @@
+/*
+ * 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 FirTryExpression : FirExpression {
+    val tryBlock: FirBlock
+
+    val catches: List<FirCatch>
+
+    val finallyBlock: FirBlock?
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitTryExpression(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        tryBlock.accept(visitor, data)
+        catches.forEach { it.accept(visitor, data) }
+        finallyBlock?.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirTypeOperatorCall.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.types.FirType
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+// is/!is/as/as?
+interface FirTypeOperatorCall : FirOperatorCall {
+    val argument: FirExpression get() = arguments.first()
+
+    val type: FirType
+
+    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) {
+        type.accept(visitor, data)
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt

@@ -19,11 +19,14 @@ interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, F
 
     val initializer: FirExpression?
 
+    val delegate: FirExpression?
+
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
         visitor.visitVariable(this, data)
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         initializer?.accept(visitor, data)
+        delegate?.accept(visitor, data)
         super<FirTypedDeclaration>.acceptChildren(visitor, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenBranch.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.FirElement
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+interface FirWhenBranch : FirElement {
+    // NB: we can represent subject, if it's inside, as a special kind of expression
+    // when (mySubject) {
+    //     $subj == 42$ -> doSmth()
+    // }
+    val condition: FirExpression
+
+    val result: FirBlock
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitWhenBranch(this, data)
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        condition.accept(visitor, data)
+        result.accept(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhenExpression.kt

@@ -0,0 +1,29 @@
+/*
+ * 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 FirWhenExpression : FirExpression {
+    val subject: FirExpression?
+
+    // when (val subjectVariable = subject()) { ... }
+    val subjectVariable: FirVariable?
+
+    val branches: List<FirWhenBranch>
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitWhenExpression(this, data)
+
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        subjectVariable?.accept(visitor, data) ?: subject?.accept(visitor, data)
+        for (branch in branches) {
+            branch.accept(visitor, data)
+        }
+        super.acceptChildren(visitor, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirWhileLoop.kt

@@ -0,0 +1,13 @@
+/*
+ * 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 FirWhileLoop : FirLoop {
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R =
+        visitor.visitWhileLoop(this, data)
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAccess.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.*
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractAccess(
+    session: FirSession,
+    psi: PsiElement?,
+    final override var safe: Boolean = false
+) : FirAbstractStatement(session, psi), FirModifiableAccess {
+    final override lateinit var calleeReference: FirReference
+
+    final override var explicitReceiver: FirExpression? = null
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
+        return super<FirAbstractStatement>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAnnotatedElement.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractAnnotatedElement(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractElement(session, psi), FirAnnotationContainer {
+    final override val annotations = mutableListOf<FirAnnotationCall>()
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractAssignment.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirOperation
+import org.jetbrains.kotlin.fir.expressions.FirPropertyAssignment
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractAssignment(
+    session: FirSession,
+    psi: PsiElement?,
+    final override var value: FirExpression,
+    final override val operation: FirOperation,
+    safe: Boolean = false
+) : FirAbstractAccess(session, psi, safe), FirPropertyAssignment {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        value = value.transformSingle(transformer, data)
+        return super<FirAbstractAccess>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractCall.kt

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirAbstractElement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirCall
@@ -14,14 +15,13 @@ import org.jetbrains.kotlin.fir.transformInplace
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 
 abstract class FirAbstractCall(
-    final override val session: FirSession,
-    final override val psi: PsiElement?
-) : FirCall {
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractExpression(session, psi), FirCall {
     final override val arguments = mutableListOf<FirExpression>()
 
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         arguments.transformInplace(transformer, data)
-
-        return this
+        return super<FirAbstractExpression>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractExpression.kt

@@ -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.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+
+abstract class FirAbstractExpression(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractStatement(session, psi), FirExpression

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoop.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.*
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirLoop
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+abstract class FirAbstractLoop(
+    session: FirSession,
+    psi: PsiElement?,
+    override var condition: FirExpression
+) : FirAbstractStatement(session, psi), FirLoop {
+    override lateinit var block: FirBlock
+
+    override var label: FirLabel? = null
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        condition = condition.transformSingle(transformer, data)
+        block = block.transformSingle(transformer, data)
+        label = label?.transformSingle(transformer, data)
+        return super<FirAbstractStatement>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractLoopJump.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirTarget
+import org.jetbrains.kotlin.fir.expressions.FirJump
+import org.jetbrains.kotlin.fir.expressions.FirLoop
+
+abstract class FirAbstractLoopJump(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractExpression(session, psi), FirJump<FirLoop> {
+    override lateinit var target: FirTarget<FirLoop>
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractStatement.kt

@@ -1,5 +1,5 @@
 /*
- * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * 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.
  */
 
@@ -7,9 +7,9 @@ package org.jetbrains.kotlin.fir.expressions.impl
 
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.expressions.FirBody
 import org.jetbrains.kotlin.fir.expressions.FirStatement
 
-class FirBlockBodyImpl(override val session: FirSession, override val psi: PsiElement?) : FirBody {
-    override val statements = mutableListOf<FirStatement>()
-}
+abstract class FirAbstractStatement(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedElement(session, psi), FirStatement

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAccessExpressionImpl.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.FirAccessExpression
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirAccessExpressionImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    safe: Boolean = false
+) : FirAbstractAccess(session, psi, safe), FirAccessExpression

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayGetCallImpl.kt

@@ -0,0 +1,25 @@
+/*
+ * 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.FirArrayGetCall
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirArrayGetCallImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override var array: FirExpression
+) : FirAbstractCall(session, psi), FirArrayGetCall {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        array = array.transformSingle(transformer, data)
+        return super<FirAbstractCall>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArrayOfCallImpl.kt

@@ -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.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirArrayOfCall
+
+class FirArrayOfCallImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractCall(session, psi), FirArrayOfCall

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirArraySetCallImpl.kt

@@ -0,0 +1,35 @@
+/*
+ * 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.FirAnnotationCall
+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.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+class FirArraySetCallImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    value: FirExpression,
+    operation: FirOperation
+) : FirAbstractAssignment(session, psi, value, operation, false), FirArraySetCall {
+    override val arguments = 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 {
+        arguments.transformInplace(transformer, data)
+
+        return super<FirAbstractAssignment>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockImpl.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright 2000-2018 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.expressions.FirStatement
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirBlockImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAnnotatedElement(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)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBreakExpressionImpl.kt

@@ -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.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirBreakExpression
+
+class FirBreakExpressionImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractLoopJump(session, psi), FirBreakExpression

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCallableReferenceAccessImpl.kt

@@ -0,0 +1,19 @@
+/*
+ * 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.FirAnnotationCall
+import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
+import org.jetbrains.kotlin.fir.transformInplace
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirCallableReferenceAccessImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractAccess(session, psi), FirCallableReferenceAccess

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirCatchImpl.kt

@@ -0,0 +1,30 @@
+/*
+ * 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.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirCatch
+import org.jetbrains.kotlin.fir.transformSingle
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirCatchImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override var parameter: FirValueParameter,
+    override var block: FirBlock
+) : FirAbstractElement(session, psi), FirCatch {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        parameter = parameter.transformSingle(transformer, data)
+        block = block.transformSingle(transformer, data)
+        return this
+    }
+
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt

@@ -0,0 +1,16 @@
+/*
+ * 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.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirComponentCall
+
+class FirComponentCallImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override val componentIndex: Int
+) : FirAbstractCall(session, psi), FirComponentCall

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirConstExpressionImpl.kt

@@ -11,11 +11,11 @@ import org.jetbrains.kotlin.fir.expressions.FirConstExpression
 import org.jetbrains.kotlin.ir.expressions.IrConstKind
 
 class FirConstExpressionImpl<T>(
-    override val session: FirSession,
-    override val psi: PsiElement?,
+    session: FirSession,
+    psi: PsiElement?,
     override val kind: IrConstKind<T>,
     override val value: T
-) : FirConstExpression<T>
+) : FirAbstractExpression(session, psi), FirConstExpression<T>
 
 fun <T> FirConstExpressionImpl(session: FirSession, psi: PsiElement?, kind: IrConstKind<T>, value: T?, errorReason: String) =
     value?.let { FirConstExpressionImpl(session, psi, kind, it) } ?: FirErrorExpressionImpl(session, psi, errorReason)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirContinueExpressionImpl.kt

@@ -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.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirContinueExpression
+
+class FirContinueExpressionImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractLoopJump(session, psi), FirContinueExpression

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt

@@ -22,6 +22,6 @@ class FirDelegatedConstructorCallImpl(
     override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
         constructedType = constructedType.transformSingle(transformer, data)
 
-        return this
+        return super<FirAbstractCall>.transformChildren(transformer, data)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDoWhileLoopImpl.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirDoWhileLoop
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+
+class FirDoWhileLoopImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    condition: FirExpression
+) : FirAbstractLoop(session, psi, condition), FirDoWhileLoop

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirElseIfTrueCondition.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.FirAbstractElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+
+// Representation of "dummy" condition at else branch
+class FirElseIfTrueCondition(
+    session: FirSession,
+    psi: PsiElement?
+): FirAbstractExpression(session, psi)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirEmptyExpressionBlock.kt

@@ -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.impl
+
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+
+class FirEmptyExpressionBlock(
+    session: FirSession
+) : FirAbstractAnnotatedElement(session, null), FirBlock {
+    override val statements = listOf()
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt

@@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 
 class FirErrorExpressionImpl(
-    override val session: FirSession,
-    override val psi: PsiElement?,
+    session: FirSession,
+    psi: PsiElement?,
     override val reason: String
-) : FirErrorExpression
+) : FirAbstractExpression(session, psi), FirErrorExpression

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionBodyImpl.kt

@@ -1,21 +0,0 @@
-/*
- * Copyright 2000-2018 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.FirSession
-import org.jetbrains.kotlin.fir.expressions.FirBody
-import org.jetbrains.kotlin.fir.expressions.FirExpression
-
-class FirExpressionBodyImpl(
-    override val session: FirSession,
-    private val expression: FirExpression
-) : FirBody {
-    override val statements = listOf(expression)
-
-    override val psi: PsiElement?
-        get() = expression.psi
-}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt

@@ -9,5 +9,7 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 
-@Deprecated("Temporary class until we have normal expressions")
-class FirExpressionStub(override val session: FirSession, override val psi: PsiElement?) : FirExpression
+class FirExpressionStub(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractExpression(session, psi)

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt

@@ -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.*
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.types.FirTypeProjection
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+
+class FirFunctionCallImpl(
+    session: FirSession,
+    psi: PsiElement?,
+    override var safe: Boolean = false
+) : FirAbstractCall(session, psi), FirFunctionCall, FirModifiableAccess {
+    override val typeArguments = mutableListOf<FirTypeProjection>()
+
+    override lateinit var calleeReference: FirNamedReference
+
+    override var explicitReceiver: FirExpression? = null
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement {
+        typeArguments.transformInplace(transformer, data)
+        calleeReference = calleeReference.transformSingle(transformer, data)
+        explicitReceiver = explicitReceiver?.transformSingle(transformer, data)
+        return super<FirAbstractCall>.transformChildren(transformer, data)
+    }
+}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirGetClassCallImpl.kt

@@ -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.impl
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.expressions.FirGetClassCall
+
+class FirGetClassCallImpl(
+    session: FirSession,
+    psi: PsiElement?
+) : FirAbstractCall(session, psi), FirGetClassCall