diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt index 493bd3289f1..fb4dfa9362e 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/inlineclasses/MemoizedInlineClassReplacements.kt @@ -173,7 +173,7 @@ class MemoizedInlineClassReplacements { val parameterMap = mutableMapOf() 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 } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/PersistentApi.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/PersistentApi.kt new file mode 100644 index 00000000000..7dc1d9e70f4 --- /dev/null +++ b/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 withStage(stage: Int, fn: () -> T): T = fn() + + val bodiesEnabled: Boolean get() = true + + fun bodyLowering(fn: () -> T): T = fn() + + fun canModify(element: IrElement): Boolean = true + + fun canAccessDeclarationsOf(declaration: IrClass): Boolean = true +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrAnonymousInitializerImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrAnonymousInitializerImpl.kt index 843deb21cd6..a3a16eb2b6a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrAnonymousInitializerImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, data: D): R { return visitor.visitAnonymousInitializer(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt index 4afabeb9ef4..57fea2812a6 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrClassImpl.kt +++ b/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(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? = null override val declarations: MutableList = ArrayList() + get() { + if (createdOn < stageController.currentStage && initialDeclarations == null) { + initialDeclarations = Collections.unmodifiableList(ArrayList(field)) + } - override var typeParameters: List = emptyList() + return if (stageController.canAccessDeclarationsOf(this)) { + ensureLowered() + field + } else { + initialDeclarations ?: field + } + } - override var superTypes: List = emptyList() + override var typeParametersField: List = emptyList() - override var metadata: MetadataSource? = null + override var typeParameters: List + get() = getCarrier().typeParametersField + set(v) { + if (typeParameters !== v) { + setCarrier().typeParametersField = v + } + } - override var attributeOwnerId: IrAttributeContainer = this + override var superTypesField: List = emptyList() + + override var superTypes: List + 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 accept(visitor: IrElementVisitor, data: D): R = visitor.visitClass(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrConstructorImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrConstructorImpl.kt index 37315a57467..515a54c65c4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrConstructorImpl.kt +++ b/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( startOffset, endOffset, origin, name, visibility, isInline, isExternal, isExpect, returnType ), - IrConstructor { + IrConstructor, + ConstructorCarrier { constructor( startOffset: Int, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrDeclarationBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrDeclarationBase.kt index 26936ece3b7..bb44aa703b0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrDeclarationBase.kt +++ b/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>( startOffset: Int, endOffset: Int, - override var origin: IrDeclarationOrigin -) : IrElementBase(startOffset, endOffset), - IrDeclaration { + origin: IrDeclarationOrigin +) : IrPersistingElementBase(startOffset, endOffset), + IrDeclaration, + DeclarationCarrier { + + 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 = 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 = emptyList() + + override var annotations: List + 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>( + startOffset: Int, + endOffset: Int +) : IrElementBase(startOffset, endOffset), + Carrier { + + override var lastModified: Int = stageController.currentStage + + var loweredUpTo = stageController.currentStage + + private var values: Array? = 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(1) + + newValues[newValues.size - 1] = this.clone() + + values = newValues + } + + this.lastModified = stage + + return this as T + } +} + +abstract class IrBodyBase>( + startOffset: Int, + endOffset: Int, + private var initializer: (B.() -> Unit)? +) : IrPersistingElementBase(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 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) + } + } +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt index 93f2ca984ce..34f88b665e3 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, 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 } -} +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrErrorDeclarationImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrErrorDeclarationImpl.kt index ccf2edc32a5..3e0c353c942 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrErrorDeclarationImpl.kt +++ b/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(startOffset, endOffset, IrDeclarationOrigin.DEFINED), IrErrorDeclaration, ErrorCarrier { override fun accept(visitor: IrElementVisitor, data: D): R { return visitor.visitErrorDeclaration(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt index ab789223de2..532f00243c4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFieldImpl.kt +++ b/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(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 = 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 = emptyList() + + override var overriddenSymbols: List + 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 accept(visitor: IrElementVisitor, data: D): R { return visitor.visitField(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFileImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFileImpl.kt index 55d61b48a86..e7d386e11c5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFileImpl.kt +++ b/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 = ArrayList() - override var annotations: List = emptyList() + override var annotations: List = ArrayList() override var metadata: MetadataSource.File? = null diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionBase.kt index 1da2ecd986c..54cbbd35fd4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionBase.kt +++ b/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>( 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(startOffset, endOffset, origin), + IrFunction, + FunctionBaseCarrier { + 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 = emptyList() + override var typeParametersField: List = emptyList() - override var dispatchReceiverParameter: IrValueParameter? = null - override var extensionReceiverParameter: IrValueParameter? = null - override var valueParameters: List = emptyList() + override var typeParameters: List + 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 = emptyList() + + override var valueParameters: List + 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 acceptChildren(visitor: IrElementVisitor, data: D) { typeParameters.forEach { it.accept(visitor, data) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt index 5f483c1adbb..5a7354dcfe3 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrFunctionImpl.kt +++ b/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(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 = emptyList() - override var attributeOwnerId: IrAttributeContainer = this + override var overriddenSymbolsField: List = emptyList() - override var correspondingPropertySymbol: IrPropertySymbol? = null + override var overriddenSymbols: List + 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( diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrLocalDelegatedPropertyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrLocalDelegatedPropertyImpl.kt index dbbeb657ace..73bc5000527 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrLocalDelegatedPropertyImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, data: D): R = visitor.visitLocalDelegatedProperty(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt index 27e19e85ee5..f2c6f02d9e3 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, 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 transformChildren(transformer: IrElementTransformer, data: D) { backingField = backingField?.transform(transformer, data) as? IrField diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrScriptImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrScriptImpl.kt index 95bf4dbac43..50f87cad650 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrScriptImpl.kt +++ b/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 = SmartList() + override val metadata: MetadataSource? get() = null + override val declarations: MutableList = mutableListOf() override val statements: MutableList = mutableListOf() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt index 924d6c5e370..2f02c3dc8a1 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt +++ b/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(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 = emptyList() + override var typeParametersField: List = emptyList() + + override var typeParameters: List + get() = getCarrier().typeParametersField + set(v) { + if (typeParameters !== v) { + setCarrier().typeParametersField = v + } + } override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitTypeAlias(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeParameterImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeParameterImpl.kt index fb02cc06593..1b70ae70174 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeParameterImpl.kt +++ b/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(startOffset, endOffset, origin), + IrTypeParameter, + TypeParameterCarrier { constructor( startOffset: Int, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrValueParameterImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrValueParameterImpl.kt index 1c7b124d050..7cb9cb7f739 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrValueParameterImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, data: D): R = visitor.visitValueParameter(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt index 7fccef108aa..4527c03bdd1 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrVariableImpl.kt +++ b/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 = emptyList() + override val metadata: MetadataSource? get() = null constructor( startOffset: Int, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/AnonymousInitializerCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/AnonymousInitializerCarrier.kt new file mode 100644 index 00000000000..c52abc28a7b --- /dev/null +++ b/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 { + 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, + override var bodyField: IrBlockBody? +) : AnonymousInitializerCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/BodyCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/BodyCarrier.kt new file mode 100644 index 00000000000..35db7980e7b --- /dev/null +++ b/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 { + + var containerField: IrDeclaration? + + override fun clone(): BodyCarrier { + return BodyCarrierImpl(lastModified, containerField) + } +} + +class BodyCarrierImpl( + override val lastModified: Int, + override var containerField: IrDeclaration? +) : BodyCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/Carrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/Carrier.kt new file mode 100644 index 00000000000..fe9586dfeb5 --- /dev/null +++ b/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> { + val lastModified: Int + + fun clone(): Carrier +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ClassCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ClassCarrier.kt new file mode 100644 index 00000000000..0d207507375 --- /dev/null +++ b/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 { + var thisReceiverField: IrValueParameter? + var metadataField: MetadataSource? + var visibilityField: Visibility + var modalityField: Modality + var attributeOwnerIdField: IrAttributeContainer + var typeParametersField: List + var superTypesField: List + + 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, + override var thisReceiverField: IrValueParameter?, + override var metadataField: MetadataSource?, + override var visibilityField: Visibility, + override var modalityField: Modality, + override var attributeOwnerIdField: IrAttributeContainer, + override var typeParametersField: List, + override var superTypesField: List +) : ClassCarrier diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ConstructorCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ConstructorCarrier.kt new file mode 100644 index 00000000000..be3e90e62d0 --- /dev/null +++ b/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 { + + 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, + 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, + override var valueParametersField: List +) : ConstructorCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/DeclarationCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/DeclarationCarrier.kt new file mode 100644 index 00000000000..5ce03a72e62 --- /dev/null +++ b/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>: Carrier { + var parentField: IrDeclarationParent? + var originField: IrDeclarationOrigin + var annotationsField: List +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/EnumEntryCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/EnumEntryCarrier.kt new file mode 100644 index 00000000000..bb80b57fec2 --- /dev/null +++ b/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 { + 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, + override var correspondingClassField: IrClass?, + override var initializerExpressionField: IrExpressionBody? +) : EnumEntryCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ErrorCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ErrorCarrier.kt new file mode 100644 index 00000000000..da83f7f4a20 --- /dev/null +++ b/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 { + + 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 + ) : ErrorCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FieldCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FieldCarrier.kt new file mode 100644 index 00000000000..2f19b8846f9 --- /dev/null +++ b/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 { + var initializerField: IrExpressionBody? + var correspondingPropertySymbolField: IrPropertySymbol? + var metadataField: MetadataSource.Property? + var overridenSymbolsField: List + + 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, + override var initializerField: IrExpressionBody?, + override var correspondingPropertySymbolField: IrPropertySymbol?, + override var metadataField: MetadataSource.Property?, + override var overridenSymbolsField: List +): FieldCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionBaseCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionBaseCarrier.kt new file mode 100644 index 00000000000..e403b39a368 --- /dev/null +++ b/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> : DeclarationCarrier { + var returnTypeFieldField: IrType + var dispatchReceiverParameterField: IrValueParameter? + var extensionReceiverParameterField: IrValueParameter? + var bodyField: IrBody? + var metadataField: MetadataSource? + var visibilityField: Visibility + var typeParametersField: List + var valueParametersField: List +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/FunctionCarrier.kt new file mode 100644 index 00000000000..c3e3bdd5185 --- /dev/null +++ b/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 { + var correspondingPropertySymbolField: IrPropertySymbol? + var overriddenSymbolsField: List + 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, + 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, + override var valueParametersField: List, + override var correspondingPropertySymbolField: IrPropertySymbol?, + override var overriddenSymbolsField: List, + override var attributeOwnerIdField: IrAttributeContainer +) : FunctionCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/LocalDelegatedPropertyCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/LocalDelegatedPropertyCarrier.kt new file mode 100644 index 00000000000..6f20315582d --- /dev/null +++ b/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 { + 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, + override var delegateField: IrVariable?, + override var getterField: IrFunction?, + override var setterField: IrFunction? +) : LocalDelegatedPropertyCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/PropertyCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/PropertyCarrier.kt new file mode 100644 index 00000000000..a1c6038041e --- /dev/null +++ b/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 { + 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, + override var backingFieldField: IrField?, + override var getterField: IrSimpleFunction?, + override var setterField: IrSimpleFunction?, + override var metadataField: MetadataSource? +) : PropertyCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeAliasCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeAliasCarrier.kt new file mode 100644 index 00000000000..ababb4d4208 --- /dev/null +++ b/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 { + + var typeParametersField: List + + 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, + override var typeParametersField: List + ) : TypeAliasCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeParameterCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/TypeParameterCarrier.kt new file mode 100644 index 00000000000..ddadbcb8562 --- /dev/null +++ b/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 { + + 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 + ) : TypeParameterCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ValueParameterCarrier.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/carriers/ValueParameterCarrier.kt new file mode 100644 index 00000000000..697a91a6fc2 --- /dev/null +++ b/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 { + 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, + override var defaultValueField: IrExpressionBody? +) : ValueParameterCarrier \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt index ad9b88d4d9d..22f319db44c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyDeclarationBase.kt +++ b/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) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrOperators.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrOperators.kt index a74c525f604..31041af2385 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrOperators.kt +++ b/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 = emptyList() + override val metadata: MetadataSource? get() = null +} + +private class NullValueDelegate { + 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 = emptyList() + override var typeParameters: List = 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 accept(visitor: IrElementVisitor, data: D): R { @@ -61,18 +100,25 @@ class IrBuiltInOperator( init { symbol.bind(this) } + + override fun acceptChildren(visitor: IrElementVisitor, data: D) { + // Do nothing + } + + override fun transformChildren(transformer: IrElementTransformer, 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 transform(transformer: IrElementTransformer, 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 = SmartList() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt index 1d47e79470e..6ce71c14c8f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrBlockBodyImpl.kt +++ b/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(startOffset, endOffset, initializer), IrBlockBody { constructor(startOffset: Int, endOffset: Int, statements: List) : 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 = ArrayList() - override val statements: MutableList = ArrayList() + override val statements: MutableList + get() = checkEnabled { statementsField } override fun accept(visitor: IrElementVisitor, data: D): R { return visitor.visitBlockBody(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt index e3122f59ea7..297a7ce84cd 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrExpressionBodyImpl.kt +++ b/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(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 accept(visitor: IrElementVisitor, data: D): R = visitor.visitExpressionBody(this, data)