diff --git a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DumpIrTreeWithDescriptorsVisitor.kt b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DumpIrTreeWithDescriptorsVisitor.kt index 8f2eca26f1e..a8a7315f698 100644 --- a/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DumpIrTreeWithDescriptorsVisitor.kt +++ b/compiler/ir/backend.common/src/org/jetbrains/kotlin/backend/common/DumpIrTreeWithDescriptorsVisitor.kt @@ -18,161 +18,158 @@ import org.jetbrains.kotlin.utils.Printer class RenderIrElementWithDescriptorsVisitor : IrElementVisitor { override fun visitElement(element: IrElement, data: Nothing?): String = - "? ${element.javaClass.simpleName}" + "? ${element.javaClass.simpleName}" override fun visitDeclaration(declaration: IrDeclaration, data: Nothing?): String = - "? ${declaration.javaClass.simpleName} ${declaration.descriptor.ref()}" + "? ${declaration.javaClass.simpleName} ${declaration.descriptor.ref()}" override fun visitModuleFragment(declaration: IrModuleFragment, data: Nothing?): String = - "MODULE_FRAGMENT ${declaration.descriptor}" + "MODULE_FRAGMENT ${declaration.descriptor}" override fun visitFile(declaration: IrFile, data: Nothing?): String = - "FILE ${declaration.path}" + "FILE ${declaration.path}" override fun visitFunction(declaration: IrFunction, data: Nothing?): String = - "FUN ${declaration.descriptor}" + "FUN ${declaration.descriptor}" override fun visitConstructor(declaration: IrConstructor, data: Nothing?): String = - "CONSTRUCTOR ${declaration.descriptor}" + "CONSTRUCTOR ${declaration.descriptor}" override fun visitProperty(declaration: IrProperty, data: Nothing?): String = - "PROPERTY ${declaration.descriptor}" + "PROPERTY ${declaration.descriptor}" override fun visitField(declaration: IrField, data: Nothing?): String = - "FIELD ${declaration.descriptor}" + "FIELD ${declaration.descriptor}" override fun visitClass(declaration: IrClass, data: Nothing?): String = - "CLASS ${declaration.descriptor}" - - override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?): String = - "TYPEALIAS ${declaration.descriptor} type=${declaration.descriptor.underlyingType.render()}" + "CLASS ${declaration.descriptor}" override fun visitVariable(declaration: IrVariable, data: Nothing?): String = - "VAR ${declaration.descriptor}" + "VAR ${declaration.descriptor}" override fun visitEnumEntry(declaration: IrEnumEntry, data: Nothing?): String = - "ENUM_ENTRY ${declaration.descriptor}" + "ENUM_ENTRY ${declaration.descriptor}" override fun visitAnonymousInitializer(declaration: IrAnonymousInitializer, data: Nothing?): String = - "ANONYMOUS_INITIALIZER ${declaration.descriptor}" + "ANONYMOUS_INITIALIZER ${declaration.descriptor}" override fun visitLocalDelegatedProperty(declaration: IrLocalDelegatedProperty, data: Nothing?): String = - "LOCAL_DELEGATED_PROPERTY ${declaration.descriptor}" + "LOCAL_DELEGATED_PROPERTY ${declaration.descriptor}" override fun visitExpressionBody(body: IrExpressionBody, data: Nothing?): String = - "EXPRESSION_BODY" + "EXPRESSION_BODY" override fun visitBlockBody(body: IrBlockBody, data: Nothing?): String = - "BLOCK_BODY" + "BLOCK_BODY" override fun visitSyntheticBody(body: IrSyntheticBody, data: Nothing?): String = - "SYNTHETIC_BODY kind=${body.kind}" + "SYNTHETIC_BODY kind=${body.kind}" override fun visitExpression(expression: IrExpression, data: Nothing?): String = - "? ${expression.javaClass.simpleName} type=${expression.type.render()}" + "? ${expression.javaClass.simpleName} type=${expression.type.render()}" override fun visitConst(expression: IrConst, data: Nothing?): String = - "CONST ${expression.kind} type=${expression.type.render()} value='${expression.value}'" + "CONST ${expression.kind} type=${expression.type.render()} value='${expression.value}'" override fun visitVararg(expression: IrVararg, data: Nothing?): String = - "VARARG type=${expression.type} varargElementType=${expression.varargElementType}" + "VARARG type=${expression.type} varargElementType=${expression.varargElementType}" override fun visitSpreadElement(spread: IrSpreadElement, data: Nothing?): String = - "SPREAD_ELEMENT" + "SPREAD_ELEMENT" override fun visitBlock(expression: IrBlock, data: Nothing?): String = - "BLOCK type=${expression.type.render()} origin=${expression.origin}" + "BLOCK type=${expression.type.render()} origin=${expression.origin}" override fun visitComposite(expression: IrComposite, data: Nothing?): String = - "COMPOSITE type=${expression.type.render()} origin=${expression.origin}" + "COMPOSITE type=${expression.type.render()} origin=${expression.origin}" override fun visitReturn(expression: IrReturn, data: Nothing?): String = - "RETURN type=${expression.type.render()} from='${expression.returnTarget}'" + "RETURN type=${expression.type.render()} from='${expression.returnTarget}'" override fun visitCall(expression: IrCall, data: Nothing?): String = - "CALL '${expression.descriptor}' ${expression.renderSuperQualifier()}" + - "type=${expression.type.render()} origin=${expression.origin}" + "CALL '${expression.descriptor}' ${expression.renderSuperQualifier()}" + + "type=${expression.type.render()} origin=${expression.origin}" private fun IrCall.renderSuperQualifier(): String = - superQualifier?.let { "superQualifier=${it.name} " } ?: "" + superQualifier?.let { "superQualifier=${it.name} " } ?: "" override fun visitDelegatingConstructorCall(expression: IrDelegatingConstructorCall, data: Nothing?): String = - "DELEGATING_CONSTRUCTOR_CALL '${expression.descriptor}'" + "DELEGATING_CONSTRUCTOR_CALL '${expression.descriptor}'" override fun visitEnumConstructorCall(expression: IrEnumConstructorCall, data: Nothing?): String = - "ENUM_CONSTRUCTOR_CALL '${expression.descriptor}'" + "ENUM_CONSTRUCTOR_CALL '${expression.descriptor}'" override fun visitInstanceInitializerCall(expression: IrInstanceInitializerCall, data: Nothing?): String = - "INSTANCE_INITIALIZER_CALL classDescriptor='${expression.classDescriptor}'" + "INSTANCE_INITIALIZER_CALL classDescriptor='${expression.classDescriptor}'" override fun visitGetValue(expression: IrGetValue, data: Nothing?): String = - "GET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" + "GET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" override fun visitSetVariable(expression: IrSetVariable, data: Nothing?): String = - "SET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" + "SET_VAR '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" override fun visitGetField(expression: IrGetField, data: Nothing?): String = - "GET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" + "GET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" override fun visitSetField(expression: IrSetField, data: Nothing?): String = - "SET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" + "SET_FIELD '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" override fun visitGetObjectValue(expression: IrGetObjectValue, data: Nothing?): String = - "GET_OBJECT '${expression.descriptor}' type=${expression.type.render()}" + "GET_OBJECT '${expression.descriptor}' type=${expression.type.render()}" override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?): String = - "GET_ENUM '${expression.descriptor}' type=${expression.type.render()}" + "GET_ENUM '${expression.descriptor}' type=${expression.type.render()}" override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?): String = - "STRING_CONCATENATION type=${expression.type.render()}" + "STRING_CONCATENATION type=${expression.type.render()}" override fun visitTypeOperator(expression: IrTypeOperatorCall, data: Nothing?): String = - "TYPE_OP origin=${expression.operator} typeOperand=${expression.typeOperand.render()}" + "TYPE_OP origin=${expression.operator} typeOperand=${expression.typeOperand.render()}" override fun visitWhen(expression: IrWhen, data: Nothing?): String = - "WHEN type=${expression.type.render()} origin=${expression.origin}" + "WHEN type=${expression.type.render()} origin=${expression.origin}" override fun visitBranch(branch: IrBranch, data: Nothing?): String = - "BRANCH" + "BRANCH" override fun visitWhileLoop(loop: IrWhileLoop, data: Nothing?): String = - "WHILE label=${loop.label} origin=${loop.origin}" + "WHILE label=${loop.label} origin=${loop.origin}" override fun visitDoWhileLoop(loop: IrDoWhileLoop, data: Nothing?): String = - "DO_WHILE label=${loop.label} origin=${loop.origin}" + "DO_WHILE label=${loop.label} origin=${loop.origin}" override fun visitBreak(jump: IrBreak, data: Nothing?): String = - "BREAK label=${jump.label} loop.label=${jump.loop.label}" + "BREAK label=${jump.label} loop.label=${jump.loop.label}" override fun visitContinue(jump: IrContinue, data: Nothing?): String = - "CONTINUE label=${jump.label} loop.label=${jump.loop.label}" + "CONTINUE label=${jump.label} loop.label=${jump.loop.label}" override fun visitThrow(expression: IrThrow, data: Nothing?): String = - "THROW type=${expression.type.render()}" + "THROW type=${expression.type.render()}" override fun visitCallableReference(expression: IrCallableReference, data: Nothing?): String = - "CALLABLE_REFERENCE '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" + "CALLABLE_REFERENCE '${expression.descriptor}' type=${expression.type.render()} origin=${expression.origin}" override fun visitClassReference(expression: IrClassReference, data: Nothing?): String = - "CLASS_REFERENCE '${expression.descriptor}' type=${expression.type.render()}" + "CLASS_REFERENCE '${expression.descriptor}' type=${expression.type.render()}" override fun visitGetClass(expression: IrGetClass, data: Nothing?): String = - "GET_CLASS type=${expression.type.render()}" + "GET_CLASS type=${expression.type.render()}" override fun visitTry(aTry: IrTry, data: Nothing?): String = - "TRY type=${aTry.type.render()}" + "TRY type=${aTry.type.render()}" override fun visitCatch(aCatch: IrCatch, data: Nothing?): String = - "CATCH parameter=${aCatch.parameter.ref()}" + "CATCH parameter=${aCatch.parameter.ref()}" override fun visitErrorDeclaration(declaration: IrErrorDeclaration, data: Nothing?): String = - "ERROR_DECL ${declaration.descriptor.javaClass.simpleName} ${declaration.descriptor.ref()}" + "ERROR_DECL ${declaration.descriptor.javaClass.simpleName} ${declaration.descriptor.ref()}" override fun visitErrorExpression(expression: IrErrorExpression, data: Nothing?): String = - "ERROR_EXPR '${expression.description}' type=${expression.type.render()}" + "ERROR_EXPR '${expression.description}' type=${expression.type.render()}" override fun visitErrorCallExpression(expression: IrErrorCallExpression, data: Nothing?): String = - "ERROR_CALL '${expression.description}' type=${expression.type.render()}" + "ERROR_CALL '${expression.description}' type=${expression.type.render()}" companion object { val DECLARATION_RENDERER = DescriptorRenderer.withOptions { @@ -187,26 +184,26 @@ class RenderIrElementWithDescriptorsVisitor : IrElementVisitor val REFERENCE_RENDERER = DescriptorRenderer.ONLY_NAMES_WITH_SHORT_TYPES internal fun IrDeclaration.name(): String = - descriptor.let { it.name.toString() } + descriptor.let { it.name.toString() } internal fun IrDeclaration.renderDeclared(): String = - DECLARATION_RENDERER.render(this.descriptor) + DECLARATION_RENDERER.render(this.descriptor) internal fun DeclarationDescriptor.ref(): String = - if (this is ReceiverParameterDescriptor) - "" - else - REFERENCE_RENDERER.render(this) + if (this is ReceiverParameterDescriptor) + "" + else + REFERENCE_RENDERER.render(this) internal fun KotlinType.render(): String = - DECLARATION_RENDERER.renderType(this) + DECLARATION_RENDERER.renderType(this) internal fun IrDeclaration.renderOrigin(): String = - if (origin != IrDeclarationOrigin.DEFINED) origin.toString() + " " else "" + if (origin != IrDeclarationOrigin.DEFINED) origin.toString() + " " else "" } } -class DumpIrTreeWithDescriptorsVisitor(out: Appendable): IrElementVisitor { +class DumpIrTreeWithDescriptorsVisitor(out: Appendable) : IrElementVisitor { val printer = Printer(out, " ") val elementRenderer = RenderIrElementWithDescriptorsVisitor() @@ -367,5 +364,5 @@ class DumpIrTreeWithDescriptorsVisitor(out: Appendable): IrElementVisitor declarator.irTypeAlias = serializeIrTypeAlias(declaration) - is IrAnonymousInitializer - -> declarator.irAnonymousInit = serializeIrAnonymousInit(declaration) - is IrConstructor - -> declarator.irConstructor = serializeIrConstructor(declaration) - is IrField - -> declarator.irField = serializeIrField(declaration) - is IrSimpleFunction - -> declarator.irFunction = serializeIrFunction(declaration) - is IrTypeParameter - -> declarator.irTypeParameter = serializeIrTypeParameter(declaration) - is IrVariable - -> declarator.irVariable = serializeIrVariable(declaration) - is IrValueParameter - -> declarator.irValueParameter = serializeIrValueParameter(declaration) - is IrClass - -> declarator.irClass = serializeIrClass(declaration) - is IrEnumEntry - -> declarator.irEnumEntry = serializeIrEnumEntry(declaration) - is IrProperty - -> declarator.irProperty = serializeIrProperty(declaration) + is IrAnonymousInitializer -> + declarator.irAnonymousInit = serializeIrAnonymousInit(declaration) + is IrConstructor -> + declarator.irConstructor = serializeIrConstructor(declaration) + is IrField -> + declarator.irField = serializeIrField(declaration) + is IrSimpleFunction -> + declarator.irFunction = serializeIrFunction(declaration) + is IrTypeParameter -> + declarator.irTypeParameter = serializeIrTypeParameter(declaration) + is IrVariable -> + declarator.irVariable = serializeIrVariable(declaration) + is IrValueParameter -> + declarator.irValueParameter = serializeIrValueParameter(declaration) + is IrClass -> + declarator.irClass = serializeIrClass(declaration) + is IrEnumEntry -> + declarator.irEnumEntry = serializeIrEnumEntry(declaration) + is IrProperty -> + declarator.irProperty = serializeIrProperty(declaration) else -> TODO("Declaration serialization not supported yet: $declaration") } @@ -1114,7 +1110,7 @@ open class IrModuleSerializer( .setAnnotations(serializeAnnotations(file.annotations)) file.declarations.forEach { - if (it is IrTypeAlias || (it.descriptor.isExpectMember && !it.descriptor.isSerializableExpectClass)) { + if (it.descriptor.isExpectMember && !it.descriptor.isSerializableExpectClass) { writer.skipDeclaration() return@forEach } diff --git a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/BaseIrElementToJsNodeTransformer.kt b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/BaseIrElementToJsNodeTransformer.kt index e057e2660e0..92af69c5be4 100644 --- a/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/BaseIrElementToJsNodeTransformer.kt +++ b/compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/BaseIrElementToJsNodeTransformer.kt @@ -7,18 +7,11 @@ package org.jetbrains.kotlin.ir.backend.js.transformers.irToJs import org.jetbrains.kotlin.ir.IrElement import org.jetbrains.kotlin.ir.backend.js.utils.TODO -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias import org.jetbrains.kotlin.ir.visitors.IrElementVisitor -import org.jetbrains.kotlin.js.backend.ast.JsEmpty import org.jetbrains.kotlin.js.backend.ast.JsNode interface BaseIrElementToJsNodeTransformer : IrElementVisitor { override fun visitElement(element: IrElement, data: D): R { TODO(element) } - - override fun visitTypeAlias(declaration: IrTypeAlias, data: D): R { - @Suppress("UNCHECKED_CAST") - return JsEmpty as R - } } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt index 481f37d8a36..828f00d937e 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ClassCodegen.kt @@ -200,9 +200,6 @@ open class ClassCodegen protected constructor( is IrAnonymousInitializer -> { // skip } - is IrTypeAlias -> { - // skip - } is IrClass -> { // Nested classes are generated separately } diff --git a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt index edf5a0e8bc7..baa75810270 100644 --- a/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt +++ b/compiler/ir/backend.jvm/src/org/jetbrains/kotlin/backend/jvm/codegen/ExpressionCodegen.kt @@ -563,10 +563,6 @@ class ExpressionCodegen( return none() } - override fun visitTypeAlias(declaration: IrTypeAlias, data: BlockInfo): StackValue { - return none() - } - override fun visitVararg(expression: IrVararg, data: BlockInfo): StackValue { expression.markLineNumber(startOffset = true) val outType = expression.type 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 c9f8c79ce82..b148753f744 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 @@ -385,7 +385,7 @@ class ClassGenerator( private fun generateMembersDeclaredInClassBody(irClass: IrClass, ktClassOrObject: KtPureClassOrObject) { // generate real body declarations ktClassOrObject.body?.let { ktClassBody -> - ktClassBody.declarations.mapTo(irClass.declarations) { ktDeclaration -> + ktClassBody.declarations.mapNotNullTo(irClass.declarations) { ktDeclaration -> declarationGenerator.generateClassMemberDeclaration(ktDeclaration, irClass) } } 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 311427e7124..6124139aee3 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 @@ -16,11 +16,12 @@ package org.jetbrains.kotlin.psi2ir.generators -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor +import org.jetbrains.kotlin.descriptors.FunctionDescriptor +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.IrPropertyImpl -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 @@ -28,8 +29,6 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.startOffsetSkippingComments import org.jetbrains.kotlin.psi2ir.endOffsetOrUndefined -import org.jetbrains.kotlin.psi2ir.pureEndOffsetOrUndefined -import org.jetbrains.kotlin.psi2ir.pureStartOffsetOrUndefined import org.jetbrains.kotlin.psi2ir.startOffsetOrUndefined import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils @@ -41,7 +40,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { fun KotlinType.toIrType() = typeTranslator.translateType(this) - fun generateMemberDeclaration(ktDeclaration: KtDeclaration): IrDeclaration = + fun generateMemberDeclaration(ktDeclaration: KtDeclaration): IrDeclaration? = when (ktDeclaration) { is KtNamedFunction -> FunctionGenerator(this).generateFunctionDeclaration(ktDeclaration) @@ -50,7 +49,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { is KtClassOrObject -> generateClassOrObjectDeclaration(ktDeclaration) is KtTypeAlias -> - generateTypeAliasDeclaration(ktDeclaration) + null else -> IrErrorDeclarationImpl( ktDeclaration.startOffsetSkippingComments, ktDeclaration.endOffset, @@ -62,7 +61,7 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { return generateClassOrObjectDeclaration(syntheticDeclaration) } - fun generateClassMemberDeclaration(ktDeclaration: KtDeclaration, irClass: IrClass): IrDeclaration = + fun generateClassMemberDeclaration(ktDeclaration: KtDeclaration, irClass: IrClass): IrDeclaration? = when (ktDeclaration) { is KtAnonymousInitializer -> AnonymousInitializerGenerator(this).generateAnonymousInitializerDeclaration(ktDeclaration, irClass) @@ -80,12 +79,6 @@ class DeclarationGenerator(override val context: GeneratorContext) : Generator { fun generateClassOrObjectDeclaration(ktClassOrObject: KtPureClassOrObject): IrClass = ClassGenerator(this).generateClass(ktClassOrObject) - private fun generateTypeAliasDeclaration(ktDeclaration: KtTypeAlias): IrDeclaration = - IrTypeAliasImpl( - ktDeclaration.startOffsetSkippingComments, ktDeclaration.endOffset, IrDeclarationOrigin.DEFINED, - getOrFail(BindingContext.TYPE_ALIAS, ktDeclaration) - ) - fun generateGlobalTypeParametersDeclarations( irTypeParametersOwner: IrTypeParametersContainer, 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 a668c7de275..c21feba33c5 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 @@ -27,6 +27,7 @@ import org.jetbrains.kotlin.ir.util.IrDeserializer import org.jetbrains.kotlin.psi.KtFile import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.lazy.descriptors.findPackageFragmentForFile +import org.jetbrains.kotlin.utils.addIfNotNull class ModuleGenerator(override val context: GeneratorContext) : Generator { @@ -66,7 +67,7 @@ class ModuleGenerator(override val context: GeneratorContext) : Generator { } for (ktDeclaration in ktFile.declarations) { - irFile.declarations.add(irDeclarationGenerator.generateMemberDeclaration(ktDeclaration)) + irFile.declarations.addIfNotNull(irDeclarationGenerator.generateMemberDeclaration(ktDeclaration)) } return irFile diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt index e1ed7b470fb..f3ac40ca083 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/StatementGenerator.kt @@ -24,7 +24,6 @@ import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.assertCast import org.jetbrains.kotlin.ir.builders.Scope import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin -import org.jetbrains.kotlin.ir.declarations.impl.IrTypeAliasImpl import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.ir.expressions.impl.* import org.jetbrains.kotlin.ir.symbols.IrSymbol @@ -472,9 +471,10 @@ class StatementGenerator( LocalClassGenerator(this).generateLocalClass(classOrObject) override fun visitTypeAlias(typeAlias: KtTypeAlias, data: Nothing?): IrStatement = - IrTypeAliasImpl( - typeAlias.startOffsetSkippingComments, typeAlias.endOffset, IrDeclarationOrigin.DEFINED, - getOrFail(BindingContext.TYPE_ALIAS, typeAlias) + IrBlockImpl( + // Compile local type aliases to empty blocks + typeAlias.startOffsetSkippingComments, typeAlias.endOffset, + context.irBuiltIns.unitType ) override fun visitClassLiteralExpression(expression: KtClassLiteralExpression, data: Nothing?): IrStatement = 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 deleted file mode 100644 index 95211809f51..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/IrTypeAlias.kt +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright 2010-2016 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.ir.declarations - -import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor - -interface IrTypeAlias : IrDeclaration { - override val descriptor: TypeAliasDescriptor -} - 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 deleted file mode 100644 index d86e7e1674b..00000000000 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/declarations/impl/IrTypeAliasImpl.kt +++ /dev/null @@ -1,45 +0,0 @@ -/* - * Copyright 2010-2016 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.ir.declarations.impl - -import org.jetbrains.kotlin.descriptors.TypeAliasDescriptor -import org.jetbrains.kotlin.ir.declarations.IrDeclarationOrigin -import org.jetbrains.kotlin.ir.declarations.IrTypeAlias -import org.jetbrains.kotlin.ir.visitors.IrElementTransformer -import org.jetbrains.kotlin.ir.visitors.IrElementVisitor - -class IrTypeAliasImpl( - startOffset: Int, - endOffset: Int, - origin: IrDeclarationOrigin, - override val descriptor: TypeAliasDescriptor -) : - IrDeclarationBase(startOffset, endOffset, origin), - IrTypeAlias { - - override fun accept(visitor: IrElementVisitor, data: D): R { - return visitor.visitTypeAlias(this, data) - } - - override fun acceptChildren(visitor: IrElementVisitor, data: D) { - // no children - } - - override fun transformChildren(transformer: IrElementTransformer, data: D) { - // no children - } -} \ No newline at end of file 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 469952782d6..9ad5f16373f 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 @@ -141,15 +141,6 @@ open class DeepCopyIrTreeWithSymbols( declaration.transformDeclarationsTo(this) } - override fun visitTypeAlias(declaration: IrTypeAlias): IrTypeAlias = - IrTypeAliasImpl( - declaration.startOffset, declaration.endOffset, - mapDeclarationOrigin(declaration.origin), - declaration.descriptor - ).apply { - transformAnnotations(declaration) - } - override fun visitSimpleFunction(declaration: IrSimpleFunction): IrSimpleFunction = IrFunctionImpl( declaration.startOffset, declaration.endOffset, 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 729bbd475bd..f7f6e365ce0 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 @@ -226,10 +226,6 @@ class RenderIrElementVisitor( "inline".takeIf { isInline } ) - override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?): String = - "TYPEALIAS ${declaration.renderOriginIfNonTrivial()}${declaration.descriptor.ref()} " + - "type=${DECLARATION_RENDERER.renderType(declaration.descriptor.underlyingType)}" - override fun visitVariable(declaration: IrVariable, data: Nothing?): String = "VAR ${declaration.renderOriginIfNonTrivial()}" + "name:${declaration.name} type:${declaration.type.render()} flags:${declaration.renderVariableFlags()}" 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 4275d100eb5..0851a779b0c 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 @@ -38,7 +38,6 @@ interface IrElementTransformer : IrElementVisitor { declaration.also { it.transformChildren(this, data) } override fun visitClass(declaration: IrClass, data: D) = visitDeclaration(declaration, data) - override fun visitTypeAlias(declaration: IrTypeAlias, data: D) = visitDeclaration(declaration, data) override fun visitFunction(declaration: IrFunction, data: D) = visitDeclaration(declaration, data) override fun visitSimpleFunction(declaration: IrSimpleFunction, data: D) = visitFunction(declaration, data) override fun visitConstructor(declaration: IrConstructor, data: D) = visitFunction(declaration, 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 388173adeb2..84d24bda148 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 @@ -49,9 +49,6 @@ abstract class IrElementTransformerVoid : IrElementTransformer { open fun visitClass(declaration: IrClass) = visitDeclaration(declaration) final override fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration) - open fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration) - final override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration) - open fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration) final override fun visitFunction(declaration: IrFunction, data: Nothing?) = visitFunction(declaration) 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 96bca6c7b0a..25c96348aa3 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 @@ -29,7 +29,6 @@ interface IrElementVisitor { fun visitDeclaration(declaration: IrDeclaration, data: D) = visitElement(declaration, data) fun visitClass(declaration: IrClass, data: D) = visitDeclaration(declaration, data) - fun visitTypeAlias(declaration: IrTypeAlias, data: D) = visitDeclaration(declaration, data) fun visitFunction(declaration: IrFunction, data: D) = visitDeclaration(declaration, data) fun visitSimpleFunction(declaration: IrSimpleFunction, data: D) = visitFunction(declaration, data) fun visitConstructor(declaration: IrConstructor, data: D) = visitFunction(declaration, 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 80a47514900..e055a7ec883 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 @@ -43,9 +43,6 @@ interface IrElementVisitorVoid : IrElementVisitor { fun visitClass(declaration: IrClass) = visitDeclaration(declaration) override fun visitClass(declaration: IrClass, data: Nothing?) = visitClass(declaration) - fun visitTypeAlias(declaration: IrTypeAlias) = visitDeclaration(declaration) - override fun visitTypeAlias(declaration: IrTypeAlias, data: Nothing?) = visitTypeAlias(declaration) - fun visitFunction(declaration: IrFunction) = visitDeclaration(declaration) override fun visitFunction(declaration: IrFunction, data: Nothing?) = visitFunction(declaration) diff --git a/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.txt b/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.txt index 73fc3405b3d..3d1a1cb3a50 100644 --- a/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.txt +++ b/compiler/testData/ir/irText/classes/delegatingConstructorCallToTypeAliasConstructor.txt @@ -31,8 +31,6 @@ FILE fqName: fileName:/delegatingConstructorCallToTypeAliasConstructor.kt overridden: FUN IR_EXTERNAL_DECLARATION_STUB name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias CT = Cell type=Cell - TYPEALIAS typealias CStr = Cell type=Cell CLASS CLASS name:C1 modality:FINAL visibility:public flags:[] superTypes:[.Cell] $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.C1 flags:[] CONSTRUCTOR visibility:public <> () returnType:.C1 flags:[primary] diff --git a/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.txt b/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.txt index 61ea3aa31e9..31cb0220ee3 100644 --- a/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.txt +++ b/compiler/testData/ir/irText/declarations/annotations/typeAliasesWithAnnotations.txt @@ -31,7 +31,3 @@ FILE fqName: fileName:/typeAliasesWithAnnotations.kt overridden: FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias TestTypeAlias = String type=kotlin.String - annotations: - CALL 'CONSTRUCTOR visibility:public <> (x:kotlin.String) returnType:.TestAnn flags:[primary]' type=.TestAnn origin=null - x: CONST String type=kotlin.String value="TestTypeAlias" diff --git a/compiler/testData/ir/irText/declarations/typeAlias.txt b/compiler/testData/ir/irText/declarations/typeAlias.txt index ade33f05e2b..50b2f4c3150 100644 --- a/compiler/testData/ir/irText/declarations/typeAlias.txt +++ b/compiler/testData/ir/irText/declarations/typeAlias.txt @@ -1,23 +1,13 @@ FILE fqName: fileName:/typeAlias.kt - TYPEALIAS typealias Test1 = String type=kotlin.String FUN name:foo visibility:public modality:FINAL <> () returnType:kotlin.Unit flags:[] BLOCK_BODY - TYPEALIAS typealias TestLocal = String type=kotlin.String - annotations: - CALL 'CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB visibility:public <> (names:kotlin.Array) returnType:kotlin.Suppress flags:[primary]' type=kotlin.Suppress origin=null - names: VARARG type=kotlin.Array varargElementType=kotlin.String - CONST String type=kotlin.String value="TOPLEVEL_TYPEALIASES_ONLY" + BLOCK type=kotlin.Unit origin=null CLASS CLASS name:C modality:FINAL visibility:public flags:[] superTypes:[kotlin.Any] $this: VALUE_PARAMETER INSTANCE_RECEIVER name: type:.C flags:[] CONSTRUCTOR visibility:public <> () returnType:.C flags:[primary] BLOCK_BODY DELEGATING_CONSTRUCTOR_CALL 'CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB visibility:public <> () returnType:kotlin.Any flags:[primary]' INSTANCE_INITIALIZER_CALL classDescriptor='CLASS CLASS name:C modality:FINAL visibility:public flags:[] superTypes:[kotlin.Any]' - TYPEALIAS typealias TestNested = String type=kotlin.String - annotations: - CALL 'CONSTRUCTOR IR_EXTERNAL_DECLARATION_STUB visibility:public <> (names:kotlin.Array) returnType:kotlin.Suppress flags:[primary]' type=kotlin.Suppress origin=null - names: VARARG type=kotlin.Array varargElementType=kotlin.String - CONST String type=kotlin.String value="TOPLEVEL_TYPEALIASES_ONLY" FUN FAKE_OVERRIDE name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean flags:[] overridden: FUN IR_EXTERNAL_DECLARATION_STUB name:equals visibility:public modality:OPEN <> ($this:kotlin.Any, other:kotlin.Any?) returnType:kotlin.Boolean flags:[] diff --git a/compiler/testData/ir/irText/expressions/kt16905.txt b/compiler/testData/ir/irText/expressions/kt16905.txt index 37d8abcbb84..545368cdfd9 100644 --- a/compiler/testData/ir/irText/expressions/kt16905.txt +++ b/compiler/testData/ir/irText/expressions/kt16905.txt @@ -80,7 +80,6 @@ FILE fqName: fileName:/kt16905.kt overridden: FUN IR_EXTERNAL_DECLARATION_STUB name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias OI = Outer.Inner type=Outer.Inner FUN name:test visibility:public modality:FINAL <> () returnType:.Outer.Inner flags:[] BLOCK_BODY RETURN type=kotlin.Nothing from='FUN name:test visibility:public modality:FINAL <> () returnType:.Outer.Inner flags:[]' diff --git a/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.txt b/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.txt index 6ac7b63c95f..f8b678fdab1 100644 --- a/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.txt +++ b/compiler/testData/ir/irText/expressions/specializedTypeAliasConstructorCall.txt @@ -31,7 +31,6 @@ FILE fqName: fileName:/specializedTypeAliasConstructorCall.kt overridden: FUN IR_EXTERNAL_DECLARATION_STUB name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias IntAlias = Cell type=Cell FUN name:test visibility:public modality:FINAL <> () returnType:.Cell flags:[] BLOCK_BODY RETURN type=kotlin.Nothing from='FUN name:test visibility:public modality:FINAL <> () returnType:.Cell flags:[]' diff --git a/compiler/testData/ir/irText/regressions/integerCoercionToT.txt b/compiler/testData/ir/irText/regressions/integerCoercionToT.txt index 29b6c0102d7..6c5284a02ec 100644 --- a/compiler/testData/ir/irText/regressions/integerCoercionToT.txt +++ b/compiler/testData/ir/irText/regressions/integerCoercionToT.txt @@ -40,7 +40,6 @@ FILE fqName: fileName:/integerCoercionToT.kt overridden: FUN FAKE_OVERRIDE name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias CInt32Var = CInt32VarX type=CInt32VarX PROPERTY name:value visibility:public modality:FINAL flags:[var] FUN name: visibility:public modality:FINAL ($receiver:.CInt32VarX<..T_INT>) returnType:..T_INT flags:[] correspondingProperty: PROPERTY name:value visibility:public modality:FINAL flags:[var] diff --git a/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.txt b/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.txt index b65cc001952..a64cc699e05 100644 --- a/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.txt +++ b/compiler/testData/ir/irText/regressions/typeAliasCtorForGenericClass.txt @@ -31,8 +31,6 @@ FILE fqName: fileName:/typeAliasCtorForGenericClass.kt overridden: FUN IR_EXTERNAL_DECLARATION_STUB name:toString visibility:public modality:OPEN <> ($this:kotlin.Any) returnType:kotlin.String flags:[] $this: VALUE_PARAMETER name: type:kotlin.Any flags:[] - TYPEALIAS typealias B = A type=A - TYPEALIAS typealias B2 = A> type=A> FUN name:bar visibility:public modality:FINAL <> () returnType:kotlin.Unit flags:[] BLOCK_BODY VAR name:b type:.A flags:[val]