From 20c4a7b2443abea22946a83f3f7260173d6cbca0 Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 11 Mar 2020 15:35:14 +0300 Subject: [PATCH] [FIR2IR] Introduce staged transformation (first step) Now FE IR -> BE IR transformation is performed in multiple stages controller by Fir2IrConverter. Stages are * files & classes registration * supertypes & type parameters handling * functions & properties signature generation * body generation After each step we have guarantee (with exception of local classes & type inference combination, and external symbols) that required symbols (class/function/property/variable/type parameter) are already bound to real declarations and have correct parents. This commit also fixes incorrect parents for local classes --- .../kotlin/fir/backend/ConversionUtils.kt | 4 + .../kotlin/fir/backend/Fir2IrCallableCache.kt | 10 - .../fir/backend/Fir2IrConversionScope.kt | 2 + .../kotlin/fir/backend/Fir2IrConverter.kt | 233 ++++++++++++--- .../fir/backend/Fir2IrDeclarationStorage.kt | 268 +++++++++--------- .../backend/Fir2IrFakeOverrideGenerator.kt | 12 +- .../kotlin/fir/backend/Fir2IrLocalStorage.kt | 10 +- .../kotlin/fir/backend/Fir2IrVisitor.kt | 200 ++++++------- .../bound/localUnitFunction.kt | 1 - .../function/getArityViaFunctionImpl.kt | 1 - .../function/local/closureWithSideEffect.kt | 1 - .../function/local/equalsHashCode.kt | 1 - .../function/local/extension.kt | 1 - .../function/local/extensionToLocalClass.kt | 1 - .../function/local/extensionToPrimitive.kt | 1 - .../function/local/extensionWithClosure.kt | 1 - .../function/local/localLocal.kt | 1 - .../function/local/recursiveClosure.kt | 1 - .../function/local/simple.kt | 1 - .../function/local/simpleClosure.kt | 1 - .../function/local/simpleWithArg.kt | 1 - .../function/local/unitWithSideEffect.kt | 1 - .../box/casts/functions/isFunKSmall.kt | 1 - .../testData/codegen/box/classes/kt2626.kt | 1 - .../closures/captureExtensionReceiverX2.kt | 1 - .../localFunctionCapturedInLambda.kt | 1 - .../closures/captureOuterProperty/kt4176.kt | 1 - .../box/closures/capturedLocalGenericFun.kt | 1 - .../localFunInsideLocalFun.kt | 1 - ...calFunInsideLocalFunDifferentSignatures.kt | 1 - .../closureInsideClosure/threeLevels.kt | 1 - .../threeLevelsDifferentSignatures.kt | 1 - .../varAsFunInsideLocalFun.kt | 1 - .../testData/codegen/box/closures/kt3905.kt | 1 - .../testData/codegen/box/closures/kt5589.kt | 1 - .../box/closures/localClassFunClosure.kt | 1 - .../box/closures/localFunctionInFunction.kt | 1 - .../closures/localFunctionInInitializer.kt | 1 - .../codegen/box/closures/localGenericFun.kt | 1 - .../codegen/box/closures/recursiveClosure.kt | 1 - .../function/local/equalsHashCode.kt | 1 - .../tailRecursion/recursiveInnerFunction.kt | 1 - .../box/enum/enumInheritedFromTrait.kt | 1 - .../testData/codegen/box/enum/inclassobj.kt | 1 - .../box/enum/kt7257_anonObjectMethod.kt | 1 - .../codegen/box/extensionFunctions/kt1953.kt | 1 - .../codegen/box/extensionFunctions/kt5467.kt | 1 - .../testData/codegen/box/functions/kt2280.kt | 1 - .../localFunctions/callInlineLocalInLambda.kt | 1 - .../captureUpperBoundedTypeParameter.kt | 1 - .../localFunctions/definedWithinLambda.kt | 1 - .../definedWithinLambdaInnerUsage1.kt | 1 - .../definedWithinLambdaInnerUsage2.kt | 1 - .../box/functions/localFunctions/kt2895.kt | 1 - .../box/functions/localFunctions/kt3308.kt | 1 - .../box/functions/localFunctions/kt3978.kt | 1 - .../box/functions/localFunctions/kt3978_2.kt | 1 - .../box/functions/localFunctions/kt4119.kt | 1 - .../box/functions/localFunctions/kt4119_2.kt | 1 - .../box/functions/localFunctions/kt4514.kt | 1 - .../box/functions/localFunctions/kt4783.kt | 1 - .../box/functions/localFunctions/kt4989.kt | 1 - .../localFunctionVsLocalVariable.kt | 1 - .../box/functions/localFunctions/nameClash.kt | 1 - .../overloadedLocalFunWithoutClosure.kt | 1 - .../localFunctions/overloadedLocalFunction.kt | 1 - .../overloadedLocalFunction1.kt | 1 - .../overloadedLocalFunction2.kt | 1 - .../overloadedLocalFunction3.kt | 1 - .../localFunctions/parameterAsDefaultValue.kt | 1 - .../typeParametersInLocalFunction.kt | 1 - .../closureConversion/closureConversion1.kt | 1 - .../closureConversion/closureConversion2.kt | 1 - .../closureConversion/closureConversion3.kt | 1 - .../closureConversion/closureConversion4.kt | 1 - .../box/ir/closureConversion/mutable1.kt | 1 - .../jvmName/multifileClassWithLocalGeneric.kt | 1 - .../codegen/box/labels/labeledDeclarations.kt | 1 - .../codegen/box/localClasses/kt4174.kt | 1 - .../recaptureVarCapturedInLocalClass1.kt | 1 - .../recaptureVarCapturedInLocalClass2.kt | 1 - .../multiDecl/ValCapturedInLocalFunction.kt | 1 - .../fromAnonymousObjectInNestedClass.kt | 1 - ...ccessedFromAnonymousObjectInNestedClass.kt | 1 - .../objects/objectInLocalAnonymousObject.kt | 1 - .../box/objects/objectLiteralInClosure.kt | 1 - .../box/objects/receiverInConstructor.kt | 1 - .../codegen/box/operatorConventions/kt4987.kt | 1 - .../box/parametersMetadata/superParams.kt | 1 - .../enclosing/lambdaInLocalFunction.kt | 1 - .../codegen/box/regressions/kt3850.kt | 1 - .../codegen/box/regressions/kt3903.kt | 1 - .../exceptionInMonitorExpression.kt | 1 - .../funInterface/partialSam.fir.txt | 4 +- .../ir/irText/lambdas/localFunction.fir.txt | 2 +- 95 files changed, 436 insertions(+), 394 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt index 1a6b5bcee5f..1141049f578 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/ConversionUtils.kt @@ -9,6 +9,7 @@ import com.intellij.psi.PsiCompiledElement import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirClass +import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction import org.jetbrains.kotlin.fir.declarations.FirVariable import org.jetbrains.kotlin.fir.expressions.FirConstExpression @@ -216,3 +217,6 @@ internal fun FirReference.statementOrigin(): IrStatementOrigin? { else -> null } } + +fun FirClass<*>.getPrimaryConstructorIfAny(): FirConstructor? = + declarations.filterIsInstance().firstOrNull()?.takeIf { it.isPrimary } \ No newline at end of file diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt index 5b096878305..1f6cdb53e70 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrCallableCache.kt @@ -17,8 +17,6 @@ class Fir2IrCallableCache { private val variableCache = mutableMapOf, IrVariable>() - private val localClassCache = mutableMapOf, IrClass>() - private val localFunctionCache = mutableMapOf, IrSimpleFunction>() fun getParameter(parameter: FirValueParameter): IrValueParameter? = parameterCache[parameter] @@ -33,13 +31,6 @@ class Fir2IrCallableCache { variableCache[firVariable] = irVariable } - fun getLocalClass(localClass: FirClass<*>): IrClass? = localClassCache[localClass] - - fun putLocalClass(localClass: FirClass<*>, irClass: IrClass) { - require(localClass !is FirRegularClass || localClass.visibility == Visibilities.LOCAL) - localClassCache[localClass] = irClass - } - fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? = localFunctionCache[localFunction] fun putLocalFunction(localFunction: FirFunction<*>, irFunction: IrSimpleFunction) { @@ -50,7 +41,6 @@ class Fir2IrCallableCache { fun clear() { parameterCache.clear() variableCache.clear() - localClassCache.clear() localFunctionCache.clear() } } \ No newline at end of file diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt index 2d604c159c0..1c1f7f3cee5 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConversionScope.kt @@ -20,6 +20,8 @@ class Fir2IrConversionScope { return parent } + fun parentFromStack(): IrDeclarationParent = parentStack.last() + fun applyParentFromStackTo(declaration: T): T { declaration.parent = parentStack.last() return declaration diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt index 21b0fa76db0..4b963b94209 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrConverter.kt @@ -7,58 +7,207 @@ package org.jetbrains.kotlin.fir.backend import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirFile +import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor import org.jetbrains.kotlin.fir.psi -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrModuleFragment +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.psi2ir.PsiSourceManager -object Fir2IrConverter { +class Fir2IrConverter( + private val moduleDescriptor: FirModuleDescriptor, + private val sourceManager: PsiSourceManager, + private val declarationStorage: Fir2IrDeclarationStorage +) { - fun createModuleFragment( - session: FirSession, - firFiles: List, - languageVersionSettings: LanguageVersionSettings, - fakeOverrideMode: FakeOverrideMode = FakeOverrideMode.NORMAL, - signaturer: IdSignatureComposer - ): Fir2IrResult { - val moduleDescriptor = FirModuleDescriptor(session) - val symbolTable = SymbolTable(signaturer) - val constantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable) - val typeTranslator = TypeTranslator(symbolTable, languageVersionSettings, moduleDescriptor.builtIns) - constantValueGenerator.typeTranslator = typeTranslator - typeTranslator.constantValueGenerator = constantValueGenerator - val builtIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, signaturer, symbolTable) - val sourceManager = PsiSourceManager() - val fir2irVisitor = Fir2IrVisitor(session, moduleDescriptor, symbolTable, sourceManager, builtIns, fakeOverrideMode) - val irFiles = mutableListOf() - for (firFile in firFiles) { - fir2irVisitor.registerFile(firFile) - } - for (firFile in firFiles) { - val irFile = firFile.accept(fir2irVisitor, null) as IrFile - val fileEntry = sourceManager.getOrCreateFileEntry(firFile.psi as KtFile) - sourceManager.putFileEntry(irFile, fileEntry) - irFiles += irFile - } - - val irModuleFragment = IrModuleFragmentImpl(moduleDescriptor, builtIns, irFiles) - generateUnboundSymbolsAsDependencies(irModuleFragment, symbolTable, builtIns) - return Fir2IrResult(irModuleFragment, symbolTable, sourceManager) + fun processLocalClassAndNestedClasses(regularClass: FirRegularClass, parent: IrDeclarationParent) { + val irClass = registerClassAndNestedClasses(regularClass, parent) + processClassAndNestedClassHeaders(regularClass) + processClassMembers(regularClass, irClass) } - private fun generateUnboundSymbolsAsDependencies( - irModule: IrModuleFragment, - symbolTable: SymbolTable, - builtIns: IrBuiltIns - ) { - // TODO: provide StubGeneratorExtensions for correct lazy stub IR generation on JVM - ExternalDependenciesGenerator(symbolTable, generateTypicalIrProviderList(irModule.descriptor, builtIns, symbolTable)) - .generateUnboundSymbolsAsDependencies() + fun processRegisteredLocalClassAndNestedClasses(regularClass: FirRegularClass, irClass: IrClass) { + regularClass.declarations.forEach { + if (it is FirRegularClass) { + registerClassAndNestedClasses(it, irClass) + } + } + processClassAndNestedClassHeaders(regularClass) + processClassMembers(regularClass, irClass) + } + + fun registerFileAndClasses(file: FirFile) { + val irFile = IrFileImpl( + sourceManager.getOrCreateFileEntry(file.psi as KtFile), + moduleDescriptor.getPackage(file.packageFqName).fragments.first() + ) + declarationStorage.registerFile(file, irFile) + file.declarations.forEach { + if (it is FirRegularClass) { + registerClassAndNestedClasses(it, irFile) + } + } + } + + fun processClassHeaders(file: FirFile) { + file.declarations.forEach { + if (it is FirRegularClass) { + processClassAndNestedClassHeaders(it) + } + } + } + + fun processFileAndClassMembers(file: FirFile) { + val irFile = declarationStorage.getIrFile(file) + for (declaration in file.declarations) { + val irDeclaration = processMemberDeclaration(declaration, irFile) ?: continue + irFile.declarations += irDeclaration + } + } + + fun processAnonymousObjectMembers( + anonymousObject: FirAnonymousObject, + irClass: IrClass = declarationStorage.getCachedIrClass(anonymousObject)!! + ): IrClass { + anonymousObject.getPrimaryConstructorIfAny()?.let { + irClass.declarations += declarationStorage.createIrConstructor(it, irClass) + } + for (declaration in anonymousObject.declarations) { + if (declaration is FirRegularClass) { + registerClassAndNestedClasses(declaration, irClass) + processClassAndNestedClassHeaders(declaration) + } + val irDeclaration = processMemberDeclaration(declaration, irClass) ?: continue + irClass.declarations += irDeclaration + } + return irClass + } + + private fun processClassMembers( + regularClass: FirRegularClass, + irClass: IrClass = declarationStorage.getCachedIrClass(regularClass)!! + ): IrClass { + regularClass.getPrimaryConstructorIfAny()?.let { + irClass.declarations += declarationStorage.createIrConstructor(it, irClass) + } + for (declaration in regularClass.declarations) { + val irDeclaration = processMemberDeclaration(declaration, irClass) ?: continue + irClass.declarations += irDeclaration + } + return irClass + } + + private fun registerClassAndNestedClasses(regularClass: FirRegularClass, parent: IrDeclarationParent): IrClass { + val irClass = declarationStorage.registerIrClass(regularClass, parent) + regularClass.declarations.forEach { + if (it is FirRegularClass) { + registerClassAndNestedClasses(it, irClass) + } + } + return irClass + } + + private fun processClassAndNestedClassHeaders(regularClass: FirRegularClass) { + declarationStorage.processClassHeader(regularClass) + regularClass.declarations.forEach { + if (it is FirRegularClass) { + processClassAndNestedClassHeaders(it) + } + } + } + + private fun processMemberDeclaration(declaration: FirDeclaration, parent: IrDeclarationParent): IrDeclaration? { + return when (declaration) { + is FirRegularClass -> { + processClassMembers(declaration) + } + is FirSimpleFunction -> { + declarationStorage.createIrFunction(declaration, parent) + } + is FirProperty -> { + declarationStorage.createIrProperty(declaration, parent) + } + is FirConstructor -> if (!declaration.isPrimary) { + declarationStorage.createIrConstructor(declaration, parent as IrClass) + } else { + null + } + is FirEnumEntry -> { + declarationStorage.createIrEnumEntry(declaration, parent as IrClass) + } + is FirAnonymousInitializer -> { + declarationStorage.createIrAnonymousInitializer(declaration, parent as IrClass) + } + is FirTypeAlias -> { + // DO NOTHING + null + } + else -> { + throw AssertionError("Unexpected member: ${declaration::class}") + } + } + } + + companion object { + fun createModuleFragment( + session: FirSession, + firFiles: List, + languageVersionSettings: LanguageVersionSettings, + fakeOverrideMode: FakeOverrideMode = FakeOverrideMode.NORMAL, + signaturer: IdSignatureComposer + ): Fir2IrResult { + val moduleDescriptor = FirModuleDescriptor(session) + val symbolTable = SymbolTable(signaturer) + val constantValueGenerator = ConstantValueGenerator(moduleDescriptor, symbolTable) + val typeTranslator = TypeTranslator(symbolTable, languageVersionSettings, moduleDescriptor.builtIns) + constantValueGenerator.typeTranslator = typeTranslator + typeTranslator.constantValueGenerator = constantValueGenerator + val builtIns = IrBuiltIns(moduleDescriptor.builtIns, typeTranslator, signaturer, symbolTable) + val sourceManager = PsiSourceManager() + val declarationStorage = Fir2IrDeclarationStorage(session, symbolTable, moduleDescriptor) + val typeConverter = Fir2IrTypeConverter(session, declarationStorage, builtIns) + declarationStorage.typeConverter = typeConverter + typeConverter.initBuiltinTypes() + val irFiles = mutableListOf() + + val converter = Fir2IrConverter(moduleDescriptor, sourceManager, declarationStorage) + for (firFile in firFiles) { + converter.registerFileAndClasses(firFile) + } + for (firFile in firFiles) { + converter.processClassHeaders(firFile) + } + for (firFile in firFiles) { + converter.processFileAndClassMembers(firFile) + } + + val fir2irVisitor = Fir2IrVisitor( + session, symbolTable, declarationStorage, converter, typeConverter, builtIns, fakeOverrideMode + ) + for (firFile in firFiles) { + val irFile = firFile.accept(fir2irVisitor, null) as IrFile + val fileEntry = sourceManager.getOrCreateFileEntry(firFile.psi as KtFile) + sourceManager.putFileEntry(irFile, fileEntry) + irFiles += irFile + } + + val irModuleFragment = IrModuleFragmentImpl(moduleDescriptor, builtIns, irFiles) + generateUnboundSymbolsAsDependencies(irModuleFragment, symbolTable, builtIns) + return Fir2IrResult(irModuleFragment, symbolTable, sourceManager) + } + + private fun generateUnboundSymbolsAsDependencies( + irModule: IrModuleFragment, + symbolTable: SymbolTable, + builtIns: IrBuiltIns + ) { + // TODO: provide StubGeneratorExtensions for correct lazy stub IR generation on JVM + ExternalDependenciesGenerator(symbolTable, generateTypicalIrProviderList(irModule.descriptor, builtIns, symbolTable)) + .generateUnboundSymbolsAsDependencies() + } } } \ No newline at end of file diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt index e77bff15920..3ebc3d0bc13 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrDeclarationStorage.kt @@ -66,6 +66,8 @@ class Fir2IrDeclarationStorage( private val constructorCache = mutableMapOf() + private val initializerCache = mutableMapOf() + private val propertyCache = mutableMapOf() private val fieldCache = mutableMapOf() @@ -98,7 +100,8 @@ class Fir2IrDeclarationStorage( fun leaveScope(descriptor: DeclarationDescriptor) { if (descriptor is WrappedSimpleFunctionDescriptor || descriptor is WrappedClassConstructorDescriptor || - descriptor is WrappedPropertyDescriptor + descriptor is WrappedPropertyDescriptor || + descriptor is WrappedEnumEntryDescriptor ) { localStorage.leaveCallable() } @@ -189,14 +192,18 @@ class Fir2IrDeclarationStorage( irClass.declarations += when (declaration) { is FirSimpleFunction -> { processedNames += declaration.name - getIrFunction(declaration, irClass) + createIrFunction(declaration, irClass) } is FirProperty -> { processedNames += declaration.name - getIrProperty(declaration, irClass) + createIrProperty(declaration, irClass) + } + is FirConstructor -> { + createIrConstructor(declaration, irClass) + } + is FirRegularClass -> { + createIrClass(declaration, irClass) } - is FirConstructor -> getIrConstructor(declaration, irClass) - is FirRegularClass -> getIrClass(declaration, exactlySourceClass = false) else -> continue } } @@ -210,14 +217,14 @@ class Fir2IrDeclarationStorage( if (functionSymbol is FirNamedFunctionSymbol) { val fakeOverrideSymbol = FirClassSubstitutionScope.createFakeOverrideFunction(session, functionSymbol.fir, functionSymbol) - irClass.declarations += getIrFunction(fakeOverrideSymbol.fir, irClass) + irClass.declarations += createIrFunction(fakeOverrideSymbol.fir, irClass) } } scope.processPropertiesByName(name) { propertySymbol -> if (propertySymbol is FirPropertySymbol) { val fakeOverrideSymbol = FirClassSubstitutionScope.createFakeOverrideProperty(session, propertySymbol.fir, propertySymbol) - irClass.declarations += getIrProperty(fakeOverrideSymbol.fir, irClass) + irClass.declarations += createIrProperty(fakeOverrideSymbol.fir, irClass) } } } @@ -228,7 +235,7 @@ class Fir2IrDeclarationStorage( } } - private fun getCachedIrClass(klass: FirClass<*>): IrClass? { + fun getCachedIrClass(klass: FirClass<*>): IrClass? { return if (klass is FirAnonymousObject || klass is FirRegularClass && klass.visibility == Visibilities.LOCAL) { localStorage.getLocalClass(klass) } else { @@ -250,24 +257,39 @@ class Fir2IrDeclarationStorage( } } - private fun createIrClass(klass: FirClass<*>, exactlySourceClass: Boolean = false): IrClass { + private fun createIrClass(klass: FirClass<*>, parent: IrDeclarationParent? = null): IrClass { // NB: klass can be either FirRegularClass or FirAnonymousObject if (klass is FirAnonymousObject) { - return createIrAnonymousObject(klass) + return createIrAnonymousObject(klass, irParent = parent) } val regularClass = klass as FirRegularClass - - val descriptor = WrappedClassDescriptor() val origin = - if (exactlySourceClass || firProvider.getFirClassifierContainerFileIfAny(klass.symbol) != null) IrDeclarationOrigin.DEFINED + if (firProvider.getFirClassifierContainerFileIfAny(klass.symbol) != null) IrDeclarationOrigin.DEFINED else IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB + val irClass = registerIrClass(regularClass, parent, origin) + processClassHeader(regularClass, irClass) + return irClass + } + + fun processClassHeader(regularClass: FirRegularClass, irClass: IrClass = getCachedIrClass(regularClass)!!): IrClass { + irClass.declareSupertypesAndTypeParameters(regularClass) + irClass.setThisReceiver() + return irClass + } + + fun registerIrClass( + regularClass: FirRegularClass, + parent: IrDeclarationParent? = null, + origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED + ): IrClass { + val descriptor = WrappedClassDescriptor() val visibility = regularClass.visibility val modality = if (regularClass.classKind == ClassKind.ENUM_CLASS) { regularClass.enumClassModality() } else { regularClass.modality ?: Modality.FINAL } - val irClass = klass.convertWithOffsets { startOffset, endOffset -> + val irClass = regularClass.convertWithOffsets { startOffset, endOffset -> irSymbolTable.declareClass(startOffset, endOffset, origin, descriptor, modality, visibility) { symbol -> IrClassImpl( startOffset, @@ -275,7 +297,7 @@ class Fir2IrDeclarationStorage( origin, symbol, regularClass.name, - klass.classKind, + regularClass.classKind, visibility, modality, isCompanion = regularClass.isCompanion, @@ -290,25 +312,22 @@ class Fir2IrDeclarationStorage( } } } - if (regularClass.visibility == Visibilities.LOCAL) { - localStorage.putLocalClass(klass, irClass) - } else { - classCache[klass] = irClass + if (parent != null) { + irClass.parent = parent + } + if (regularClass.visibility == Visibilities.LOCAL) { + localStorage.putLocalClass(regularClass, irClass) + } else { + classCache[regularClass] = irClass } - irClass.declareSupertypesAndTypeParameters(klass) - irClass.setThisReceiver() return irClass } - fun getIrClass(klass: FirClass<*>, exactlySourceClass: Boolean = true): IrClass { - return getCachedIrClass(klass) ?: createIrClass(klass, exactlySourceClass) - } - - private fun createIrAnonymousObject( + fun createIrAnonymousObject( anonymousObject: FirAnonymousObject, visibility: Visibility = Visibilities.LOCAL, name: Name = Name.special(""), - irParent: IrClass? = null + irParent: IrDeclarationParent? = null ): IrClass { val descriptor = WrappedClassDescriptor() val origin = IrDeclarationOrigin.DEFINED @@ -335,18 +354,9 @@ class Fir2IrDeclarationStorage( return result } - fun getIrAnonymousObject( - anonymousObject: FirAnonymousObject, - visibility: Visibility = Visibilities.LOCAL, - name: Name = Name.special(""), - irParent: IrClass? = null - ): IrClass { + private fun getIrAnonymousObjectForEnumEntry(anonymousObject: FirAnonymousObject, name: Name, irParent: IrClass?): IrClass { localStorage.getLocalClass(anonymousObject)?.let { return it } - return createIrAnonymousObject(anonymousObject, visibility, name, irParent) - } - - private fun getIrEnumEntryClass(enumEntry: FirEnumEntry, anonymousObject: FirAnonymousObject, irParent: IrClass?): IrClass { - return getIrAnonymousObject(anonymousObject, Visibilities.PRIVATE, enumEntry.name, irParent) + return createIrAnonymousObject(anonymousObject, Visibilities.PRIVATE, name, irParent) } private fun getIrTypeParameter( @@ -487,7 +497,7 @@ class Fir2IrDeclarationStorage( declareDefaultSetterParameter(type) } else if (function != null) { valueParameters = function.valueParameters.mapIndexed { index, valueParameter -> - createAndSaveIrParameter( + createIrParameter( valueParameter, index, useStubForDefaultValueStub = function !is FirConstructor || containingClass?.name != Name.identifier("Enum"), typeContext @@ -535,16 +545,18 @@ class Fir2IrDeclarationStorage( return this } - fun T.enterLocalScope(function: FirFunction<*>): T { - enterScope(descriptor) + fun T.putParametersInScope(function: FirFunction<*>): T { for ((firParameter, irParameter) in function.valueParameters.zip(valueParameters)) { - irSymbolTable.introduceValueParameter(irParameter) localStorage.putParameter(firParameter, irParameter) } return this } - private fun getCachedIrFunction(function: FirFunction<*>): IrSimpleFunction? { + fun putEnumEntryClassInScope(enumEntry: FirEnumEntry, correspondingClass: IrClass) { + localStorage.putLocalClass(enumEntry.initializer as FirAnonymousObject, correspondingClass) + } + + fun getCachedIrFunction(function: FirFunction<*>): IrSimpleFunction? { return if (function !is FirSimpleFunction || function.visibility == Visibilities.LOCAL) { localStorage.getLocalFunction(function) } else { @@ -552,10 +564,9 @@ class Fir2IrDeclarationStorage( } } - private fun createIrFunction( + fun createIrFunction( function: FirFunction<*>, irParent: IrDeclarationParent?, - shouldLeaveScope: Boolean = true, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED ): IrSimpleFunction { val simpleFunction = function as? FirSimpleFunction @@ -591,9 +602,7 @@ class Fir2IrDeclarationStorage( result }.bindAndDeclareParameters(function, descriptor, irParent, isStatic = simpleFunction?.isStatic == true) - if (shouldLeaveScope) { - leaveScope(created.descriptor) - } + leaveScope(created.descriptor) if (visibility == Visibilities.LOCAL) { localStorage.putLocalFunction(function, created) return created @@ -607,33 +616,32 @@ class Fir2IrDeclarationStorage( return created } - fun getIrFunction( - function: FirFunction<*>, - irParent: IrDeclarationParent?, - shouldLeaveScope: Boolean = true, - origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED - ): IrSimpleFunction { - return getCachedIrFunction(function)?.apply { - if (!shouldLeaveScope) enterLocalScope(function) - } ?: createIrFunction(function, irParent, shouldLeaveScope, origin) + fun getCachedIrAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer): IrAnonymousInitializer? = + initializerCache[anonymousInitializer] + + fun createIrAnonymousInitializer( + anonymousInitializer: FirAnonymousInitializer, + irParent: IrClass + ): IrAnonymousInitializer { + return anonymousInitializer.convertWithOffsets { startOffset, endOffset -> + irSymbolTable.declareAnonymousInitializer(startOffset, endOffset, IrDeclarationOrigin.DEFINED, irParent.descriptor).apply { + this.parent = irParent + initializerCache[anonymousInitializer] = this + } + } } - private fun getCachedIrConstructor( - constructor: FirConstructor - ): IrConstructor? { - return constructorCache[constructor] - } + fun getCachedIrConstructor(constructor: FirConstructor): IrConstructor? = constructorCache[constructor] - private fun createIrConstructor( + fun createIrConstructor( constructor: FirConstructor, - irParent: IrDeclarationParent, - shouldLeaveScope: Boolean = true, + irParent: IrClass, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED ): IrConstructor { val descriptor = WrappedClassConstructorDescriptor() val isPrimary = constructor.isPrimary - val visibility = when { - irParent is IrClass && irParent.modality == Modality.SEALED -> Visibilities.PRIVATE + val visibility = when (irParent.modality) { + Modality.SEALED -> Visibilities.PRIVATE else -> constructor.visibility } val created = constructor.convertWithOffsets { startOffset, endOffset -> @@ -646,9 +654,7 @@ class Fir2IrDeclarationStorage( ).apply { enterScope(descriptor) }.bindAndDeclareParameters(constructor, descriptor, irParent, isStatic = true).apply { - if (shouldLeaveScope) { - leaveScope(descriptor) - } + leaveScope(descriptor) } } } @@ -656,18 +662,6 @@ class Fir2IrDeclarationStorage( return created } - fun getIrConstructor( - constructor: FirConstructor, - irParent: IrDeclarationParent, - shouldLeaveScope: Boolean = true - ): IrConstructor { - val cached = getCachedIrConstructor(constructor) - if (cached != null) { - return if (shouldLeaveScope) cached else cached.enterLocalScope(constructor) - } - return createIrConstructor(constructor, irParent, shouldLeaveScope) - } - private fun createIrPropertyAccessor( propertyAccessor: FirPropertyAccessor?, property: FirProperty, @@ -725,49 +719,48 @@ class Fir2IrDeclarationStorage( } } + fun getCachedIrEnumEntry(enumEntry: FirEnumEntry): IrEnumEntry? = enumEntryCache[enumEntry] - fun getIrEnumEntry( + fun createIrEnumEntry( enumEntry: FirEnumEntry, - irParent: IrClass? = null, + irParent: IrClass?, origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED ): IrEnumEntry { - return enumEntryCache.getOrPut(enumEntry) { - enumEntry.convertWithOffsets { startOffset, endOffset -> - val desc = WrappedEnumEntryDescriptor() - enterScope(desc) - val result = irSymbolTable.declareEnumEntry(startOffset, endOffset, origin, desc) { symbol -> - IrEnumEntryImpl( - startOffset, endOffset, origin, symbol, enumEntry.name - ).apply { - desc.bind(this) - val irType = enumEntry.returnTypeRef.toIrType() - if (irParent != null) { - this.parent = irParent - } - val initializer = enumEntry.initializer - if (initializer != null) { - initializer as FirAnonymousObject - val klass = getIrEnumEntryClass(enumEntry, initializer, irParent) + return enumEntry.convertWithOffsets { startOffset, endOffset -> + val desc = WrappedEnumEntryDescriptor() + enterScope(desc) + val result = irSymbolTable.declareEnumEntry(startOffset, endOffset, origin, desc) { symbol -> + IrEnumEntryImpl( + startOffset, endOffset, origin, symbol, enumEntry.name + ).apply { + desc.bind(this) + val irType = enumEntry.returnTypeRef.toIrType() + if (irParent != null) { + this.parent = irParent + } + val initializer = enumEntry.initializer + if (initializer != null) { + initializer as FirAnonymousObject + val klass = getIrAnonymousObjectForEnumEntry(initializer, enumEntry.name, irParent) - this.correspondingClass = klass - } else if (irParent != null) { - this.initializerExpression = IrExpressionBodyImpl( - IrEnumConstructorCallImpl(startOffset, endOffset, irType, irParent.constructors.first().symbol) - ) - } + this.correspondingClass = klass + } else if (irParent != null) { + this.initializerExpression = IrExpressionBodyImpl( + IrEnumConstructorCallImpl(startOffset, endOffset, irType, irParent.constructors.first().symbol) + ) } } - leaveScope(desc) - result } + leaveScope(desc) + enumEntryCache[enumEntry] = result + result } } - private fun createIrProperty( + fun createIrProperty( property: FirProperty, irParent: IrDeclarationParent?, - origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED, - shouldLeaveScope: Boolean = true + origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED ): IrProperty { val containerSource = property.containerSource val descriptor = containerSource?.let { WrappedPropertyDescriptorWithContainerSource(it) } ?: WrappedPropertyDescriptor() @@ -818,29 +811,13 @@ class Fir2IrDeclarationStorage( } } } - if (shouldLeaveScope) { - leaveScope(descriptor) - } + leaveScope(descriptor) propertyCache[property] = result result } } - fun getIrProperty( - property: FirProperty, - irParent: IrDeclarationParent?, - origin: IrDeclarationOrigin = IrDeclarationOrigin.DEFINED, - shouldLeaveScope: Boolean = true - ): IrProperty { - val cached = propertyCache[property] - if (cached != null) { - if (!shouldLeaveScope) { - enterScope(cached.descriptor) - } - return cached - } - return createIrProperty(property, irParent, origin, shouldLeaveScope) - } + fun getCachedIrProperty(property: FirProperty): IrProperty? = propertyCache[property] private fun createIrField(field: FirField): IrField { val descriptor = WrappedFieldDescriptor() @@ -866,7 +843,7 @@ class Fir2IrDeclarationStorage( } } - private fun createAndSaveIrParameter( + private fun createIrParameter( valueParameter: FirValueParameter, index: Int = -1, useStubForDefaultValueStub: Boolean = true, @@ -929,7 +906,7 @@ class Fir2IrDeclarationStorage( } } - fun createAndSaveIrVariable(variable: FirVariable<*>, givenOrigin: IrDeclarationOrigin? = null): IrVariable { + fun createIrVariable(variable: FirVariable<*>, irParent: IrDeclarationParent, givenOrigin: IrDeclarationOrigin? = null): IrVariable { val type = variable.returnTypeRef.toIrType() // Some temporary variables are produced in RawFirBuilder, but we consistently use special names for them. val origin = when { @@ -944,6 +921,7 @@ class Fir2IrDeclarationStorage( variable.name, type, variable.isVar, isConst = false, isLateinit = false ) } + irVariable.parent = irParent localStorage.putVariable(variable, irVariable) return irVariable } @@ -961,6 +939,7 @@ class Fir2IrDeclarationStorage( fun getIrClassSymbol(firClassSymbol: FirClassSymbol<*>): IrClassSymbol { val firClass = firClassSymbol.fir getCachedIrClass(firClass)?.let { return irSymbolTable.referenceClass(it.descriptor) } + // TODO: remove all this code and change to unbound symbol creation val irClass = createIrClass(firClass) if (firClass is FirAnonymousObject || firClass is FirRegularClass && firClass.visibility == Visibilities.LOCAL) { return irSymbolTable.referenceClass(irClass.descriptor) @@ -982,10 +961,22 @@ class Fir2IrDeclarationStorage( firTypeParameterSymbol: FirTypeParameterSymbol, typeContext: ConversionTypeContext ): IrTypeParameterSymbol { + // TODO: use cached type parameter here val irTypeParameter = getIrTypeParameter(firTypeParameterSymbol.fir, typeContext = typeContext) return irSymbolTable.referenceTypeParameter(irTypeParameter.descriptor) } + fun getIrConstructorSymbol(firConstructorSymbol: FirConstructorSymbol): IrConstructorSymbol { + val firConstructor = firConstructorSymbol.fir + getCachedIrConstructor(firConstructor)?.let { return irSymbolTable.referenceConstructor(it.descriptor) } + val irParent = findIrParent(firConstructor) as IrClass + val parentOrigin = (irParent as? IrDeclaration)?.origin ?: IrDeclarationOrigin.DEFINED + val irDeclaration = createIrConstructor(firConstructor, irParent, origin = parentOrigin).apply { + setAndModifyParent(irParent) + } + return irSymbolTable.referenceConstructor(irDeclaration.descriptor) + } + fun getIrFunctionSymbol(firFunctionSymbol: FirFunctionSymbol<*>): IrFunctionSymbol { return when (val firDeclaration = firFunctionSymbol.fir) { is FirSimpleFunction, is FirAnonymousFunction -> { @@ -998,13 +989,7 @@ class Fir2IrDeclarationStorage( irSymbolTable.referenceSimpleFunction(irDeclaration.descriptor) } is FirConstructor -> { - getCachedIrConstructor(firDeclaration)?.let { return irSymbolTable.referenceConstructor(it.descriptor) } - val irParent = findIrParent(firDeclaration)!! - val parentOrigin = (irParent as? IrDeclaration)?.origin ?: IrDeclarationOrigin.DEFINED - val irDeclaration = createIrConstructor(firDeclaration, irParent, origin = parentOrigin).apply { - setAndModifyParent(irParent) - } - irSymbolTable.referenceConstructor(irDeclaration.descriptor) + getIrConstructorSymbol(firDeclaration.symbol) } else -> throw AssertionError("Should not be here: ${firDeclaration::class.java}: ${firDeclaration.render()}") } @@ -1058,10 +1043,11 @@ class Fir2IrDeclarationStorage( fun getIrValueSymbol(firVariableSymbol: FirVariableSymbol<*>): IrSymbol { return when (val firDeclaration = firVariableSymbol.fir) { is FirEnumEntry -> { + getCachedIrEnumEntry(firDeclaration)?.let { return irSymbolTable.referenceEnumEntry(it.descriptor) } val containingFile = firProvider.getFirCallableContainerFile(firVariableSymbol) val parentClassSymbol = firVariableSymbol.callableId.classId?.let { firSymbolProvider.getClassLikeSymbolByFqName(it) } - val irParentClass = (parentClassSymbol?.fir as? FirClass<*>)?.let { getIrClass(it) } - val irEnumEntry = getIrEnumEntry( + val irParentClass = (parentClassSymbol?.fir as? FirClass<*>)?.let { getCachedIrClass(it) } + val irEnumEntry = createIrEnumEntry( firDeclaration, irParent = irParentClass, origin = if (containingFile == null) IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB else IrDeclarationOrigin.DEFINED diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrFakeOverrideGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrFakeOverrideGenerator.kt index eea0cc65783..c45289b0785 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrFakeOverrideGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrFakeOverrideGenerator.kt @@ -43,9 +43,7 @@ class Fir2IrFakeOverrideGenerator( firOverriddenSymbol: FirPropertySymbol ): IrProperty { val firOverriddenProperty = firOverriddenSymbol.fir - val overriddenProperty = declarationStorage.getIrProperty( - firOverriddenProperty, declarationStorage.findIrParent(firOverriddenProperty) - ) + val overriddenProperty = declarationStorage.getCachedIrProperty(firOverriddenProperty)!! getter?.apply { overriddenProperty.getter?.symbol?.let { overriddenSymbols = listOf(it) } } @@ -71,7 +69,7 @@ class Fir2IrFakeOverrideGenerator( if (functionSymbol.isFakeOverride) { // Substitution case val baseSymbol = functionSymbol.deepestOverriddenSymbol() as FirNamedFunctionSymbol - val irFunction = declarationStorage.getIrFunction( + val irFunction = declarationStorage.createIrFunction( // TODO: parents for functions and properties should be consistent originalFunction, declarationStorage.findIrParent(baseSymbol.fir), origin = origin ) @@ -89,7 +87,7 @@ class Fir2IrFakeOverrideGenerator( ) val fakeOverrideFunction = fakeOverrideSymbol.fir - val irFunction = declarationStorage.getIrFunction( + val irFunction = declarationStorage.createIrFunction( fakeOverrideFunction, declarationStorage.findIrParent(originalFunction), origin = origin ) val overriddenSymbol = declarationStorage.getIrFunctionSymbol(functionSymbol) as IrSimpleFunctionSymbol @@ -106,7 +104,7 @@ class Fir2IrFakeOverrideGenerator( if (propertySymbol.isFakeOverride) { // Substitution case val baseSymbol = propertySymbol.deepestOverriddenSymbol() as FirPropertySymbol - val irProperty = declarationStorage.getIrProperty( + val irProperty = declarationStorage.createIrProperty( originalProperty, irParent = this, origin = origin ) declarations += irProperty.withProperty { @@ -119,7 +117,7 @@ class Fir2IrFakeOverrideGenerator( ) val fakeOverrideProperty = fakeOverrideSymbol.fir - val irProperty = declarationStorage.getIrProperty( + val irProperty = declarationStorage.createIrProperty( fakeOverrideProperty, irParent = this, origin = origin ) declarations += irProperty.withProperty { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt index 843a60a8634..a767c75269d 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrLocalStorage.kt @@ -18,6 +18,8 @@ class Fir2IrLocalStorage { private val cacheStack = mutableListOf() + private val localClassCache = mutableMapOf, IrClass>() + fun enterCallable() { cacheStack += Fir2IrCallableCache() } @@ -44,11 +46,7 @@ class Fir2IrLocalStorage { } fun getLocalClass(localClass: FirClass<*>): IrClass? { - for (cache in cacheStack.asReversed()) { - val local = cache.getLocalClass(localClass) - if (local != null) return local - } - return null + return localClassCache[localClass] } fun getLocalFunction(localFunction: FirFunction<*>): IrSimpleFunction? { @@ -68,7 +66,7 @@ class Fir2IrLocalStorage { } fun putLocalClass(firClass: FirClass<*>, irClass: IrClass) { - cacheStack.last().putLocalClass(firClass, irClass) + localClassCache[firClass] = irClass } fun putLocalFunction(firFunction: FirFunction<*>, irFunction: IrSimpleFunction) { diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt index 12cf0970106..1e83eb5f7bd 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/Fir2IrVisitor.kt @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter -import org.jetbrains.kotlin.fir.descriptors.FirModuleDescriptor import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition import org.jetbrains.kotlin.fir.expressions.impl.FirNoReceiverExpression @@ -34,7 +33,6 @@ import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET import org.jetbrains.kotlin.ir.builders.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl -import org.jetbrains.kotlin.ir.declarations.impl.IrFileImpl import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* @@ -44,14 +42,14 @@ import org.jetbrains.kotlin.ir.util.* import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.psi2ir.PsiSourceManager import java.util.* class Fir2IrVisitor( private val session: FirSession, - private val moduleDescriptor: FirModuleDescriptor, private val symbolTable: SymbolTable, - private val sourceManager: PsiSourceManager, + private val declarationStorage: Fir2IrDeclarationStorage, + private val converter: Fir2IrConverter, + private val typeConverter: Fir2IrTypeConverter, override val irBuiltIns: IrBuiltIns, fakeOverrideMode: FakeOverrideMode ) : FirDefaultVisitor(), IrGeneratorContextInterface { @@ -63,40 +61,24 @@ class Fir2IrVisitor( private val integerApproximator = IntegerLiteralTypeApproximationTransformer(session.firSymbolProvider, session.inferenceContext) - private val declarationStorage = Fir2IrDeclarationStorage(session, symbolTable, moduleDescriptor) + private val conversionScope = Fir2IrConversionScope() - private val typeConverter = Fir2IrTypeConverter(session, declarationStorage, irBuiltIns).also { - declarationStorage.typeConverter = it - it.initBuiltinTypes() - } + private val fakeOverrideGenerator = Fir2IrFakeOverrideGenerator(session, declarationStorage, conversionScope, fakeOverrideMode) private fun FirTypeRef.toIrType(): IrType = with(typeConverter) { toIrType() } private fun ConeKotlinType.toIrType(): IrType = with(typeConverter) { toIrType() } - private val conversionScope = Fir2IrConversionScope() - private fun applyParentFromStackTo(declaration: T): T = conversionScope.applyParentFromStackTo(declaration) - private val fakeOverrideGenerator = Fir2IrFakeOverrideGenerator(session, declarationStorage, conversionScope, fakeOverrideMode) - override fun visitElement(element: FirElement, data: Any?): IrElement { TODO("Should not be here: ${element.render()}") } - fun registerFile(file: FirFile) { - val irFile = IrFileImpl( - sourceManager.getOrCreateFileEntry(file.psi as KtFile), - moduleDescriptor.getPackage(file.packageFqName).fragments.first() - ) - declarationStorage.registerFile(file, irFile) - } - override fun visitFile(file: FirFile, data: Any?): IrFile { return conversionScope.withParent(declarationStorage.getIrFile(file)) { file.declarations.forEach { - val irDeclaration = it.toIrDeclaration() ?: return@forEach - declarations += irDeclaration + it.toIrDeclaration() } annotations = file.annotations.mapNotNull { @@ -110,9 +92,14 @@ class Fir2IrVisitor( return accept(this@Fir2IrVisitor, null) as IrDeclaration } + // ================================================================================== + override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Any?): IrElement { - val irEnumEntry = declarationStorage.getIrEnumEntry(enumEntry, irParent = conversionScope.lastClass()) + val irEnumEntry = declarationStorage.getCachedIrEnumEntry(enumEntry)!! val correspondingClass = irEnumEntry.correspondingClass ?: return irEnumEntry + declarationStorage.enterScope(irEnumEntry.descriptor) + declarationStorage.putEnumEntryClassInScope(enumEntry, correspondingClass) + converter.processAnonymousObjectMembers(enumEntry.initializer as FirAnonymousObject, correspondingClass) conversionScope.withParent(correspondingClass) { setClassContent(enumEntry.initializer as FirAnonymousObject) irEnumEntry.initializerExpression = IrExpressionBodyImpl( @@ -122,25 +109,27 @@ class Fir2IrVisitor( ) ) } + declarationStorage.leaveScope(irEnumEntry.descriptor) return irEnumEntry } - private fun FirClass<*>.getPrimaryConstructorIfAny(): FirConstructor? = - declarations.filterIsInstance().firstOrNull()?.takeIf { it.isPrimary } - private fun IrClass.setClassContent(klass: FirClass<*>) { declarationStorage.enterScope(descriptor) conversionScope.withClass(this) { val primaryConstructor = klass.getPrimaryConstructorIfAny() - val irPrimaryConstructor = primaryConstructor?.accept(this@Fir2IrVisitor, null) as IrConstructor? + val irPrimaryConstructor = primaryConstructor?.let { declarationStorage.getCachedIrConstructor(it)!! } if (irPrimaryConstructor != null) { - declarations += irPrimaryConstructor + with(declarationStorage) { + enterScope(irPrimaryConstructor.descriptor) + irPrimaryConstructor.valueParameters.forEach { symbolTable.introduceValueParameter(it) } + irPrimaryConstructor.putParametersInScope(primaryConstructor) + irPrimaryConstructor.setFunctionContent(irPrimaryConstructor.descriptor, primaryConstructor) + } } val processedCallableNames = mutableListOf() klass.declarations.forEach { if (it !is FirConstructor || !it.isPrimary) { - val irDeclaration = it.toIrDeclaration() ?: return@forEach - declarations += irDeclaration + it.toIrDeclaration() ?: return@forEach when (it) { is FirSimpleFunction -> processedCallableNames += it.name is FirProperty -> processedCallableNames += it.name @@ -159,16 +148,64 @@ class Fir2IrVisitor( } override fun visitRegularClass(regularClass: FirRegularClass, data: Any?): IrElement { - return conversionScope.withParent( - applyParentFromStackTo(declarationStorage.getIrClass(regularClass)) - ) { + if (regularClass.visibility == Visibilities.LOCAL) { + val irParent = conversionScope.parentFromStack() + val irClass = declarationStorage.getCachedIrClass(regularClass)?.apply { this.parent = irParent } + if (irClass != null) { + converter.processRegisteredLocalClassAndNestedClasses(regularClass, irClass) + return conversionScope.withParent(irClass) { + setClassContent(regularClass) + } + } + converter.processLocalClassAndNestedClasses(regularClass, irParent) + } + val irClass = declarationStorage.getCachedIrClass(regularClass)!! + return conversionScope.withParent(irClass) { setClassContent(regularClass) } } + override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): IrElement { + val irParent = conversionScope.parentFromStack() + // NB: for implicit types it is possible that anonymous object is already cached + val irAnonymousObject = declarationStorage.getCachedIrClass(anonymousObject)?.apply { this.parent = irParent } + ?: declarationStorage.createIrAnonymousObject(anonymousObject, irParent = irParent) + converter.processAnonymousObjectMembers(anonymousObject, irAnonymousObject) + conversionScope.withParent(irAnonymousObject) { + setClassContent(anonymousObject) + } + val anonymousClassType = irAnonymousObject.thisReceiver!!.type + return anonymousObject.convertWithOffsets { startOffset, endOffset -> + IrBlockImpl( + startOffset, endOffset, anonymousClassType, IrStatementOrigin.OBJECT_LITERAL, + listOf( + irAnonymousObject, + IrConstructorCallImpl.fromSymbolOwner( + startOffset, + endOffset, + anonymousClassType, + irAnonymousObject.constructors.first().symbol, + irAnonymousObject.typeParameters.size, + origin = IrStatementOrigin.OBJECT_LITERAL + ) + ) + ) + } + } + + // ================================================================================== + private fun T.setFunctionContent(descriptor: FunctionDescriptor, firFunction: FirFunction<*>?): T { conversionScope.withParent(this) { if (firFunction != null) { + if (this !is IrConstructor || !this.isPrimary) { + // Scope for primary constructor should be entered before class declaration processing + with(declarationStorage) { + enterScope(descriptor) + valueParameters.forEach { symbolTable.introduceValueParameter(it) } + putParametersInScope(firFunction) + } + } for ((valueParameter, firValueParameter) in valueParameters.zip(firFunction.valueParameters)) { valueParameter.setDefaultValue(firValueParameter) } @@ -208,27 +245,18 @@ class Fir2IrVisitor( } override fun visitConstructor(constructor: FirConstructor, data: Any?): IrElement { - val irConstructor = declarationStorage.getIrConstructor( - constructor, irParent = conversionScope.lastClass()!!, shouldLeaveScope = false - ) + val irConstructor = declarationStorage.getCachedIrConstructor(constructor)!! return conversionScope.withFunction(irConstructor) { setFunctionContent(irConstructor.descriptor, constructor) } } override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Any?): IrElement { - val origin = IrDeclarationOrigin.DEFINED - val parent = conversionScope.lastClass()!! - return anonymousInitializer.convertWithOffsets { startOffset, endOffset -> - symbolTable.declareAnonymousInitializer( - startOffset, endOffset, origin, parent.descriptor - ).apply { - this.parent = parent - declarationStorage.enterScope(descriptor) - body = anonymousInitializer.body!!.convertToIrBlockBody() - declarationStorage.leaveScope(descriptor) - } - } + val irAnonymousInitializer = declarationStorage.getCachedIrAnonymousInitializer(anonymousInitializer)!! + declarationStorage.enterScope(irAnonymousInitializer.descriptor) + irAnonymousInitializer.body = anonymousInitializer.body!!.convertToIrBlockBody() + declarationStorage.leaveScope(irAnonymousInitializer.descriptor) + return irAnonymousInitializer } private fun FirDelegatedConstructorCall.toIrDelegatingConstructorCall(): IrCallWithIndexedArgumentsBase? { @@ -265,9 +293,12 @@ class Fir2IrVisitor( } override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: Any?): IrElement { - val irFunction = declarationStorage.getIrFunction( - simpleFunction, irParent = conversionScope.parent(), shouldLeaveScope = false - ) + val irFunction = if (simpleFunction.visibility == Visibilities.LOCAL) { + val irParent = conversionScope.parent() + declarationStorage.createIrFunction(simpleFunction, irParent) + } else { + declarationStorage.getCachedIrFunction(simpleFunction)!! + } return conversionScope.withFunction(irFunction) { setFunctionContent(irFunction.descriptor, simpleFunction) } @@ -275,7 +306,7 @@ class Fir2IrVisitor( override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: Any?): IrElement { return anonymousFunction.convertWithOffsets { startOffset, endOffset -> - val irFunction = declarationStorage.getIrFunction(anonymousFunction, conversionScope.parent(), shouldLeaveScope = false) + val irFunction = declarationStorage.createIrFunction(anonymousFunction, conversionScope.parent()) conversionScope.withFunction(irFunction) { setFunctionContent(irFunction.descriptor, anonymousFunction) } @@ -299,14 +330,13 @@ class Fir2IrVisitor( val isNextVariable = initializer is FirFunctionCall && initializer.resolvedNamedFunctionSymbol()?.callableId?.isIteratorNext() == true && variable.source.psi?.parent is KtForExpression - val irVariable = declarationStorage.createAndSaveIrVariable( - variable, if (isNextVariable) IrDeclarationOrigin.FOR_LOOP_VARIABLE else null + val irVariable = declarationStorage.createIrVariable( + variable, conversionScope.parentFromStack(), if (isNextVariable) IrDeclarationOrigin.FOR_LOOP_VARIABLE else null ) - return applyParentFromStackTo(irVariable).apply { - if (initializer != null) { - this.initializer = initializer.toIrExpression() - } + if (initializer != null) { + irVariable.initializer = initializer.toIrExpression() } + return irVariable } private fun IrProperty.createBackingField( @@ -373,14 +403,15 @@ class Fir2IrVisitor( annotations = property.annotations.mapNotNull { it.accept(this@Fir2IrVisitor, null) as? IrConstructorCall } - declarationStorage.leaveScope(descriptor) return this } override fun visitProperty(property: FirProperty, data: Any?): IrElement { if (property.isLocal) return visitLocalVariable(property) - val irProperty = declarationStorage.getIrProperty(property, irParent = conversionScope.parent(), shouldLeaveScope = false) - return conversionScope.withProperty(irProperty) { setPropertyContent(irProperty.descriptor, property) } + val irProperty = declarationStorage.getCachedIrProperty(property)!! + return conversionScope.withProperty(irProperty) { + setPropertyContent(irProperty.descriptor, property) + } } private fun IrFieldAccessExpression.setReceiver(declaration: IrDeclaration): IrFieldAccessExpression { @@ -400,11 +431,6 @@ class Fir2IrVisitor( isDefault: Boolean ) { conversionScope.withFunction(this) { - if (propertyAccessor != null) { - with(declarationStorage) { this@setPropertyAccessorContent.enterLocalScope(propertyAccessor) } - } else { - declarationStorage.enterScope(descriptor) - } applyParentFromStackTo(this) setFunctionContent(descriptor, propertyAccessor) if (isDefault) { @@ -518,14 +544,12 @@ class Fir2IrVisitor( val irClass = symbol.owner val fir = firSymbol?.fir as? FirClass<*> val irConstructor = fir?.getPrimaryConstructorIfAny()?.let { firConstructor -> - declarationStorage.getIrConstructor(firConstructor, irParent = irClass) - }?.apply { - this.parent = irClass + declarationStorage.getIrConstructorSymbol(firConstructor.symbol) } if (irConstructor == null) { IrErrorCallExpressionImpl(startOffset, endOffset, type, "No annotation constructor found: ${irClass.name}") } else { - IrConstructorCallImpl.fromSymbolDescriptor(startOffset, endOffset, type, irConstructor.symbol) + IrConstructorCallImpl.fromSymbolDescriptor(startOffset, endOffset, type, irConstructor) } } @@ -623,7 +647,7 @@ class Fir2IrVisitor( it is FirAnonymousObject || it is FirRegularClass && it.classKind == ClassKind.OBJECT } firClass?.convertWithOffsets { startOffset, endOffset -> - val irClass = declarationStorage.getIrClass(firClass) + val irClass = declarationStorage.getCachedIrClass(firClass)!! IrGetObjectValueImpl(startOffset, endOffset, irClass.defaultType, irClass.symbol) } } @@ -691,7 +715,7 @@ class Fir2IrVisitor( it is FirAnonymousObject || it is FirRegularClass && it.classKind == ClassKind.OBJECT } if (firObject != null) { - val irObject = declarationStorage.getIrClass(firObject) + val irObject = declarationStorage.getCachedIrClass(firObject)!! if (irObject != conversionScope.lastClass()) { return thisReceiverExpression.convertWithOffsets { startOffset, endOffset -> IrGetObjectValueImpl(startOffset, endOffset, irObject.defaultType, irObject.symbol) @@ -827,30 +851,6 @@ class Fir2IrVisitor( } } - override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: Any?): IrElement { - val anonymousClass = declarationStorage.getIrAnonymousObject(anonymousObject) - conversionScope.withParent(applyParentFromStackTo(anonymousClass)) { - setClassContent(anonymousObject) - } - val anonymousClassType = anonymousClass.thisReceiver!!.type - return anonymousObject.convertWithOffsets { startOffset, endOffset -> - IrBlockImpl( - startOffset, endOffset, anonymousClassType, IrStatementOrigin.OBJECT_LITERAL, - listOf( - anonymousClass, - IrConstructorCallImpl.fromSymbolOwner( - startOffset, - endOffset, - anonymousClassType, - anonymousClass.constructors.first().symbol, - anonymousClass.typeParameters.size, - origin = IrStatementOrigin.OBJECT_LITERAL - ) - ) - ) - } - } - // ================================================================================== private fun FirStatement.toIrStatement(): IrStatement? { @@ -1082,8 +1082,8 @@ class Fir2IrVisitor( override fun visitCatch(catch: FirCatch, data: Any?): IrElement { return catch.convertWithOffsets { startOffset, endOffset -> - val catchParameter = declarationStorage.createAndSaveIrVariable(catch.parameter) - IrCatchImpl(startOffset, endOffset, applyParentFromStackTo(catchParameter)).apply { + val catchParameter = declarationStorage.createIrVariable(catch.parameter, conversionScope.parentFromStack()) + IrCatchImpl(startOffset, endOffset, catchParameter).apply { result = catch.block.convertToIrExpressionOrBlock() } } diff --git a/compiler/testData/codegen/box/callableReference/bound/localUnitFunction.kt b/compiler/testData/codegen/box/callableReference/bound/localUnitFunction.kt index 932e8004cf0..dcb5c44738b 100644 --- a/compiler/testData/codegen/box/callableReference/bound/localUnitFunction.kt +++ b/compiler/testData/codegen/box/callableReference/bound/localUnitFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME diff --git a/compiler/testData/codegen/box/callableReference/function/getArityViaFunctionImpl.kt b/compiler/testData/codegen/box/callableReference/function/getArityViaFunctionImpl.kt index 7b2e4fd2415..2f6bbdb8022 100644 --- a/compiler/testData/codegen/box/callableReference/function/getArityViaFunctionImpl.kt +++ b/compiler/testData/codegen/box/callableReference/function/getArityViaFunctionImpl.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // IGNORE_BACKEND: JS_IR // TODO: muted automatically, investigate should it be ran for JS or not // IGNORE_BACKEND: JS, NATIVE diff --git a/compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt b/compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt index 2b360bb8c06..e58484c9479 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/closureWithSideEffect.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var result = "Fail" diff --git a/compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt b/compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt index 74940077335..5dedeb7e836 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/equalsHashCode.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // IGNORE_BACKEND: JS, JS_IR fun box(): String { diff --git a/compiler/testData/codegen/box/callableReference/function/local/extension.kt b/compiler/testData/codegen/box/callableReference/function/local/extension.kt index ff70c5a646d..3919a320e81 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/extension.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/extension.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class A fun box(): String { diff --git a/compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt b/compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt index 79d50b14ad6..43537f177e9 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/extensionToLocalClass.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { class A fun A.foo() = "OK" diff --git a/compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt b/compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt index 09175fc87ae..9cb84f4df07 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/extensionToPrimitive.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun Int.is42With(that: Int) = this + 2 * that == 42 return if ((Int::is42With)(16, 13)) "OK" else "Fail" diff --git a/compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt b/compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt index 9dbc7086074..cbbbcd219b1 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/extensionWithClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class A fun box(): String { diff --git a/compiler/testData/codegen/box/callableReference/function/local/localLocal.kt b/compiler/testData/codegen/box/callableReference/function/local/localLocal.kt index 5dfd6e60340..a34a24395b6 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/localLocal.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/localLocal.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(): String { fun bar() = "OK" diff --git a/compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt b/compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt index 57e965a874f..75ca4009a47 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/recursiveClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(until: Int): String { fun bar(x: Int): String = if (x == until) "OK" else bar(x + 1) diff --git a/compiler/testData/codegen/box/callableReference/function/local/simple.kt b/compiler/testData/codegen/box/callableReference/function/local/simple.kt index c75c6b3f1e0..789703872db 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/simple.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/simple.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo() = "OK" return (::foo)() diff --git a/compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt b/compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt index 35e698936a9..5aeb154fbdd 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/simpleClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { val result = "OK" diff --git a/compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt b/compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt index ba3d3eb7390..e45fce85e2e 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/simpleWithArg.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(s: String) = s return (::foo)("OK") diff --git a/compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt b/compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt index 9afad964667..5da17e9d5e5 100644 --- a/compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt +++ b/compiler/testData/codegen/box/callableReference/function/local/unitWithSideEffect.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR var state = 23 fun box(): String { diff --git a/compiler/testData/codegen/box/casts/functions/isFunKSmall.kt b/compiler/testData/codegen/box/casts/functions/isFunKSmall.kt index 748e850b527..68ab7d465d2 100644 --- a/compiler/testData/codegen/box/casts/functions/isFunKSmall.kt +++ b/compiler/testData/codegen/box/casts/functions/isFunKSmall.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // IGNORE_BACKEND: JS_IR // TODO: muted automatically, investigate should it be ran for JS or not // IGNORE_BACKEND: JS, NATIVE diff --git a/compiler/testData/codegen/box/classes/kt2626.kt b/compiler/testData/codegen/box/classes/kt2626.kt index d1b617af2e9..34ba1d2ad8d 100644 --- a/compiler/testData/codegen/box/classes/kt2626.kt +++ b/compiler/testData/codegen/box/classes/kt2626.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR package example2 fun box() = Context.OsType.OK.toString() diff --git a/compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt b/compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt index eaf94fe8e6c..95ba048f18e 100644 --- a/compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt +++ b/compiler/testData/codegen/box/closures/captureExtensionReceiverX2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun String.f(x: String): String { fun String.g() = { this@f + this@g }() return x.g() diff --git a/compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt b/compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt index 11f8fcc7f6f..78f9220fb50 100644 --- a/compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt +++ b/compiler/testData/codegen/box/closures/captureInSuperConstructorCall/localFunctionCapturedInLambda.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR open class Base(val fn: () -> String) fun box(): String { diff --git a/compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt b/compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt index 98de302213e..129b3ad92c8 100644 --- a/compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt +++ b/compiler/testData/codegen/box/closures/captureOuterProperty/kt4176.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR open class Z(val s: Int) { open fun a() {} } diff --git a/compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt b/compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt index e982e1afb56..ebe26220013 100644 --- a/compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt +++ b/compiler/testData/codegen/box/closures/capturedLocalGenericFun.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box() : String { fun local(s : T) : T { diff --git a/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt b/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt index ff77e20edf2..106b0a763b3 100644 --- a/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt +++ b/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFun.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun rec(n : Int) { fun x(m : Int) { diff --git a/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt b/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt index 87094e647ad..38c08c8a19d 100644 --- a/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt +++ b/compiler/testData/codegen/box/closures/closureInsideClosure/localFunInsideLocalFunDifferentSignatures.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun rec(n : Int) { fun x(m : Int, k : Int) { diff --git a/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt b/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt index a2403abcf00..e0fc6457f26 100644 --- a/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt +++ b/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevels.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(x: Int) { fun bar(y: Int) { diff --git a/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt b/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt index 1061a702845..a5fadc55936 100644 --- a/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt +++ b/compiler/testData/codegen/box/closures/closureInsideClosure/threeLevelsDifferentSignatures.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(x: Int, s: String): String { fun bar(y: Int) { diff --git a/compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt b/compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt index aa93b03030e..ec2ea57118e 100644 --- a/compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt +++ b/compiler/testData/codegen/box/closures/closureInsideClosure/varAsFunInsideLocalFun.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR //KT-3276 fun box(): String { diff --git a/compiler/testData/codegen/box/closures/kt3905.kt b/compiler/testData/codegen/box/closures/kt3905.kt index 839108da438..fafd87700d3 100644 --- a/compiler/testData/codegen/box/closures/kt3905.kt +++ b/compiler/testData/codegen/box/closures/kt3905.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box() : String { fun foo(t:() -> T) : T = t() diff --git a/compiler/testData/codegen/box/closures/kt5589.kt b/compiler/testData/codegen/box/closures/kt5589.kt index a0802a7c8d0..3b3a27d91ca 100644 --- a/compiler/testData/codegen/box/closures/kt5589.kt +++ b/compiler/testData/codegen/box/closures/kt5589.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { val x = "OK" fun bar(y: String = x): String = y diff --git a/compiler/testData/codegen/box/closures/localClassFunClosure.kt b/compiler/testData/codegen/box/closures/localClassFunClosure.kt index 6c81a8ea1f6..ba0ae9734a0 100644 --- a/compiler/testData/codegen/box/closures/localClassFunClosure.kt +++ b/compiler/testData/codegen/box/closures/localClassFunClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { val o = "O" fun ok() = o + "K" diff --git a/compiler/testData/codegen/box/closures/localFunctionInFunction.kt b/compiler/testData/codegen/box/closures/localFunctionInFunction.kt index 16e1bedf028..4639ab437dd 100644 --- a/compiler/testData/codegen/box/closures/localFunctionInFunction.kt +++ b/compiler/testData/codegen/box/closures/localFunctionInFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun local():Int { diff --git a/compiler/testData/codegen/box/closures/localFunctionInInitializer.kt b/compiler/testData/codegen/box/closures/localFunctionInInitializer.kt index 4507ecdcc69..6035aac60ad 100644 --- a/compiler/testData/codegen/box/closures/localFunctionInInitializer.kt +++ b/compiler/testData/codegen/box/closures/localFunctionInInitializer.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun local():Int { diff --git a/compiler/testData/codegen/box/closures/localGenericFun.kt b/compiler/testData/codegen/box/closures/localGenericFun.kt index 993b1bbee77..fe55a5834b5 100644 --- a/compiler/testData/codegen/box/closures/localGenericFun.kt +++ b/compiler/testData/codegen/box/closures/localGenericFun.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box() : String { fun local(s : T) : T { diff --git a/compiler/testData/codegen/box/closures/recursiveClosure.kt b/compiler/testData/codegen/box/closures/recursiveClosure.kt index 5314a540b35..25c8a6a86ce 100644 --- a/compiler/testData/codegen/box/closures/recursiveClosure.kt +++ b/compiler/testData/codegen/box/closures/recursiveClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(s: String): String { fun bar(count: Int): String = if (count == 0) s else bar(count - 1) diff --git a/compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt b/compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt index 0ae9030fa9e..b36c14dd409 100644 --- a/compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt +++ b/compiler/testData/codegen/box/coroutines/featureIntersection/callableReference/function/local/equalsHashCode.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // IGNORE_BACKEND: JS, JS_IR // WITH_RUNTIME diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt index cf45378de95..bfb7320b4f7 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveInnerFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // DONT_RUN_GENERATED_CODE: JS fun test() { diff --git a/compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt b/compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt index 4af40939562..8171865caed 100644 --- a/compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt +++ b/compiler/testData/codegen/box/enum/enumInheritedFromTrait.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR package test fun box() = MyEnum.E1.f() + MyEnum.E2.f() diff --git a/compiler/testData/codegen/box/enum/inclassobj.kt b/compiler/testData/codegen/box/enum/inclassobj.kt index bf6a6019a71..5006013d4b7 100644 --- a/compiler/testData/codegen/box/enum/inclassobj.kt +++ b/compiler/testData/codegen/box/enum/inclassobj.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box() = if(Context.operatingSystemType == Context.Companion.OsType.OTHER) "OK" else "fail" public class Context diff --git a/compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt b/compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt index 1f3e05f80f2..4f5e5ce5bda 100644 --- a/compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt +++ b/compiler/testData/codegen/box/enum/kt7257_anonObjectMethod.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR enum class X { B { val value2 = "K" diff --git a/compiler/testData/codegen/box/extensionFunctions/kt1953.kt b/compiler/testData/codegen/box/extensionFunctions/kt1953.kt index da2ccce360b..4db9260f942 100644 --- a/compiler/testData/codegen/box/extensionFunctions/kt1953.kt +++ b/compiler/testData/codegen/box/extensionFunctions/kt1953.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // KJS_WITH_FULL_RUNTIME fun box(): String { val sb = StringBuilder() diff --git a/compiler/testData/codegen/box/extensionFunctions/kt5467.kt b/compiler/testData/codegen/box/extensionFunctions/kt5467.kt index 5ce661487d0..5d5ab0473a5 100644 --- a/compiler/testData/codegen/box/extensionFunctions/kt5467.kt +++ b/compiler/testData/codegen/box/extensionFunctions/kt5467.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun String.foo() : String { fun Int.bar() : String { fun Long.baz() : String { diff --git a/compiler/testData/codegen/box/functions/kt2280.kt b/compiler/testData/codegen/box/functions/kt2280.kt index 7e3c85bff55..79debb72bdf 100644 --- a/compiler/testData/codegen/box/functions/kt2280.kt +++ b/compiler/testData/codegen/box/functions/kt2280.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun rmrf(i: Int) { if (i > 0) rmrf(i - 1) diff --git a/compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt b/compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt index 1d3cdf8d171..a59a7507800 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/callInlineLocalInLambda.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // WITH_RUNTIME import kotlin.test.assertEquals diff --git a/compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt b/compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt index 98dadda9421..628728199a3 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/captureUpperBoundedTypeParameter.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun f(x: V): V { fun g(y: V) = y return g(x) diff --git a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt index 93e6ff56a42..935d8b4963c 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambda.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // WITH_RUNTIME import kotlin.test.assertEquals diff --git a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt index 2c8ed00194c..6609be78133 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage1.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // WITH_RUNTIME import kotlin.test.assertEquals diff --git a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt index fcc98fd91f6..158e845f9ad 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/definedWithinLambdaInnerUsage2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // WITH_RUNTIME import kotlin.test.assertEquals diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt2895.kt b/compiler/testData/codegen/box/functions/localFunctions/kt2895.kt index 133f3a5acab..76db2bdc71e 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt2895.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt2895.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun outer() { fun inner(i: Int) { if (i > 0){ diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt3308.kt b/compiler/testData/codegen/box/functions/localFunctions/kt3308.kt index cd75165a8ce..b97dfa7fb79 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt3308.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt3308.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(t: T) = t diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt3978.kt b/compiler/testData/codegen/box/functions/localFunctions/kt3978.kt index 715ed4eb695..71295ca6f4c 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt3978.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt3978.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box() : String { fun local(i: Int = 1) : Int { return i diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt b/compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt index 491d42dc17e..603a93a2951 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt3978_2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class C() { fun box(): Int { fun local(i: Int = 1): Int { diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt4119.kt b/compiler/testData/codegen/box/functions/localFunctions/kt4119.kt index ddd7efc4927..746e41ee392 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt4119.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt4119.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(f: (Int?) -> Int): Int { return f(0) } diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt b/compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt index 1a77a30c7f1..edb647f84a9 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt4119_2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { infix fun Int.foo(a: Int): Int = a + 2 diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt4514.kt b/compiler/testData/codegen/box/functions/localFunctions/kt4514.kt index 18220e33f0c..c767d3f0352 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt4514.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt4514.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun String.f() = this val vf: String.() -> String = { this } diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt4783.kt b/compiler/testData/codegen/box/functions/localFunctions/kt4783.kt index c661deeceb5..5d5d9d55f6a 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt4783.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt4783.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class T(val value: Int) { } diff --git a/compiler/testData/codegen/box/functions/localFunctions/kt4989.kt b/compiler/testData/codegen/box/functions/localFunctions/kt4989.kt index 80b43779e26..e4cee2aa56f 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/kt4989.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/kt4989.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class It(val id: String) fun box(): String { diff --git a/compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt b/compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt index 87fb2bcdac8..df58363773a 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/localFunctionVsLocalVariable.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var s = "" var foo = "O" diff --git a/compiler/testData/codegen/box/functions/localFunctions/nameClash.kt b/compiler/testData/codegen/box/functions/localFunctions/nameClash.kt index 2374fe33694..f82797d9010 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/nameClash.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/nameClash.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun test(b: Boolean): String { if (b) { diff --git a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt index d9564999523..078f029fe75 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunWithoutClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { fun foo(x: String) = x fun foo() = foo("K") diff --git a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt index ef690f66193..6e349f27ae9 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var s = "" diff --git a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt index 843cc350fbf..79645a8716d 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction1.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var s = "" var foo = "K" diff --git a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt index 5c244b771a8..1cf01ce4e21 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var s = "" var foo = "K" diff --git a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt index 01352d2a9bd..9504e6ebfac 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/overloadedLocalFunction3.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var s = "" var foo = "O" diff --git a/compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt b/compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt index 9c42ee1c814..e90fe97fede 100644 --- a/compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt +++ b/compiler/testData/codegen/box/functions/localFunctions/parameterAsDefaultValue.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(): String { fun bar(x: String, y: String = x): String { return y diff --git a/compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt b/compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt index 82332c0a633..69bd1f5338d 100644 --- a/compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt +++ b/compiler/testData/codegen/box/functions/typeParametersInLocalFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class Holder(val v: T) diff --git a/compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt b/compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt index 9d0692f206b..486df9872db 100644 --- a/compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt +++ b/compiler/testData/codegen/box/ir/closureConversion/closureConversion1.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(x: String): String { fun bar(y: String) = x + y return bar("K") diff --git a/compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt b/compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt index f87778b647f..806aad1fa65 100644 --- a/compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt +++ b/compiler/testData/codegen/box/ir/closureConversion/closureConversion2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(x: X): String { fun bar(y: Y) = x.toString() + y.toString() diff --git a/compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt b/compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt index bb6727c56e6..7f0e7d4647b 100644 --- a/compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt +++ b/compiler/testData/codegen/box/ir/closureConversion/closureConversion3.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun foo(x: String): String { fun bar(y: String): String { fun qux(z: String): String = diff --git a/compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt b/compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt index c413ed82076..aa59458d534 100644 --- a/compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt +++ b/compiler/testData/codegen/box/ir/closureConversion/closureConversion4.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun String.foo(): String { fun bar(y: String) = this + y return bar("K") diff --git a/compiler/testData/codegen/box/ir/closureConversion/mutable1.kt b/compiler/testData/codegen/box/ir/closureConversion/mutable1.kt index f9ec5e0255c..6eb6bb71ff7 100644 --- a/compiler/testData/codegen/box/ir/closureConversion/mutable1.kt +++ b/compiler/testData/codegen/box/ir/closureConversion/mutable1.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var result = "" fun add(s: String) { diff --git a/compiler/testData/codegen/box/jvmName/multifileClassWithLocalGeneric.kt b/compiler/testData/codegen/box/jvmName/multifileClassWithLocalGeneric.kt index af304e9ff40..334fd082b2a 100644 --- a/compiler/testData/codegen/box/jvmName/multifileClassWithLocalGeneric.kt +++ b/compiler/testData/codegen/box/jvmName/multifileClassWithLocalGeneric.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME diff --git a/compiler/testData/codegen/box/labels/labeledDeclarations.kt b/compiler/testData/codegen/box/labels/labeledDeclarations.kt index 5e93b07a517..5b407c979fb 100644 --- a/compiler/testData/codegen/box/labels/labeledDeclarations.kt +++ b/compiler/testData/codegen/box/labels/labeledDeclarations.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR data class A(val a: Int, val b: Int) fun box() : String diff --git a/compiler/testData/codegen/box/localClasses/kt4174.kt b/compiler/testData/codegen/box/localClasses/kt4174.kt index bd834c3edcc..56a73053979 100644 --- a/compiler/testData/codegen/box/localClasses/kt4174.kt +++ b/compiler/testData/codegen/box/localClasses/kt4174.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR open class C(val s: String) { fun test(): String { return s diff --git a/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt b/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt index d5a0fe9d180..2200b560d4a 100644 --- a/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt +++ b/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass1.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var x = "" diff --git a/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt b/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt index 2b738faba6d..b3553b16847 100644 --- a/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt +++ b/compiler/testData/codegen/box/localClasses/recaptureVarCapturedInLocalClass2.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var x = "" diff --git a/compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt b/compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt index b096649b29a..91dfb1d7eb5 100644 --- a/compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt +++ b/compiler/testData/codegen/box/multiDecl/ValCapturedInLocalFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class A { operator fun component1() = 1 operator fun component2() = 2 diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt index f3266d6c146..87bbe826f4e 100644 --- a/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/multipleCompanionsWithAccessors/fromAnonymousObjectInNestedClass.kt @@ -1,5 +1,4 @@ // !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField -// IGNORE_BACKEND_FIR: JVM_IR // FILE: fromAnonymousObjectInNestedClass.kt import outer.* diff --git a/compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt b/compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt index 365b82b6bf0..0841ff513e0 100644 --- a/compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt +++ b/compiler/testData/codegen/box/objects/companionObjectAccess/privateCompanionObjectAccessedFromAnonymousObjectInNestedClass.kt @@ -1,5 +1,4 @@ // !LANGUAGE: +ProperVisibilityForCompanionObjectInstanceField -// IGNORE_BACKEND_FIR: JVM_IR class Outer { private companion object { diff --git a/compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt b/compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt index 9490139313d..f21c93edf75 100644 --- a/compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt +++ b/compiler/testData/codegen/box/objects/objectInLocalAnonymousObject.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { var boo = "OK" var foo = object { diff --git a/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt b/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt index 48544b52c83..49e19260616 100644 --- a/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt +++ b/compiler/testData/codegen/box/objects/objectLiteralInClosure.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR package p private class C(val y: Int) { diff --git a/compiler/testData/codegen/box/objects/receiverInConstructor.kt b/compiler/testData/codegen/box/objects/receiverInConstructor.kt index 0d19b7c3c13..b3b7a3dcb57 100644 --- a/compiler/testData/codegen/box/objects/receiverInConstructor.kt +++ b/compiler/testData/codegen/box/objects/receiverInConstructor.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR open class A(open val v: String) fun A.a(newv: String) = object: A("fail") { diff --git a/compiler/testData/codegen/box/operatorConventions/kt4987.kt b/compiler/testData/codegen/box/operatorConventions/kt4987.kt index 8ea47f84d77..ed28874dbbc 100644 --- a/compiler/testData/codegen/box/operatorConventions/kt4987.kt +++ b/compiler/testData/codegen/box/operatorConventions/kt4987.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR fun box(): String { operator fun Int?.inc() = (this ?: 0) + 1 var counter: Int? = null diff --git a/compiler/testData/codegen/box/parametersMetadata/superParams.kt b/compiler/testData/codegen/box/parametersMetadata/superParams.kt index 09e074db9b0..3441bcdde9f 100644 --- a/compiler/testData/codegen/box/parametersMetadata/superParams.kt +++ b/compiler/testData/codegen/box/parametersMetadata/superParams.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // SKIP_JDK6 // TARGET_BACKEND: JVM // WITH_RUNTIME diff --git a/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalFunction.kt b/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalFunction.kt index 2a34e74bb01..afbcf6c3ec5 100644 --- a/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalFunction.kt +++ b/compiler/testData/codegen/box/reflection/enclosing/lambdaInLocalFunction.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_REFLECT diff --git a/compiler/testData/codegen/box/regressions/kt3850.kt b/compiler/testData/codegen/box/regressions/kt3850.kt index 953fdfa0c58..03acfce7df7 100644 --- a/compiler/testData/codegen/box/regressions/kt3850.kt +++ b/compiler/testData/codegen/box/regressions/kt3850.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR private class One { val a1 = arrayOf( object { val fy = "text"} diff --git a/compiler/testData/codegen/box/regressions/kt3903.kt b/compiler/testData/codegen/box/regressions/kt3903.kt index fbc1f3b71ea..1d08051cded 100644 --- a/compiler/testData/codegen/box/regressions/kt3903.kt +++ b/compiler/testData/codegen/box/regressions/kt3903.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR class Foo { fun bar(): String { fun foo(t:() -> T) : T = t() diff --git a/compiler/testData/codegen/box/synchronized/exceptionInMonitorExpression.kt b/compiler/testData/codegen/box/synchronized/exceptionInMonitorExpression.kt index 1f6da529e37..cf4ade8b111 100644 --- a/compiler/testData/codegen/box/synchronized/exceptionInMonitorExpression.kt +++ b/compiler/testData/codegen/box/synchronized/exceptionInMonitorExpression.kt @@ -1,4 +1,3 @@ -// IGNORE_BACKEND_FIR: JVM_IR // TARGET_BACKEND: JVM // WITH_RUNTIME diff --git a/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.txt b/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.txt index b1023a2c0d6..533fbe4fdf4 100644 --- a/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.txt +++ b/compiler/testData/ir/irText/expressions/funInterface/partialSam.fir.txt @@ -108,7 +108,7 @@ FILE fqName: fileName:/partialSam.kt BLOCK_BODY CALL 'public final fun runConversion (f1: .Fn, f2: .Fn): kotlin.Int declared in .J' type=kotlin.Int origin=null $this: GET_VAR 'j: .J declared in .test' type=.J origin=null - f1: CALL 'public final fun (): .fsi. declared in ' type=. origin=GET_PROPERTY + f1: CALL 'public final fun (): .fsi. declared in ' type=.fsi. origin=GET_PROPERTY f2: FUN_EXPR type=kotlin.Function3 origin=LAMBDA FUN LOCAL_FUNCTION_FOR_LAMBDA name: visibility:local modality:FINAL <> (s:kotlin.String, i:kotlin.Int, ti:kotlin.Int) returnType:kotlin.String VALUE_PARAMETER name:s index:0 type:kotlin.String @@ -127,4 +127,4 @@ FILE fqName: fileName:/partialSam.kt BLOCK_BODY RETURN type=kotlin.Nothing from='local final fun (s: kotlin.String, i: kotlin.Int, ts: kotlin.String): kotlin.Int declared in .test' CONST Int type=kotlin.Int value=1 - f2: CALL 'public final fun (): .fis. declared in ' type=. origin=GET_PROPERTY + f2: CALL 'public final fun (): .fis. declared in ' type=.fis. origin=GET_PROPERTY diff --git a/compiler/testData/ir/irText/lambdas/localFunction.fir.txt b/compiler/testData/ir/irText/lambdas/localFunction.fir.txt index cb5b7f6fe03..1f76bebefaf 100644 --- a/compiler/testData/ir/irText/lambdas/localFunction.fir.txt +++ b/compiler/testData/ir/irText/lambdas/localFunction.fir.txt @@ -11,4 +11,4 @@ FILE fqName: fileName:/localFunction.kt CALL 'public final fun inc (): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=null $this: GET_VAR 'val tmp_0: kotlin.Int [val] declared in .outer.local' type=kotlin.Int origin=null GET_VAR 'val tmp_0: kotlin.Int [val] declared in .outer.local' type=kotlin.Int origin=null - CALL 'local final fun local (): kotlin.Unit declared in ' type=kotlin.Unit origin=null + CALL 'local final fun local (): kotlin.Unit declared in .outer' type=kotlin.Unit origin=null