Persistent IR implementation

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt

@@ -173,7 +173,7 @@ class MemoizedInlineClassReplacements {
         val parameterMap = mutableMapOf<IrValueParameterSymbol, IrValueParameter>()
         val replacement = buildReplacement(function) {
             // Generate metadata for the replacement function instead of the original.
-            if (function is IrFunctionBase) {
+            if (function is IrFunctionBase<*>) {
                 metadata = function.metadata
                 function.metadata = null
             }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/PersistentApi.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.ir.declarations
+
+import org.jetbrains.kotlin.ir.IrElement
+import org.jetbrains.kotlin.ir.expressions.IrBody
+
+// TODO threadlocal
+// TODO make a IrDeclarationBase field? (requires IR factory)
+var stageController: StageController = object : StageController {}
+
+interface StageController {
+    val currentStage: Int get() = 0
+
+    fun lazyLower(declaration: IrDeclaration) {}
+
+    fun lazyLower(body: IrBody) {}
+
+    fun <T> withStage(stage: Int, fn: () -> T): T = fn()
+
+    val bodiesEnabled: Boolean get() = true
+
+    fun <T> bodyLowering(fn: () -> T): T = fn()
+
+    fun canModify(element: IrElement): Boolean = true
+
+    fun canAccessDeclarationsOf(declaration: IrClass): Boolean = true
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrAnonymousInitializerImpl.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrAnonymousInitializer
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.AnonymousInitializerCarrier
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.symbols.IrAnonymousInitializerSymbol
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
@@ -30,8 +31,9 @@ class IrAnonymousInitializerImpl(
     origin: IrDeclarationOrigin,
     override val symbol: IrAnonymousInitializerSymbol,
     override val isStatic: Boolean = false
-) : IrDeclarationBase(startOffset, endOffset, origin),
-    IrAnonymousInitializer {
+) : IrDeclarationBase<AnonymousInitializerCarrier>(startOffset, endOffset, origin),
+    IrAnonymousInitializer,
+    AnonymousInitializerCarrier {
 
     init {
         symbol.bind(this)
@@ -39,7 +41,18 @@ class IrAnonymousInitializerImpl(
 
     override val descriptor: ClassDescriptor get() = symbol.descriptor
 
-    override lateinit var body: IrBlockBody
+    override var bodyField: IrBlockBody? = null
+
+    override var body: IrBlockBody
+        get() = getCarrier().bodyField!!
+        set(v) {
+            if (getCarrier().bodyField !== v) {
+                if (v is IrBodyBase<*>) {
+                    v.container = this
+                }
+                setCarrier().bodyField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitAnonymousInitializer(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.ClassCarrier
 import org.jetbrains.kotlin.ir.symbols.IrClassSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.transform
@@ -29,6 +30,7 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
+import java.util.*
 import kotlin.collections.ArrayList
 
 class IrClassImpl(
@@ -38,8 +40,8 @@ class IrClassImpl(
     override val symbol: IrClassSymbol,
     override val name: Name,
     override val kind: ClassKind,
-    override var visibility: Visibility,
-    override var modality: Modality,
+    visibility: Visibility,
+    modality: Modality,
     override val isCompanion: Boolean,
     override val isInner: Boolean,
     override val isData: Boolean,
@@ -48,8 +50,9 @@ class IrClassImpl(
     override val isExpect: Boolean,
     override val isFun: Boolean
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrClass {
+    IrDeclarationBase<ClassCarrier>(startOffset, endOffset, origin),
+    IrClass,
+    ClassCarrier {
 
     constructor(
         startOffset: Int,
@@ -78,17 +81,91 @@ class IrClassImpl(
 
     override val descriptor: ClassDescriptor get() = symbol.descriptor
 
-    override var thisReceiver: IrValueParameter? = null
+    override var visibilityField: Visibility = visibility
+
+    override var visibility: Visibility
+        get() = getCarrier().visibilityField
+        set(v) {
+            if (visibility !== v) {
+                setCarrier().visibilityField = v
+            }
+        }
+
+    override var thisReceiverField: IrValueParameter? = null
+
+    override var thisReceiver: IrValueParameter?
+        get() = getCarrier().thisReceiverField
+        set(v) {
+            if (thisReceiver !== v) {
+                setCarrier().thisReceiverField = v
+            }
+        }
+
+    private var initialDeclarations: MutableList<IrDeclaration>? = null
 
     override val declarations: MutableList<IrDeclaration> = ArrayList()
+        get() {
+            if (createdOn < stageController.currentStage && initialDeclarations == null) {
+                initialDeclarations = Collections.unmodifiableList(ArrayList(field))
+            }
 
-    override var typeParameters: List<IrTypeParameter> = emptyList()
+            return if (stageController.canAccessDeclarationsOf(this)) {
+                ensureLowered()
+                field
+            } else {
+                initialDeclarations ?: field
+            }
+        }
 
-    override var superTypes: List<IrType> = emptyList()
+    override var typeParametersField: List<IrTypeParameter> = emptyList()
 
-    override var metadata: MetadataSource? = null
+    override var typeParameters: List<IrTypeParameter>
+        get() = getCarrier().typeParametersField
+        set(v) {
+            if (typeParameters !== v) {
+                setCarrier().typeParametersField = v
+            }
+        }
 
-    override var attributeOwnerId: IrAttributeContainer = this
+    override var superTypesField: List<IrType> = emptyList()
+
+    override var superTypes: List<IrType>
+        get() = getCarrier().superTypesField
+        set(v) {
+            if (superTypes !== v) {
+                setCarrier().superTypesField = v
+            }
+        }
+
+    override var metadataField: MetadataSource? = null
+
+    override var metadata: MetadataSource?
+        get() = getCarrier().metadataField
+        set(v) {
+            if (metadata !== v) {
+                setCarrier().metadataField = v
+            }
+        }
+
+    override var modalityField: Modality = modality
+
+    override var modality: Modality
+        get() = getCarrier().modalityField
+        set(v) {
+            if (modality !== v) {
+                setCarrier().modalityField = v
+            }
+        }
+
+    override var attributeOwnerIdField: IrAttributeContainer = this
+
+    override var attributeOwnerId: IrAttributeContainer
+        get() = getCarrier().attributeOwnerIdField
+        set(v) {
+            if (attributeOwnerId !== v) {
+                setCarrier().attributeOwnerIdField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitClass(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrConstructorImpl.kt

@@ -18,8 +18,8 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.ir.declarations.IrConstructor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.ConstructorCarrier
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.symbols.IrConstructorSymbol
 import org.jetbrains.kotlin.ir.types.IrType
@@ -40,13 +40,14 @@ class IrConstructorImpl(
     override val isPrimary: Boolean,
     isExpect: Boolean
 ) :
-    IrFunctionBase(
+    IrFunctionBase<ConstructorCarrier>(
         startOffset, endOffset, origin, name,
         visibility,
         isInline, isExternal, isExpect,
         returnType
     ),
-    IrConstructor {
+    IrConstructor,
+    ConstructorCarrier {
 
     constructor(
         startOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrDeclarationBase.kt

@@ -17,30 +17,172 @@
 package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.ir.IrElementBase
-import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
-import org.jetbrains.kotlin.ir.declarations.MetadataSource
-import org.jetbrains.kotlin.ir.expressions.IrCall
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.BodyCarrier
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.Carrier
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.DeclarationCarrier
+import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 
-abstract class IrDeclarationBase(
+abstract class IrDeclarationBase<T : DeclarationCarrier<T>>(
     startOffset: Int,
     endOffset: Int,
-    override var origin: IrDeclarationOrigin
-) : IrElementBase(startOffset, endOffset),
-    IrDeclaration {
+    origin: IrDeclarationOrigin
+) : IrPersistingElementBase<T>(startOffset, endOffset),
+    IrDeclaration,
+    DeclarationCarrier<T> {
+
+    override var parentField: IrDeclarationParent? = null
 
-    private var _parent: IrDeclarationParent? = null
     override var parent: IrDeclarationParent
-        get() = _parent
-            ?: throw UninitializedPropertyAccessException("Parent not initialized: $this")
-        set(v) {
-            _parent = v
+        get() = getCarrier().parentField ?: throw UninitializedPropertyAccessException("Parent not initialized: $this")
+        set(p) {
+            if (getCarrier().parentField !== p) {
+                setCarrier().parentField = p
+            }
         }
 
-    override var annotations: List<IrConstructorCall> = emptyList()
+    override var originField: IrDeclarationOrigin = origin
+
+    override var origin: IrDeclarationOrigin
+        get() = getCarrier().originField
+        set(p) {
+            if (getCarrier().originField !== p) {
+                setCarrier().originField = p
+            }
+        }
+
+    var removedOn: Int = Int.MAX_VALUE
+
+    override var annotationsField: List<IrConstructorCall> = emptyList()
+
+    override var annotations: List<IrConstructorCall>
+        get() = getCarrier().annotationsField
+        set(v) {
+            if (getCarrier().annotationsField !== v) {
+                setCarrier().annotationsField = v
+            }
+        }
 
     override val metadata: MetadataSource?
         get() = null
+
+    override fun ensureLowered() {
+        if (stageController.currentStage > loweredUpTo) {
+            stageController.lazyLower(this)
+        }
+    }
 }
+
+abstract class IrPersistingElementBase<T : Carrier<T>>(
+    startOffset: Int,
+    endOffset: Int
+) : IrElementBase(startOffset, endOffset),
+    Carrier<T> {
+
+    override var lastModified: Int = stageController.currentStage
+
+    var loweredUpTo = stageController.currentStage
+
+    private var values: Array<Any?>? = null
+
+    val createdOn: Int = stageController.currentStage
+//        get() = values?.let { (it[0] as T).lastModified } ?: lastModified
+
+    abstract fun ensureLowered()
+
+    protected fun getCarrier(): T {
+        stageController.currentStage.let { stage ->
+            ensureLowered()
+
+            if (stage >= lastModified) return this as T
+
+            if (stage < createdOn) error("Access before creation")
+
+            val v = values
+                ?: error("How come?")
+
+            var l = -1
+            var r = v.size
+            while (r - l > 1) {
+                val m = (l + r) / 2
+                if ((v[m] as T).lastModified <= stage) {
+                    l = m
+                } else {
+                    r = m
+                }
+            }
+            if (l < 0) {
+                error("access before creation")
+            }
+
+            return v[l] as T
+        }
+    }
+
+    protected fun setCarrier(): T {
+        val stage = stageController.currentStage
+
+        ensureLowered()
+
+        if (!stageController.canModify(this)) {
+            error("Cannot modify this element!")
+        }
+
+        if (loweredUpTo > stage) {
+            error("retrospective modification")
+        }
+
+        if (stage == lastModified) {
+            return this as T
+        } else {
+            val newValues = values?.let { oldValues ->
+                oldValues.copyOf(oldValues.size + 1)
+            } ?: arrayOfNulls<Any?>(1)
+
+            newValues[newValues.size - 1] = this.clone()
+
+            values = newValues
+        }
+
+        this.lastModified = stage
+
+        return this as T
+    }
+}
+
+abstract class IrBodyBase<B : IrBodyBase<B>>(
+    startOffset: Int,
+    endOffset: Int,
+    private var initializer: (B.() -> Unit)?
+) : IrPersistingElementBase<BodyCarrier>(startOffset, endOffset), IrBody, BodyCarrier {
+    override var containerField: IrDeclaration? = null
+
+    var container: IrDeclaration
+        get() = getCarrier().containerField!!
+        set(p) {
+            if (getCarrier().containerField !== p) {
+                setCarrier().containerField = p
+            }
+        }
+
+    protected fun <T> checkEnabled(fn: () -> T): T {
+        if (!stageController.bodiesEnabled) error("Bodies disabled!")
+        ensureLowered()
+        return fn()
+    }
+
+    override fun ensureLowered() {
+        initializer?.let { initFn ->
+            initializer = null
+            stageController.withStage(createdOn) {
+                stageController.bodyLowering {
+                    initFn.invoke(this as B)
+                }
+            }
+        }
+        if (loweredUpTo + 1 < stageController.currentStage) {
+            stageController.lazyLower(this)
+        }
+    }
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrClass
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrEnumEntry
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.EnumEntryCarrier
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrEnumEntrySymbol
@@ -33,8 +34,9 @@ class IrEnumEntryImpl(
     origin: IrDeclarationOrigin,
     override val symbol: IrEnumEntrySymbol,
     override val name: Name
-) : IrDeclarationBase(startOffset, endOffset, origin),
-    IrEnumEntry {
+) : IrDeclarationBase<EnumEntryCarrier>(startOffset, endOffset, origin),
+    IrEnumEntry,
+    EnumEntryCarrier {
 
     constructor(
         startOffset: Int,
@@ -49,8 +51,29 @@ class IrEnumEntryImpl(
     }
 
     override val descriptor: ClassDescriptor get() = symbol.descriptor
-    override var correspondingClass: IrClass? = null
-    override var initializerExpression: IrExpressionBody? = null
+
+    override var correspondingClassField: IrClass? = null
+
+    override var correspondingClass: IrClass?
+        get() = getCarrier().correspondingClassField
+        set(v) {
+            if (correspondingClass !== v) {
+                setCarrier().correspondingClassField = v
+            }
+        }
+
+    override var initializerExpressionField: IrExpressionBody? = null
+
+    override var initializerExpression: IrExpressionBody?
+        get() = getCarrier().initializerExpressionField
+        set(v) {
+            if (initializerExpression !== v) {
+                if (v is IrBodyBase<*>) {
+                    v.container = this
+                }
+                setCarrier().initializerExpressionField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitEnumEntry(this, data)
@@ -65,4 +88,4 @@ class IrEnumEntryImpl(
         initializerExpression = initializerExpression?.transform(transformer, data)
         correspondingClass = correspondingClass?.transform(transformer, data) as? IrClass
     }
-}
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrErrorDeclarationImpl.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrErrorDeclaration
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.ErrorCarrier
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -26,7 +27,7 @@ class IrErrorDeclarationImpl(
     startOffset: Int,
     endOffset: Int,
     override val descriptor: DeclarationDescriptor
-) : IrDeclarationBase(startOffset, endOffset, IrDeclarationOrigin.DEFINED), IrErrorDeclaration {
+) : IrDeclarationBase<ErrorCarrier>(startOffset, endOffset, IrDeclarationOrigin.DEFINED), IrErrorDeclaration, ErrorCarrier {
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitErrorDeclaration(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt

@@ -18,10 +18,8 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrField
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.declarations.MetadataSource
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.FieldCarrier
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
@@ -45,8 +43,9 @@ class IrFieldImpl(
     override val isExternal: Boolean,
     override val isStatic: Boolean,
     override val isFakeOverride: Boolean
-) : IrDeclarationBase(startOffset, endOffset, origin),
-    IrField {
+) : IrDeclarationBase<FieldCarrier>(startOffset, endOffset, origin),
+    IrField,
+    FieldCarrier {
 
     constructor(
         startOffset: Int,
@@ -80,13 +79,48 @@ class IrFieldImpl(
 
     override val descriptor: PropertyDescriptor = symbol.descriptor
 
-    override var initializer: IrExpressionBody? = null
+    override var initializerField: IrExpressionBody? = null
 
-    override var correspondingPropertySymbol: IrPropertySymbol? = null
+    override var initializer: IrExpressionBody?
+        get() = getCarrier().initializerField
+        set(v) {
+            if (initializer !== v) {
+                if (v is IrBodyBase<*>) {
+                    v.container = this
+                }
+                setCarrier().initializerField = v
+            }
+        }
 
-    override var overriddenSymbols: List<IrFieldSymbol> = emptyList()
+    override var correspondingPropertySymbolField: IrPropertySymbol? = null
 
-    override var metadata: MetadataSource.Property? = null
+    override var correspondingPropertySymbol: IrPropertySymbol?
+        get() = getCarrier().correspondingPropertySymbolField
+        set(v) {
+            if (correspondingPropertySymbol !== v) {
+                setCarrier().correspondingPropertySymbolField = v
+            }
+        }
+
+    override var overridenSymbolsField: List<IrFieldSymbol> = emptyList()
+
+    override var overriddenSymbols: List<IrFieldSymbol>
+        get() = getCarrier().overridenSymbolsField
+        set(v) {
+            if (overriddenSymbols !== v) {
+                setCarrier().overridenSymbolsField = v
+            }
+        }
+
+    override var metadataField: MetadataSource.Property? = null
+
+    override var metadata: MetadataSource.Property?
+        get() = getCarrier().metadataField
+        set(v) {
+            if (metadata !== v) {
+                setCarrier().metadataField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitField(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFileImpl.kt

@@ -19,9 +19,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
 import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.SourceManager
-import org.jetbrains.kotlin.ir.declarations.IrDeclaration
-import org.jetbrains.kotlin.ir.declarations.IrFile
-import org.jetbrains.kotlin.ir.declarations.MetadataSource
+import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrFileSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrFileSymbolImpl
@@ -55,7 +53,7 @@ class IrFileImpl(
 
     override val declarations: MutableList<IrDeclaration> = ArrayList()
 
-    override var annotations: List<IrConstructorCall> = emptyList()
+    override var annotations: List<IrConstructorCall> = ArrayList()
 
     override var metadata: MetadataSource.File? = null
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionBase.kt

@@ -18,44 +18,120 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.FunctionBaseCarrier
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.types.impl.IrUninitializedType
 import org.jetbrains.kotlin.ir.util.mapOptimized
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 
-abstract class IrFunctionBase(
+abstract class IrFunctionBase<T : FunctionBaseCarrier<T>>(
     startOffset: Int,
     endOffset: Int,
     origin: IrDeclarationOrigin,
     override val name: Name,
-    override var visibility: Visibility,
+    visibility: Visibility,
     override val isInline: Boolean,
     override val isExternal: Boolean,
     override val isExpect: Boolean,
     returnType: IrType
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrFunction {
+    IrDeclarationBase<T>(startOffset, endOffset, origin),
+    IrFunction,
+    FunctionBaseCarrier<T> {
 
+    override var returnTypeFieldField: IrType = returnType
+
+    private var returnTypeField: IrType
+        get() = getCarrier().returnTypeFieldField
+        set(v) {
+            if (returnTypeField !== v) {
+                setCarrier().returnTypeFieldField = v
+            }
+        }
     @Suppress("DEPRECATION")
-    final override var returnType: IrType = returnType
-        get() = if (field === org.jetbrains.kotlin.ir.types.impl.IrUninitializedType) {
-            error("Return type is not initialized")
-        } else {
-            field
+    final override var returnType: IrType
+        get() = returnTypeField.let {
+            if (it !== IrUninitializedType) it else error("Return type is not initialized")
+        }
+        set(c) {
+            returnTypeField = c
         }
 
-    override var typeParameters: List<IrTypeParameter> = emptyList()
+    override var typeParametersField: List<IrTypeParameter> = emptyList()
 
-    override var dispatchReceiverParameter: IrValueParameter? = null
-    override var extensionReceiverParameter: IrValueParameter? = null
-    override var valueParameters: List<IrValueParameter> = emptyList()
+    override var typeParameters: List<IrTypeParameter>
+        get() = getCarrier().typeParametersField
+        set(v) {
+            if (typeParameters !== v) {
+                setCarrier().typeParametersField = v
+            }
+        }
 
-    final override var body: IrBody? = null
+    override var dispatchReceiverParameterField: IrValueParameter? = null
 
-    override var metadata: MetadataSource? = null
+    override var dispatchReceiverParameter: IrValueParameter?
+        get() = getCarrier().dispatchReceiverParameterField
+        set(v) {
+            if (dispatchReceiverParameter !== v) {
+                setCarrier().dispatchReceiverParameterField = v
+            }
+        }
+
+    override var extensionReceiverParameterField: IrValueParameter? = null
+
+    override var extensionReceiverParameter: IrValueParameter?
+        get() = getCarrier().extensionReceiverParameterField
+        set(v) {
+            if (extensionReceiverParameter !== v) {
+                setCarrier().extensionReceiverParameterField = v
+            }
+        }
+
+    override var valueParametersField: List<IrValueParameter> = emptyList()
+
+    override var valueParameters: List<IrValueParameter>
+        get() = getCarrier().valueParametersField
+        set(v) {
+            if (valueParameters !== v) {
+                setCarrier().valueParametersField = v
+            }
+        }
+
+    override var bodyField: IrBody? = null
+
+    final override var body: IrBody?
+        get() = getCarrier().bodyField
+        set(v) {
+            if (body !== v) {
+                if (v is IrBodyBase<*>) {
+                    v.container = this
+                }
+                setCarrier().bodyField = v
+            }
+        }
+
+    override var metadataField: MetadataSource? = null
+
+    override var metadata: MetadataSource?
+        get() = getCarrier().metadataField
+        set(v) {
+            if (metadata !== v) {
+                setCarrier().metadataField = v
+            }
+        }
+
+    override var visibilityField: Visibility = visibility
+
+    override var visibility: Visibility
+        get() = getCarrier().visibilityField
+        set(v) {
+            if (visibility !== v) {
+                setCarrier().visibilityField = v
+            }
+        }
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         typeParameters.forEach { it.accept(visitor, data) }

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt

@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.IrAttributeContainer
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.FunctionCarrier
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrSimpleFunctionSymbolImpl
@@ -35,8 +35,9 @@ class IrFunctionImpl(
     isExpect: Boolean,
     override val isFakeOverride: Boolean
 ) :
-    IrFunctionBase(startOffset, endOffset, origin, name, visibility, isInline, isExternal, isExpect, returnType),
-    IrSimpleFunction {
+    IrFunctionBase<FunctionCarrier>(startOffset, endOffset, origin, name, visibility, isInline, isExternal, isExpect, returnType),
+    IrSimpleFunction,
+    FunctionCarrier {
 
     constructor(
         startOffset: Int,
@@ -63,10 +64,35 @@ class IrFunctionImpl(
 
     override val descriptor: FunctionDescriptor = symbol.descriptor
 
-    override var overriddenSymbols: List<IrSimpleFunctionSymbol> = emptyList()
-    override var attributeOwnerId: IrAttributeContainer = this
+    override var overriddenSymbolsField: List<IrSimpleFunctionSymbol> = emptyList()
 
-    override var correspondingPropertySymbol: IrPropertySymbol? = null
+    override var overriddenSymbols: List<IrSimpleFunctionSymbol>
+        get() = getCarrier().overriddenSymbolsField
+        set(v) {
+            if (overriddenSymbols !== v) {
+                setCarrier().overriddenSymbolsField = v
+            }
+        }
+
+    override var attributeOwnerIdField: IrAttributeContainer = this
+
+    override var attributeOwnerId: IrAttributeContainer
+        get() = getCarrier().attributeOwnerIdField
+        set(v) {
+            if (attributeOwnerId !== v) {
+                setCarrier().attributeOwnerIdField = v
+            }
+        }
+
+    override var correspondingPropertySymbolField: IrPropertySymbol? = null
+
+    override var correspondingPropertySymbol: IrPropertySymbol?
+        get() = getCarrier().correspondingPropertySymbolField
+        set(v) {
+            if (correspondingPropertySymbol !== v) {
+                setCarrier().correspondingPropertySymbolField = v
+            }
+        }
 
     // Used by kotlin-native in InteropLowering.kt and IrUtils2.kt
     constructor(

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrLocalDelegatedPropertyImpl.kt

@@ -17,10 +17,8 @@
 package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrFunction
-import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.LocalDelegatedPropertyCarrier
 import org.jetbrains.kotlin.ir.symbols.IrLocalDelegatedPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrLocalDelegatedPropertySymbolImpl
 import org.jetbrains.kotlin.ir.types.IrType
@@ -28,6 +26,7 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 
+// TODO make not persistent
 class IrLocalDelegatedPropertyImpl(
     startOffset: Int,
     endOffset: Int,
@@ -37,8 +36,9 @@ class IrLocalDelegatedPropertyImpl(
     override val type: IrType,
     override val isVar: Boolean
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrLocalDelegatedProperty {
+    IrDeclarationBase<LocalDelegatedPropertyCarrier>(startOffset, endOffset, origin),
+    IrLocalDelegatedProperty,
+    LocalDelegatedPropertyCarrier {
 
     init {
         symbol.bind(this)
@@ -85,7 +85,6 @@ class IrLocalDelegatedPropertyImpl(
         descriptor.name, type, descriptor.isVar
     )
 
-    @Suppress("DEPRECATION")
     @Deprecated("Creates unbound symbol")
     constructor(
         startOffset: Int,
@@ -105,11 +104,35 @@ class IrLocalDelegatedPropertyImpl(
     override val descriptor: VariableDescriptorWithAccessors
         get() = symbol.descriptor
 
-    override lateinit var delegate: IrVariable
+    override var delegateField: IrVariable? = null
 
-    override lateinit var getter: IrFunction
+    override var delegate: IrVariable
+        get() = getCarrier().delegateField!!
+        set(v) {
+            if (getCarrier().delegateField !== v) {
+                setCarrier().delegateField = v
+            }
+        }
 
-    override var setter: IrFunction? = null
+    override var getterField: IrFunction? = null
+
+    override var getter: IrFunction
+        get() = getCarrier().getterField!!
+        set(v) {
+            if (getCarrier().getterField !== v) {
+                setCarrier().getterField = v
+            }
+        }
+
+    override var setterField: IrFunction? = null
+
+    override var setter: IrFunction?
+        get() = getCarrier().setterField
+        set(v) {
+            if (setter !== v) {
+                setCarrier().setterField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitLocalDelegatedProperty(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.PropertyCarrier
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrPropertySymbolImpl
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
@@ -43,8 +44,9 @@ class IrPropertyImpl(
     override val isExternal: Boolean = symbol.descriptor.isEffectivelyExternal(),
     override val isExpect: Boolean = symbol.descriptor.isExpect,
     override val isFakeOverride: Boolean = origin == IrDeclarationOrigin.FAKE_OVERRIDE
-) : IrDeclarationBase(startOffset, endOffset, origin),
-    IrProperty {
+) : IrDeclarationBase<PropertyCarrier>(startOffset, endOffset, origin),
+    IrProperty,
+    PropertyCarrier {
 
     @Deprecated(message = "Don't use descriptor-based API for IrProperty", level = DeprecationLevel.WARNING)
     constructor(
@@ -133,9 +135,36 @@ class IrPropertyImpl(
 
     override val descriptor: PropertyDescriptor = symbol.descriptor
 
-    override var backingField: IrField? = null
-    override var getter: IrSimpleFunction? = null
-    override var setter: IrSimpleFunction? = null
+    override var backingFieldField: IrField? = null
+
+    override var backingField: IrField?
+        get() = getCarrier().backingFieldField
+        set(v) {
+            if (backingField !== v) {
+                setCarrier().backingFieldField = v
+            }
+        }
+
+    override var getterField: IrSimpleFunction? = null
+
+    override var getter: IrSimpleFunction?
+        get() = getCarrier().getterField
+        set(v) {
+            if (getter !== v) {
+                setCarrier().getterField = v
+            }
+        }
+
+    override var setterField: IrSimpleFunction? = null
+
+    override var setter: IrSimpleFunction?
+        get() = getCarrier().setterField
+        set(v) {
+            if (setter !== v) {
+                setCarrier().setterField = v
+            }
+        }
+
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitProperty(this, data)
@@ -147,7 +176,15 @@ class IrPropertyImpl(
         setter?.accept(visitor, data)
     }
 
-    override var metadata: MetadataSource? = null
+    override var metadataField: MetadataSource? = null
+
+    override var metadata: MetadataSource?
+        get() = getCarrier().metadataField
+        set(v) {
+            if (metadata !== v) {
+                setCarrier().metadataField = v
+            }
+        }
 
     override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
         backingField = backingField?.transform(transformer, data) as? IrField

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrScriptImpl.kt

@@ -9,18 +9,35 @@ import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.ir.IrStatement
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.symbols.IrScriptSymbol
 import org.jetbrains.kotlin.ir.util.transform
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.utils.SmartList
 
 private val SCRIPT_ORIGIN = object : IrDeclarationOriginImpl("FIELD_FOR_OBJECT_INSTANCE") {}
 
 class IrScriptImpl(
     override val symbol: IrScriptSymbol,
     override val name: Name
-) : IrScript, IrDeclarationBase(UNDEFINED_OFFSET, UNDEFINED_OFFSET, SCRIPT_ORIGIN) {
+) : IrScript, IrDeclaration {
+    override val startOffset: Int get() = UNDEFINED_OFFSET
+    override val endOffset: Int get() = UNDEFINED_OFFSET
+    override var origin: IrDeclarationOrigin = SCRIPT_ORIGIN
+
+    private var _parent: IrDeclarationParent? = null
+    override var parent: IrDeclarationParent
+        get() = _parent
+            ?: throw UninitializedPropertyAccessException("Parent not initialized: $this")
+        set(v) {
+            _parent = v
+        }
+
+    override var annotations: List<IrConstructorCall> = SmartList()
+    override val metadata: MetadataSource? get() = null
+
     override val declarations: MutableList<IrDeclaration> = mutableListOf()
     override val statements: MutableList<IrStatement> = mutableListOf()
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrTypeAlias
 import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.TypeAliasCarrier
 import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol
 import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.util.mapOptimized
@@ -27,8 +28,9 @@ class IrTypeAliasImpl(
     override val isActual: Boolean,
     origin: IrDeclarationOrigin
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrTypeAlias {
+    IrDeclarationBase<TypeAliasCarrier>(startOffset, endOffset, origin),
+    IrTypeAlias,
+    TypeAliasCarrier {
 
     init {
         symbol.bind(this)
@@ -37,7 +39,15 @@ class IrTypeAliasImpl(
     override val descriptor: TypeAliasDescriptor
         get() = symbol.descriptor
 
-    override var typeParameters: List<IrTypeParameter> = emptyList()
+    override var typeParametersField: List<IrTypeParameter> = emptyList()
+
+    override var typeParameters: List<IrTypeParameter>
+        get() = getCarrier().typeParametersField
+        set(v) {
+            if (typeParameters !== v) {
+                setCarrier().typeParametersField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitTypeAlias(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeParameterImpl.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.TypeParameterCarrier
 import org.jetbrains.kotlin.ir.symbols.IrTypeParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrTypeParameterSymbolImpl
 import org.jetbrains.kotlin.ir.types.IrType
@@ -38,8 +39,9 @@ class IrTypeParameterImpl(
     override val isReified: Boolean,
     override val variance: Variance
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrTypeParameter {
+    IrDeclarationBase<TypeParameterCarrier>(startOffset, endOffset, origin),
+    IrTypeParameter,
+    TypeParameterCarrier {
 
     constructor(
         startOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrValueParameterImpl.kt

@@ -20,6 +20,7 @@ import org.jetbrains.kotlin.descriptors.ParameterDescriptor
 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
 import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.impl.carriers.ValueParameterCarrier
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrValueParameterSymbolImpl
@@ -41,8 +42,9 @@ class IrValueParameterImpl(
     override val isCrossinline: Boolean,
     override val isNoinline: Boolean
 ) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrValueParameter {
+    IrDeclarationBase<ValueParameterCarrier>(startOffset, endOffset, origin),
+    IrValueParameter,
+    ValueParameterCarrier {
 
     constructor(
         startOffset: Int,
@@ -79,7 +81,18 @@ class IrValueParameterImpl(
         symbol.bind(this)
     }
 
-    override var defaultValue: IrExpressionBody? = null
+    override var defaultValueField: IrExpressionBody? = null
+
+    override var defaultValue: IrExpressionBody?
+        get() = getCarrier().defaultValueField
+        set(v) {
+            if (defaultValue !== v) {
+                if (v is IrBodyBase<*>) {
+                    v.container = this
+                }
+                setCarrier().defaultValueField = v
+            }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitValueParameter(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt

@@ -18,7 +18,10 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.VariableDescriptor
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
 import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.MetadataSource
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.symbols.IrVariableSymbol
 import org.jetbrains.kotlin.ir.symbols.impl.IrVariableSymbolImpl
@@ -26,20 +29,30 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.utils.SmartList
 
 class IrVariableImpl(
-    startOffset: Int,
-    endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override val startOffset: Int,
+    override val endOffset: Int,
+    override var origin: IrDeclarationOrigin,
     override val symbol: IrVariableSymbol,
     override val name: Name,
     override val type: IrType,
     override val isVar: Boolean,
     override val isConst: Boolean,
     override val isLateinit: Boolean
-) :
-    IrDeclarationBase(startOffset, endOffset, origin),
-    IrVariable {
+) : IrVariable {
+
+    private var _parent: IrDeclarationParent? = null
+    override var parent: IrDeclarationParent
+        get() = _parent
+            ?: throw UninitializedPropertyAccessException("Parent not initialized: $this")
+        set(v) {
+            _parent = v
+        }
+
+    override var annotations: List<IrConstructorCall> = emptyList()
+    override val metadata: MetadataSource? get() = null
 
     constructor(
         startOffset: Int,

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/AnonymousInitializerCarrier.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrBlockBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface AnonymousInitializerCarrier : DeclarationCarrier<AnonymousInitializerCarrier> {
+    var bodyField: IrBlockBody?
+
+    override fun clone(): AnonymousInitializerCarrier {
+        return AnonymousInitializerCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            bodyField
+        )
+    }
+}
+
+class AnonymousInitializerCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var bodyField: IrBlockBody?
+) : AnonymousInitializerCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/BodyCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclaration
+
+interface BodyCarrier : Carrier<BodyCarrier> {
+
+    var containerField: IrDeclaration?
+
+    override fun clone(): BodyCarrier {
+        return BodyCarrierImpl(lastModified, containerField)
+    }
+}
+
+class BodyCarrierImpl(
+    override val lastModified: Int,
+    override var containerField: IrDeclaration?
+) : BodyCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/Carrier.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.ir.declarations.impl.carriers
+
+interface Carrier<in T : Carrier<T>> {
+    val lastModified: Int
+
+    fun clone(): Carrier<T>
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ClassCarrier.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.types.IrType
+
+interface ClassCarrier : DeclarationCarrier<ClassCarrier> {
+    var thisReceiverField: IrValueParameter?
+    var metadataField: MetadataSource?
+    var visibilityField: Visibility
+    var modalityField: Modality
+    var attributeOwnerIdField: IrAttributeContainer
+    var typeParametersField: List<IrTypeParameter>
+    var superTypesField: List<IrType>
+
+    override fun clone(): ClassCarrier {
+        return ClassCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            thisReceiverField,
+            metadataField,
+            visibilityField,
+            modalityField,
+            attributeOwnerIdField,
+            typeParametersField,
+            superTypesField
+        )
+    }
+}
+
+class ClassCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var thisReceiverField: IrValueParameter?,
+    override var metadataField: MetadataSource?,
+    override var visibilityField: Visibility,
+    override var modalityField: Modality,
+    override var attributeOwnerIdField: IrAttributeContainer,
+    override var typeParametersField: List<IrTypeParameter>,
+    override var superTypesField: List<IrType>
+) : ClassCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ConstructorCarrier.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.types.IrType
+
+
+interface ConstructorCarrier : FunctionBaseCarrier<ConstructorCarrier> {
+
+    override fun clone(): ConstructorCarrier {
+        return ConstructorCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            returnTypeFieldField,
+            dispatchReceiverParameterField,
+            extensionReceiverParameterField,
+            bodyField,
+            metadataField,
+            visibilityField,
+            typeParametersField,
+            valueParametersField
+        )
+    }
+}
+
+class ConstructorCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var returnTypeFieldField: IrType,
+    override var dispatchReceiverParameterField: IrValueParameter?,
+    override var extensionReceiverParameterField: IrValueParameter?,
+    override var bodyField: IrBody?,
+    override var metadataField: MetadataSource?,
+    override var visibilityField: Visibility,
+    override var typeParametersField: List<IrTypeParameter>,
+    override var valueParametersField: List<IrValueParameter>
+) : ConstructorCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/DeclarationCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.utils.SmartList
+
+interface DeclarationCarrier<in T : DeclarationCarrier<T>>: Carrier<T> {
+    var parentField: IrDeclarationParent?
+    var originField: IrDeclarationOrigin
+    var annotationsField: List<IrConstructorCall>
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/EnumEntryCarrier.kt

@@ -0,0 +1,37 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrClass
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+
+interface EnumEntryCarrier : DeclarationCarrier<EnumEntryCarrier> {
+    var correspondingClassField: IrClass?
+    var initializerExpressionField: IrExpressionBody?
+    
+    override fun clone(): EnumEntryCarrier {
+        return EnumEntryCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            correspondingClassField,
+            initializerExpressionField
+        )
+    }
+}
+
+class EnumEntryCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var correspondingClassField: IrClass?,
+    override var initializerExpressionField: IrExpressionBody?
+) : EnumEntryCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ErrorCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface ErrorCarrier : DeclarationCarrier<ErrorCarrier> {
+
+    override fun clone(): ErrorCarrier {
+        return ErrorCarrierImpl(lastModified, parentField, originField, annotationsField)
+    }
+}
+
+class ErrorCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>
+    ) : ErrorCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FieldCarrier.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.MetadataSource
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+import org.jetbrains.kotlin.ir.symbols.IrFieldSymbol
+import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
+
+interface FieldCarrier : DeclarationCarrier<FieldCarrier> {
+    var initializerField: IrExpressionBody?
+    var correspondingPropertySymbolField: IrPropertySymbol?
+    var metadataField: MetadataSource.Property?
+    var overridenSymbolsField: List<IrFieldSymbol>
+
+    override fun clone(): FieldCarrier {
+        return FieldCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            initializerField,
+            correspondingPropertySymbolField,
+            metadataField,
+            overridenSymbolsField
+        )
+    }
+}
+
+class FieldCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var initializerField: IrExpressionBody?,
+    override var correspondingPropertySymbolField: IrPropertySymbol?,
+    override var metadataField: MetadataSource.Property?,
+    override var overridenSymbolsField: List<IrFieldSymbol>
+): FieldCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionBaseCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.declarations.IrValueParameter
+import org.jetbrains.kotlin.ir.declarations.MetadataSource
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.types.IrType
+
+interface FunctionBaseCarrier<T : FunctionBaseCarrier<T>> : DeclarationCarrier<T> {
+    var returnTypeFieldField: IrType
+    var dispatchReceiverParameterField: IrValueParameter?
+    var extensionReceiverParameterField: IrValueParameter?
+    var bodyField: IrBody?
+    var metadataField: MetadataSource?
+    var visibilityField: Visibility
+    var typeParametersField: List<IrTypeParameter>
+    var valueParametersField: List<IrValueParameter>
+}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionCarrier.kt

@@ -0,0 +1,58 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
+import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
+import org.jetbrains.kotlin.ir.types.IrType
+
+interface FunctionCarrier : FunctionBaseCarrier<FunctionCarrier> {
+    var correspondingPropertySymbolField: IrPropertySymbol?
+    var overriddenSymbolsField: List<IrSimpleFunctionSymbol>
+    var attributeOwnerIdField: IrAttributeContainer
+
+    override fun clone(): FunctionCarrier {
+        return FunctionCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            returnTypeFieldField,
+            dispatchReceiverParameterField,
+            extensionReceiverParameterField,
+            bodyField,
+            metadataField,
+            visibilityField,
+            typeParametersField,
+            valueParametersField,
+            correspondingPropertySymbolField,
+            overriddenSymbolsField,
+            attributeOwnerIdField
+        )
+    }
+}
+
+class FunctionCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var returnTypeFieldField: IrType,
+    override var dispatchReceiverParameterField: IrValueParameter?,
+    override var extensionReceiverParameterField: IrValueParameter?,
+    override var bodyField: IrBody?,
+    override var metadataField: MetadataSource?,
+    override var visibilityField: Visibility,
+    override var typeParametersField: List<IrTypeParameter>,
+    override var valueParametersField: List<IrValueParameter>,
+    override var correspondingPropertySymbolField: IrPropertySymbol?,
+    override var overriddenSymbolsField: List<IrSimpleFunctionSymbol>,
+    override var attributeOwnerIdField: IrAttributeContainer
+) : FunctionCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/LocalDelegatedPropertyCarrier.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface LocalDelegatedPropertyCarrier : DeclarationCarrier<LocalDelegatedPropertyCarrier> {
+    var delegateField: IrVariable?
+    var getterField: IrFunction?
+    var setterField: IrFunction?
+
+    override fun clone(): LocalDelegatedPropertyCarrier {
+        return LocalDelegatedPropertyCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            delegateField,
+            getterField,
+            setterField
+        )
+    }
+}
+
+class LocalDelegatedPropertyCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var delegateField: IrVariable?,
+    override var getterField: IrFunction?,
+    override var setterField: IrFunction?
+) : LocalDelegatedPropertyCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/PropertyCarrier.kt

@@ -0,0 +1,40 @@
+/*
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface PropertyCarrier : DeclarationCarrier<PropertyCarrier> {
+    var backingFieldField: IrField?
+    var getterField: IrSimpleFunction?
+    var setterField: IrSimpleFunction?
+    var metadataField: MetadataSource?
+
+    override fun clone(): PropertyCarrier {
+        return PropertyCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            backingFieldField,
+            getterField,
+            setterField,
+            metadataField
+        )
+    }
+}
+
+class PropertyCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var backingFieldField: IrField?,
+    override var getterField: IrSimpleFunction?,
+    override var setterField: IrSimpleFunction?,
+    override var metadataField: MetadataSource?
+) : PropertyCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeAliasCarrier.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * 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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.declarations.IrTypeParameter
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface TypeAliasCarrier : DeclarationCarrier<TypeAliasCarrier> {
+
+    var typeParametersField: List<IrTypeParameter>
+
+    override fun clone(): TypeAliasCarrier {
+        return TypeAliasCarrierImpl(
+            lastModified,
+            parentField,
+            originField,
+            annotationsField,
+            typeParametersField
+        )
+    }
+}
+
+class TypeAliasCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var typeParametersField: List<IrTypeParameter>
+    ) : TypeAliasCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeParameterCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+
+interface TypeParameterCarrier : DeclarationCarrier<TypeParameterCarrier> {
+
+    override fun clone(): TypeParameterCarrier {
+        return TypeParameterCarrierImpl(lastModified, parentField, originField, annotationsField)
+    }
+}
+
+class TypeParameterCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>
+    ) : TypeParameterCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ValueParameterCarrier.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.ir.declarations.impl.carriers
+
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationParent
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
+
+interface ValueParameterCarrier : DeclarationCarrier<ValueParameterCarrier> {
+    var defaultValueField: IrExpressionBody?
+
+    override fun clone(): ValueParameterCarrier {
+        return ValueParameterCarrierImpl(lastModified, parentField, originField, annotationsField, defaultValueField)
+    }
+}
+
+class ValueParameterCarrierImpl(
+    override val lastModified: Int,
+    override var parentField: IrDeclarationParent?,
+    override var originField: IrDeclarationOrigin,
+    override var annotationsField: List<IrConstructorCall>,
+    override var defaultValueField: IrExpressionBody?
+) : ValueParameterCarrier

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt

@@ -6,9 +6,9 @@
 package org.jetbrains.kotlin.ir.declarations.lazy
 
 import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase
 import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl
 import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator
@@ -19,10 +19,10 @@ import org.jetbrains.kotlin.types.KotlinType
 abstract class IrLazyDeclarationBase(
     startOffset: Int,
     endOffset: Int,
-    origin: IrDeclarationOrigin,
+    override var origin: IrDeclarationOrigin,
     private val stubGenerator: DeclarationStubGenerator,
     protected val typeTranslator: TypeTranslator
-) : IrDeclarationBase(startOffset, endOffset, origin) {
+) : IrElementBase(startOffset, endOffset), IrDeclaration {
 
     protected fun KotlinType.toIrType() = typeTranslator.translateType(this)
 

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrOperators.kt

@@ -8,8 +8,8 @@ package org.jetbrains.kotlin.ir.descriptors
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase
-import org.jetbrains.kotlin.ir.declarations.impl.IrFunctionBase
+import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrConstructorCall
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.symbols.IrPropertySymbol
 import org.jetbrains.kotlin.ir.symbols.IrSimpleFunctionSymbol
@@ -21,33 +21,72 @@ import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.types.Variance
 import org.jetbrains.kotlin.utils.SmartList
+import kotlin.reflect.KProperty
 
 interface IrBuiltinWithMangle : IrDeclaration, IrSymbolOwner {
     val mangle: String
 }
 
+abstract class IrBuiltInOperatorBase : IrDeclaration {
+    override val startOffset: Int get() = UNDEFINED_OFFSET
+    override val endOffset: Int get() = UNDEFINED_OFFSET
+
+    override var origin: IrDeclarationOrigin
+        get() = IrBuiltIns.BUILTIN_OPERATOR
+        set(_) {}
+
+    private var _parent: IrDeclarationParent? = null
+    override var parent: IrDeclarationParent
+        get() = _parent
+            ?: throw UninitializedPropertyAccessException("Parent not initialized: $this")
+        set(v) {
+            _parent = v
+        }
+
+    override var annotations: List<IrConstructorCall> = emptyList()
+    override val metadata: MetadataSource? get() = null
+}
+
+private class NullValueDelegate<T> {
+    operator fun getValue(thisRef: Any?, property: KProperty<*>): T? = null
+    operator fun setValue(thisRef: Any?, property: KProperty<*>, v: T?) {
+        error("IrBuiltInOperators are not supposed to be mutated")
+    }
+}
+
 class IrBuiltInOperator(
     override val symbol: IrSimpleFunctionSymbol,
-    name: Name,
-    returnType: IrType,
+    override val name: Name,
+    override var returnType: IrType,
     val suffix: String
 ) :
     IrSimpleFunction,
     IrBuiltinWithMangle,
-    IrFunctionBase(
-        UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrBuiltIns.BUILTIN_OPERATOR,
-        name, Visibilities.PUBLIC, false, false, false,
-        returnType
-    ) {
+    IrFunction,
+    IrBuiltInOperatorBase() {
+
+    override val visibility: Visibility get() = Visibilities.PUBLIC
+
+    override val isInline: Boolean get() = false
+    override val isExternal: Boolean get() = false
+    override val isExpect: Boolean get() = false
+
+    override var dispatchReceiverParameter: IrValueParameter? by NullValueDelegate()
+
+    override var extensionReceiverParameter: IrValueParameter? by NullValueDelegate()
+
+    override var body: IrBody? by NullValueDelegate()
+
+    override var valueParameters: List<IrValueParameter> = emptyList()
+    override var typeParameters: List<IrTypeParameter> = emptyList()
 
     override val modality get() = Modality.FINAL
     override val isTailrec get() = false
     override val isSuspend get() = false
     override val isFakeOverride get() = false
     override val isOperator: Boolean get() = false
-    override var correspondingPropertySymbol: IrPropertySymbol?
-        get() = null
-        set(_) {}
+    override var correspondingPropertySymbol: IrPropertySymbol? by NullValueDelegate()
+
     override val descriptor: FunctionDescriptor get() = symbol.descriptor
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
@@ -61,18 +100,25 @@ class IrBuiltInOperator(
     init {
         symbol.bind(this)
     }
+
+    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
+        // Do nothing
+    }
+
+    override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
+        // Do nothing
+    }
 }
 
 class IrBuiltInOperatorValueParameter(override val symbol: IrValueParameterSymbol, override val index: Int, override val type: IrType) :
-    IrValueParameter, IrDeclarationBase(UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrBuiltIns.BUILTIN_OPERATOR) {
+    IrValueParameter, IrBuiltInOperatorBase() {
 
     override val descriptor: ParameterDescriptor get() = symbol.descriptor
     override val varargElementType: IrType? get() = null
     override val isCrossinline: Boolean get() = false
     override val isNoinline: Boolean get() = false
-    override var defaultValue: IrExpressionBody?
-        get() = null
-        set(_) {}
+    override var defaultValue: IrExpressionBody? by NullValueDelegate()
+
     override val name: Name = Name.identifier("arg$index")
 
     override fun <D> transform(transformer: IrElementTransformer<D>, data: D) =
@@ -92,7 +138,7 @@ class IrBuiltInOperatorTypeParameter(
     override val variance: Variance,
     override val index: Int,
     override val isReified: Boolean
-) : IrTypeParameter, IrDeclarationBase(UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrBuiltIns.BUILTIN_OPERATOR) {
+) : IrTypeParameter, IrBuiltInOperatorBase() {
 
     override val descriptor: TypeParameterDescriptor get() = symbol.descriptor
     override val superTypes: MutableList<IrType> = SmartList()

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt

@@ -16,8 +16,8 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.ir.IrElementBase
 import org.jetbrains.kotlin.ir.IrStatement
+import org.jetbrains.kotlin.ir.declarations.impl.IrBodyBase
 import org.jetbrains.kotlin.ir.expressions.IrBlockBody
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
@@ -25,20 +25,20 @@ import java.util.*
 
 class IrBlockBodyImpl(
     startOffset: Int,
-    endOffset: Int
+    endOffset: Int,
+    initializer: (IrBlockBodyImpl.() -> Unit)? = null
 ) :
-    IrElementBase(startOffset, endOffset),
+    IrBodyBase<IrBlockBodyImpl>(startOffset, endOffset, initializer),
     IrBlockBody {
 
     constructor(startOffset: Int, endOffset: Int, statements: List<IrStatement>) : this(startOffset, endOffset) {
-        this.statements.addAll(statements)
+        statementsField.addAll(statements)
     }
 
-    constructor(startOffset: Int, endOffset: Int, fn: IrBlockBodyImpl.() -> Unit) : this(startOffset, endOffset) {
-        this.fn()
-    }
+    private var statementsField: MutableList<IrStatement> = ArrayList()
 
-    override val statements: MutableList<IrStatement> = ArrayList()
+    override val statements: MutableList<IrStatement>
+        get() = checkEnabled { statementsField }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
         return visitor.visitBlockBody(this, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt

@@ -16,30 +16,32 @@
 
 package org.jetbrains.kotlin.ir.expressions.impl
 
-import org.jetbrains.kotlin.ir.IrElementBase
+import org.jetbrains.kotlin.ir.declarations.impl.IrBodyBase
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformer
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-class IrExpressionBodyImpl(
+class IrExpressionBodyImpl private constructor(
     startOffset: Int,
-    endOffset: Int
+    endOffset: Int,
+    private var expressionField: IrExpression? = null,
+    initializer: (IrExpressionBodyImpl.() -> Unit)? = null
 ) :
-    IrElementBase(startOffset, endOffset),
+    IrBodyBase<IrExpressionBodyImpl>(startOffset, endOffset, initializer),
     IrExpressionBody {
 
-    constructor(startOffset: Int, endOffset: Int, expression: IrExpression) : this(startOffset, endOffset) {
-        this.expression = expression
-    }
+    constructor(expression: IrExpression) : this(expression.startOffset, expression.endOffset, expression, null)
 
-    constructor(expression: IrExpression) : this(expression.startOffset, expression.endOffset, expression)
+    constructor(startOffset: Int, endOffset: Int, expression: IrExpression) : this(startOffset, endOffset, expression, null)
 
-    constructor(startOffset: Int, endOffset: Int, initFn: IrExpressionBodyImpl.() -> Unit) : this(startOffset, endOffset) {
-        this.initFn()
-    }
+    constructor(startOffset: Int, endOffset: Int, initializer: IrExpressionBodyImpl.() -> Unit) : this(startOffset, endOffset, null, initializer)
 
-    override lateinit var expression: IrExpression
+    override var expression: IrExpression
+        get() = checkEnabled { expressionField!! }
+        set(e) {
+            checkEnabled { expressionField = e }
+        }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
         visitor.visitExpressionBody(this, data)