IR: remove JVM-specific methods from DeclarationFactory

compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/ir/DeclarationFactory.kt

@@ -6,14 +6,11 @@
 package org.jetbrains.kotlin.backend.common.ir
 
 import org.jetbrains.kotlin.ir.declarations.*
-import org.jetbrains.kotlin.ir.types.IrType
 
 interface DeclarationFactory {
     object FIELD_FOR_OUTER_THIS : IrDeclarationOriginImpl("FIELD_FOR_OUTER_THIS", isSynthetic = true)
 
-    fun getFieldForEnumEntry(enumEntry: IrEnumEntry): IrField
     fun getOuterThisField(innerClass: IrClass): IrField
     fun getInnerClassConstructorWithOuterThisParameter(innerClassConstructor: IrConstructor): IrConstructor
     fun getInnerClassOriginalPrimaryConstructorOrNull(innerClass: IrClass): IrConstructor?
-    fun getFieldForObjectInstance(singleton: IrClass): IrField
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsDeclarationFactory.kt

@@ -9,29 +9,25 @@ import org.jetbrains.kotlin.backend.common.getOrPut
 import org.jetbrains.kotlin.backend.common.ir.DeclarationFactory
 import org.jetbrains.kotlin.backend.common.ir.copyTo
 import org.jetbrains.kotlin.backend.common.ir.copyTypeParametersFrom
-import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.ir.ObsoleteDescriptorBasedAPI
 import org.jetbrains.kotlin.ir.backend.js.JsMapping
 import org.jetbrains.kotlin.ir.backend.js.ir.JsIrBuilder
 import org.jetbrains.kotlin.ir.backend.js.utils.Namer
 import org.jetbrains.kotlin.ir.builders.declarations.buildConstructor
 import org.jetbrains.kotlin.ir.builders.declarations.buildField
-import org.jetbrains.kotlin.ir.declarations.*
+import org.jetbrains.kotlin.ir.declarations.IrClass
-import org.jetbrains.kotlin.ir.types.IrType
+import org.jetbrains.kotlin.ir.declarations.IrConstructor
+import org.jetbrains.kotlin.ir.declarations.IrField
 import org.jetbrains.kotlin.ir.util.defaultType
 import org.jetbrains.kotlin.ir.util.dump
 import org.jetbrains.kotlin.name.Name
 
 class JsDeclarationFactory(mapping: JsMapping) : DeclarationFactory {
-    private val singletonFieldDescriptors = mapping.singletonFieldDescriptors
     private val outerThisFieldSymbols = mapping.outerThisFieldSymbols
     private val innerClassConstructors = mapping.innerClassConstructors
     private val originalInnerClassPrimaryConstructorByClass = mapping.originalInnerClassPrimaryConstructorByClass
 
-    override fun getFieldForEnumEntry(enumEntry: IrEnumEntry): IrField = TODO()
-
     override fun getOuterThisField(innerClass: IrClass): IrField =
         if (!innerClass.isInner) throw AssertionError("Class is not inner: ${innerClass.dump()}")
         else {
@@ -39,30 +35,20 @@ class JsDeclarationFactory(mapping: JsMapping) : DeclarationFactory {
                 val outerClass = innerClass.parent as? IrClass
                     ?: throw AssertionError("No containing class for inner class ${innerClass.dump()}")
 
-
+                buildField {
-                val name = Name.identifier("\$this")
+                    origin = DeclarationFactory.FIELD_FOR_OUTER_THIS
-                val fieldType = outerClass.defaultType
+                    name = Name.identifier("\$this")
-                val visibility = Visibilities.PROTECTED
+                    type = outerClass.defaultType
-
+                    visibility = Visibilities.PROTECTED
-                createPropertyWithBackingField(name, visibility, innerClass, fieldType, DeclarationFactory.FIELD_FOR_OUTER_THIS)
+                    isFinal = true
+                    isExternal = false
+                    isStatic = false
+                }.also {
+                    it.parent = innerClass
+                }
             }
         }
 
-    private fun createPropertyWithBackingField(
-        name: Name, visibility: Visibility, parent: IrClass, fieldType: IrType, origin: IrDeclarationOrigin
-    ): IrField =
-        buildField {
-            this.origin = origin
-            this.name = name
-            this.type = fieldType
-            this.visibility = visibility
-            this.isFinal = true
-            this.isExternal = false
-            this.isStatic = false
-        }.also {
-            it.parent = parent
-        }
-
     override fun getInnerClassConstructorWithOuterThisParameter(innerClassConstructor: IrConstructor): IrConstructor {
         val innerClass = innerClassConstructor.parent as IrClass
         assert(innerClass.isInner) { "Class is not inner: $innerClass" }
@@ -108,17 +94,4 @@ class JsDeclarationFactory(mapping: JsMapping) : DeclarationFactory {
 
         return newConstructor
     }
-
-    override fun getFieldForObjectInstance(singleton: IrClass): IrField =
-        singletonFieldDescriptors.getOrPut(singleton) {
-            createObjectInstanceFieldDescriptor(singleton, JsIrBuilder.SYNTHESIZED_DECLARATION)
-        }
-
-    private fun createObjectInstanceFieldDescriptor(singleton: IrClass, origin: IrDeclarationOrigin): IrField {
-        assert(singleton.kind == ClassKind.OBJECT) { "Should be an object: $singleton" }
-
-        val name = Name.identifier("INSTANCE")
-
-        return createPropertyWithBackingField(name, Visibilities.PUBLIC, singleton, singleton.defaultType, origin)
-    }
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/JsMapping.kt

@@ -10,7 +10,6 @@ import org.jetbrains.kotlin.backend.common.Mapping
 import org.jetbrains.kotlin.ir.declarations.*
 
 class JsMapping : DefaultMapping() {
-    val singletonFieldDescriptors = newMapping<IrClass, IrField>()
     val outerThisFieldSymbols = newMapping<IrClass, IrField>()
     val innerClassConstructors = newMapping<IrConstructor, IrConstructor>()
     val originalInnerClassPrimaryConstructorByClass = newMapping<IrClass, IrConstructor>()

compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/descriptors/JvmDeclarationFactory.kt

@@ -47,7 +47,7 @@ class JvmDeclarationFactory(
     private val defaultImplsClasses = HashMap<IrClass, IrClass>()
     private val defaultImplsRedirections = HashMap<IrSimpleFunction, IrSimpleFunction>()
 
-    override fun getFieldForEnumEntry(enumEntry: IrEnumEntry): IrField =
+    fun getFieldForEnumEntry(enumEntry: IrEnumEntry): IrField =
         singletonFieldDeclarations.getOrPut(enumEntry) {
             buildField {
                 setSourceRange(enumEntry)
@@ -114,7 +114,7 @@ class JvmDeclarationFactory(
             metadata = oldConstructor.metadata
         }
 
-    override fun getFieldForObjectInstance(singleton: IrClass): IrField =
+    fun getFieldForObjectInstance(singleton: IrClass): IrField =
         singletonFieldDeclarations.getOrPut(singleton) {
             val originalVisibility = singleton.visibility
             val isNotMappedCompanion = singleton.isCompanion && !isMappedIntrinsicCompanionObject(singleton.descriptor)