diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt index 3fc2b6efeda..d4f721d14a5 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/EnumClassLowering.kt @@ -187,7 +187,7 @@ class EnumClassLowering(val context: JvmBackendContext) : ClassLoweringPass { enumEntriesByField[fieldPropertyDescriptor] = enumEntry.descriptor enumEntryFields.add(fieldPropertyDescriptor) - val enumEntryInitializer = enumEntry.initializerExpression + val enumEntryInitializer = enumEntry.initializerExpression!! return IrFieldImpl( enumEntry.startOffset, enumEntry.endOffset, JvmLoweredDeclarationOrigin.FIELD_FOR_ENUM_ENTRY, fieldPropertyDescriptor, diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt index 9afd026d399..01f4630d716 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/lower/SyntheticAccessorLowering.kt @@ -139,7 +139,7 @@ class SyntheticAccessorLowering(val state: GenerationState) : FileLoweringPass, UNDEFINED_OFFSET, UNDEFINED_OFFSET, JvmLoweredDeclarationOrigin.SYNTHETIC_ACCESSOR, accessorDescriptor, body ) - val calleeDescriptor = accessor.calleeDescriptor + val calleeDescriptor = accessor.calleeDescriptor as FunctionDescriptor val returnExpr = IrCallImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, calleeDescriptor) copyAllArgsToValueParams(returnExpr, accessorDescriptor) body.statements.add(IrReturnImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, accessor, returnExpr)) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt index 2baaee697ea..0af859198b8 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/CallGenerator.kt @@ -90,8 +90,10 @@ class CallGenerator(statementGenerator: StatementGenerator): StatementGeneratorE ) = @Suppress("DEPRECATION") if (descriptor is LocalVariableDescriptor && descriptor.isDelegated) { - val getter = context.symbolTable.referenceFunction(descriptor.getter!!) - IrCallImpl(startOffset, endOffset, descriptor.type, getter, typeArguments, origin ?: IrStatementOrigin.GET_LOCAL_PROPERTY) + val getterDescriptor = descriptor.getter!! + val getterSymbol = context.symbolTable.referenceFunction(getterDescriptor.original) + IrCallImpl(startOffset, endOffset, descriptor.type, getterSymbol, getterDescriptor, + typeArguments, origin ?: IrStatementOrigin.GET_LOCAL_PROPERTY) } else IrGetValueImpl(startOffset, endOffset, context.symbolTable.referenceValue(descriptor), origin) @@ -100,7 +102,7 @@ class CallGenerator(statementGenerator: StatementGenerator): StatementGeneratorE call.callReceiver.call { dispatchReceiver, extensionReceiver -> val descriptor = call.descriptor as? ClassConstructorDescriptor ?: throw AssertionError("Class constructor expected: ${call.descriptor}") - val constructorSymbol = context.symbolTable.referenceConstructor(descriptor) + val constructorSymbol = context.symbolTable.referenceConstructor(descriptor.original) val irCall = IrDelegatingConstructorCallImpl(startOffset, endOffset, constructorSymbol, getTypeArguments(call.original)) irCall.dispatchReceiver = dispatchReceiver?.load() irCall.extensionReceiver = extensionReceiver?.load() @@ -158,20 +160,21 @@ class CallGenerator(statementGenerator: StatementGenerator): StatementGeneratorE } private fun generateFunctionCall( - descriptor: FunctionDescriptor, + functionDescriptor: FunctionDescriptor, startOffset: Int, endOffset: Int, origin: IrStatementOrigin?, call: CallBuilder ): IrExpression = call.callReceiver.call { dispatchReceiverValue, extensionReceiverValue -> - val returnType = descriptor.returnType!! - val functionSymbol = context.symbolTable.referenceFunction(descriptor) + val returnType = functionDescriptor.returnType!! + val functionSymbol = context.symbolTable.referenceFunction(functionDescriptor.original) val superQualifierSymbol = call.superQualifier?.let { context.symbolTable.referenceClass(it) } val irCall = IrCallImpl( startOffset, endOffset, returnType, functionSymbol, + functionDescriptor, getTypeArguments(call.original), origin, superQualifierSymbol diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt index 7abd3595f7c..e8d5deb1aa8 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ClassGenerator.kt @@ -210,7 +210,7 @@ class ClassGenerator(declarationGenerator: DeclarationGenerator) : DeclarationGe val endOffset = irDelegate.endOffset val irBlockBody = IrBlockBodyImpl(startOffset, endOffset) val returnType = overridden.returnType!! - val irCall = IrCallImpl(startOffset, endOffset, returnType, context.symbolTable.referenceFunction(overridden), null) + val irCall = IrCallImpl(startOffset, endOffset, returnType, context.symbolTable.referenceFunction(overridden.original), overridden, null) irCall.dispatchReceiver = IrGetFieldImpl( startOffset, endOffset, irDelegate.symbol, diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt index a671448e4b0..60cef947b3c 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DeclarationGenerator.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.psi2ir.generators import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrErrorDeclarationImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrFieldImpl import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl import org.jetbrains.kotlin.ir.declarations.impl.IrTypeAliasImpl import org.jetbrains.kotlin.ir.expressions.IrExpressionBody @@ -114,7 +115,12 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { IrDeclarationOrigin.FAKE_OVERRIDE, false, propertyDescriptor, - null, + if (propertyDescriptor.getter == null) + context.symbolTable.declareField( + ktElement.startOffsetOrUndefined, ktElement.endOffsetOrUndefined, IrDeclarationOrigin.FAKE_OVERRIDE, + propertyDescriptor + ) + else null, propertyDescriptor.getter?.let { generateFakeOverrideFunction(it, ktElement) }, propertyDescriptor.setter?.let { generateFakeOverrideFunction(it, ktElement) } ) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt index 47a6e50b206..e257bed9a75 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/DelegatedPropertyGenerator.kt @@ -113,18 +113,18 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D kPropertyType: KotlinType, ktDelegate: KtPropertyDelegate ): IrField { - val irActualDelegateInitializer = generateInitializerBodyForPropertyDelegate( - propertyDescriptor, kPropertyType, ktDelegate, - context.symbolTable.referenceField(propertyDescriptor) - ) - - val delegateType = irActualDelegateInitializer.expression.type + val delegateType = getDelegatedPropertyDelegateType(propertyDescriptor, ktDelegate) val delegateDescriptor = createPropertyDelegateDescriptor(propertyDescriptor, delegateType, kPropertyType) return context.symbolTable.declareField( ktDelegate.startOffset, ktDelegate.endOffset, IrDeclarationOrigin.DELEGATE, - delegateDescriptor, irActualDelegateInitializer - ) + delegateDescriptor + ).also { irDelegate -> + irDelegate.initializer = generateInitializerBodyForPropertyDelegate( + propertyDescriptor, kPropertyType, ktDelegate, + irDelegate.symbol + ) + } } private fun generateInitializerBodyForPropertyDelegate( @@ -257,7 +257,7 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D kPropertyType: KotlinType, scopeOwner: IrSymbol ): IrVariable { - val delegateType = getLocalDelegatedPropertyDelegateType(variableDescriptor, ktDelegate) + val delegateType = getDelegatedPropertyDelegateType(variableDescriptor, ktDelegate) val delegateDescriptor = createLocalPropertyDelegatedDescriptor(variableDescriptor, delegateType, kPropertyType) return context.symbolTable.declareVariable( @@ -272,11 +272,11 @@ class DelegatedPropertyGenerator(declarationGenerator: DeclarationGenerator) : D } } - private fun getLocalDelegatedPropertyDelegateType( - variableDescriptor: VariableDescriptorWithAccessors, + private fun getDelegatedPropertyDelegateType( + delegatedPropertyDescriptor: VariableDescriptorWithAccessors, ktDelegate: KtPropertyDelegate ): KotlinType { - val provideDelegateResolvedCall = get(BindingContext.PROVIDE_DELEGATE_RESOLVED_CALL, variableDescriptor) + val provideDelegateResolvedCall = get(BindingContext.PROVIDE_DELEGATE_RESOLVED_CALL, delegatedPropertyDescriptor) return if (provideDelegateResolvedCall != null) provideDelegateResolvedCall.resultingDescriptor.returnType!! else diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt index 3958981dd41..70e7b4d5b84 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/FunctionGenerator.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.psi2ir.generators +import com.sun.org.apache.xpath.internal.operations.Mod import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.IrBlockBody @@ -114,11 +115,14 @@ class FunctionGenerator(declarationGenerator: DeclarationGenerator) : Declaratio } private fun generateDefaultAccessorBody(ktProperty: KtElement, accessor: PropertyAccessorDescriptor, irAccessor: IrSimpleFunction) = - when (accessor) { - is PropertyGetterDescriptor -> generateDefaultGetterBody(ktProperty, accessor, irAccessor) - is PropertySetterDescriptor -> generateDefaultSetterBody(ktProperty, accessor, irAccessor) - else -> throw AssertionError("Should be getter or setter: $accessor") - } + if (accessor.modality == Modality.ABSTRACT) + null + else + when (accessor) { + is PropertyGetterDescriptor -> generateDefaultGetterBody(ktProperty, accessor, irAccessor) + is PropertySetterDescriptor -> generateDefaultSetterBody(ktProperty, accessor, irAccessor) + else -> throw AssertionError("Should be getter or setter: $accessor") + } private fun generateDefaultGetterBody(ktProperty: KtElement, getter: PropertyGetterDescriptor, irAccessor: IrSimpleFunction): IrBlockBody { val property = getter.correspondingProperty diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt index 43610576d78..36f30578c26 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/GeneratorContext.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.psi2ir.generators import org.jetbrains.kotlin.builtins.ReflectionTypes import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.ir.builders.IrGeneratorContext +import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.psi2ir.Psi2IrConfiguration import org.jetbrains.kotlin.psi2ir.PsiSourceManager diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt index 2a236fbc161..5f9126bb873 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/LocalClassGenerator.kt @@ -49,7 +49,9 @@ class LocalClassGenerator(statementGenerator: StatementGenerator): StatementGene IrCallImpl( ktObjectLiteral.startOffset, ktObjectLiteral.endOffset, objectLiteralType, context.symbolTable.referenceConstructor(objectConstructor), - null, IrStatementOrigin.OBJECT_LITERAL + objectConstructor, + null, + IrStatementOrigin.OBJECT_LITERAL ) ) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleDependenciesGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleDependenciesGenerator.kt new file mode 100644 index 00000000000..e031b2bf5e4 --- /dev/null +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleDependenciesGenerator.kt @@ -0,0 +1,202 @@ +/* + * Copyright 2010-2017 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.psi2ir.generators + +import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.ir.UNDEFINED_OFFSET +import org.jetbrains.kotlin.ir.declarations.* +import org.jetbrains.kotlin.ir.declarations.impl.IrModuleFragmentImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrPropertyImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrTypeParameterImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrValueParameterImpl +import org.jetbrains.kotlin.ir.descriptors.IrDeclarationStubBuilder +import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.resolve.DescriptorUtils +import org.jetbrains.kotlin.resolve.scopes.MemberScope + +class ModuleDependenciesGenerator(override val context: GeneratorContext) : Generator { + private class DependenciesCollector { + private val modulesForDependencyDescriptors = LinkedHashSet() + private val packageFragmentsForDependencyDescriptors = LinkedHashMap>() + private val topLevelDescriptors = LinkedHashMap>() + + val dependencyModules: Collection get() = modulesForDependencyDescriptors + + fun getPackageFragments(moduleDescriptor: ModuleDescriptor): Collection = + packageFragmentsForDependencyDescriptors[moduleDescriptor] ?: emptyList() + + fun getTopLevelDescriptors(packageFragmentDescriptor: PackageFragmentDescriptor): Collection = + topLevelDescriptors[packageFragmentDescriptor] ?: emptyList() + + fun collectTopLevelDescriptorsForUnboundSymbols(symbolTable: SymbolTable) { + assert(symbolTable.unboundTypeParameters.isEmpty()) { "Unbound type parameters: ${symbolTable.unboundTypeParameters}" } + assert(symbolTable.unboundValueParameters.isEmpty()) { "Unbound value parameters: ${symbolTable.unboundValueParameters}" } + assert(symbolTable.unboundVariables.isEmpty()) { "Unbound variables: ${symbolTable.unboundVariables}" } + + symbolTable.unboundClasses.addTopLevelDeclarations() + symbolTable.unboundConstructors.addTopLevelDeclarations() + symbolTable.unboundEnumEntries.addTopLevelDeclarations() + symbolTable.unboundFields.addTopLevelDeclarations() + symbolTable.unboundSimpleFunctions.addTopLevelDeclarations() + } + + private fun Collection.addTopLevelDeclarations() { + forEach { addTopLevelDeclaration(it) } + } + + fun addTopLevelDeclaration(symbol: IrSymbol) { + val descriptor = symbol.descriptor + val topLevelDeclaration = getTopLevelDeclaration(descriptor) + addTopLevelDescriptor(topLevelDeclaration) + } + + private fun getTopLevelDeclaration(descriptor: DeclarationDescriptor): DeclarationDescriptor { + val containingDeclaration = descriptor.containingDeclaration + return when (containingDeclaration) { + is PackageFragmentDescriptor -> descriptor + is ClassDescriptor -> getTopLevelDeclaration(containingDeclaration) + else -> throw AssertionError("Package or class expected: $containingDeclaration") + } + } + + private fun addTopLevelDescriptor(descriptor: DeclarationDescriptor) { + val packageFragmentDescriptor = DescriptorUtils.getParentOfType(descriptor, PackageFragmentDescriptor::class.java)!! + + val moduleDescriptor = packageFragmentDescriptor.containingDeclaration + modulesForDependencyDescriptors.add(moduleDescriptor) + + packageFragmentsForDependencyDescriptors.getOrPut(moduleDescriptor) { LinkedHashSet() }.add(packageFragmentDescriptor) + topLevelDescriptors.getOrPut(packageFragmentDescriptor) { LinkedHashSet() }.add(descriptor) + } + } + + fun generateUnboundSymbolsAsDependencies(irModule: IrModuleFragment) { + val collector = DependenciesCollector() + collector.collectTopLevelDescriptorsForUnboundSymbols(context.symbolTable) + + collector.dependencyModules.mapTo(irModule.dependencyModules) { moduleDescriptor -> + generateModuleStub(collector, moduleDescriptor) + } + } + + private fun generateModuleStub(collector: DependenciesCollector, moduleDescriptor: ModuleDescriptor): IrModuleFragmentImpl = + IrModuleFragmentImpl(moduleDescriptor, context.irBuiltIns).also { irDependencyModule -> + collector.getPackageFragments(moduleDescriptor).mapTo(irDependencyModule.externalPackageFragments) { packageFragmentDescriptor -> + generatePackageStub(packageFragmentDescriptor, collector.getTopLevelDescriptors(packageFragmentDescriptor)) + } + } + + private fun generatePackageStub(packageFragmentDescriptor: PackageFragmentDescriptor, topLevelDescriptors: Collection): IrExternalPackageFragment = + context.symbolTable.declareExternalPackageFragment(packageFragmentDescriptor).also { irExternalPackageFragment -> + topLevelDescriptors.mapTo(irExternalPackageFragment.declarations) { + generateStub(it) + } + } + + private fun generateStub(descriptor: DeclarationDescriptor): IrDeclaration = + when (descriptor) { + is ClassDescriptor -> + if (DescriptorUtils.isEnumEntry(descriptor)) + generateEnumEntryStub(descriptor) + else + generateClassStub(descriptor) + is ClassConstructorDescriptor -> + generateConstructorStub(descriptor) + is FunctionDescriptor -> + generateFunctionStub(descriptor) + is PropertyDescriptor -> + generatePropertyStub(descriptor) + else -> + throw AssertionError("Unexpected top-level descriptor: $descriptor") + } + + private fun MemberScope.generateChildStubs(irParent: IrDeclarationContainer) { + getContributedDescriptors().generateChildStubs(irParent) + } + + private fun Collection.generateChildStubs(irParent: IrDeclarationContainer) { + mapTo(irParent.declarations) { generateStub(it) } + } + + private fun Collection.generateTypeParameterStubs(irParent: IrTypeParametersContainer) { + mapTo(irParent.typeParameters) { generateTypeParameterStub(it) } + } + + private fun Collection.generateValueParametersStubs(irParent: IrFunction) { + mapTo(irParent.valueParameters) { generateValueParameterStub(it) } + } + + private fun generateClassStub(classDescriptor: ClassDescriptor): IrClass = + context.symbolTable.declareClass( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + classDescriptor + ).also { irClass -> + classDescriptor.declaredTypeParameters.generateTypeParameterStubs(irClass) + classDescriptor.constructors.generateChildStubs(irClass) + classDescriptor.defaultType.memberScope.generateChildStubs(irClass) + classDescriptor.staticScope.generateChildStubs(irClass) + } + + private fun generateEnumEntryStub(enumEntryDescriptor: ClassDescriptor): IrEnumEntry = + context.symbolTable.declareEnumEntry( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + enumEntryDescriptor + ) + + private fun generateTypeParameterStub(typeParameterDescriptor: TypeParameterDescriptor): IrTypeParameter = + IrTypeParameterImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, typeParameterDescriptor) + + private fun generateValueParameterStub(valueParameterDescriptor: ValueParameterDescriptor): IrValueParameter = + IrValueParameterImpl(UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, valueParameterDescriptor) + + private fun generateConstructorStub(constructorDescriptor: ClassConstructorDescriptor): IrConstructor = + context.symbolTable.declareConstructor( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + constructorDescriptor + ).also { irConstructor -> + constructorDescriptor.valueParameters.generateValueParametersStubs(irConstructor) + } + + private fun generateFunctionStub(functionDescriptor: FunctionDescriptor): IrFunction = + context.symbolTable.declareSimpleFunction( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + functionDescriptor + ).also { irFunction -> + functionDescriptor.typeParameters.generateTypeParameterStubs(irFunction) + functionDescriptor.valueParameters.generateValueParametersStubs(irFunction) + } + + private fun generatePropertyStub(propertyDescriptor: PropertyDescriptor): IrProperty = + IrPropertyImpl( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + propertyDescriptor + ).also { irProperty -> + val getterDescriptor = propertyDescriptor.getter + if (getterDescriptor == null) { + irProperty.backingField = + context.symbolTable.declareField( + UNDEFINED_OFFSET, UNDEFINED_OFFSET, IrDeclarationOrigin.IR_EXTERNAL_DECLARATION_STUB, + propertyDescriptor + ) + } + else { + irProperty.getter = generateFunctionStub(getterDescriptor) + } + + irProperty.setter = propertyDescriptor.setter?.let { generateFunctionStub(it) } + } +} \ No newline at end of file diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt index 9bfbe0f5ad8..9c4d215750a 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/ModuleGenerator.kt @@ -25,10 +25,20 @@ import org.jetbrains.kotlin.resolve.BindingContext class ModuleGenerator(override val context: GeneratorContext) : Generator { fun generateModuleFragment(ktFiles: Collection): IrModuleFragment = - IrModuleFragmentImpl(context.moduleDescriptor, context.irBuiltIns, - generateFiles(ktFiles)) + generateModuleFragmentWithoutDependencies(ktFiles).also { irModule -> + generateUnboundSymbolsAsDependencies(irModule) + } - fun generateFiles(ktFiles: Collection): List { + fun generateModuleFragmentWithoutDependencies(ktFiles: Collection): IrModuleFragment = + IrModuleFragmentImpl(context.moduleDescriptor, context.irBuiltIns).also { irModule -> + irModule.files.addAll(generateFiles(ktFiles)) + } + + private fun generateUnboundSymbolsAsDependencies(irModule: IrModuleFragment) { + ModuleDependenciesGenerator(context).generateUnboundSymbolsAsDependencies(irModule) + } + + private fun generateFiles(ktFiles: Collection): List { val irDeclarationGenerator = DeclarationGenerator(context) return ktFiles.map { ktFile -> @@ -36,10 +46,6 @@ class ModuleGenerator(override val context: GeneratorContext) : Generator { } } - fun generateSingleFileFragment(ktFile: KtFile) = - IrModuleFragmentImpl(context.moduleDescriptor, context.irBuiltIns, - listOf(generateSingleFile(DeclarationGenerator(context), ktFile))) - private fun generateSingleFile(irDeclarationGenerator: DeclarationGenerator, ktFile: KtFile): IrFileImpl { val irFile = createEmptyIrFile(ktFile) @@ -54,7 +60,7 @@ class ModuleGenerator(override val context: GeneratorContext) : Generator { return irFile } - fun createEmptyIrFile(ktFile: KtFile): IrFileImpl { + private fun createEmptyIrFile(ktFile: KtFile): IrFileImpl { val fileEntry = context.sourceManager.getOrCreateFileEntry(ktFile) val packageFragmentDescriptor = getOrFail(BindingContext.FILE_TO_PACKAGE_FRAGMENT, ktFile) val irFile = IrFileImpl(fileEntry, packageFragmentDescriptor) diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SymbolTable.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SymbolTable.kt index 1a0f81632cb..f338f229aca 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SymbolTable.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/SymbolTable.kt @@ -66,6 +66,7 @@ class SymbolTable { val s = get(d) if (s == null) { val new = createSymbol().also { markAsUnbound(it) } + set(d, new) return new } return s @@ -173,6 +174,9 @@ class SymbolTable { fun declareFile(fileEntry: SourceManager.FileEntry, packageFragmentDescriptor: PackageFragmentDescriptor): IrFile = IrFileImpl(fileEntry, IrFileSymbolImpl(packageFragmentDescriptor)) + fun declareExternalPackageFragment(packageFragmentDescriptor: PackageFragmentDescriptor): IrExternalPackageFragment = + IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(packageFragmentDescriptor)) + fun declareAnonymousInitializer(startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, descriptor: ClassDescriptor): IrAnonymousInitializer = IrAnonymousInitializerImpl( startOffset, endOffset, origin, @@ -186,7 +190,6 @@ class SymbolTable { { IrClassImpl(startOffset, endOffset, origin, it) } ) - fun referenceClass(descriptor: ClassDescriptor) = classSymbolTable.referenced(descriptor) { IrClassSymbolImpl(descriptor) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/DelegatedLocalPropertyLValue.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/DelegatedLocalPropertyLValue.kt index 23f0b80a812..d35176ebdc4 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/DelegatedLocalPropertyLValue.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/DelegatedLocalPropertyLValue.kt @@ -31,10 +31,10 @@ class DelegatedLocalPropertyLValue( val origin: IrStatementOrigin? = null ) : LValue, AssignmentReceiver { override fun load(): IrExpression = - IrCallImpl(startOffset, endOffset, type, getterSymbol!!, null, origin) + IrCallImpl(startOffset, endOffset, type, getterSymbol!!, getterSymbol.descriptor, null, origin) override fun store(irExpression: IrExpression): IrExpression = - IrCallImpl(startOffset, endOffset, type, setterSymbol!!, null, origin).apply { + IrCallImpl(startOffset, endOffset, type, setterSymbol!!, setterSymbol.descriptor, null, origin).apply { putValueArgument(0, irExpression) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt index 8dc570aabc8..ed7857fbb06 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/builders/ExpressionHelpers.kt @@ -138,7 +138,7 @@ fun IrBuilderWithScope.irGet(receiver: IrExpression, getterSymbol: IrFunctionSym IrGetterCallImpl(startOffset, endOffset, getterSymbol, null, receiver, null, IrStatementOrigin.GET_PROPERTY) fun IrBuilderWithScope.irCall(callee: IrFunctionSymbol, type: KotlinType): IrCall = - IrCallImpl(startOffset, endOffset, type, callee, null) + IrCallImpl(startOffset, endOffset, type, callee, callee.descriptor, null) fun IrBuilderWithScope.irCallOp(callee: IrFunctionSymbol, dispatchReceiver: IrExpression, argument: IrExpression): IrCall = irCall(callee, callee.descriptor.returnType!!).apply { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt index 94df56c6835..596f9ed9923 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrDeclarationOrigin.kt @@ -31,6 +31,8 @@ interface IrDeclarationOrigin { object NEW_INSTANCE_RECEIVER : IrDeclarationOriginImpl("NEW_INSTANCE_RECEIVER") object PRIMARY_CONSTRUCTOR_PARAMETER : IrDeclarationOriginImpl("PRIMARY_CONSTRUCTOR_PARAMETER") object IR_TEMPORARY_VARIABLE : IrDeclarationOriginImpl("IR_TEMPORARY_VARIABLE") + object IR_EXTERNAL_DECLARATION_STUB : IrDeclarationOriginImpl("IR_EXTERNAL_DECLARATION_STUB") + object IR_BUILTINS_STUB : IrDeclarationOriginImpl("IR_BUILTINS_STUB") } abstract class IrDeclarationOriginImpl(val name: String): IrDeclarationOrigin { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrEnumEntry.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrEnumEntry.kt index 97215879fd5..df014af605f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrEnumEntry.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrEnumEntry.kt @@ -26,6 +26,6 @@ interface IrEnumEntry : IrSymbolDeclaration { override val descriptor: ClassDescriptor var correspondingClass: IrClass? - var initializerExpression: IrExpression + var initializerExpression: IrExpression? } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModuleFragment.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModuleFragment.kt index 61e49074985..3fa4bf1a5a5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModuleFragment.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrModuleFragment.kt @@ -25,7 +25,9 @@ import org.jetbrains.kotlin.ir.visitors.IrElementTransformer interface IrModuleFragment : IrElement { val descriptor: ModuleDescriptor val irBuiltins: IrBuiltIns - val files: List + val files: MutableList + val externalPackageFragments: MutableList + val dependencyModules: MutableList override val startOffset: Int get() = UNDEFINED_OFFSET override val endOffset: Int get() = UNDEFINED_OFFSET diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt index 50ddc4b57fd..67e58a1ae6a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrEnumEntryImpl.kt @@ -46,19 +46,19 @@ class IrEnumEntryImpl( override val descriptor: ClassDescriptor get() = symbol.descriptor override var correspondingClass: IrClass? = null - override lateinit var initializerExpression: IrExpression + override var initializerExpression: IrExpression? = null override fun accept(visitor: IrElementVisitor, data: D): R { return visitor.visitEnumEntry(this, data) } override fun acceptChildren(visitor: IrElementVisitor, data: D) { - initializerExpression.accept(visitor, data) + initializerExpression?.accept(visitor, data) correspondingClass?.accept(visitor, data) } override fun transformChildren(transformer: IrElementTransformer, data: D) { - initializerExpression = initializerExpression.transform(transformer, data) + initializerExpression = initializerExpression?.transform(transformer, data) correspondingClass = correspondingClass?.transform(transformer, data) as? IrClass } } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrModuleFragmentImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrModuleFragmentImpl.kt index 2136a8045b2..676fba68db0 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrModuleFragmentImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrModuleFragmentImpl.kt @@ -17,30 +17,27 @@ package org.jetbrains.kotlin.ir.declarations.impl import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.ir.declarations.IrExternalPackageFragment import org.jetbrains.kotlin.ir.declarations.IrFile import org.jetbrains.kotlin.ir.declarations.IrModuleFragment import org.jetbrains.kotlin.ir.descriptors.IrBuiltIns import org.jetbrains.kotlin.ir.visitors.IrElementTransformer import org.jetbrains.kotlin.ir.visitors.IrElementVisitor -import java.util.* +import kotlin.collections.ArrayList class IrModuleFragmentImpl( override val descriptor: ModuleDescriptor, override val irBuiltins: IrBuiltIns ) : IrModuleFragment { constructor(descriptor: ModuleDescriptor, irBuiltins: IrBuiltIns, files: List) : this(descriptor, irBuiltins) { - this.addAll(files) + this.files.addAll(files) } override val files: MutableList = ArrayList() - fun addFile(file: IrFile) { - files.add(file) - } + override val externalPackageFragments: MutableList = ArrayList() - fun addAll(newFiles: List) { - files.addAll(newFiles) - } + override val dependencyModules: MutableList = ArrayList() override fun accept(visitor: IrElementVisitor, data: D): R = visitor.visitModuleFragment(this, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt index 04fa19a8a51..967ae4df914 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrPropertyImpl.kt @@ -30,6 +30,11 @@ class IrPropertyImpl( override val isDelegated: Boolean, override val descriptor: PropertyDescriptor ) : IrDeclarationBase(startOffset, endOffset, origin), IrProperty { + constructor( + startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, + descriptor: PropertyDescriptor + ) : this(startOffset, endOffset, origin, descriptor.isDelegated, descriptor) + constructor( startOffset: Int, endOffset: Int, origin: IrDeclarationOrigin, isDelegated: Boolean, descriptor: PropertyDescriptor, backingField: IrField? diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt index 6c5179a08da..e455eef28c7 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrBuiltIns.kt @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin import org.jetbrains.kotlin.ir.declarations.IrDeclarationOriginImpl import org.jetbrains.kotlin.ir.declarations.IrSimpleFunction import org.jetbrains.kotlin.ir.declarations.impl.IrExternalPackageFragmentImpl @@ -37,9 +38,7 @@ class IrBuiltIns(val builtIns: KotlinBuiltIns) { private val packageFragment = IrBuiltinsPackageFragmentDescriptorImpl(builtIns.builtInsModule, KOTLIN_INTERNAL_IR_FQN) val irBuiltInsExternalPackageFragment = IrExternalPackageFragmentImpl(IrExternalPackageFragmentSymbolImpl(packageFragment)) - object IR_BUILTINS_STUB : IrDeclarationOriginImpl("IR_BUILTINS_STUB") - - private val stubBuilder = IrDeclarationStubBuilder(IR_BUILTINS_STUB) + private val stubBuilder = IrDeclarationStubBuilder(IrDeclarationOrigin.IR_BUILTINS_STUB) private fun defineOperator(name: String, returnType: KotlinType, valueParameterTypes: List): IrSimpleFunction { val operatorDescriptor = IrSimpleBuiltinOperatorDescriptorImpl(packageFragment, Name.identifier(name), returnType) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDeclarationStubBuilder.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDeclarationStubBuilder.kt index f2937348bf6..988f1e2b855 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDeclarationStubBuilder.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/descriptors/IrDeclarationStubBuilder.kt @@ -51,11 +51,7 @@ class IrDeclarationStubBuilder(val defaultOrigin: IrDeclarationOrigin) { private fun T.buildTypeParameterStubs(typeParameterDescriptors: List, origin: IrDeclarationOrigin): T = apply { - typeParameterDescriptors.forEach { typeParameterDescriptor -> - typeParameters.add( - buildTypeParameterStub(IrTypeParameterSymbolImpl(typeParameterDescriptor), origin) - ) - } + typeParameterDescriptors.mapTo(typeParameters) { buildTypeParameterStub(IrTypeParameterSymbolImpl(it), origin) } } private fun @@ -66,11 +62,7 @@ class IrDeclarationStubBuilder(val defaultOrigin: IrDeclarationOrigin) { addIfNotNull(functionDescriptor.extensionReceiverParameter) addAll(functionDescriptor.valueParameters) } - valueParameterDescriptors.forEach { valueParameterDescriptor -> - valueParameters.add( - buildValueParameterStub(IrValueParameterSymbolImpl(valueParameterDescriptor), origin) - ) - } + valueParameterDescriptors.mapTo(valueParameters) { buildValueParameterStub(IrValueParameterSymbolImpl(it), origin) } } private val DeclarationDescriptorWithSource.startOffset diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt index 5704999e4ed..f5478bdf02e 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/impl/IrCallImpl.kt @@ -32,6 +32,7 @@ class IrCallImpl( endOffset: Int, type: KotlinType, override val symbol: IrFunctionSymbol, + override val descriptor: FunctionDescriptor, typeArguments: Map?, override val origin: IrStatementOrigin? = null, override val superQualifierSymbol: IrClassSymbol? = null @@ -42,14 +43,15 @@ class IrCallImpl( constructor( startOffset: Int, endOffset: Int, - calleeDescriptor: CallableMemberDescriptor, + calleeDescriptor: FunctionDescriptor, typeArguments: Map? = null, origin: IrStatementOrigin? = null, superQualifierDescriptor: ClassDescriptor? = null ) : this( startOffset, endOffset, calleeDescriptor.returnType!!, - createFunctionSymbol(calleeDescriptor), + createFunctionSymbol(calleeDescriptor.original), + calleeDescriptor, typeArguments, origin, createClassSymbolOrNull(superQualifierDescriptor) ) @@ -57,12 +59,16 @@ class IrCallImpl( constructor( startOffset: Int, endOffset: Int, symbol: IrFunctionSymbol, + descriptor: FunctionDescriptor, typeArguments: Map? = null, origin: IrStatementOrigin? = null, superQualifierSymbol: IrClassSymbol? = null - ) : this(startOffset, endOffset, symbol.descriptor.returnType!!, symbol, typeArguments, origin, superQualifierSymbol) + ) : this(startOffset, endOffset, symbol.descriptor.returnType!!, symbol, descriptor, typeArguments, origin, superQualifierSymbol) + + constructor(startOffset: Int, endOffset: Int, symbol: IrFunctionSymbol) : + this(startOffset, endOffset, symbol, symbol.descriptor) + - override val descriptor: FunctionDescriptor = symbol.descriptor override val superQualifier: ClassDescriptor? = superQualifierSymbol?.descriptor override fun accept(visitor: IrElementVisitor, data: D): R = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt index 4b2ba7a3f41..45a7d30efdf 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/impl/IrSymbolBase.kt @@ -32,7 +32,7 @@ abstract class IrBindableSymbolBase { element.dumpLabeledSubTree(data) } + override fun visitModuleFragment(declaration: IrModuleFragment, data: String) { + declaration.dumpLabeledElementWith(data) { + declaration.files.dumpElements() + declaration.externalPackageFragments.dumpElements() + } + } + override fun visitFile(declaration: IrFile, data: String) { declaration.dumpLabeledElementWith(data) { if (declaration.fileAnnotations.isNotEmpty()) { @@ -117,7 +124,7 @@ class DumpIrTreeVisitor(out: Appendable): IrElementVisitor { override fun visitEnumEntry(declaration: IrEnumEntry, data: String) { declaration.dumpLabeledElementWith(data) { - declaration.initializerExpression.accept(this, "init") + declaration.initializerExpression?.accept(this, "init") declaration.correspondingClass?.accept(this, "class") } } diff --git a/compiler/testData/ir/irText/classes/abstractMembers.kt b/compiler/testData/ir/irText/classes/abstractMembers.kt new file mode 100644 index 00000000000..933599e2d4b --- /dev/null +++ b/compiler/testData/ir/irText/classes/abstractMembers.kt @@ -0,0 +1,12 @@ +abstract class AbstractClass { + abstract fun abstractFun() + abstract val abstractVal: Int + abstract var abstractVar: Int +} + +interface Interface { + abstract fun abstractFun() + abstract val abstractVal: Int + abstract var abstractVar: Int +} + diff --git a/compiler/testData/ir/irText/classes/abstractMembers.txt b/compiler/testData/ir/irText/classes/abstractMembers.txt new file mode 100644 index 00000000000..93d7ea6a9b3 --- /dev/null +++ b/compiler/testData/ir/irText/classes/abstractMembers.txt @@ -0,0 +1,36 @@ +FILE /abstractMembers.kt + CLASS CLASS AbstractClass + $new: VALUE_PARAMETER + CONSTRUCTOR public constructor AbstractClass() + BLOCK_BODY + DELEGATING_CONSTRUCTOR_CALL 'constructor Any()' + INSTANCE_INITIALIZER_CALL classDescriptor='AbstractClass' + FUN public abstract fun abstractFun(): kotlin.Unit + $this: VALUE_PARAMETER + PROPERTY public abstract val abstractVal: kotlin.Int + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int + $this: VALUE_PARAMETER + PROPERTY public abstract var abstractVar: kotlin.Int + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int + $this: VALUE_PARAMETER + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (: kotlin.Int): kotlin.Unit + $this: VALUE_PARAMETER + VALUE_PARAMETER value-parameter : kotlin.Int + FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean + FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int + FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String + CLASS INTERFACE Interface + FUN public abstract fun abstractFun(): kotlin.Unit + $this: VALUE_PARAMETER + PROPERTY public abstract val abstractVal: kotlin.Int + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int + $this: VALUE_PARAMETER + PROPERTY public abstract var abstractVar: kotlin.Int + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int + $this: VALUE_PARAMETER + FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (: kotlin.Int): kotlin.Unit + $this: VALUE_PARAMETER + VALUE_PARAMETER value-parameter : kotlin.Int + FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean + FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int + FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/classes/delegatedImplementation.txt b/compiler/testData/ir/irText/classes/delegatedImplementation.txt index 78c29148d39..54cca350421 100644 --- a/compiler/testData/ir/irText/classes/delegatedImplementation.txt +++ b/compiler/testData/ir/irText/classes/delegatedImplementation.txt @@ -39,48 +39,24 @@ FILE /delegatedImplementation.kt PROPERTY public abstract val x: kotlin.String FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.String $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): String' - GET_FIELD 'x: String' type=kotlin.String origin=null - receiver: GET_VAR '' type=IOther origin=null PROPERTY public abstract var y: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): Int' - GET_FIELD 'y: Int' type=kotlin.Int origin=null - receiver: GET_VAR '' type=IOther origin=null FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (: kotlin.Int): kotlin.Unit $this: VALUE_PARAMETER VALUE_PARAMETER value-parameter : kotlin.Int - BLOCK_BODY - SET_FIELD 'y: Int' type=kotlin.Unit origin=null - receiver: GET_VAR '' type=IOther origin=null - value: GET_VAR 'value-parameter : Int' type=kotlin.Int origin=null PROPERTY public abstract val kotlin.Byte.z1: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun kotlin.Byte.(): kotlin.Int $this: VALUE_PARAMETER $receiver: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='() on Byte: Int' - GET_FIELD 'z1: Int on Byte' type=kotlin.Int origin=null - receiver: GET_VAR '' type=IOther origin=null PROPERTY public abstract var kotlin.Byte.z2: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun kotlin.Byte.(): kotlin.Int $this: VALUE_PARAMETER $receiver: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='() on Byte: Int' - GET_FIELD 'z2: Int on Byte' type=kotlin.Int origin=null - receiver: GET_VAR '' type=IOther origin=null FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun kotlin.Byte.(: kotlin.Int): kotlin.Unit $this: VALUE_PARAMETER $receiver: VALUE_PARAMETER VALUE_PARAMETER value-parameter : kotlin.Int - BLOCK_BODY - SET_FIELD 'z2: Int on Byte' type=kotlin.Unit origin=null - receiver: GET_VAR '' type=IOther origin=null - value: GET_VAR 'value-parameter : Int' type=kotlin.Int origin=null FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/declarations/fakeOverrides.txt b/compiler/testData/ir/irText/declarations/fakeOverrides.txt index 7d37f0cdad7..f395af8bec6 100644 --- a/compiler/testData/ir/irText/declarations/fakeOverrides.txt +++ b/compiler/testData/ir/irText/declarations/fakeOverrides.txt @@ -10,10 +10,6 @@ FILE /fakeOverrides.kt PROPERTY public abstract val bar: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): Int' - GET_FIELD 'bar: Int' type=kotlin.Int origin=null - receiver: GET_VAR '' type=IBar origin=null FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/declarations/interfaceProperties.txt b/compiler/testData/ir/irText/declarations/interfaceProperties.txt index 76b2f7d3281..6c1c97a3bfa 100644 --- a/compiler/testData/ir/irText/declarations/interfaceProperties.txt +++ b/compiler/testData/ir/irText/declarations/interfaceProperties.txt @@ -3,10 +3,6 @@ FILE /interfaceProperties.kt PROPERTY public abstract val test1: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): Int' - GET_FIELD 'test1: Int' type=kotlin.Int origin=null - receiver: GET_VAR '' type=C origin=null PROPERTY public open val test2: kotlin.Int FUN public open fun (): kotlin.Int $this: VALUE_PARAMETER @@ -16,17 +12,9 @@ FILE /interfaceProperties.kt PROPERTY public abstract var test3: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): Int' - GET_FIELD 'test3: Int' type=kotlin.Int origin=null - receiver: GET_VAR '' type=C origin=null FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (: kotlin.Int): kotlin.Unit $this: VALUE_PARAMETER VALUE_PARAMETER value-parameter : kotlin.Int - BLOCK_BODY - SET_FIELD 'test3: Int' type=kotlin.Unit origin=null - receiver: GET_VAR '' type=C origin=null - value: GET_VAR 'value-parameter : Int' type=kotlin.Int origin=null PROPERTY public open var test4: kotlin.Int FUN public open fun (): kotlin.Int $this: VALUE_PARAMETER diff --git a/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.txt b/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.txt index 237e9a32cee..1f59edc854d 100644 --- a/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.txt +++ b/compiler/testData/ir/irText/declarations/parameters/delegatedMembers.txt @@ -7,10 +7,6 @@ FILE /delegatedMembers.kt PROPERTY public abstract val bar: kotlin.Int FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): kotlin.Int $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): Int' - GET_FIELD 'bar: Int' type=kotlin.Int origin=null - receiver: GET_VAR '' type=IBase origin=null FUN public abstract fun qux(t: T, x: X): kotlin.Unit TYPE_PARAMETER $this: VALUE_PARAMETER diff --git a/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.txt b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.txt index 50a4dedfbca..58356a7bb11 100644 --- a/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.txt +++ b/compiler/testData/ir/irText/expressions/enumEntryAsReceiver.txt @@ -53,10 +53,6 @@ FILE /enumEntryAsReceiver.kt PROPERTY public abstract val value: () -> kotlin.String FUN DEFAULT_PROPERTY_ACCESSOR public abstract fun (): () -> kotlin.String $this: VALUE_PARAMETER - BLOCK_BODY - RETURN type=kotlin.Nothing from='(): () -> String' - GET_FIELD 'value: () -> String' type=() -> kotlin.String origin=null - receiver: GET_VAR '' type=X origin=null FUN FAKE_OVERRIDE protected final override fun clone(): kotlin.Any FUN FAKE_OVERRIDE protected/*protected and package*/ final override fun finalize(): kotlin.Unit FUN FAKE_OVERRIDE public final override fun getDeclaringClass(): java.lang.Class! diff --git a/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.txt b/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.txt index 02572383928..179e630fe92 100644 --- a/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.txt +++ b/compiler/testData/ir/irText/expressions/jvmInstanceFieldReference.txt @@ -24,6 +24,7 @@ FILE /Derived.kt receiver: GET_VAR '' type=Derived origin=null value: GET_VAR 'value-parameter value: Int' type=kotlin.Int origin=null PROPERTY FAKE_OVERRIDE public final override var value: kotlin.Int + FIELD FAKE_OVERRIDE public final override var value: kotlin.Int FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/expressions/kt16904.txt b/compiler/testData/ir/irText/expressions/kt16904.txt index 8e29c6415b1..ad417563a01 100644 --- a/compiler/testData/ir/irText/expressions/kt16904.txt +++ b/compiler/testData/ir/irText/expressions/kt16904.txt @@ -90,6 +90,7 @@ FILE /kt16904.kt receiver: GET_VAR '' type=Test2 origin=null value: CONST Int type=kotlin.Int value='42' PROPERTY FAKE_OVERRIDE public final override var field: kotlin.Int + FIELD FAKE_OVERRIDE public final override var field: kotlin.Int FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.txt b/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.txt index fd30deadf15..b71a83eb627 100644 --- a/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.txt +++ b/compiler/testData/ir/irText/expressions/setFieldWithImplicitCast.txt @@ -19,6 +19,7 @@ FILE /Derived.kt value: TYPE_OP type=kotlin.String! origin=IMPLICIT_CAST typeOperand=kotlin.String! GET_VAR 'value-parameter v: Any' type=kotlin.Any origin=null PROPERTY FAKE_OVERRIDE public final override var value: kotlin.String! + FIELD FAKE_OVERRIDE public final override var value: kotlin.String! FUN FAKE_OVERRIDE public open override fun equals(other: kotlin.Any?): kotlin.Boolean FUN FAKE_OVERRIDE public open override fun hashCode(): kotlin.Int FUN FAKE_OVERRIDE public open override fun toString(): kotlin.String diff --git a/compiler/testData/ir/irText/stubs/simple.kt b/compiler/testData/ir/irText/stubs/simple.kt new file mode 100644 index 00000000000..3de5bfcc2db --- /dev/null +++ b/compiler/testData/ir/irText/stubs/simple.kt @@ -0,0 +1,3 @@ +// !DUMP_DEPENDENCIES + +val test = 2 + 2 \ No newline at end of file diff --git a/compiler/testData/ir/irText/stubs/simple.txt b/compiler/testData/ir/irText/stubs/simple.txt new file mode 100644 index 00000000000..87225a79a0a --- /dev/null +++ b/compiler/testData/ir/irText/stubs/simple.txt @@ -0,0 +1,11 @@ +FILE /simple.kt + PROPERTY public val test: kotlin.Int = 4 + FIELD PROPERTY_BACKING_FIELD public val test: kotlin.Int = 4 + EXPRESSION_BODY + CALL 'plus(Int): Int' type=kotlin.Int origin=PLUS + $this: CONST Int type=kotlin.Int value='2' + other: CONST Int type=kotlin.Int value='2' + FUN DEFAULT_PROPERTY_ACCESSOR public fun (): kotlin.Int + BLOCK_BODY + RETURN type=kotlin.Nothing from='(): Int' + GET_FIELD 'test: Int' type=kotlin.Int origin=null diff --git a/compiler/testData/ir/irText/stubs/simple__.txt b/compiler/testData/ir/irText/stubs/simple__.txt new file mode 100644 index 00000000000..f5b25b304b4 --- /dev/null +++ b/compiler/testData/ir/irText/stubs/simple__.txt @@ -0,0 +1,134 @@ +MODULE_FRAGMENT + EXTERNAL_PACKAGE_FRAGMENT kotlin + CLASS IR_EXTERNAL_DECLARATION_STUB CLASS Int + CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB private constructor Int() + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun and(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun compareTo(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun compareTo(other: kotlin.Double): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun compareTo(other: kotlin.Float): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun compareTo(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun compareTo(other: kotlin.Long): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun compareTo(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun dec(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun div(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun equals(other: kotlin.Any?): kotlin.Boolean + VALUE_PARAMETER value-parameter other: kotlin.Any? + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun hashCode(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun inc(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final fun inv(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun minus(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.Deprecated public final operator fun mod(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun or(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun plus(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun rangeTo(other: kotlin.Byte): kotlin.ranges.IntRange + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun rangeTo(other: kotlin.Int): kotlin.ranges.IntRange + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun rangeTo(other: kotlin.Long): kotlin.ranges.LongRange + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun rangeTo(other: kotlin.Short): kotlin.ranges.IntRange + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB @kotlin.SinceKotlin public final operator fun rem(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun shl(bitCount: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter bitCount: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun shr(bitCount: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter bitCount: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Byte): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Double): kotlin.Double + VALUE_PARAMETER value-parameter other: kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Float): kotlin.Float + VALUE_PARAMETER value-parameter other: kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Long): kotlin.Long + VALUE_PARAMETER value-parameter other: kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun times(other: kotlin.Short): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toByte(): kotlin.Byte + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toChar(): kotlin.Char + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toDouble(): kotlin.Double + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toFloat(): kotlin.Float + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toInt(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toLong(): kotlin.Long + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toShort(): kotlin.Short + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toString(): kotlin.String + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun unaryMinus(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final operator fun unaryPlus(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun ushr(bitCount: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter bitCount: kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public final infix fun xor(other: kotlin.Int): kotlin.Int + VALUE_PARAMETER value-parameter other: kotlin.Int + CLASS IR_EXTERNAL_DECLARATION_STUB OBJECT companion object of Int + CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB private constructor Companion() + PROPERTY IR_EXTERNAL_DECLARATION_STUB public const final val MAX_VALUE: kotlin.Int = 2147483647 + FUN IR_EXTERNAL_DECLARATION_STUB public final fun (): kotlin.Int + PROPERTY IR_EXTERNAL_DECLARATION_STUB public const final val MIN_VALUE: kotlin.Int = -2147483648 + FUN IR_EXTERNAL_DECLARATION_STUB public final fun (): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun equals(other: kotlin.Any?): kotlin.Boolean + VALUE_PARAMETER value-parameter other: kotlin.Any? + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun hashCode(): kotlin.Int + FUN IR_EXTERNAL_DECLARATION_STUB public open override fun toString(): kotlin.String diff --git a/compiler/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt b/compiler/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt index 6bd40ecef8b..e9c6911011a 100644 --- a/compiler/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt +++ b/compiler/tests/org/jetbrains/kotlin/ir/AbstractIrTextTestCase.kt @@ -20,10 +20,7 @@ import com.intellij.openapi.util.text.StringUtil import junit.framework.TestCase import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor -import org.jetbrains.kotlin.ir.declarations.IrClass -import org.jetbrains.kotlin.ir.declarations.IrFile -import org.jetbrains.kotlin.ir.declarations.IrFunction -import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer +import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.util.deepCopy import org.jetbrains.kotlin.ir.util.dump import org.jetbrains.kotlin.ir.util.dumpTreesFromLineNumber @@ -38,9 +35,24 @@ abstract class AbstractIrTextTestCase : AbstractIrGeneratorTestCase() { override fun doTest(wholeFile: File, testFiles: List) { val dir = wholeFile.parentFile val ignoreErrors = shouldIgnoreErrors(wholeFile) - for ((testFile, irFile) in generateIrFilesAsSingleModule(testFiles, ignoreErrors)) { + val irModule = generateIrModule(ignoreErrors) + + val ktFiles = testFiles.filter { it.name.endsWith(".kt") } + for ((testFile, irFile) in ktFiles.zip(irModule.files)) { doTestIrFileAgainstExpectations(dir, testFile, irFile) } + + if (shouldDumpDependencies(wholeFile)) { + doTestIrModuleDependencies(wholeFile, irModule) + } + } + + private fun doTestIrModuleDependencies(wholeFile: File, irModule: IrModuleFragment) { + irModule.dependencyModules.forEach { irDependencyModule -> + val actual = irDependencyModule.dump() + val expectedFileName = wholeFile.absolutePath.replace(".kt", "__${irDependencyModule.descriptor.name.asString()}.txt") + KotlinTestUtils.assertEqualsToFile(File(expectedFileName), actual) + } } protected fun doTestIrFileAgainstExpectations(dir: File, testFile: TestFile, irFile: IrFile) { @@ -166,6 +178,11 @@ abstract class AbstractIrTextTestCase : AbstractIrGeneratorTestCase() { private val EXPECTED_OCCURRENCES_PATTERN = Regex("""^\s*//\s*(\d+)\s*(.*)$""") private val IR_FILE_TXT_PATTERN = Regex("""// IR_FILE: (.*)$""") + private val DUMP_DEPENDENCIES_PATTERN = Regex("""// !DUMP_DEPENDENCIES""") + + internal fun shouldDumpDependencies(wholeFile: File): Boolean = + DUMP_DEPENDENCIES_PATTERN.containsMatchIn(wholeFile.readText()) + internal fun parseExpectations(dir: File, testFile: TestFile): Expectations { val regexps = ArrayList() val treeFiles = ArrayList() diff --git a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java index 7e9969f2579..e3bd2f8b14a 100644 --- a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java @@ -40,6 +40,12 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class Classes extends AbstractIrTextTestCase { + @TestMetadata("abstractMembers.kt") + public void testAbstractMembers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irText/classes/abstractMembers.kt"); + doTest(fileName); + } + public void testAllFilesPresentInClasses() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irText/classes"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @@ -1010,4 +1016,19 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { doTest(fileName); } } + + @TestMetadata("compiler/testData/ir/irText/stubs") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Stubs extends AbstractIrTextTestCase { + public void testAllFilesPresentInStubs() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irText/stubs"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("simple.kt") + public void testSimple() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irText/stubs/simple.kt"); + doTest(fileName); + } + } }