Drop IrPropertyAccessor (and subclasses).

Drop IrLocalPropertyAccessor (and subclasses).
Introduce IrField.

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/IrSlots.kt

@@ -44,6 +44,7 @@ const val TRY_RESULT_SLOT = -13
 const val FINALLY_EXPRESSION_SLOT = -14
 const val PROPERTY_GETTER_SLOT = -15
 const val PROPERTY_SETTER_SLOT = -16
-const val DELEGATE_SLOT = -17
+const val BACKING_FIELD_SLOT = -17
 const val ENUM_ENTRY_CLASS_SLOT = -18
-const val ENUM_ENTRY_INITIALIZER_SLOT = -19
+const val ENUM_ENTRY_INITIALIZER_SLOT = -19
+const val LOCAL_DELEGATE_SLOT = -20

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

@@ -32,10 +32,10 @@ fun IrClass.getInstanceInitializerMembers() =
             when (it) {
                 is IrAnonymousInitializer ->
                     true
-                is IrSimpleProperty ->
+                is IrProperty ->
+                    it.backingField?.initializer != null
+                is IrField ->
                     it.initializer != null
-                is IrDelegatedProperty ->
-                    true
                 else -> false
             }
         }

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

@@ -33,6 +33,7 @@ enum class IrDeclarationKind {
     FUNCTION,
     CONSTRUCTOR,
     PROPERTY,
+    FIELD,
     PROPERTY_ACCESSOR,
     VARIABLE,
     LOCAL_PROPERTY,
@@ -44,6 +45,8 @@ enum class IrDeclarationKind {
 
 enum class IrDeclarationOrigin {
     DEFINED,
+    PROPERTY_BACKING_FIELD,
+    DEFAULT_PROPERTY_ACCESSOR,
     DELEGATE,
     DELEGATED_PROPERTY_ACCESSOR,
     DELEGATED_MEMBER,

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

@@ -21,15 +21,13 @@ import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 
-interface IrGeneralFunction : IrDeclaration {
+interface IrFunction : IrDeclaration {
     override val descriptor: FunctionDescriptor
     var body: IrBody?
 
     override val declarationKind: IrDeclarationKind
         get() = IrDeclarationKind.FUNCTION
-}
 
-interface IrFunction : IrGeneralFunction {
     fun putDefault(parameter: ValueParameterDescriptor, expressionBody: IrExpressionBody)
     fun getDefault(parameter: ValueParameterDescriptor): IrExpressionBody?
 }

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

@@ -22,17 +22,9 @@ import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
 interface IrLocalDelegatedProperty : IrDeclaration {
     override val descriptor: VariableDescriptorWithAccessors
     var delegate: IrVariable
-    var getter: IrLocalPropertyAccessor
-    var setter: IrLocalPropertyAccessor?
+    var getter: IrFunction
+    var setter: IrFunction?
 
     override val declarationKind: IrDeclarationKind
         get() = IrDeclarationKind.LOCAL_PROPERTY
 }
-
-interface IrLocalPropertyAccessor : IrGeneralFunction {
-    override val descriptor: VariableAccessorDescriptor
-
-    override val declarationKind: IrDeclarationKind
-        get() = IrDeclarationKind.LOCAL_PROPERTY_ACCESSOR
-}
-

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

@@ -17,22 +17,24 @@
 package org.jetbrains.kotlin.ir.declarations
 
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 
 interface IrProperty : IrDeclaration {
     override val descriptor: PropertyDescriptor
-    var getter: IrPropertyGetter?
-    var setter: IrPropertySetter?
+    val isDelegated: Boolean
+    var backingField: IrField?
+    var getter: IrFunction?
+    var setter: IrFunction?
 
     override val declarationKind: IrDeclarationKind
         get() = IrDeclarationKind.PROPERTY
 }
 
-interface IrSimpleProperty : IrProperty {
-    var initializer: IrBody?
-}
+interface IrField : IrDeclaration {
+    override val descriptor: PropertyDescriptor
 
-interface IrDelegatedProperty : IrProperty {
-    var delegate: IrSimpleProperty
-}
+    override val declarationKind: IrDeclarationKind
+        get() = IrDeclarationKind.FIELD
 
+    var initializer: IrExpressionBody?
+}

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

@@ -1,39 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations
-
-import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor
-import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
-import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
-
-interface IrPropertyAccessor : IrGeneralFunction {
-    override val descriptor: PropertyAccessorDescriptor
-
-    override val declarationKind: IrDeclarationKind
-        get() = IrDeclarationKind.PROPERTY_ACCESSOR
-}
-
-interface IrPropertyGetter : IrPropertyAccessor {
-    override val descriptor: PropertyGetterDescriptor
-
-
-}
-
-interface IrPropertySetter : IrPropertyAccessor {
-    override val descriptor: PropertySetterDescriptor
-}
-

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

@@ -1,72 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.ir.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrSimpleProperty
-import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-
-class IrDelegatedPropertyImpl(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        descriptor: PropertyDescriptor
-) : IrPropertyBase(startOffset, endOffset, origin, descriptor), IrDelegatedProperty {
-    constructor(
-            startOffset: Int,
-            endOffset: Int,
-            origin: IrDeclarationOrigin,
-            descriptor: PropertyDescriptor,
-            delegate: IrSimpleProperty
-    ) : this(startOffset, endOffset, origin, descriptor) {
-        this.delegate = delegate
-    }
-
-    private var delegateImpl: IrSimpleProperty? = null
-    override var delegate: IrSimpleProperty
-        get() = delegateImpl!!
-        set(value) {
-            delegateImpl?.detach()
-            delegateImpl = value
-            value.setTreeLocation(this, DELEGATE_SLOT)
-        }
-
-    override fun getChild(slot: Int): IrElement? =
-            when (slot) {
-                DELEGATE_SLOT -> delegate
-                else -> super.getChild(slot)
-            }
-
-    override fun replaceChild(slot: Int, newChild: IrElement) {
-        when (slot) {
-            DELEGATE_SLOT -> delegate = newChild.assertCast()
-            else -> super.replaceChild(slot, newChild)
-        }
-    }
-
-    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
-            visitor.visitDelegatedProperty(this, data)
-
-    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
-        delegate.accept(visitor, data)
-        getter?.accept(visitor, data)
-        setter?.accept(visitor, data)
-    }
-}

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

@@ -19,18 +19,24 @@ package org.jetbrains.kotlin.ir.declarations.impl
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrSimpleProperty
-import org.jetbrains.kotlin.ir.expressions.IrBody
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.expressions.IrExpressionBody
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-class IrSimplePropertyImpl(
+
+class IrFieldImpl(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin,
-        descriptor: PropertyDescriptor,
-        valueInitializer: IrBody? = null
-) : IrPropertyBase(startOffset, endOffset, origin, descriptor), IrSimpleProperty {
-    override var initializer: IrBody? = valueInitializer
+        override val descriptor: PropertyDescriptor
+): IrDeclarationBase(startOffset, endOffset, origin), IrField {
+    constructor(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: PropertyDescriptor,
+                initializer: IrExpressionBody?
+    ) : this(startOffset, endOffset, origin, descriptor) {
+        this.initializer = initializer
+    }
+
+    override var initializer: IrExpressionBody? = null
         set(value) {
             field?.detach()
             field = value
@@ -40,22 +46,21 @@ class IrSimplePropertyImpl(
     override fun getChild(slot: Int): IrElement? =
             when (slot) {
                 INITIALIZER_SLOT -> initializer
-                else -> super.getChild(slot)
+                else -> null
             }
 
     override fun replaceChild(slot: Int, newChild: IrElement) {
         when (slot) {
             INITIALIZER_SLOT -> initializer = newChild.assertCast()
-            else -> super.replaceChild(slot, newChild)
+            else -> throwNoSuchSlot(slot)
         }
     }
 
-    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
-            visitor.visitSimpleProperty(this, data)
+    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
+        return visitor.visitField(this, data)
+    }
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
         initializer?.accept(visitor, data)
-        getter?.accept(visitor, data)
-        setter?.accept(visitor, data)
     }
 }

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

@@ -18,8 +18,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrGeneralFunction
-import org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase
+import org.jetbrains.kotlin.ir.declarations.IrFunction
 import org.jetbrains.kotlin.ir.expressions.IrBody
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -27,16 +26,7 @@ abstract class IrGeneralFunctionBase(
         startOffset: Int,
         endOffset: Int,
         origin: IrDeclarationOrigin
-) : IrDeclarationBase(startOffset, endOffset, origin), IrGeneralFunction {
-    constructor(
-            startOffset: Int,
-            endOffset: Int,
-            origin: IrDeclarationOrigin,
-            body: IrBody
-    ) : this(startOffset, endOffset, origin) {
-        this.body = body
-    }
-
+) : IrDeclarationBase(startOffset, endOffset, origin), IrFunction {
     final override var body: IrBody? = null
         set(newValue) {
             field?.detach()

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

@@ -18,10 +18,7 @@ package org.jetbrains.kotlin.ir.declarations.impl
 
 import org.jetbrains.kotlin.descriptors.VariableDescriptorWithAccessors
 import org.jetbrains.kotlin.ir.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrLocalDelegatedProperty
-import org.jetbrains.kotlin.ir.declarations.IrLocalPropertyAccessor
-import org.jetbrains.kotlin.ir.declarations.IrVariable
+import org.jetbrains.kotlin.ir.declarations.*
 import org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
@@ -47,11 +44,11 @@ class IrLocalDelegatedPropertyImpl(
         set(value) {
             delegateImpl?.detach()
             delegateImpl = value
-            value.setTreeLocation(this, DELEGATE_SLOT)
+            value.setTreeLocation(this, LOCAL_DELEGATE_SLOT)
         }
 
-    private var getterImpl: IrLocalPropertyAccessor? = null
-    override var getter: IrLocalPropertyAccessor
+    private var getterImpl: IrFunction? = null
+    override var getter: IrFunction
         get() = getterImpl!!
         set(value) {
             getterImpl?.detach()
@@ -59,7 +56,7 @@ class IrLocalDelegatedPropertyImpl(
             value.setTreeLocation(this, PROPERTY_GETTER_SLOT)
         }
 
-    override var setter: IrLocalPropertyAccessor? = null
+    override var setter: IrFunction? = null
         set(value) {
             field?.detach()
             field = value
@@ -68,7 +65,7 @@ class IrLocalDelegatedPropertyImpl(
 
     override fun getChild(slot: Int): IrElement? =
             when (slot) {
-                DELEGATE_SLOT -> delegate
+                LOCAL_DELEGATE_SLOT -> delegate
                 PROPERTY_GETTER_SLOT -> getter
                 PROPERTY_SETTER_SLOT -> setter
                 else -> null
@@ -76,7 +73,7 @@ class IrLocalDelegatedPropertyImpl(
 
     override fun replaceChild(slot: Int, newChild: IrElement) {
         when (slot) {
-            DELEGATE_SLOT -> delegate = newChild.assertCast()
+            LOCAL_DELEGATE_SLOT -> delegate = newChild.assertCast()
             PROPERTY_GETTER_SLOT -> getter = newChild.assertCast()
             PROPERTY_SETTER_SLOT -> setter = newChild.assertCast()
             else -> throwNoSuchSlot(slot)

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

@@ -1,44 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.descriptors.VariableAccessorDescriptor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrLocalPropertyAccessor
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-
-class IrLocalPropertyAccessorImpl(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        override val descriptor: VariableAccessorDescriptor
-) : IrGeneralFunctionBase(startOffset, endOffset, origin), IrLocalPropertyAccessor {
-    constructor(
-            startOffset: Int,
-            endOffset: Int,
-            origin: IrDeclarationOrigin,
-            descriptor: VariableAccessorDescriptor,
-            body: IrBody
-    ) : this(startOffset, endOffset, origin, descriptor) {
-        this.body = body
-    }
-
-    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
-        return visitor.visitLocalPropertyAccessor(this, data)
-    }
-}

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

@@ -1,26 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrPropertyAccessor
-
-abstract class IrPropertyAccessorBase(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin
-) : IrGeneralFunctionBase(startOffset, endOffset, origin), IrPropertyAccessor

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

@@ -1,61 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.ir.*
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrProperty
-import org.jetbrains.kotlin.ir.declarations.IrPropertyGetter
-import org.jetbrains.kotlin.ir.declarations.IrPropertySetter
-import org.jetbrains.kotlin.ir.declarations.impl.IrDeclarationBase
-
-abstract class IrPropertyBase(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        override val descriptor: PropertyDescriptor
-) : IrDeclarationBase(startOffset, endOffset, origin), IrProperty {
-    override var getter: IrPropertyGetter? = null
-        set(newGetter) {
-            field?.detach()
-            field = newGetter
-            newGetter?.setTreeLocation(this, PROPERTY_GETTER_SLOT)
-        }
-
-    override var setter: IrPropertySetter? = null
-        set(newSetter) {
-            field?.detach()
-            field = newSetter
-            newSetter?.setTreeLocation(this, PROPERTY_SETTER_SLOT)
-        }
-
-    override fun getChild(slot: Int): IrElement? =
-            when (slot) {
-                PROPERTY_GETTER_SLOT -> getter
-                PROPERTY_SETTER_SLOT -> setter
-                else -> null
-            }
-
-    override fun replaceChild(slot: Int, newChild: IrElement) {
-        when (slot) {
-            PROPERTY_GETTER_SLOT -> getter = newChild.assertCast()
-            PROPERTY_SETTER_SLOT -> setter = newChild.assertCast()
-            else -> throwNoSuchSlot(slot)
-        }
-    }
-}

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.descriptors.PropertyGetterDescriptor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrPropertyGetter
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-
-class IrPropertyGetterImpl(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        override val descriptor: PropertyGetterDescriptor
-) : IrPropertyAccessorBase(startOffset, endOffset, origin), IrPropertyGetter {
-    constructor(
-            startOffset: Int,
-            endOffset: Int,
-            origin: IrDeclarationOrigin,
-            descriptor: PropertyGetterDescriptor,
-            body: IrBody
-    ) : this(startOffset, endOffset, origin, descriptor) {
-        this.body = body
-    }
-
-    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
-            visitor.visitPropertyGetter(this, data)
-}

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

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2010-2016 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.ir.declarations.impl
+
+import org.jetbrains.kotlin.descriptors.PropertyDescriptor
+import org.jetbrains.kotlin.ir.*
+import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
+import org.jetbrains.kotlin.ir.declarations.IrField
+import org.jetbrains.kotlin.ir.declarations.IrFunction
+import org.jetbrains.kotlin.ir.declarations.IrProperty
+import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
+
+class IrPropertyImpl(
+        startOffset: Int,
+        endOffset: Int,
+        origin: IrDeclarationOrigin,
+        override val isDelegated: Boolean,
+        override val descriptor: PropertyDescriptor
+) : IrDeclarationBase(startOffset, endOffset, origin), IrProperty {
+    constructor(
+            startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, isDelegated: Boolean, descriptor: PropertyDescriptor,
+            backingField: IrField?
+    ) : this(startOffset, endOffset, origin, isDelegated, descriptor) {
+        this.backingField = backingField
+    }
+
+    constructor(
+            startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, isDelegated: Boolean, descriptor: PropertyDescriptor,
+            backingField: IrField?, getter: IrFunction?, setter: IrFunction?
+    ) : this(startOffset, endOffset, origin, isDelegated, descriptor, backingField) {
+        this.getter = getter
+        this.setter = setter
+    }
+
+    override var backingField: IrField? = null
+        set(value) {
+            field?.detach()
+            field = value
+            value?.setTreeLocation(this, BACKING_FIELD_SLOT)
+        }
+
+    override var getter: IrFunction? = null
+        set(value) {
+            field?.detach()
+            field = value
+            value?.setTreeLocation(this, PROPERTY_GETTER_SLOT)
+        }
+
+    override var setter: IrFunction? = null
+        set(value) {
+            field?.detach()
+            field = value
+            value?.setTreeLocation(this, PROPERTY_SETTER_SLOT)
+        }
+
+    override fun getChild(slot: Int): IrElement? =
+            when (slot) {
+                BACKING_FIELD_SLOT -> backingField
+                PROPERTY_GETTER_SLOT -> getter
+                PROPERTY_SETTER_SLOT -> setter
+                else -> null
+            }
+
+    override fun replaceChild(slot: Int, newChild: IrElement) {
+        when (slot) {
+            BACKING_FIELD_SLOT -> backingField = newChild.assertCast()
+            PROPERTY_GETTER_SLOT -> getter = newChild.assertCast()
+            PROPERTY_SETTER_SLOT -> setter = newChild.assertCast()
+            else -> throwNoSuchSlot(slot)
+        }
+    }
+
+    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
+        return visitor.visitProperty(this, data)
+    }
+
+    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
+        backingField?.accept(visitor, data)
+        getter?.accept(visitor, data)
+        setter?.accept(visitor, data)
+    }
+}

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

@@ -1,43 +0,0 @@
-/*
- * Copyright 2010-2016 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.ir.declarations.impl
-
-import org.jetbrains.kotlin.descriptors.PropertySetterDescriptor
-import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin
-import org.jetbrains.kotlin.ir.declarations.IrPropertySetter
-import org.jetbrains.kotlin.ir.expressions.IrBody
-import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
-
-class IrPropertySetterImpl(
-        startOffset: Int,
-        endOffset: Int,
-        origin: IrDeclarationOrigin,
-        override val descriptor: PropertySetterDescriptor
-) : IrPropertyAccessorBase(startOffset, endOffset, origin), IrPropertySetter {
-    constructor(
-            startOffset: Int,
-            endOffset: Int,
-            origin: IrDeclarationOrigin,
-            descriptor: PropertySetterDescriptor,
-            body: IrBody
-    ) : this(startOffset, endOffset, origin, descriptor) {
-        this.body = body
-    }
-
-    override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R =
-            visitor.visitPropertySetter(this, data)
-}

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrFieldExpression.kt

@@ -19,15 +19,15 @@ package org.jetbrains.kotlin.ir.expressions
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 
-interface IrBackingFieldExpression : IrDeclarationReference {
+interface IrFieldExpression : IrDeclarationReference {
     override val descriptor: PropertyDescriptor
     val superQualifier: ClassDescriptor?
     var receiver: IrExpression?
     val operator: IrOperator?
 }
 
-interface IrGetBackingField : IrBackingFieldExpression
+interface IrGetField : IrFieldExpression
 
-interface IrSetBackingField : IrBackingFieldExpression {
+interface IrSetField : IrFieldExpression {
     var value: IrExpression
 }

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

@@ -19,19 +19,19 @@ package org.jetbrains.kotlin.ir.expressions.impl
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.*
-import org.jetbrains.kotlin.ir.expressions.IrBackingFieldExpression
+import org.jetbrains.kotlin.ir.expressions.IrFieldExpression
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrOperator
 import org.jetbrains.kotlin.types.KotlinType
 
-abstract class IrBackingFieldExpressionBase(
+abstract class IrFieldExpressionBase(
         startOffset: Int,
         endOffset: Int,
         descriptor: PropertyDescriptor,
         type: KotlinType,
         override val operator: IrOperator? = null,
         override val superQualifier: ClassDescriptor? = null
-) : IrDeclarationReferenceBase<PropertyDescriptor>(startOffset, endOffset, type, descriptor), IrBackingFieldExpression {
+) : IrDeclarationReferenceBase<PropertyDescriptor>(startOffset, endOffset, type, descriptor), IrFieldExpression {
     override final var receiver: IrExpression? = null
         set(value) {
             field?.detach()

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

@@ -20,17 +20,17 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.IrElement
 import org.jetbrains.kotlin.ir.expressions.IrExpression
-import org.jetbrains.kotlin.ir.expressions.IrGetBackingField
+import org.jetbrains.kotlin.ir.expressions.IrGetField
 import org.jetbrains.kotlin.ir.expressions.IrOperator
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 
-class IrGetBackingFieldImpl(
+class IrGetFieldImpl(
         startOffset: Int,
         endOffset: Int,
         descriptor: PropertyDescriptor,
         operator: IrOperator? = null,
         superQualifier: ClassDescriptor? = null
-) : IrBackingFieldExpressionBase(startOffset, endOffset, descriptor, descriptor.type, operator, superQualifier), IrGetBackingField {
+) : IrFieldExpressionBase(startOffset, endOffset, descriptor, descriptor.type, operator, superQualifier), IrGetField {
     constructor(
             startOffset: Int,
             endOffset: Int,
@@ -50,7 +50,7 @@ class IrGetBackingFieldImpl(
     }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
-        return visitor.visitGetBackingField(this, data)
+        return visitor.visitGetField(this, data)
     }
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {

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

@@ -21,18 +21,18 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.ir.*
 import org.jetbrains.kotlin.ir.expressions.IrExpression
 import org.jetbrains.kotlin.ir.expressions.IrOperator
-import org.jetbrains.kotlin.ir.expressions.IrSetBackingField
-import org.jetbrains.kotlin.ir.expressions.impl.IrBackingFieldExpressionBase
+import org.jetbrains.kotlin.ir.expressions.IrSetField
+import org.jetbrains.kotlin.ir.expressions.impl.IrFieldExpressionBase
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitor
 import org.jetbrains.kotlin.types.typeUtil.builtIns
 
-class IrSetBackingFieldImpl(
+class IrSetFieldImpl(
         startOffset: Int,
         endOffset: Int,
         descriptor: PropertyDescriptor,
         operator: IrOperator? = null,
         superQualifier: ClassDescriptor? = null
-) : IrBackingFieldExpressionBase(startOffset, endOffset, descriptor, descriptor.type.builtIns.unitType, operator, superQualifier), IrSetBackingField {
+) : IrFieldExpressionBase(startOffset, endOffset, descriptor, descriptor.type.builtIns.unitType, operator, superQualifier), IrSetField {
     constructor(
             startOffset: Int,
             endOffset: Int,
@@ -69,7 +69,7 @@ class IrSetBackingFieldImpl(
     }
 
     override fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R {
-        return visitor.visitSetBackingField(this, data)
+        return visitor.visitSetField(this, data)
     }
 
     override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt

@@ -72,14 +72,6 @@ class DumpIrTreeVisitor(out: Appendable): IrElementVisitor<Unit, String> {
         visitFunctionWithParameters(declaration, data)
     }
 
-    override fun visitDelegatedProperty(declaration: IrDelegatedProperty, data: String) {
-        declaration.dumpLabeledElementWith(data) {
-            declaration.delegate.accept(this, "delegate")
-            declaration.getter?.accept(this, "")
-            declaration.setter?.accept(this, "")
-        }
-    }
-
     override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: String) {
         expression.dumpLabeledElementWith(data) {
             expression.explicitReceiver?.accept(this, "receiver")
@@ -113,13 +105,13 @@ class DumpIrTreeVisitor(out: Appendable): IrElementVisitor<Unit, String> {
         }
     }
 
-    override fun visitGetBackingField(expression: IrGetBackingField, data: String) {
+    override fun visitGetField(expression: IrGetField, data: String) {
         expression.dumpLabeledElementWith(data) {
             expression.receiver?.accept(this, "receiver")
         }
     }
 
-    override fun visitSetBackingField(expression: IrSetBackingField, data: String) {
+    override fun visitSetField(expression: IrSetField, data: String) {
         expression.dumpLabeledElementWith(data) {
             expression.receiver?.accept(this, "receiver")
             expression.value.accept(this, "value")

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt

@@ -51,11 +51,8 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
     override fun visitProperty(declaration: IrProperty, data: Nothing?): String =
             "PROPERTY ${declaration.renderDeclared()}"
 
-    override fun visitPropertyGetter(declaration: IrPropertyGetter, data: Nothing?): String =
-            "PROPERTY_GETTER ${declaration.renderDeclared()}"
-
-    override fun visitPropertySetter(declaration: IrPropertySetter, data: Nothing?): String =
-            "PROPERTY_SETTER ${declaration.renderDeclared()}"
+    override fun visitField(declaration: IrField, data: Nothing?): String =
+            "FIELD ${declaration.renderDeclared()}"
 
     override fun visitClass(declaration: IrClass, data: Nothing?): String =
             "CLASS ${declaration.descriptor.kind} ${declaration.descriptor.ref()}"
@@ -75,9 +72,6 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
     override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?): String =
             "LOCAL_DELEGATED_PROPERTY ${declaration.renderDeclared()}"
 
-    override fun visitLocalPropertyAccessor(declaration: IrLocalPropertyAccessor, data: Nothing?): String =
-            "LOCAL_PROPERTY_ACCESSOR ${declaration.descriptor.ref()}" // can't render, see nullability for modality
-
     override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?): String =
             "EXPRESSION_BODY"
 
@@ -140,10 +134,10 @@ class RenderIrElementVisitor : IrElementVisitor<String, Nothing?> {
     override fun visitSetVariable(expression: IrSetVariable, data: Nothing?): String =
             "SET_VAR '${expression.descriptor.ref()}' type=${expression.type.render()} operator=${expression.operator}"
 
-    override fun visitGetBackingField(expression: IrGetBackingField, data: Nothing?): String =
+    override fun visitGetField(expression: IrGetField, data: Nothing?): String =
             "GET_BACKING_FIELD '${expression.descriptor.ref()}' type=${expression.type.render()} operator=${expression.operator}"
 
-    override fun visitSetBackingField(expression: IrSetBackingField, data: Nothing?): String =
+    override fun visitSetField(expression: IrSetField, data: Nothing?): String =
             "SET_BACKING_FIELD '${expression.descriptor.ref()}' type=${expression.type.render()} operator=${expression.operator}"
 
     override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?): String =

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt

@@ -28,16 +28,11 @@ interface IrElementVisitor<out R, in D> {
     fun visitDeclaration(declaration: IrDeclaration, data: D) = visitElement(declaration, data)
     fun visitClass(declaration: IrClass, data: D) = visitDeclaration(declaration, data)
     fun visitTypeAlias(declaration: IrTypeAlias, data: D) = visitDeclaration(declaration, data)
-    fun visitGeneralFunction(declaration: IrGeneralFunction, data: D) = visitDeclaration(declaration, data)
-    fun visitFunction(declaration: IrFunction, data: D) = visitGeneralFunction(declaration, data)
-    fun visitPropertyGetter(declaration: IrPropertyGetter, data: D) = visitGeneralFunction(declaration, data)
-    fun visitPropertySetter(declaration: IrPropertySetter, data: D) = visitGeneralFunction(declaration, data)
-    fun visitConstructor(declaration: IrConstructor, data: D) = visitGeneralFunction(declaration, data)
+    fun visitFunction(declaration: IrFunction, data: D) = visitDeclaration(declaration, data)
+    fun visitConstructor(declaration: IrConstructor, data: D) = visitFunction(declaration, data)
     fun visitProperty(declaration: IrProperty, data: D) = visitDeclaration(declaration, data)
-    fun visitSimpleProperty(declaration: IrSimpleProperty, data: D) = visitProperty(declaration, data)
-    fun visitDelegatedProperty(declaration: IrDelegatedProperty, data: D) = visitProperty(declaration, data)
+    fun visitField(declaration: IrField, data: D) = visitDeclaration(declaration, data)
     fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: D) = visitDeclaration(declaration, data)
-    fun visitLocalPropertyAccessor(declaration: IrLocalPropertyAccessor, data: D) = visitGeneralFunction(declaration, data)
     fun visitVariable(declaration: IrVariable, data: D) = visitDeclaration(declaration, data)
     fun visitEnumEntry(declaration: IrEnumEntry, data: D) = visitDeclaration(declaration, data)
     fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D) = visitDeclaration(declaration, data)
@@ -65,9 +60,9 @@ interface IrElementVisitor<out R, in D> {
     fun visitVariableAccess(expression: IrVariableAccessExpression, data: D) = visitDeclarationReference(expression, data)
     fun visitGetVariable(expression: IrGetVariable, data: D) = visitVariableAccess(expression, data)
     fun visitSetVariable(expression: IrSetVariable, data: D) = visitVariableAccess(expression, data)
-    fun visitBackingFieldReference(expression: IrBackingFieldExpression, data: D) = visitDeclarationReference(expression, data)
-    fun visitGetBackingField(expression: IrGetBackingField, data: D) = visitBackingFieldReference(expression, data)
-    fun visitSetBackingField(expression: IrSetBackingField, data: D) = visitBackingFieldReference(expression, data)
+    fun visitBackingFieldReference(expression: IrFieldExpression, data: D) = visitDeclarationReference(expression, data)
+    fun visitGetField(expression: IrGetField, data: D) = visitBackingFieldReference(expression, data)
+    fun visitSetField(expression: IrSetField, data: D) = visitBackingFieldReference(expression, data)
     fun visitGetExtensionReceiver(expression: IrGetExtensionReceiver, data: D) = visitDeclarationReference(expression, data)
     fun visitGeneralCall(expression: IrGeneralCall, data: D) = visitDeclarationReference(expression, data)
     fun visitCall(expression: IrCall, data: D) = visitGeneralCall(expression, data)

compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt

@@ -39,36 +39,21 @@ interface IrElementVisitorVoid : IrElementVisitor<Unit, Nothing?> {
     fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration)
     override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration)
 
-    fun visitGeneralFunction(declaration: IrGeneralFunction) = visitDeclaration(declaration)
-    override fun visitGeneralFunction(declaration: IrGeneralFunction, data: Nothing?) = visitGeneralFunction(declaration)
-
-    fun visitFunction(declaration: IrFunction) = visitGeneralFunction(declaration)
+    fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration)
     override fun visitFunction(declaration: IrFunction, data: Nothing?) = visitFunction(declaration)
 
-    fun visitPropertyGetter(declaration: IrPropertyGetter) = visitGeneralFunction(declaration)
-    override fun visitPropertyGetter(declaration: IrPropertyGetter, data: Nothing?) = visitPropertyGetter(declaration)
-
-    fun visitPropertySetter(declaration: IrPropertySetter) = visitGeneralFunction(declaration)
-    override fun visitPropertySetter(declaration: IrPropertySetter, data: Nothing?) = visitPropertySetter(declaration)
-
-    fun visitConstructor(declaration: IrConstructor) = visitGeneralFunction(declaration)
+    fun visitConstructor(declaration: IrConstructor) = visitFunction(declaration)
     override fun visitConstructor(declaration: IrConstructor, data: Nothing?) = visitConstructor(declaration)
 
     fun visitProperty(declaration: IrProperty) = visitDeclaration(declaration)
     override fun visitProperty(declaration: IrProperty, data: Nothing?) = visitProperty(declaration)
 
-    fun visitSimpleProperty(declaration: IrSimpleProperty) = visitProperty(declaration)
-    override fun visitSimpleProperty(declaration: IrSimpleProperty, data: Nothing?) = visitSimpleProperty(declaration)
-
-    fun visitDelegatedProperty(declaration: IrDelegatedProperty) = visitProperty(declaration)
-    override fun visitDelegatedProperty(declaration: IrDelegatedProperty, data: Nothing?) = visitDelegatedProperty(declaration)
+    fun visitField(declaration: IrField) = visitDeclaration(declaration)
+    override fun visitField(declaration: IrField, data: Nothing?) = visitField(declaration)
 
     fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty) = visitDeclaration(declaration)
     override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?) = visitLocalDelegatedProperty(declaration)
 
-    fun visitLocalPropertyAccessor(declaration: IrLocalPropertyAccessor) = visitGeneralFunction(declaration)
-    override fun visitLocalPropertyAccessor(declaration: IrLocalPropertyAccessor, data: Nothing?) = visitLocalPropertyAccessor(declaration)
-
     fun visitVariable(declaration: IrVariable) = visitDeclaration(declaration)
     override fun visitVariable(declaration: IrVariable, data: Nothing?) = visitVariable(declaration)
 
@@ -138,14 +123,14 @@ interface IrElementVisitorVoid : IrElementVisitor<Unit, Nothing?> {
     fun visitSetVariable(expression: IrSetVariable) = visitVariableAccess(expression)
     override fun visitSetVariable(expression: IrSetVariable, data: Nothing?) = visitSetVariable(expression)
 
-    fun visitBackingFieldReference(expression: IrBackingFieldExpression) = visitDeclarationReference(expression)
-    override fun visitBackingFieldReference(expression: IrBackingFieldExpression, data: Nothing?) = visitBackingFieldReference(expression)
+    fun visitBackingFieldReference(expression: IrFieldExpression) = visitDeclarationReference(expression)
+    override fun visitBackingFieldReference(expression: IrFieldExpression, data: Nothing?) = visitBackingFieldReference(expression)
 
-    fun visitGetBackingField(expression: IrGetBackingField) = visitBackingFieldReference(expression)
-    override fun visitGetBackingField(expression: IrGetBackingField, data: Nothing?) = visitGetBackingField(expression)
+    fun visitGetBackingField(expression: IrGetField) = visitBackingFieldReference(expression)
+    override fun visitGetField(expression: IrGetField, data: Nothing?) = visitGetBackingField(expression)
 
-    fun visitSetBackingField(expression: IrSetBackingField) = visitBackingFieldReference(expression)
-    override fun visitSetBackingField(expression: IrSetBackingField, data: Nothing?) = visitSetBackingField(expression)
+    fun visitSetBackingField(expression: IrSetField) = visitBackingFieldReference(expression)
+    override fun visitSetField(expression: IrSetField, data: Nothing?) = visitSetBackingField(expression)
 
     fun visitGetExtensionReceiver(expression: IrGetExtensionReceiver) = visitDeclarationReference(expression)
     override fun visitGetExtensionReceiver(expression: IrGetExtensionReceiver, data: Nothing?) = visitGetExtensionReceiver(expression)