From e459105128928a0ebd408e29f02c0e7cf4d5bc2f Mon Sep 17 00:00:00 2001 From: Dmitry Petrov Date: Fri, 26 Aug 2016 17:06:11 +0300 Subject: [PATCH] Primary constructor generation. --- .../kotlin/psi2ir/generators/BodyGenerator.kt | 7 ++ .../psi2ir/generators/ClassGenerator.kt | 77 ++++++++++++++++++- .../generators/OperatorExpressionGenerator.kt | 35 +++++++-- .../intermediate/PropertyInitializerLValue.kt | 45 +++++++++++ .../ir/expressions/IrInitializeProperty.kt | 63 +++++++++++++++ .../kotlin/ir/expressions/IrOperator.kt | 3 +- .../kotlin/ir/util/RenderIrElement.kt | 3 + .../kotlin/ir/visitors/IrElementVisitor.kt | 1 + .../ir/irText/classes/classMembers.txt | 9 +++ .../ir/irText/classes/primaryConstructor.kt | 13 ++++ .../ir/irText/classes/primaryConstructor.txt | 34 ++++++++ .../expressions/arrayAugmentedAssignment1.txt | 5 ++ .../ir/irText/expressions/assignments.txt | 5 ++ .../expressions/forWithImplicitReceivers.txt | 5 ++ .../ir/irText/expressions/safeCalls.txt | 5 ++ .../kotlin/ir/IrTextTestCaseGenerated.java | 6 ++ 16 files changed, 306 insertions(+), 10 deletions(-) create mode 100644 compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyInitializerLValue.kt create mode 100644 compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInitializeProperty.kt create mode 100644 compiler/testData/ir/irText/classes/primaryConstructor.kt create mode 100644 compiler/testData/ir/irText/classes/primaryConstructor.txt diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt index 2132c168bb1..c87911db5cf 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/BodyGenerator.kt @@ -18,6 +18,7 @@ package org.jetbrains.kotlin.psi2ir.generators import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.ir.IrStatement import org.jetbrains.kotlin.ir.expressions.* import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset @@ -99,6 +100,10 @@ class BodyGenerator(val scopeOwner: CallableDescriptor, override val context: Ge return irBlockBody } + fun generateAnonymousInitializer(ktInitializer: KtAnonymousInitializer): IrStatement { + return createStatementGenerator().generateStatement(ktInitializer.body!!) + } + private fun createStatementGenerator() = StatementGenerator(context, scopeOwner, this, scope) @@ -108,5 +113,7 @@ class BodyGenerator(val scopeOwner: CallableDescriptor, override val context: Ge fun getLoop(expression: KtExpression): IrLoop? = loopTable[expression] + + } 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 f3ad23625af..fd98054249e 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 @@ -16,9 +16,11 @@ package org.jetbrains.kotlin.psi2ir.generators +import org.jetbrains.kotlin.descriptors.ConstructorDescriptor +import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.ir.declarations.* -import org.jetbrains.kotlin.psi.KtClassOrObject -import org.jetbrains.kotlin.psi.KtParameter +import org.jetbrains.kotlin.ir.expressions.* +import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.endOffset import org.jetbrains.kotlin.psi.psiUtil.startOffset import org.jetbrains.kotlin.resolve.BindingContext @@ -30,12 +32,25 @@ class ClassGenerator(val declarationGenerator: DeclarationGenerator) : Generator val descriptor = getOrFail(BindingContext.CLASS, ktClassOrObject) val irClass = IrClassImpl(ktClassOrObject.startOffset, ktClassOrObject.endOffset, IrDeclarationOrigin.DEFINED, descriptor) + generatePrimaryConstructor(irClass, ktClassOrObject) generatePropertiesDeclaredInPrimaryConstructor(irClass, ktClassOrObject) generateMembersDeclaredInClassBody(irClass, ktClassOrObject) return irClass } + private fun generatePrimaryConstructor(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) { + val ktPrimaryConstructor = ktClassOrObject.getPrimaryConstructor() ?: return + + val primaryConstructorDescriptor = getOrFail(BindingContext.CONSTRUCTOR, ktPrimaryConstructor) + val irPrimaryConstructor = IrFunctionImpl(ktClassOrObject.startOffset, ktClassOrObject.endOffset, IrDeclarationOrigin.DEFINED, + primaryConstructorDescriptor) + + irPrimaryConstructor.body = generatePrimaryConstructorBodyFromClass(ktClassOrObject, primaryConstructorDescriptor) + + irClass.addMember(irPrimaryConstructor) + } + private fun generatePropertiesDeclaredInPrimaryConstructor(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) { ktClassOrObject.getPrimaryConstructor()?.let { ktPrimaryConstructor -> for (ktParameter in ktPrimaryConstructor.valueParameters) { @@ -49,6 +64,8 @@ class ClassGenerator(val declarationGenerator: DeclarationGenerator) : Generator private fun generateMembersDeclaredInClassBody(irClass: IrClassImpl, ktClassOrObject: KtClassOrObject) { ktClassOrObject.getBody()?.let { ktClassBody -> for (ktDeclaration in ktClassBody.declarations) { + if (ktDeclaration is KtAnonymousInitializer) continue + val irMember = declarationGenerator.generateMemberDeclaration(ktDeclaration) irClass.addMember(irMember) if (irMember is IrProperty) { @@ -60,7 +77,61 @@ class ClassGenerator(val declarationGenerator: DeclarationGenerator) : Generator } private fun generatePropertyForPrimaryConstructorParameter(ktParameter: KtParameter): IrDeclaration { + val valueParameterDescriptor = getOrFail(BindingContext.VALUE_PARAMETER, ktParameter) val propertyDescriptor = getOrFail(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, ktParameter) - return IrSimplePropertyImpl(ktParameter.startOffset, ktParameter.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor) + val irProperty = IrSimplePropertyImpl(ktParameter.startOffset, ktParameter.endOffset, IrDeclarationOrigin.DEFINED, propertyDescriptor) + val irGetParameter = IrGetVariableImpl(ktParameter.startOffset, ktParameter.endOffset, + valueParameterDescriptor, IrOperator.INITIALIZE_PROPERTY_FROM_PARAMETER) + irProperty.valueInitializer = IrExpressionBodyImpl(ktParameter.startOffset, ktParameter.endOffset, irGetParameter) + return irProperty } + + private fun generatePrimaryConstructorBodyFromClass(ktClassOrObject: KtClassOrObject, primaryConstructorDescriptor: ConstructorDescriptor): IrBody { + val irBlockBody = IrBlockBodyImpl(ktClassOrObject.startOffset, ktClassOrObject.endOffset) + + generateInitializersForPropertiesDefinedInPrimaryConstructor(irBlockBody, ktClassOrObject) + generateInitializersForClassBody(irBlockBody, ktClassOrObject, primaryConstructorDescriptor) + + return irBlockBody + } + + private fun generateInitializersForClassBody(irBlockBody: IrBlockBodyImpl, ktClassOrObject: KtClassOrObject, primaryConstructorDescriptor: ConstructorDescriptor) { + ktClassOrObject.getBody()?.let { ktClassBody -> + for (ktDeclaration in ktClassBody.declarations) { + when (ktDeclaration) { + is KtProperty -> generateInitializerForPropertyDefinedInClassBody(irBlockBody, ktDeclaration) + is KtClassInitializer -> generateAnonymousInitializer(irBlockBody, ktDeclaration, primaryConstructorDescriptor) + } + } + } + } + + private fun generateAnonymousInitializer(irBlockBody: IrBlockBodyImpl, ktClassInitializer: KtClassInitializer, primaryConstructorDescriptor: ConstructorDescriptor) { + if (ktClassInitializer.body == null) return + val irInitializer = BodyGenerator(primaryConstructorDescriptor, context).generateAnonymousInitializer(ktClassInitializer) + irBlockBody.addStatement(irInitializer) + } + + private fun generateInitializerForPropertyDefinedInClassBody(irBlockBody: IrBlockBodyImpl, ktProperty: KtProperty) { + val propertyDescriptor = getOrFail(BindingContext.VARIABLE, ktProperty) as PropertyDescriptor + if (ktProperty.initializer != null) { + irBlockBody.addStatement(createInitializeProperty(ktProperty, propertyDescriptor)) + } + } + + private fun generateInitializersForPropertiesDefinedInPrimaryConstructor(irBlockBody: IrBlockBodyImpl, ktClassOrObject: KtClassOrObject) { + ktClassOrObject.getPrimaryConstructor()?.let { ktPrimaryConstructor -> + for (ktParameter in ktPrimaryConstructor.valueParameters) { + if (ktParameter.hasValOrVar()) { + val propertyDescriptor = getOrFail(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, ktParameter) + irBlockBody.addStatement(createInitializeProperty(ktParameter, propertyDescriptor)) + } + } + } + } + + private fun createInitializeProperty(ktElement: KtElement, propertyDescriptor: PropertyDescriptor) = + IrInitializePropertyImpl(ktElement.startOffset, ktElement.endOffset, context.builtIns.unitType, propertyDescriptor) + + } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt index d792d3a7692..c1c784ca5fd 100644 --- a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/generators/OperatorExpressionGenerator.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.psi2ir.generators +import org.jetbrains.kotlin.descriptors.ConstructorDescriptor import org.jetbrains.kotlin.descriptors.PropertyDescriptor import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor import org.jetbrains.kotlin.ir.IrStatement @@ -28,6 +29,8 @@ import org.jetbrains.kotlin.psi2ir.defaultLoad import org.jetbrains.kotlin.psi2ir.intermediate.* import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.calls.callUtil.isSafeCall +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.scopes.receivers.ThisClassReceiver import org.jetbrains.kotlin.types.typeUtil.makeNullable import java.lang.AssertionError @@ -319,17 +322,37 @@ class OperatorExpressionGenerator( TODO("Delegated local variable") else VariableLValue(ktLeft.startOffset, ktLeft.endOffset, descriptor, irOperator) - is PropertyDescriptor -> { - val propertyReceiver = statementGenerator.generateCallReceiver( - ktLeft, resolvedCall.dispatchReceiver, resolvedCall.extensionReceiver, resolvedCall.call.isSafeCall() - ) - SimplePropertyLValue(scope, ktLeft.startOffset, ktLeft.endOffset, irOperator, descriptor, propertyReceiver) - } + is PropertyDescriptor -> + generateAssignmentReceiverForProperty(descriptor, irOperator, ktLeft, resolvedCall) else -> TODO("Other cases of LHS") } } + private fun generateAssignmentReceiverForProperty( + descriptor: PropertyDescriptor, + irOperator: IrOperator, + ktLeft: KtExpression, + resolvedCall: ResolvedCall<*> + ): AssignmentReceiver { + if (isPropertyInitializationWithinPrimaryConstructor(descriptor, resolvedCall)) { + return PropertyInitializerLValue(ktLeft.startOffset, ktLeft.endOffset, descriptor) + } + + val propertyReceiver = statementGenerator.generateCallReceiver( + ktLeft, resolvedCall.dispatchReceiver, resolvedCall.extensionReceiver, resolvedCall.call.isSafeCall()) + + return SimplePropertyLValue(scope, ktLeft.startOffset, ktLeft.endOffset, irOperator, descriptor, propertyReceiver) + } + + private fun isPropertyInitializationWithinPrimaryConstructor(descriptor: PropertyDescriptor, resolvedCall: ResolvedCall<*>): Boolean { + val scopeOwner = statementGenerator.scopeOwner + + return scopeOwner is ConstructorDescriptor && scopeOwner.isPrimary && + descriptor.containingDeclaration == scopeOwner.containingDeclaration && + resolvedCall.extensionReceiver == null && resolvedCall.dispatchReceiver is ThisClassReceiver + } + private fun generateArrayAccessAssignmentReceiver(ktLeft: KtArrayAccessExpression, irOperator: IrOperator): ArrayAccessAssignmentReceiver { val irArray = statementGenerator.generateExpression(ktLeft.arrayExpression!!) val irIndexExpressions = ktLeft.indexExpressions.map { statementGenerator.generateExpression(it) } diff --git a/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyInitializerLValue.kt b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyInitializerLValue.kt new file mode 100644 index 00000000000..440bf4be8dd --- /dev/null +++ b/compiler/ir/ir.psi2ir/src/org/jetbrains/kotlin/psi2ir/intermediate/PropertyInitializerLValue.kt @@ -0,0 +1,45 @@ +/* + * 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.psi2ir.intermediate + +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.ir.expressions.IrExpression +import org.jetbrains.kotlin.ir.expressions.IrInitializePropertyImpl +import org.jetbrains.kotlin.types.KotlinType +import org.jetbrains.kotlin.types.typeUtil.builtIns + +class PropertyInitializerLValue( + val startOffset: Int, + val endOffset: Int, + val propertyDescriptor: PropertyDescriptor +) : LValue, AssignmentReceiver { + override val type: KotlinType get() = propertyDescriptor.type + + override fun store(irExpression: IrExpression): IrExpression { + val irInitProperty = IrInitializePropertyImpl(startOffset, endOffset, type.builtIns.unitType, propertyDescriptor) + irInitProperty.initBlockExpression = irExpression + return irInitProperty + } + + override fun load(): IrExpression { + throw AssertionError("Property initializer LValue for $propertyDescriptor should not be used in compound assignment.") + } + + override fun assign(withLValue: (LValue) -> IrExpression): IrExpression { + return withLValue(this) + } +} diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInitializeProperty.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInitializeProperty.kt new file mode 100644 index 00000000000..ee4640ffaac --- /dev/null +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrInitializeProperty.kt @@ -0,0 +1,63 @@ +/* + * 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.expressions + +import org.jetbrains.kotlin.descriptors.PropertyDescriptor +import org.jetbrains.kotlin.ir.* +import org.jetbrains.kotlin.ir.visitors.IrElementVisitor +import org.jetbrains.kotlin.types.KotlinType + +interface IrInitializeProperty : IrDeclarationReference { + override val descriptor: PropertyDescriptor + + var initBlockExpression: IrExpression? +} + +class IrInitializePropertyImpl( + startOffset: Int, + endOffset: Int, + type: KotlinType, + descriptor: PropertyDescriptor +) : IrDeclarationReferenceBase(startOffset, endOffset, type, descriptor), IrInitializeProperty { + override var initBlockExpression: IrExpression? = null + set(value) { + value?.assertDetached() + field?.detach() + field = value + value?.setTreeLocation(this, CHILD_EXPRESSION_SLOT) + } + + override fun getChild(slot: Int): IrElement? = + when (slot) { + CHILD_EXPRESSION_SLOT -> initBlockExpression + else -> null + } + + override fun replaceChild(slot: Int, newChild: IrElement) { + when (slot) { + CHILD_EXPRESSION_SLOT -> initBlockExpression = newChild.assertCast() + } + } + + override fun accept(visitor: IrElementVisitor, data: D): R { + return visitor.visitInitializeProperty(this, data) + } + + override fun acceptChildren(visitor: IrElementVisitor, data: D) { + initBlockExpression?.accept(visitor, data) + } +} \ No newline at end of file diff --git a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrOperator.kt b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrOperator.kt index c786f16d667..2af955740f2 100644 --- a/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrOperator.kt +++ b/compiler/ir/ir.tree/src/org/jetbrains/kotlin/ir/expressions/IrOperator.kt @@ -72,7 +72,6 @@ interface IrOperator { object DESTRUCTURING_DECLARATION : IrOperatorImpl("DESTRUCTURING_DECLARATION") object GET_PROPERTY : IrOperatorImpl("GET_PROPERTY") - object SET_PROPERTY : IrOperatorImpl("SET_PROPERTY") object IF : IrOperatorImpl("IF") object WHEN : IrOperatorImpl("WHEN") @@ -89,6 +88,8 @@ interface IrOperator { object ANONYMOUS_FUNCTION : IrOperatorImpl("ANONYMOUS_FUNCTION") object DELEGATING_CONSTRUCTOR_CALL : IrOperatorImpl("DELEGATING_CONSTRUCTOR_CALL") + object INITIALIZE_PROPERTY_FROM_PARAMETER : IrOperatorImpl("INITIALIZE_PROPERTY_FROM_PARAMETER") + object ANONYMOUS_INITIALIZER : IrOperatorImpl("ANONYMOUS_INITIALIZER") data class COMPONENT_N private constructor(val index: Int) : IrOperatorImpl("COMPONENT_$index") { companion object { 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 20c13cea1fc..fc61548bd07 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 @@ -106,6 +106,9 @@ class RenderIrElementVisitor : IrElementVisitor { override fun visitGetEnumValue(expression: IrGetEnumValue, data: Nothing?): String = "GET_ENUM_VALUE ${expression.descriptor.name} type=${expression.type.render()}" + override fun visitInitializeProperty(expression: IrInitializeProperty, data: Nothing?): String = + "INITIALIZE_PROPERTY ${expression.descriptor.name}" + override fun visitStringConcatenation(expression: IrStringConcatenation, data: Nothing?): String = "STRING_CONCATENATION type=${expression.type.render()}" 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 9b9c5ca1ec0..612ca9bc996 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 @@ -57,6 +57,7 @@ interface IrElementVisitor { fun visitGetVariable(expression: IrGetVariable, data: D) = visitDeclarationReference(expression, data) fun visitSetVariable(expression: IrSetVariable, data: D) = visitDeclarationReference(expression, data) fun visitGetExtensionReceiver(expression: IrGetExtensionReceiver, data: D) = visitDeclarationReference(expression, data) + fun visitInitializeProperty(expression: IrInitializeProperty, data: D): R = visitDeclarationReference(expression, data) fun visitCall(expression: IrCall, data: D) = visitDeclarationReference(expression, data) fun visitCallableReference(expression: IrCallableReference, data: D) = visitDeclarationReference(expression, data) diff --git a/compiler/testData/ir/irText/classes/classMembers.txt b/compiler/testData/ir/irText/classes/classMembers.txt index f8a028320d7..776a21a94a8 100644 --- a/compiler/testData/ir/irText/classes/classMembers.txt +++ b/compiler/testData/ir/irText/classes/classMembers.txt @@ -1,7 +1,16 @@ FILE /classMembers.kt CLASS CLASS C + FUN public constructor C(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int, /*2*/ z: kotlin.Int = ...) + BLOCK_BODY + INITIALIZE_PROPERTY y + INITIALIZE_PROPERTY z + INITIALIZE_PROPERTY property PROPERTY public final val y: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR y type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER PROPERTY public final var z: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR z type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER FUN public constructor C() BLOCK_BODY CALL . type=C operator=DELEGATING_CONSTRUCTOR_CALL diff --git a/compiler/testData/ir/irText/classes/primaryConstructor.kt b/compiler/testData/ir/irText/classes/primaryConstructor.kt new file mode 100644 index 00000000000..a59485957a4 --- /dev/null +++ b/compiler/testData/ir/irText/classes/primaryConstructor.kt @@ -0,0 +1,13 @@ +class Test1(val x: Int, val y: Int) + +class Test2(x: Int, val y: Int) { + val x = x +} + +class Test3(x: Int, val y: Int) { + val x: Int + + init { + this.x = x + } +} \ No newline at end of file diff --git a/compiler/testData/ir/irText/classes/primaryConstructor.txt b/compiler/testData/ir/irText/classes/primaryConstructor.txt new file mode 100644 index 00000000000..ac1198f7dd5 --- /dev/null +++ b/compiler/testData/ir/irText/classes/primaryConstructor.txt @@ -0,0 +1,34 @@ +FILE /primaryConstructor.kt + CLASS CLASS Test1 + FUN public constructor Test1(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY x + INITIALIZE_PROPERTY y + PROPERTY public final val x: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR x type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER + PROPERTY public final val y: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR y type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER + CLASS CLASS Test2 + FUN public constructor Test2(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY y + INITIALIZE_PROPERTY x + PROPERTY public final val y: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR y type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER + PROPERTY public final val x: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR x type=kotlin.Int operator=null + CLASS CLASS Test3 + FUN public constructor Test3(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY y + BLOCK type=kotlin.Unit operator=null + INITIALIZE_PROPERTY x + GET_VAR x type=kotlin.Int operator=null + PROPERTY public final val y: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR y type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER + PROPERTY public final val x: kotlin.Int getter=null setter=null diff --git a/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.txt b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.txt index 855df049542..532fc031db6 100644 --- a/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.txt +++ b/compiler/testData/ir/irText/expressions/arrayAugmentedAssignment1.txt @@ -12,7 +12,12 @@ FILE /arrayAugmentedAssignment1.kt RETURN type=kotlin.Nothing CONST Int type=kotlin.Int value='42' CLASS CLASS C + FUN public constructor C(/*0*/ x: kotlin.IntArray) + BLOCK_BODY + INITIALIZE_PROPERTY x PROPERTY public final val x: kotlin.IntArray getter=null setter=null + EXPRESSION_BODY + GET_VAR x type=kotlin.IntArray operator=INITIALIZE_PROPERTY_FROM_PARAMETER FUN public fun testVariable(): kotlin.Unit BLOCK_BODY VAR var x: kotlin.IntArray diff --git a/compiler/testData/ir/irText/expressions/assignments.txt b/compiler/testData/ir/irText/expressions/assignments.txt index da420633288..1b22571f0d6 100644 --- a/compiler/testData/ir/irText/expressions/assignments.txt +++ b/compiler/testData/ir/irText/expressions/assignments.txt @@ -1,6 +1,11 @@ FILE /assignments.kt CLASS CLASS Ref + FUN public constructor Ref(/*0*/ x: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY x PROPERTY public final var x: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR x type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER FUN public fun test1(): kotlin.Unit BLOCK_BODY VAR var x: kotlin.Int diff --git a/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.txt b/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.txt index fc02909bc14..a382b5ad9fb 100644 --- a/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.txt +++ b/compiler/testData/ir/irText/expressions/forWithImplicitReceivers.txt @@ -1,7 +1,12 @@ FILE /forWithImplicitReceivers.kt CLASS OBJECT FiveTimes CLASS CLASS IntCell + FUN public constructor IntCell(/*0*/ value: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY value PROPERTY public final var value: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR value type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER CLASS INTERFACE IReceiver FUN public open operator fun FiveTimes.iterator(): IntCell BLOCK_BODY diff --git a/compiler/testData/ir/irText/expressions/safeCalls.txt b/compiler/testData/ir/irText/expressions/safeCalls.txt index 2d3661c7183..85b917b79f9 100644 --- a/compiler/testData/ir/irText/expressions/safeCalls.txt +++ b/compiler/testData/ir/irText/expressions/safeCalls.txt @@ -1,6 +1,11 @@ FILE /safeCalls.kt CLASS CLASS Ref + FUN public constructor Ref(/*0*/ value: kotlin.Int) + BLOCK_BODY + INITIALIZE_PROPERTY value PROPERTY public final var value: kotlin.Int getter=null setter=null + EXPRESSION_BODY + GET_VAR value type=kotlin.Int operator=INITIALIZE_PROPERTY_FROM_PARAMETER CLASS INTERFACE IHost FUN public open fun kotlin.String.extLength(): kotlin.Int BLOCK_BODY diff --git a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java index 822647c1418..36df216f325 100644 --- a/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/ir/IrTextTestCaseGenerated.java @@ -49,6 +49,12 @@ public class IrTextTestCaseGenerated extends AbstractIrTextTestCase { doTest(fileName); } + @TestMetadata("primaryConstructor.kt") + public void testPrimaryConstructor() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irText/classes/primaryConstructor.kt"); + doTest(fileName); + } + @TestMetadata("secondaryConstructors.kt") public void testSecondaryConstructors() throws Exception { String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/ir/irText/classes/secondaryConstructors.kt");