From 48ae76ac286b9efd9cf08d0145f7ca1543dc282b Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Mon, 22 Jul 2019 16:48:05 +0300 Subject: [PATCH] IR: Introduce IrTypeAlias element --- .../kotlin/fir/Fir2IrTextTestGenerated.java | 5 ++ .../psi2ir/generators/DeclarationGenerator.kt | 16 ++++- .../kotlin/ir/declarations/IrTypeAlias.kt | 20 ++++++ .../ir/declarations/impl/IrTypeAliasImpl.kt | 71 +++++++++++++++++++ .../ir/declarations/lazy/IrLazyTypeAlias.kt | 69 ++++++++++++++++++ .../jetbrains/kotlin/ir/symbols/IrSymbol.kt | 7 ++ .../kotlin/ir/symbols/impl/IrSymbolBase.kt | 6 +- .../org/jetbrains/kotlin/ir/types/IrType.kt | 10 ++- .../kotlin/ir/types/impl/IrSimpleTypeImpl.kt | 13 ++-- .../ir/types/impl/IrTypeAbbreviationImpl.kt | 39 ++++++++++ .../ir/util/DeclarationStubGenerator.kt | 11 +++ .../ir/util/DeepCopyIrTreeWithSymbols.kt | 14 ++++ .../kotlin/ir/util/DeepCopySymbolRemapper.kt | 12 ++++ .../kotlin/ir/util/DeepCopyTypeRemapper.kt | 47 ++++++------ .../kotlin/ir/util/DescriptorsRemapper.kt | 1 + .../jetbrains/kotlin/ir/util/DumpIrTree.kt | 7 ++ .../ir/util/ExternalDependenciesGenerator.kt | 4 ++ .../kotlin/ir/util/IrSymbolVisitor.kt | 3 + .../kotlin/ir/util/RenderIrElement.kt | 37 +++++++++- .../kotlin/ir/util/SymbolRemapper.kt | 3 + .../jetbrains/kotlin/ir/util/SymbolTable.kt | 14 ++++ .../kotlin/ir/util/TypeTranslator.kt | 16 +++++ .../ir/visitors/IrElementTransformer.kt | 1 + .../ir/visitors/IrElementTransformerVoid.kt | 3 + .../kotlin/ir/visitors/IrElementVisitor.kt | 1 + .../ir/visitors/IrElementVisitorVoid.kt | 3 + .../declarations/fileWithTypeAliasesOnly.txt | 2 + .../ir/irText/types/abbreviatedTypes.kt | 7 ++ .../ir/irText/types/abbreviatedTypes.txt | 24 +++++++ .../kotlin/ir/IrTextTestCaseGenerated.java | 5 ++ 30 files changed, 440 insertions(+), 31 deletions(-) create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeAlias.kt create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrTypeAbbreviationImpl.kt create mode 100644 compiler/testData/ir/irText/types/abbreviatedTypes.kt create mode 100644 compiler/testData/ir/irText/types/abbreviatedTypes.txt diff --git a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java index 9da6b6da652..2042a2828de 100644 --- a/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java +++ b/compiler/fir/fir2ir/tests/org/jetbrains/kotlin/fir/Fir2IrTextTestGenerated.java @@ -1607,6 +1607,11 @@ public class Fir2IrTextTestGenerated extends AbstractFir2IrTextTest { KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); } + @TestMetadata("abbreviatedTypes.kt") + public void testAbbreviatedTypes() throws Exception { + runTest("compiler/testData/ir/irText/types/abbreviatedTypes.kt"); + } + public void testAllFilesPresentInTypes() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } 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 6124139aee3..52247b3d0d2 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 @@ -22,6 +22,7 @@ import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.declarations.impl.IrErrorDeclarationImpl +import org.jetbrains.kotlin.ir.declarations.impl.IrTypeAliasImpl import org.jetbrains.kotlin.ir.expressions.IrExpressionBody import org.jetbrains.kotlin.ir.symbols.IrSymbol import org.jetbrains.kotlin.ir.util.withScope @@ -49,7 +50,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { is KtClassOrObject -> generateClassOrObjectDeclaration(ktDeclaration) is KtTypeAlias -> - null + generateTypeAliasDeclaration(ktDeclaration) else -> IrErrorDeclarationImpl( ktDeclaration.startOffsetSkippingComments, ktDeclaration.endOffset, @@ -79,6 +80,19 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { fun generateClassOrObjectDeclaration(ktClassOrObject: KtPureClassOrObject): IrClass = ClassGenerator(this).generateClass(ktClassOrObject) + private fun generateTypeAliasDeclaration(ktTypeAlias: KtTypeAlias): IrTypeAlias { + val typeAliasDescriptor = getOrFail(BindingContext.TYPE_ALIAS, ktTypeAlias) + val irTypeAlias = context.symbolTable.declareTypeAlias(typeAliasDescriptor) { symbol -> + IrTypeAliasImpl.fromSymbolDescriptor( + ktTypeAlias.startOffsetSkippingComments, ktTypeAlias.endOffset, + symbol, + typeAliasDescriptor.expandedType.toIrType(), + IrDeclarationOrigin.DEFINED + ) + } + generateGlobalTypeParametersDeclarations(irTypeAlias, typeAliasDescriptor.declaredTypeParameters) + return irTypeAlias + } fun generateGlobalTypeParametersDeclarations( irTypeParametersOwner: IrTypeParametersContainer, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeAlias.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeAlias.kt new file mode 100644 index 00000000000..ae08d13265d --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeAlias.kt @@ -0,0 +1,20 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.declarations + +import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol +import org.jetbrains.kotlin.ir.types.IrType + +interface IrTypeAlias : + IrSymbolDeclaration, + IrDeclarationWithName, + IrDeclarationWithVisibility, + IrTypeParametersContainer { + + override val descriptor: TypeAliasDescriptor + val expandedType: IrType +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt new file mode 100644 index 00000000000..2cd639ee5bb --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt @@ -0,0 +1,71 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.declarations.impl + +import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.IrTypeAlias +import org.jetbrains.kotlin.ir.declarations.IrTypeParameter +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol +import org.jetbrains.kotlin.ir.symbols.impl.IrTypeAliasSymbolImpl +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.util.transform +import org.jetbrains.kotlin.ir.visitors.IrElementTransformer +import org.jetbrains.kotlin.ir.visitors.IrElementVisitor +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.utils.SmartList + +class IrTypeAliasImpl( + startOffset: Int, + endOffset: Int, + override val symbol: IrTypeAliasSymbol, + override val name: Name, + override val visibility: Visibility, + override val expandedType: IrType, + origin: IrDeclarationOrigin +) : + IrDeclarationBase(startOffset, endOffset, origin), + IrTypeAlias { + + init { + symbol.bind(this) + } + + override val descriptor: TypeAliasDescriptor + get() = symbol.descriptor + + override val typeParameters: MutableList = SmartList() + + override fun accept(visitor: IrElementVisitor, data: D): R = + visitor.visitTypeAlias(this, data) + + override fun acceptChildren(visitor: IrElementVisitor, data: D) { + typeParameters.forEach { it.accept(visitor, data) } + } + + override fun transformChildren(transformer: IrElementTransformer, data: D) { + typeParameters.transform { it.transform(transformer, data) } + } + + companion object { + fun fromSymbolDescriptor( + startOffset: Int, + endOffset: Int, + symbol: IrTypeAliasSymbol, + expandedType: IrType, + origin: IrDeclarationOrigin + ) = + IrTypeAliasImpl( + startOffset, endOffset, + symbol, + symbol.descriptor.name, + symbol.descriptor.visibility, + expandedType, + origin + ) + } +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt new file mode 100644 index 00000000000..f1c9979b700 --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/lazy/IrLazyTypeAlias.kt @@ -0,0 +1,69 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.declarations.lazy + +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin +import org.jetbrains.kotlin.ir.declarations.IrTypeAlias +import org.jetbrains.kotlin.ir.declarations.IrTypeParameter +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol +import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.util.DeclarationStubGenerator +import org.jetbrains.kotlin.ir.util.TypeTranslator +import org.jetbrains.kotlin.ir.util.transform +import org.jetbrains.kotlin.ir.visitors.IrElementTransformer +import org.jetbrains.kotlin.ir.visitors.IrElementVisitor +import org.jetbrains.kotlin.name.Name + +class IrLazyTypeAlias( + startOffset: Int, + endOffset: Int, + origin: IrDeclarationOrigin, + override val symbol: IrTypeAliasSymbol, + stubGenerator: DeclarationStubGenerator, + typeTranslator: TypeTranslator +) : + IrLazyDeclarationBase(startOffset, endOffset, origin, stubGenerator, typeTranslator), + IrTypeAlias { + + init { + symbol.bind(this) + } + + override val descriptor: TypeAliasDescriptor + get() = symbol.descriptor + + override val name: Name + get() = descriptor.name + + override val visibility: Visibility + get() = descriptor.visibility + + override val typeParameters: MutableList by lazy { + descriptor.declaredTypeParameters.mapTo(arrayListOf()) { + stubGenerator.generateOrGetTypeParameterStub(it) + } + } + + override val expandedType: IrType by lazy { + typeTranslator.buildWithScope(this) { + descriptor.expandedType.toIrType() + } + } + + override fun accept(visitor: IrElementVisitor, data: D): R = + visitor.visitTypeAlias(this, data) + + override fun acceptChildren(visitor: IrElementVisitor, data: D) { + typeParameters.forEach { it.accept(visitor, data) } + } + + override fun transformChildren(transformer: IrElementTransformer, data: D) { + typeParameters.transform { it.transform(transformer, data) } + } +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt index 8e8704ed9da..cbed2fb1550 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/symbols/IrSymbol.kt @@ -178,4 +178,11 @@ interface IrLocalDelegatedPropertySymbol : override fun accept(visitor: IrSymbolVisitor, data: D): R = visitor.visitLocalDelegatedPropertySymbol(this, data) +} + +interface IrTypeAliasSymbol : + IrBindableSymbol { + + override fun accept(visitor: IrSymbolVisitor, data: D): R = + visitor.visitTypeAliasSymbol(this, data) } \ No newline at end of file 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 190e16be566..49e0a07a1f9 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 @@ -110,4 +110,8 @@ class IrPropertySymbolImpl(descriptor: PropertyDescriptor) : class IrLocalDelegatedPropertySymbolImpl(descriptor: VariableDescriptorWithAccessors) : IrBindableSymbolBase(descriptor), - IrLocalDelegatedPropertySymbol \ No newline at end of file + IrLocalDelegatedPropertySymbol + +class IrTypeAliasSymbolImpl(descriptor: TypeAliasDescriptor) : + IrBindableSymbolBase(descriptor), + IrTypeAliasSymbol \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrType.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrType.kt index 16150ee1ce2..7d3b469e71c 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrType.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/IrType.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.ir.types import org.jetbrains.kotlin.ir.declarations.IrAnnotationContainer import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol import org.jetbrains.kotlin.types.Variance import org.jetbrains.kotlin.types.model.* @@ -33,9 +34,10 @@ interface IrSimpleType : IrType, SimpleTypeMarker, TypeArgumentListMarker { val classifier: IrClassifierSymbol val hasQuestionMark: Boolean val arguments: List + val abbreviation: IrTypeAbbreviation? } -interface IrTypeArgument: TypeArgumentMarker { +interface IrTypeArgument : TypeArgumentMarker { override fun equals(other: Any?): Boolean override fun hashCode(): Int @@ -46,4 +48,10 @@ interface IrStarProjection : IrTypeArgument interface IrTypeProjection : IrTypeArgument { val variance: Variance val type: IrType +} + +interface IrTypeAbbreviation : IrAnnotationContainer { + val typeAlias: IrTypeAliasSymbol + val hasQuestionMark: Boolean + val arguments: List } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt index 250fdec1c0f..4543f28cfa4 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrSimpleTypeImpl.kt @@ -17,15 +17,17 @@ class IrSimpleTypeImpl( override val classifier: IrClassifierSymbol, override val hasQuestionMark: Boolean, override val arguments: List, - annotations: List + annotations: List, + override val abbreviation: IrTypeAbbreviation? = null ) : IrTypeBase(kotlinType, annotations, Variance.INVARIANT), IrSimpleType, IrTypeProjection { constructor( classifier: IrClassifierSymbol, hasQuestionMark: Boolean, arguments: List, - annotations: List - ) : this(null, classifier, hasQuestionMark, arguments, annotations) + annotations: List, + abbreviation: IrTypeAbbreviation? = null + ) : this(null, classifier, hasQuestionMark, arguments, annotations, abbreviation) override fun equals(other: Any?): Boolean = other is IrSimpleTypeImpl && @@ -45,6 +47,7 @@ class IrSimpleTypeBuilder { var hasQuestionMark = false var arguments: List = emptyList() var annotations: List = emptyList() + var abbreviation: IrTypeAbbreviation? = null var variance = Variance.INVARIANT } @@ -55,6 +58,7 @@ fun IrSimpleType.toBuilder() = b.hasQuestionMark = hasQuestionMark b.arguments = arguments b.annotations = annotations + b.abbreviation = abbreviation } fun IrSimpleTypeBuilder.buildSimpleType() = @@ -63,7 +67,8 @@ fun IrSimpleTypeBuilder.buildSimpleType() = classifier ?: throw AssertionError("Classifier not provided"), hasQuestionMark, arguments, - annotations + annotations, + abbreviation ) fun IrSimpleTypeBuilder.buildTypeProjection() = diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrTypeAbbreviationImpl.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrTypeAbbreviationImpl.kt new file mode 100644 index 00000000000..7b0d30f32e0 --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/types/impl/IrTypeAbbreviationImpl.kt @@ -0,0 +1,39 @@ +/* + * Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.ir.types.impl + +import org.jetbrains.kotlin.ir.expressions.IrConstructorCall +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol +import org.jetbrains.kotlin.ir.types.IrTypeAbbreviation +import org.jetbrains.kotlin.ir.types.IrTypeArgument + +class IrTypeAbbreviationImpl( + override val typeAlias: IrTypeAliasSymbol, + override val hasQuestionMark: Boolean, + override val arguments: List, + override val annotations: List +) : IrTypeAbbreviation + +class IrTypeAbbreviationBuilder { + var typeAlias: IrTypeAliasSymbol? = null + var hasQuestionMark: Boolean = false + var arguments: List = emptyList() + var annotations: List = emptyList() +} + +fun IrTypeAbbreviationImpl.toBuilder() = + IrTypeAbbreviationBuilder().also { b -> + b.typeAlias = typeAlias + b.hasQuestionMark = hasQuestionMark + b.arguments = arguments + b.annotations = annotations + } + +fun IrTypeAbbreviationBuilder.build() = + IrTypeAbbreviationImpl( + typeAlias ?: throw AssertionError("typeAlias not provided"), + hasQuestionMark, arguments, annotations + ) \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt index 4485a1ada14..3ac5f0c07d1 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeclarationStubGenerator.kt @@ -243,4 +243,15 @@ class DeclarationStubGenerator( IrLazyTypeParameter(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, this, typeTranslator) } } + + internal fun generateTypeAliasStub(descriptor: TypeAliasDescriptor): IrTypeAlias { + val referenced = symbolTable.referenceTypeAlias(descriptor) + if (referenced.isBound) { + return referenced.owner + } + val origin = computeOrigin(descriptor) + return symbolTable.declareTypeAlias(descriptor) { + IrLazyTypeAlias(UNDEFINED_OFFSET, UNDEFINED_OFFSET, origin, it, this, typeTranslator) + } + } } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt index 41e603d15bf..79b89ffb0d5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyIrTreeWithSymbols.kt @@ -51,6 +51,7 @@ interface SymbolRenamer { fun getVariableName(symbol: IrVariableSymbol): Name = symbol.owner.name fun getTypeParameterName(symbol: IrTypeParameterSymbol): Name = symbol.owner.name fun getValueParameterName(symbol: IrValueParameterSymbol): Name = symbol.owner.name + fun getTypeAliasName(symbol: IrTypeAliasSymbol): Name = symbol.owner.name object DEFAULT : SymbolRenamer } @@ -333,6 +334,19 @@ open class DeepCopyIrTreeWithSymbols( defaultValue = declaration.defaultValue?.transform() } + override fun visitTypeAlias(declaration: IrTypeAlias): IrTypeAlias = + IrTypeAliasImpl( + declaration.startOffset, declaration.endOffset, + symbolRemapper.getDeclaredTypeAlias(declaration.symbol), + symbolRenamer.getTypeAliasName(declaration.symbol), + declaration.visibility, + declaration.expandedType.remapType(), + mapDeclarationOrigin(declaration.origin) + ).apply { + transformAnnotations(declaration) + copyTypeParametersFrom(declaration) + } + override fun visitBody(body: IrBody): IrBody = throw IllegalArgumentException("Unsupported body type: $body") diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopySymbolRemapper.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopySymbolRemapper.kt index c5203f6cfa2..cad8de5193b 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopySymbolRemapper.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopySymbolRemapper.kt @@ -43,6 +43,7 @@ open class DeepCopySymbolRemapper( private val valueParameters = hashMapOf() private val variables = hashMapOf() private val localDelegatedProperties = hashMapOf() + private val typeAliases = hashMapOf() override fun visitElement(element: IrElement) { element.acceptChildrenVoid(this) @@ -138,6 +139,13 @@ open class DeepCopySymbolRemapper( declaration.acceptChildrenVoid(this) } + override fun visitTypeAlias(declaration: IrTypeAlias) { + remapSymbol(typeAliases, declaration) { + IrTypeAliasSymbolImpl(descriptorsRemapper.remapDeclaredTypeAlias(it.descriptor)) + } + declaration.acceptChildrenVoid(this) + } + override fun visitBlock(expression: IrBlock) { if (expression is IrReturnableBlock) { remapSymbol(returnableBlocks, expression) { @@ -171,6 +179,8 @@ open class DeepCopySymbolRemapper( override fun getDeclaredLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol): IrLocalDelegatedPropertySymbol = localDelegatedProperties.getDeclared(symbol) + override fun getDeclaredTypeAlias(symbol: IrTypeAliasSymbol): IrTypeAliasSymbol = typeAliases.getDeclared(symbol) + override fun getReferencedClass(symbol: IrClassSymbol): IrClassSymbol = classes.getReferenced(symbol) override fun getReferencedClassOrNull(symbol: IrClassSymbol?): IrClassSymbol? = symbol?.let { classes.getReferenced(it) } override fun getReferencedEnumEntry(symbol: IrEnumEntrySymbol): IrEnumEntrySymbol = enumEntries.getReferenced(symbol) @@ -205,4 +215,6 @@ open class DeepCopySymbolRemapper( is IrTypeParameterSymbol -> typeParameters.getReferenced(symbol) else -> throw IllegalArgumentException("Unexpected symbol $symbol ${symbol.descriptor}") } + + override fun getReferencedTypeAlias(symbol: IrTypeAliasSymbol): IrTypeAliasSymbol = typeAliases.getReferenced(symbol) } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyTypeRemapper.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyTypeRemapper.kt index aef160b9196..8eebfc11f56 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyTypeRemapper.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DeepCopyTypeRemapper.kt @@ -7,11 +7,9 @@ package org.jetbrains.kotlin.ir.util import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer import org.jetbrains.kotlin.ir.expressions.IrConstructorCall -import org.jetbrains.kotlin.ir.types.IrSimpleType -import org.jetbrains.kotlin.ir.types.IrType -import org.jetbrains.kotlin.ir.types.IrTypeProjection +import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.types.impl.IrSimpleTypeImpl -import org.jetbrains.kotlin.ir.types.impl.IrTypeProjectionImpl +import org.jetbrains.kotlin.ir.types.impl.IrTypeAbbreviationImpl import org.jetbrains.kotlin.ir.types.impl.makeTypeProjection class DeepCopyTypeRemapper( @@ -28,27 +26,30 @@ class DeepCopyTypeRemapper( // TODO } - // TODO This is a hack - override fun remapType(type: IrType): IrType { - if (type !is IrSimpleType) return type + override fun remapType(type: IrType): IrType = + if (type !is IrSimpleType) + type + else + IrSimpleTypeImpl( + null, + symbolRemapper.getReferencedClassifier(type.classifier), + type.hasQuestionMark, + type.arguments.map { remapTypeArgument(it) }, + type.annotations.map { it.transform(deepCopy, null) as IrConstructorCall }, + type.abbreviation?.remapTypeAbbreviation() + ) - val arguments = type.arguments.map { - if (it is IrTypeProjection) { - makeTypeProjection(this.remapType(it.type), it.variance) - } else { - it - } - } + private fun remapTypeArgument(typeArgument: IrTypeArgument): IrTypeArgument = + if (typeArgument is IrTypeProjection) + makeTypeProjection(this.remapType(typeArgument.type), typeArgument.variance) + else + typeArgument - val annotations = type.annotations.map { it.transform(deepCopy, null) as IrConstructorCall } - - return IrSimpleTypeImpl( - null, - symbolRemapper.getReferencedClassifier(type.classifier), - type.hasQuestionMark, - arguments, + private fun IrTypeAbbreviation.remapTypeAbbreviation() = + IrTypeAbbreviationImpl( + symbolRemapper.getReferencedTypeAlias(typeAlias), + hasQuestionMark, + arguments.map { remapTypeArgument(it) }, annotations ) - } - } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorsRemapper.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorsRemapper.kt index bbd24a6dd84..6be2012e176 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorsRemapper.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DescriptorsRemapper.kt @@ -31,6 +31,7 @@ interface DescriptorsRemapper { fun remapDeclaredValueParameter(descriptor: ParameterDescriptor): ParameterDescriptor = descriptor fun remapDeclaredVariable(descriptor: VariableDescriptor): VariableDescriptor = descriptor fun remapDeclaredLocalDelegatedProperty(descriptor: VariableDescriptorWithAccessors): VariableDescriptorWithAccessors = descriptor + fun remapDeclaredTypeAlias(descriptor: TypeAliasDescriptor): TypeAliasDescriptor = descriptor object Default : DescriptorsRemapper } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt index c512eebc3a5..258b1ab307a 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/DumpIrTree.kt @@ -77,6 +77,13 @@ class DumpIrTreeVisitor( } } + override fun visitTypeAlias(declaration: IrTypeAlias, data: String) { + declaration.dumpLabeledElementWith(data) { + dumpAnnotations(declaration) + declaration.typeParameters.dumpElements() + } + } + override fun visitTypeParameter(declaration: IrTypeParameter, data: String) { declaration.dumpLabeledElementWith(data) { dumpAnnotations(declaration) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt index 5b85faeebc5..eb2ebdc1295 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/ExternalDependenciesGenerator.kt @@ -60,6 +60,9 @@ class ExternalDependenciesGenerator( ArrayList(symbolTable.unboundTypeParameters).forEach { stubGenerator.generateOrGetTypeParameterStub(it.descriptor) } + ArrayList(symbolTable.unboundTypeAliases).forEach { + stubGenerator.generateTypeAliasStub(it.descriptor) + } deserializer?.declareForwardDeclarations() @@ -70,6 +73,7 @@ class ExternalDependenciesGenerator( assertEmpty(symbolTable.unboundSimpleFunctions, "simple functions") assertEmpty(symbolTable.unboundProperties, "properties") assertEmpty(symbolTable.unboundTypeParameters, "type parameters") + assertEmpty(symbolTable.unboundTypeAliases, "type aliases") } private fun assertEmpty(s: Set, marker: String) { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt index cc6e2c44147..de725929fbb 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/IrSymbolVisitor.kt @@ -66,4 +66,7 @@ interface IrSymbolVisitor { fun visitLocalDelegatedPropertySymbol(symbol: IrLocalDelegatedPropertySymbol, data: D) = visitSymbol(symbol, data) + + fun visitTypeAliasSymbol(symbol: IrTypeAliasSymbol, data: D) = + visitSymbol(symbol, data) } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt index e94d76c0934..c86aaec5271 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/RenderIrElement.kt @@ -24,6 +24,7 @@ import org.jetbrains.kotlin.ir.declarations.* import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.symbols.IrClassifierSymbol import org.jetbrains.kotlin.ir.symbols.IrSymbol +import org.jetbrains.kotlin.ir.symbols.IrTypeAliasSymbol import org.jetbrains.kotlin.ir.types.* import org.jetbrains.kotlin.ir.visitors.IrElementVisitor import org.jetbrains.kotlin.renderer.DescriptorRenderer @@ -113,11 +114,32 @@ class RenderIrElementVisitor : IrElementVisitor { if (hasQuestionMark) { append('?') } + abbreviation?.let { + append(it.renderTypeAbbreviation()) + } } else -> "{${javaClass.simpleName} $this}" } + private fun IrTypeAbbreviation.renderTypeAbbreviation(): String = + buildString { + append("{ ") + append(renderTypeAnnotations(annotations)) + append(typeAlias.renderTypeAliasFqn()) + if (arguments.isNotEmpty()) { + append( + arguments.joinToString(prefix = "<", postfix = ">", separator = ", ") { + it.renderTypeArgument() + } + ) + } + if (hasQuestionMark) { + append('?') + } + append(" }") + } + private fun IrTypeArgument.renderTypeArgument(): String = when (this) { is IrStarProjection -> "*" @@ -473,6 +495,12 @@ class RenderIrElementVisitor : IrElementVisitor { "name:$name type:${type.render()} flags:${renderLocalDelegatedPropertyFlags()}" } + override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?): String = + declaration.run { + "TYPEALIAS ${declaration.renderOriginIfNonTrivial()}" + + "name:$name visibility:$visibility expandedType:${expandedType.render()}" + } + private fun IrLocalDelegatedProperty.renderLocalDelegatedPropertyFlags() = if (isVar) "var" else "val" @@ -667,7 +695,14 @@ internal fun IrClassifierSymbol.renderClassifierFqn(): String = is IrTypeParameter -> owner.renderTypeParameterFqn() else -> "`unexpected classifier: ${owner.render()}`" } - else "" + else + "" + +internal fun IrTypeAliasSymbol.renderTypeAliasFqn(): String = + if (isBound) + StringBuilder().also { owner.renderDeclarationFqn(it) }.toString() + else + "" internal fun IrClass.renderClassFqn(): String = StringBuilder().also { renderDeclarationFqn(it) }.toString() diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolRemapper.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolRemapper.kt index 5329545070f..2f57081ef81 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolRemapper.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolRemapper.kt @@ -31,6 +31,8 @@ interface SymbolRemapper { fun getDeclaredLocalDelegatedProperty(symbol: IrLocalDelegatedPropertySymbol): IrLocalDelegatedPropertySymbol fun getDeclaredTypeParameter(symbol: IrTypeParameterSymbol): IrTypeParameterSymbol fun getDeclaredValueParameter(symbol: IrValueParameterSymbol): IrValueParameterSymbol + fun getDeclaredTypeAlias(symbol: IrTypeAliasSymbol): IrTypeAliasSymbol + fun getReferencedClass(symbol: IrClassSymbol): IrClassSymbol fun getReferencedClassOrNull(symbol: IrClassSymbol?): IrClassSymbol? fun getReferencedEnumEntry(symbol: IrEnumEntrySymbol): IrEnumEntrySymbol @@ -44,4 +46,5 @@ interface SymbolRemapper { fun getReferencedSimpleFunction(symbol: IrSimpleFunctionSymbol): IrSimpleFunctionSymbol fun getReferencedReturnableBlock(symbol: IrReturnableBlockSymbol): IrReturnableBlockSymbol fun getReferencedClassifier(symbol: IrClassifierSymbol): IrClassifierSymbol + fun getReferencedTypeAlias(symbol: IrTypeAliasSymbol): IrTypeAliasSymbol } \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt index f2a1e453407..ec83035f647 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/SymbolTable.kt @@ -14,6 +14,8 @@ * limitations under the License. */ +@file:Suppress("DEPRECATION") + package org.jetbrains.kotlin.ir.util import org.jetbrains.kotlin.descriptors.* @@ -48,6 +50,8 @@ interface ReferenceSymbolTable { fun referenceTypeParameter(classifier: TypeParameterDescriptor): IrTypeParameterSymbol fun referenceVariable(descriptor: VariableDescriptor): IrVariableSymbol + fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol + fun enterScope(owner: DeclarationDescriptor) fun leaveScope(owner: DeclarationDescriptor) @@ -55,6 +59,7 @@ interface ReferenceSymbolTable { open class SymbolTable : ReferenceSymbolTable { + @Suppress("LeakingThis") val lazyWrapper = IrLazySymbolTable(this) private abstract class SymbolTableBase> { @@ -191,6 +196,7 @@ open class SymbolTable : ReferenceSymbolTable { private val fieldSymbolTable = FlatSymbolTable() private val simpleFunctionSymbolTable = FlatSymbolTable() private val propertySymbolTable = FlatSymbolTable() + private val typeAliasSymbolTable = FlatSymbolTable() private val globalTypeParameterSymbolTable = FlatSymbolTable() private val scopedTypeParameterSymbolTable = ScopedSymbolTable() @@ -343,6 +349,14 @@ open class SymbolTable : ReferenceSymbolTable { val unboundProperties: Set get() = propertySymbolTable.unboundSymbols + override fun referenceTypeAlias(descriptor: TypeAliasDescriptor): IrTypeAliasSymbol = + typeAliasSymbolTable.referenced(descriptor) { IrTypeAliasSymbolImpl(descriptor) } + + fun declareTypeAlias(descriptor: TypeAliasDescriptor, factory: (IrTypeAliasSymbol) -> IrTypeAlias): IrTypeAlias = + typeAliasSymbolTable.declare(descriptor, { IrTypeAliasSymbolImpl(descriptor) }, factory) + + val unboundTypeAliases: Set get() = typeAliasSymbolTable.unboundSymbols + fun declareSimpleFunction( startOffset: Int, endOffset: Int, diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt index 294a80d7963..6dea47bb11f 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/util/TypeTranslator.kt @@ -9,11 +9,13 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.ir.declarations.IrTypeParametersContainer import org.jetbrains.kotlin.ir.expressions.IrConstructorCall import org.jetbrains.kotlin.ir.types.IrType +import org.jetbrains.kotlin.ir.types.IrTypeAbbreviation import org.jetbrains.kotlin.ir.types.IrTypeProjection import org.jetbrains.kotlin.ir.types.impl.* import org.jetbrains.kotlin.types.* @@ -79,6 +81,7 @@ class TypeTranslator( this.kotlinType = kotlinType hasQuestionMark = approximatedType.isMarkedNullable this.variance = variance + this.abbreviation = approximatedType.getAbbreviation()?.toIrTypeAbbreviation() when (ktTypeDescriptor) { is TypeParameterDescriptor -> { classifier = resolveTypeParameter(ktTypeDescriptor) @@ -97,6 +100,19 @@ class TypeTranslator( }.buildTypeProjection() } + private fun SimpleType.toIrTypeAbbreviation(): IrTypeAbbreviation { + val typeAliasDescriptor = constructor.declarationDescriptor.let { + it as? TypeAliasDescriptor + ?: throw AssertionError("TypeAliasDescriptor expected: $it") + } + return IrTypeAbbreviationImpl( + symbolTable.referenceTypeAlias(typeAliasDescriptor), + isMarkedNullable, + translateTypeArguments(this.arguments), + translateTypeAnnotations(this.annotations) + ) + } + private inner class LegacyTypeApproximation { fun approximate(ktType: KotlinType): KotlinType { diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt index b0de6548987..cd41a520755 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformer.kt @@ -49,6 +49,7 @@ interface IrElementTransformer : IrElementVisitor { override fun visitVariable(declaration: IrVariable, data: D) = visitDeclaration(declaration, data) override fun visitTypeParameter(declaration: IrTypeParameter, data: D) = visitDeclaration(declaration, data) override fun visitValueParameter(declaration: IrValueParameter, data: D) = visitDeclaration(declaration, data) + override fun visitTypeAlias(declaration: IrTypeAlias, data: D) = visitDeclaration(declaration, data) override fun visitBody(body: IrBody, data: D): IrBody = body.also { it.transformChildren(this, data) } diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt index bbe8ef6499e..837d9617511 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementTransformerVoid.kt @@ -84,6 +84,9 @@ abstract class IrElementTransformerVoid : IrElementTransformer { open fun visitVariable(declaration: IrVariable) = visitDeclaration(declaration) final override fun visitVariable(declaration: IrVariable, data: Nothing?) = visitVariable(declaration) + open fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration) + final override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration) + open fun visitBody(body: IrBody): IrBody = body.transformChildren() final override fun visitBody(body: IrBody, data: Nothing?): IrBody = visitBody(body) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt index 7c8a1fd7b9f..e0190280cb5 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitor.kt @@ -40,6 +40,7 @@ interface IrElementVisitor { fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: D) = visitDeclaration(declaration, data) fun visitTypeParameter(declaration: IrTypeParameter, data: D) = visitDeclaration(declaration, data) fun visitValueParameter(declaration: IrValueParameter, data: D) = visitDeclaration(declaration, data) + fun visitTypeAlias(declaration: IrTypeAlias, data: D) = visitDeclaration(declaration, data) fun visitBody(body: IrBody, data: D) = visitElement(body, data) fun visitExpressionBody(body: IrExpressionBody, data: D) = visitBody(body, data) diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt index 067a7ec6f52..2285b98c073 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/visitors/IrElementVisitorVoid.kt @@ -77,6 +77,9 @@ interface IrElementVisitorVoid : IrElementVisitor { fun visitValueParameter(declaration: IrValueParameter) = visitDeclaration(declaration) override fun visitValueParameter(declaration: IrValueParameter, data: Nothing?) = visitValueParameter(declaration) + fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration) + override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration) + fun visitBody(body: IrBody) = visitElement(body) override fun visitBody(body: IrBody, data: Nothing?) = visitBody(body) diff --git a/compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.txt b/compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.txt index 8b10fc32485..da9bb34b868 100644 --- a/compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.txt +++ b/compiler/testData/ir/irText/declarations/fileWithTypeAliasesOnly.txt @@ -1 +1,3 @@ FILE fqName: fileName:/fileWithTypeAliasesOnly.kt + TYPEALIAS name:Bar visibility:public expandedType:kotlin.Function1.Bar, kotlin.String> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] diff --git a/compiler/testData/ir/irText/types/abbreviatedTypes.kt b/compiler/testData/ir/irText/types/abbreviatedTypes.kt new file mode 100644 index 00000000000..4ce8c470538 --- /dev/null +++ b/compiler/testData/ir/irText/types/abbreviatedTypes.kt @@ -0,0 +1,7 @@ +typealias I = Int +typealias L = List + +fun test1(x: L) = x +fun test2(x: List>) = x +fun test3(x: L>) = x +fun test4(x: L>) = x \ No newline at end of file diff --git a/compiler/testData/ir/irText/types/abbreviatedTypes.txt b/compiler/testData/ir/irText/types/abbreviatedTypes.txt new file mode 100644 index 00000000000..5b958c801ce --- /dev/null +++ b/compiler/testData/ir/irText/types/abbreviatedTypes.txt @@ -0,0 +1,24 @@ +FILE fqName: fileName:/abbreviatedTypes.kt + TYPEALIAS name:I visibility:public expandedType:kotlin.Int + TYPEALIAS name:L visibility:public expandedType:kotlin.collections.List.L> + TYPE_PARAMETER name:T index:0 variance: superTypes:[kotlin.Any?] + FUN name:test1 visibility:public modality:FINAL <> (x:kotlin.collections.List.I }>{ .L.I }> }) returnType:kotlin.collections.List.I }>{ .L.I }> } + VALUE_PARAMETER name:x index:0 type:kotlin.collections.List.I }>{ .L.I }> } + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun test1 (x: kotlin.collections.List.I }>{ .L.I }> }): kotlin.collections.List.I }>{ .L.I }> } declared in ' + GET_VAR 'x: kotlin.collections.List.I }>{ .L.I }> } declared in .test1' type=kotlin.collections.List.I }>{ .L.I }> } origin=null + FUN name:test2 visibility:public modality:FINAL <> (x:kotlin.collections.List.I }>{ .L.I }> }>) returnType:kotlin.collections.List.I }>{ .L.I }> }> + VALUE_PARAMETER name:x index:0 type:kotlin.collections.List.I }>{ .L.I }> }> + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun test2 (x: kotlin.collections.List.I }>{ .L.I }> }>): kotlin.collections.List.I }>{ .L.I }> }> declared in ' + GET_VAR 'x: kotlin.collections.List.I }>{ .L.I }> }> declared in .test2' type=kotlin.collections.List.I }>{ .L.I }> }> origin=null + FUN name:test3 visibility:public modality:FINAL <> (x:kotlin.collections.List.I }>>{ .L.I }>> }) returnType:kotlin.collections.List.I }>>{ .L.I }>> } + VALUE_PARAMETER name:x index:0 type:kotlin.collections.List.I }>>{ .L.I }>> } + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun test3 (x: kotlin.collections.List.I }>>{ .L.I }>> }): kotlin.collections.List.I }>>{ .L.I }>> } declared in ' + GET_VAR 'x: kotlin.collections.List.I }>>{ .L.I }>> } declared in .test3' type=kotlin.collections.List.I }>>{ .L.I }>> } origin=null + FUN name:test4 visibility:public modality:FINAL <> (x:kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> }) returnType:kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> } + VALUE_PARAMETER name:x index:0 type:kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> } + BLOCK_BODY + RETURN type=kotlin.Nothing from='public final fun test4 (x: kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> }): kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> } declared in ' + GET_VAR 'x: kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> } declared in .test4' type=kotlin.collections.List.I }>>{ .L.I }>{ .L.I }> }> } origin=null diff --git a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java index bb64cc92a8a..630dc2fa669 100644 --- a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java @@ -1607,6 +1607,11 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); } + @TestMetadata("abbreviatedTypes.kt") + public void testAbbreviatedTypes() throws Exception { + runTest("compiler/testData/ir/irText/types/abbreviatedTypes.kt"); + } + public void testAllFilesPresentInTypes() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/ir/irText/types"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); }