Support lazy ir in native

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt

@@ -75,7 +75,7 @@ fun runTopLevelPhases(konanConfig: KonanConfig, environment: KotlinCoreEnvironme
         @Suppress("DEPRECATION")
         context.psi2IrGeneratorContext = generatorContext
 
-        val symbols = KonanSymbols(context, generatorContext.symbolTable)
+        val symbols = KonanSymbols(context, generatorContext.symbolTable, generatorContext.symbolTable.lazyWrapper)
 
         val module = translator.generateModuleFragment(generatorContext, environment.getSourceFiles())
 

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ir/Ir.kt

@@ -45,9 +45,7 @@ import org.jetbrains.kotlin.ir.types.IrType
 import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl
 import org.jetbrains.kotlin.ir.types.impl.IrStarProjectionImpl
 import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection
-import org.jetbrains.kotlin.ir.util.SymbolTable
-import org.jetbrains.kotlin.ir.util.constructors
-import org.jetbrains.kotlin.ir.util.translateErased
+import org.jetbrains.kotlin.ir.util.*
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -68,12 +66,12 @@ internal class KonanIr(context: Context, irModule: IrModuleFragment): Ir<Context
 
     fun get(descriptor: FunctionDescriptor): IrFunction {
         return moduleIndexForCodegen.functions[descriptor]
-                ?: symbols.symbolTable.referenceFunction(descriptor).owner
+                ?: symbols.lazySymbolTable.referenceFunction(descriptor).owner
     }
 
     fun get(descriptor: ClassDescriptor): IrClass {
         return moduleIndexForCodegen.classes[descriptor]
-                ?: symbols.symbolTable.referenceClass(descriptor)
+                ?: symbols.lazySymbolTable.referenceClass(descriptor)
                         .also {
                             if (!it.isBound)
                                 error(descriptor)
@@ -92,7 +90,7 @@ internal class KonanIr(context: Context, irModule: IrModuleFragment): Ir<Context
         assert(descriptor.kind == ClassKind.ENUM_ENTRY)
 
         return originalModuleIndex.enumEntries[descriptor]
-                ?: symbols.symbolTable.referenceEnumEntry(descriptor).owner
+                ?: symbols.lazySymbolTable.referenceEnumEntry(descriptor).owner
     }
 
     fun translateErased(type: KotlinType): IrSimpleType = symbols.symbolTable.translateErased(type)
@@ -127,7 +125,7 @@ internal class KonanIr(context: Context, irModule: IrModuleFragment): Ir<Context
     }
 }
 
-internal class KonanSymbols(context: Context, val symbolTable: SymbolTable): Symbols<Context>(context, symbolTable) {
+internal class KonanSymbols(context: Context, val symbolTable: SymbolTable, val lazySymbolTable: ReferenceSymbolTable): Symbols<Context>(context, lazySymbolTable) {
 
     val entryPoint = findMainEntryPoint(context)?.let { symbolTable.referenceSimpleFunction(it) }
 

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/ExpectDeclarationsRemoving.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.ir.expressions.IrGetValue
 import org.jetbrains.kotlin.ir.expressions.impl.IrGetValueImpl
 import org.jetbrains.kotlin.ir.symbols.IrValueParameterSymbol
 import org.jetbrains.kotlin.ir.symbols.IrValueSymbol
+import org.jetbrains.kotlin.ir.util.referenceFunction
 import org.jetbrains.kotlin.ir.visitors.IrElementTransformerVoid
 import org.jetbrains.kotlin.ir.visitors.IrElementVisitorVoid
 import org.jetbrains.kotlin.ir.visitors.acceptChildrenVoid

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUnboundSymbolReplacer.kt

@@ -117,7 +117,7 @@ private class DeclarationSymbolCollector : IrElementVisitorVoid {
 }
 
 private class IrUnboundSymbolReplacer(
-        val symbolTable: SymbolTable,
+        val symbolTable: ReferenceSymbolTable,
         val descriptorToSymbol: Map<DeclarationDescriptor, IrSymbol>,
         val context: Context
 ) : IrElementTransformerVoid() {
@@ -137,7 +137,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     private inline fun <reified D : DeclarationDescriptor, reified S : IrSymbol> S.replace(
-            referenceSymbol: (SymbolTable, D) -> S): S? {
+            referenceSymbol: (ReferenceSymbolTable, D) -> S): S? {
 
         if (this.isBound) {
             return null
@@ -156,7 +156,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     private inline fun <reified D : DeclarationDescriptor, reified S : IrSymbol> S.replaceOrSame(
-            referenceSymbol: (SymbolTable, D) -> S): S = this.replace(referenceSymbol) ?: this
+            referenceSymbol: (ReferenceSymbolTable, D) -> S): S = this.replace(referenceSymbol) ?: this
 
     private inline fun <reified S : IrSymbol> S.replaceLocal(): S? {
         return if (this.isBound) {
@@ -185,7 +185,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitGetObjectValue(expression: IrGetObjectValue): IrExpression {
-        val symbol = expression.symbol.replace(SymbolTable::referenceClass) ?:
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceClass) ?:
                 return super.visitGetObjectValue(expression)
 
         expression.transformChildrenVoid(this)
@@ -195,7 +195,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitGetEnumValue(expression: IrGetEnumValue): IrExpression {
-        val symbol = expression.symbol.replace(SymbolTable::referenceEnumEntry) ?:
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceEnumEntry) ?:
                 return super.visitGetEnumValue(expression)
 
         expression.transformChildrenVoid(this)
@@ -205,7 +205,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitClassReference(expression: IrClassReference): IrExpression {
-        val symbol = expression.symbol.replace(SymbolTable::referenceClassifier)
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceClassifier)
                 ?: return super.visitClassReference(expression)
 
         expression.transformChildrenVoid(this)
@@ -221,9 +221,9 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitGetField(expression: IrGetField): IrExpression {
-        val symbol = expression.symbol.replaceOrSame(SymbolTable::referenceField)
+        val symbol = expression.symbol.replaceOrSame(ReferenceSymbolTable::referenceField)
 
-        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(SymbolTable::referenceClass)
+        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(ReferenceSymbolTable::referenceClass)
 
         if (symbol == expression.symbol && superQualifierSymbol == expression.superQualifierSymbol) {
             return super.visitGetField(expression)
@@ -236,9 +236,9 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitSetField(expression: IrSetField): IrExpression {
-        val symbol = expression.symbol.replaceOrSame(SymbolTable::referenceField)
+        val symbol = expression.symbol.replaceOrSame(ReferenceSymbolTable::referenceField)
 
-        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(SymbolTable::referenceClass)
+        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(ReferenceSymbolTable::referenceClass)
 
         if (symbol == expression.symbol && superQualifierSymbol == expression.superQualifierSymbol) {
             return super.visitSetField(expression)
@@ -253,9 +253,9 @@ private class IrUnboundSymbolReplacer(
     override fun visitCall(expression: IrCall): IrExpression {
         expression.replaceTypeArguments()
 
-        val symbol = expression.symbol.replace(SymbolTable::referenceFunction) ?: expression.symbol
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceFunction) ?: expression.symbol
 
-        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(SymbolTable::referenceClass)
+        val superQualifierSymbol = expression.superQualifierSymbol?.replaceOrSame(ReferenceSymbolTable::referenceClass)
 
         if (symbol == expression.symbol && superQualifierSymbol == expression.superQualifierSymbol) {
             return super.visitCall(expression)
@@ -288,7 +288,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitEnumConstructorCall(expression: IrEnumConstructorCall): IrExpression {
-        val symbol = expression.symbol.replace(SymbolTable::referenceConstructor) ?:
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceConstructor) ?:
                 return super.visitEnumConstructorCall(expression)
 
         return with(expression) {
@@ -301,7 +301,7 @@ private class IrUnboundSymbolReplacer(
     override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall): IrExpression {
         expression.replaceTypeArguments()
 
-        val symbol = expression.symbol.replace(SymbolTable::referenceConstructor) ?:
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceConstructor) ?:
                 return super.visitDelegatingConstructorCall(expression)
 
         expression.transformChildrenVoid()
@@ -316,7 +316,7 @@ private class IrUnboundSymbolReplacer(
     override fun visitFunctionReference(expression: IrFunctionReference): IrExpression {
         expression.replaceTypeArguments()
 
-        val symbol = expression.symbol.replace(SymbolTable::referenceFunction) ?:
+        val symbol = expression.symbol.replace(ReferenceSymbolTable::referenceFunction) ?:
                 return super.visitFunctionReference(expression)
 
         expression.transformChildrenVoid(this)
@@ -331,9 +331,9 @@ private class IrUnboundSymbolReplacer(
     override fun visitPropertyReference(expression: IrPropertyReference): IrExpression {
         expression.replaceTypeArguments()
 
-        val field = expression.field?.replaceOrSame(SymbolTable::referenceField)
-        val getter = expression.getter?.replace(SymbolTable::referenceFunction) ?: expression.getter
-        val setter = expression.setter?.replace(SymbolTable::referenceFunction) ?: expression.setter
+        val field = expression.field?.replaceOrSame(ReferenceSymbolTable::referenceField)
+        val getter = expression.getter?.replace(ReferenceSymbolTable::referenceFunction) ?: expression.getter
+        val setter = expression.setter?.replace(ReferenceSymbolTable::referenceFunction) ?: expression.setter
 
         if (field == expression.field && getter == expression.getter && setter == expression.setter) {
             return super.visitPropertyReference(expression)
@@ -354,9 +354,9 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitLocalDelegatedPropertyReference(expression: IrLocalDelegatedPropertyReference): IrExpression {
-        val delegate = expression.delegate.replaceOrSame(SymbolTable::referenceVariable)
-        val getter = expression.getter.replace(SymbolTable::referenceFunction) ?: expression.getter
-        val setter = expression.setter?.replace(SymbolTable::referenceFunction) ?: expression.setter
+        val delegate = expression.delegate.replaceOrSame(ReferenceSymbolTable::referenceVariable)
+        val getter = expression.getter.replace(ReferenceSymbolTable::referenceFunction) ?: expression.getter
+        val setter = expression.setter?.replace(ReferenceSymbolTable::referenceFunction) ?: expression.setter
 
         if (delegate == expression.delegate && getter == expression.getter && setter == expression.setter) {
             return super.visitLocalDelegatedPropertyReference(expression)
@@ -379,7 +379,7 @@ private class IrUnboundSymbolReplacer(
         try {
             if (declaration is IrSimpleFunction) {
                 declaration.overriddenSymbols.forEachIndexed { index, symbol ->
-                    val newSymbol = symbol.replace(SymbolTable::referenceSimpleFunction)
+                    val newSymbol = symbol.replace(ReferenceSymbolTable::referenceSimpleFunction)
                     if (newSymbol != null) {
                         declaration.overriddenSymbols[index] = newSymbol
                     }
@@ -424,7 +424,7 @@ private class IrUnboundSymbolReplacer(
     }
 
     override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall): IrExpression {
-        val classSymbol = expression.classSymbol.replace(SymbolTable::referenceClass) ?:
+        val classSymbol = expression.classSymbol.replace(ReferenceSymbolTable::referenceClass) ?:
                 return super.visitInstanceInitializerCall(expression)
 
         expression.transformChildrenVoid(this)

backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/ir/util/IrUtils2.kt

@@ -227,7 +227,7 @@ private fun createFakeOverride(
 }
 
 
-fun IrSimpleFunction.setOverrides(symbolTable: SymbolTable) {
+fun IrSimpleFunction.setOverrides(symbolTable: ReferenceSymbolTable) {
     assert(this.overriddenSymbols.isEmpty())
 
     this.descriptor.overriddenDescriptors.mapTo(this.overriddenSymbols) {
@@ -312,7 +312,7 @@ fun IrClass.setSuperSymbols(superTypes: List<IrType>) {
 private fun IrClass.superDescriptors() =
         this.descriptor.typeConstructor.supertypes.map { it.constructor.declarationDescriptor as ClassDescriptor }
 
-fun IrClass.setSuperSymbols(symbolTable: SymbolTable) {
+fun IrClass.setSuperSymbols(symbolTable: ReferenceSymbolTable) {
     assert(this.superTypes.isEmpty())
     this.descriptor.typeConstructor.supertypes.mapTo(this.superTypes) { symbolTable.translateErased(it) }
 
@@ -665,7 +665,7 @@ fun CallableMemberDescriptor.createValueParameter(
     return IrValueParameterImpl(startOffset, endOffset, IrDeclarationOrigin.DEFINED, descriptor, type, null)
 }
 
-fun SymbolTable.translateErased(type: KotlinType): IrSimpleType {
+fun ReferenceSymbolTable.translateErased(type: KotlinType): IrSimpleType {
     val descriptor = TypeUtils.getClassDescriptor(type)
     if (descriptor == null) return translateErased(type.immediateSupertypes().first())
     val classSymbol = this.referenceClass(descriptor)