diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index bbaf36c1e50..944c62eda01 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -16,11 +16,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.* import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirBody import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.impl.FirAnnotationCallImpl -import org.jetbrains.kotlin.fir.expressions.impl.FirBlockBodyImpl -import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionBodyImpl -import org.jetbrains.kotlin.fir.expressions.impl.FirExpressionStub -import org.jetbrains.kotlin.fir.types.FirUserType +import org.jetbrains.kotlin.fir.expressions.impl.* import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.types.FirTypeProjection import org.jetbrains.kotlin.fir.types.impl.* @@ -70,14 +66,17 @@ class RawFirBuilder(val session: FirSession) { this.accept(this@Visitor, Unit) as R private fun KtTypeReference?.toFirOrImplicitType(): FirType = - convertSafe() ?: FirImplicitTypeImpl(session, this) + convertSafe() ?: FirImplicitTypeImpl(session, this) private fun KtTypeReference?.toFirOrErrorType(): FirType = - convertSafe() ?: FirErrorTypeImpl(session, this, false) + convertSafe() ?: FirErrorTypeImpl(session, this, false, if (this == null) "Incomplete code" else "Conversion failed") private fun KtExpression?.toFirBody(): FirBody? = convertSafe()?.let { it as? FirBody ?: FirExpressionBodyImpl(session, it) } + private fun KtExpression?.toFirExpression(): FirExpression = + convertSafe() ?: FirErrorExpressionImpl(session, this) + private fun KtPropertyAccessor?.toFirPropertyAccessor( property: KtProperty, propertyType: FirType, @@ -143,6 +142,59 @@ class RawFirBuilder(val session: FirSession) { } } + private fun KtCallElement.extractArgumentsTo(container: FirAbstractCall) { + for (argument in this.valueArguments) { + container.arguments += argument.getArgumentExpression().toFirExpression() + } + } + + private fun KtClassOrObject.extractSuperTypeListEntriesTo(container: FirClassImpl) { + var superTypeCallEntry: KtSuperTypeCallEntry? = null + for (superTypeListEntry in superTypeListEntries) { + when (superTypeListEntry) { + is KtSuperTypeEntry -> { + container.superTypes += superTypeListEntry.typeReference.toFirOrErrorType() + } + is KtSuperTypeCallEntry -> { + container.superTypes += superTypeListEntry.calleeExpression.typeReference.toFirOrErrorType() + superTypeCallEntry = superTypeListEntry + } + is KtDelegatedSuperTypeEntry -> { + val type = superTypeListEntry.typeReference.toFirOrErrorType() + container.superTypes += FirDelegatedTypeImpl( + type, + superTypeListEntry.delegateExpression.convertSafe() + ) + } + } + } + val firPrimaryConstructor = primaryConstructor?.toFirConstructor(superTypeCallEntry) ?: return + container.declarations += firPrimaryConstructor + } + + private fun KtPrimaryConstructor.toFirConstructor(superTypeCallEntry: KtSuperTypeCallEntry?): FirConstructor { + val constructorCallee = superTypeCallEntry?.calleeExpression + val firDelegatedCall = constructorCallee?.let { + FirDelegatedConstructorCallImpl( + session, + constructorCallee, + FirErrorTypeImpl(session, constructorCallee, false, "Not implemented yet"), + isThis = false + ).apply { + superTypeCallEntry.extractArgumentsTo(this) + } + } + val firConstructor = FirPrimaryConstructorImpl( + session, + this, + visibility, + firDelegatedCall + ) + extractAnnotationsTo(firConstructor) + extractValueParametersTo(firConstructor) + return firConstructor + } + override fun visitKtFile(file: KtFile, data: Unit): FirElement { val firFile = FirFileImpl(session, file, file.name, file.packageFqName) for (annotationEntry in file.annotationEntries) { @@ -163,6 +215,20 @@ class RawFirBuilder(val session: FirSession) { return firFile } + override fun visitEnumEntry(enumEntry: KtEnumEntry, data: Unit): FirElement { + val firEnumEntry = FirEnumEntryImpl( + session, + enumEntry, + enumEntry.nameAsSafeName + ) + enumEntry.extractAnnotationsTo(firEnumEntry) + enumEntry.extractSuperTypeListEntriesTo(firEnumEntry) + for (declaration in enumEntry.declarations) { + firEnumEntry.declarations += declaration.convert() + } + return firEnumEntry + } + override fun visitClassOrObject(classOrObject: KtClassOrObject, data: Unit): FirElement { val classKind = when (classOrObject) { is KtObjectDeclaration -> ClassKind.OBJECT @@ -181,29 +247,13 @@ class RawFirBuilder(val session: FirSession) { classOrObject.visibility, classOrObject.modality, classKind, + isInner = classOrObject.hasModifier(KtTokens.INNER_KEYWORD), isCompanion = (classOrObject as? KtObjectDeclaration)?.isCompanion() == true, isData = (classOrObject as? KtClass)?.isData() == true ) classOrObject.extractAnnotationsTo(firClass) classOrObject.extractTypeParametersTo(firClass) - for (superTypeListEntry in classOrObject.superTypeListEntries) { - when (superTypeListEntry) { - is KtSuperTypeEntry -> { - firClass.superTypes += superTypeListEntry.typeReference.toFirOrErrorType() - } - is KtSuperTypeCallEntry -> { - firClass.superTypes += superTypeListEntry.calleeExpression.typeReference.toFirOrErrorType() - // TODO: primary constructor! - } - is KtDelegatedSuperTypeEntry -> { - val type = superTypeListEntry.typeReference.toFirOrErrorType() - firClass.superTypes += FirDelegatedTypeImpl( - type, - superTypeListEntry.delegateExpression.convertSafe() - ) - } - } - } + classOrObject.extractSuperTypeListEntriesTo(firClass) for (declaration in classOrObject.declarations) { firClass.declarations += declaration.convert() } @@ -223,6 +273,11 @@ class RawFirBuilder(val session: FirSession) { } override fun visitNamedFunction(function: KtNamedFunction, data: Unit): FirElement { + if (function.name == null) { + // TODO: return anonymous function here + // TODO: what if name is not null but we're in expression position? + return FirExpressionStub(session, function) + } val firFunction = FirMemberFunctionImpl( session, function, @@ -246,15 +301,27 @@ class RawFirBuilder(val session: FirSession) { } override fun visitSecondaryConstructor(constructor: KtSecondaryConstructor, data: Unit): FirElement { - val firConstructor = FirSecondaryConstructorImpl( + val firConstructor = FirConstructorImpl( session, constructor, constructor.visibility, constructor.getDelegationCall().convert(), constructor.bodyExpression.toFirBody() ) + constructor.extractAnnotationsTo(firConstructor) constructor.extractValueParametersTo(firConstructor) - return super.visitSecondaryConstructor(constructor, data) + return firConstructor + } + + override fun visitConstructorDelegationCall(call: KtConstructorDelegationCall, data: Unit): FirElement { + val firConstructorCall = FirDelegatedConstructorCallImpl( + session, + call, + FirErrorTypeImpl(session, call, false, "Not implemented yet"), + call.isCallToThis || call.isImplicit + ) + call.extractArgumentsTo(firConstructorCall) + return firConstructorCall } override fun visitAnonymousInitializer(initializer: KtAnonymousInitializer, data: Unit): FirElement { @@ -274,6 +341,7 @@ class RawFirBuilder(val session: FirSession) { property.visibility, property.modality, property.hasModifier(KtTokens.OVERRIDE_KEYWORD), + property.hasModifier(KtTokens.CONST_KEYWORD), property.receiverTypeReference.convertSafe(), propertyType, property.isVar, @@ -298,18 +366,25 @@ class RawFirBuilder(val session: FirSession) { val firType = when (unwrappedElement) { is KtDynamicType -> FirDynamicTypeImpl(session, typeReference, isNullable) is KtUserType -> { - val referenceExpression = unwrappedElement.referenceExpression + var referenceExpression = unwrappedElement.referenceExpression if (referenceExpression != null) { val userType = FirUserTypeImpl( - session, typeReference, isNullable, - referenceExpression.getReferencedNameAsName() + session, typeReference, isNullable ) - for (typeArgument in unwrappedElement.typeArguments) { - userType.arguments += typeArgument.convert() - } + var qualifier: KtUserType? = unwrappedElement + do { + val firQualifier = FirQualifierPartImpl(referenceExpression!!.getReferencedNameAsName()) + for (typeArgument in qualifier!!.typeArguments) { + firQualifier.typeArguments += typeArgument.convert() + } + userType.qualifier.add(0, firQualifier) + + qualifier = qualifier.qualifier + referenceExpression = qualifier?.referenceExpression + } while (referenceExpression != null) userType } else { - FirErrorTypeImpl(session, typeReference, isNullable) + FirErrorTypeImpl(session, typeReference, isNullable, "Incomplete user type") } } is KtFunctionType -> { @@ -325,7 +400,7 @@ class RawFirBuilder(val session: FirSession) { } functionType } - null -> FirErrorTypeImpl(session, typeReference, isNullable) + null -> FirErrorTypeImpl(session, typeReference, isNullable, "Unwrapped type is null") else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}") } @@ -336,12 +411,14 @@ class RawFirBuilder(val session: FirSession) { } override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement { - return FirAnnotationCallImpl( + val firAnnotationCall = FirAnnotationCallImpl( session, annotationEntry, annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(), annotationEntry.typeReference.toFirOrErrorType() ) + annotationEntry.extractArgumentsTo(firAnnotationCall) + return firAnnotationCall } override fun visitTypeParameter(parameter: KtTypeParameter, data: Unit): FirElement { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt index 561ac710557..dd2bacce312 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt @@ -22,11 +22,13 @@ interface FirElement { fun accept(visitor: FirVisitorVoid) = accept(visitor, null) - fun acceptChildren(visitor: FirVisitor, data: D) {} + fun acceptChildren(visitor: FirVisitor, data: D) {} fun acceptChildren(visitor: FirVisitorVoid) = acceptChildren(visitor, null) fun transform(visitor: FirTransformer, data: D): CompositeTransformResult = - accept(visitor, data) as CompositeTransformResult + CompositeTransformResult(accept(visitor, data)) + + fun transformChildren(transformer: FirTransformer, data: D): FirElement = this } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index 4c9da20d6f4..640602c9d83 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -118,7 +118,12 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { if (memberDeclaration.isInline) { print("inline ") } + } else if (memberDeclaration is FirProperty) { + if (memberDeclaration.isConst) { + print("const ") + } } + visitNamedDeclaration(memberDeclaration) } @@ -130,7 +135,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { override fun visitDeclaration(declaration: FirDeclaration) { print( when (declaration) { - is FirClass -> "class" + is FirClass -> declaration.classKind.name.toLowerCase().replace("_", " ") is FirTypeAlias -> "typealias" is FirNamedFunction -> "function" is FirProperty -> "property" @@ -146,6 +151,7 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { override fun visitClass(klass: FirClass) { visitMemberDeclaration(klass) val attributes = listOfNotNull( + "inner".takeIf { klass.isInner }, "companion".takeIf { klass.isCompanion }, "data".takeIf { klass.isData } ) @@ -203,6 +209,9 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { constructor.valueParameters.renderParameters() constructor.delegatedConstructor?.accept(this) constructor.body?.accept(this) + if (constructor.body == null) { + println() + } } override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { @@ -306,8 +315,8 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { visitCall(annotationCall) } - override fun visitConstructorCall(constructorCall: FirConstructorCall) { - visitCall(constructorCall) + override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { + visitCall(delegatedConstructorCall) } override fun visitType(type: FirType) { @@ -365,11 +374,16 @@ class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { override fun visitUserType(userType: FirUserType) { userType.annotations.renderAnnotations() - print(userType.name) - if (userType.arguments.isNotEmpty()) { - print("<") - userType.arguments.renderSeparated() - print(">") + for ((index, qualifier) in userType.qualifier.withIndex()) { + if (index != 0) { + print(".") + } + print(qualifier.name) + if (qualifier.typeArguments.isNotEmpty()) { + print("<") + qualifier.typeArguments.renderSeparated() + print(">") + } } visitTypeWithNullability(userType) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Utils.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Utils.kt new file mode 100644 index 00000000000..f5ce9130a91 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/Utils.kt @@ -0,0 +1,30 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir + +import org.jetbrains.kotlin.fir.visitors.FirTransformer + +fun MutableList.transformInplace(transformer: FirTransformer, data: D) { + val iterator = this.listIterator() + while (iterator.hasNext()) { + val next = iterator.next() + val result = next.transform(transformer, data) + if (result.isSingle) { + iterator.set(result.single) + } else { + val resultIterator = result.list.listIterator() + if (!resultIterator.hasNext()) { + iterator.remove() + } else { + iterator.set(resultIterator.next()) + } + while (resultIterator.hasNext()) { + iterator.add(resultIterator.next()) + } + } + } +} + diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMember.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMember.kt index 224eb45b228..f444354b82f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMember.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirCallableMember.kt @@ -18,7 +18,7 @@ interface FirCallableMember : @VisitedSupertype FirDeclaration, FirMemberDeclara override fun accept(visitor: FirVisitor, data: D): R = visitor.visitCallableMember(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { receiverType?.accept(visitor, data) super.acceptChildren(visitor, data) returnType.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt index f3238c2a684..5d36438c5ef 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirClass.kt @@ -6,17 +6,21 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be all containers should be properties and not base classes // About descriptors: introduce something like FirDescriptor which is FirUnresolved at the beginning and FirSymbol(descriptor) at the end +@BaseTransformedType interface FirClass : FirDeclarationContainer, FirMemberDeclaration { // including delegated types val superTypes: List val classKind: ClassKind + val isInner: Boolean + val isCompanion: Boolean val isData: Boolean @@ -24,7 +28,7 @@ interface FirClass : FirDeclarationContainer, FirMemberDeclaration { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitClass(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) for (superType in superTypes) { superType.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt index cee69321149..89a01c97daa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirConstructor.kt @@ -6,21 +6,26 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer -import org.jetbrains.kotlin.fir.expressions.FirConstructorCall +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirConstructor : FirFunction, FirAnnotationContainer { - val delegatedConstructor: FirConstructorCall? + val delegatedConstructor: FirDelegatedConstructorCall? val visibility: Visibility override fun accept(visitor: FirVisitor, data: D): R = visitor.visitConstructor(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) delegatedConstructor?.accept(visitor, data) - super.acceptChildren(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + body?.accept(visitor, data) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationWithBody.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationWithBody.kt index a5c66aef806..695a068c638 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationWithBody.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationWithBody.kt @@ -14,7 +14,7 @@ interface FirDeclarationWithBody : FirDeclaration { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitDeclarationWithBody(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { body?.accept(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt index ba50acdc007..5c201693376 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirEnumEntry.kt @@ -5,19 +5,20 @@ package org.jetbrains.kotlin.fir.declarations -import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.BaseTransformedType +import org.jetbrains.kotlin.fir.VisitedSupertype +import org.jetbrains.kotlin.fir.expressions.FirCall import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirEnumEntry : FirClass { - val arguments: List - +@BaseTransformedType +interface FirEnumEntry : @VisitedSupertype FirClass, FirCall { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitEnumEntry(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { for (argument in arguments) { argument.accept(visitor, data) } - super.acceptChildren(visitor, data) + super.acceptChildren(visitor, data) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFile.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFile.kt index 6e546456a24..8bb2b166577 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFile.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFile.kt @@ -5,11 +5,13 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.FqName +@BaseTransformedType interface FirFile : @VisitedSupertype FirPackageFragment, FirDeclaration, FirAnnotationContainer { val name: String @@ -20,7 +22,7 @@ interface FirFile : @VisitedSupertype FirPackageFragment, FirDeclaration, FirAnn override fun accept(visitor: FirVisitor, data: D): R = visitor.visitFile(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) for (import in imports) { import.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt index 6bfabaabdf1..e98fa19b916 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirFunction.kt @@ -15,7 +15,7 @@ interface FirFunction : FirDeclarationWithBody, FirAnnotationContainer { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitFunction(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) for (parameter in valueParameters) { parameter.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt index 0d1ca54cd43..bdfae6d0fc6 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirMemberDeclaration.kt @@ -18,7 +18,7 @@ interface FirMemberDeclaration : FirTypeParameterContainer, FirNamedDeclaration, override fun accept(visitor: FirVisitor, data: D): R = visitor.visitMemberDeclaration(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) for (typeParameter in typeParameters) { typeParameter.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt index 50830354082..3be3528ab14 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedFunction.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMember { val isOperator: Boolean @@ -18,8 +20,11 @@ interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMember { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitNamedFunction(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) - super.acceptChildren(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + body?.accept(visitor, data) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPackageFragment.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPackageFragment.kt index c0b5a282a76..aca0b5bfa10 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPackageFragment.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPackageFragment.kt @@ -12,7 +12,7 @@ interface FirPackageFragment : FirElement, FirDeclarationContainer { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitPackageFragment(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { for (declaration in declarations) { declaration.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt index 8e591e11209..82772c14d80 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirProperty.kt @@ -5,13 +5,17 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirVariable import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be should not inherit FirVariable +@BaseTransformedType interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMember, FirVariable { + val isConst: Boolean + // Should it be nullable or have some default? val getter: FirPropertyAccessor @@ -22,7 +26,7 @@ interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMember, Fir override fun accept(visitor: FirVisitor, data: D): R = visitor.visitProperty(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) initializer?.accept(visitor, data) delegate?.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt index 85e7857a6d8..803d864fd1c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPropertyAccessor.kt @@ -19,8 +19,11 @@ interface FirPropertyAccessor : @VisitedSupertype FirFunction, FirTypedDeclarati override fun accept(visitor: FirVisitor, data: D): R = visitor.visitPropertyAccessor(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) - super.acceptChildren(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + body?.accept(visitor, data) } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt index de63da900c7..34fac5b11fa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt @@ -5,18 +5,16 @@ package org.jetbrains.kotlin.fir.declarations -import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirTypeAlias : FirMemberDeclaration, FirAnnotationContainer { +interface FirTypeAlias : FirMemberDeclaration { val abbreviatedType: FirType override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypeAlias(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { - acceptAnnotations(visitor, data) + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) abbreviatedType.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt index e4acaf9f969..8a6e9c9de9b 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeParameter.kt @@ -5,11 +5,13 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.types.Variance +@BaseTransformedType interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer { val variance: Variance @@ -18,7 +20,7 @@ interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypeParameter(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) super.acceptChildren(visitor, data) for (bound in bounds) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt index ad52c011de2..7fed4f5d5ce 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypedDeclaration.kt @@ -15,7 +15,7 @@ interface FirTypedDeclaration : FirDeclaration, FirAnnotationContainer { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypedDeclaration(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) super.acceptChildren(visitor, data) returnType.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt index 8fb29d03ddb..b546a591eaa 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirValueParameter.kt @@ -5,10 +5,12 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration { val isCrossinline: Boolean @@ -21,7 +23,7 @@ interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclarat override fun accept(visitor: FirVisitor, data: D): R = visitor.visitValueParameter(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) defaultValue?.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt index d7e487cc79c..f266c71c7e8 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt @@ -12,20 +12,32 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.transformInplace import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.fir.visitors.FirTransformer -class FirClassImpl( +open class FirClassImpl( session: FirSession, psi: PsiElement?, name: Name, visibility: Visibility, modality: Modality, - override val classKind: ClassKind, - override val isCompanion: Boolean, - override val isData: Boolean + final override val classKind: ClassKind, + final override val isInner: Boolean, + final override val isCompanion: Boolean, + final override val isData: Boolean ) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality), FirClass { override val superTypes = mutableListOf() override val declarations = mutableListOf() + + + override fun transformChildren(transformer: FirTransformer, data: D): FirClass { + typeParameters.transformInplace(transformer, data) + superTypes.transformInplace(transformer, data) + declarations.transformInplace(transformer, data) + + return this + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSecondaryConstructorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt similarity index 72% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSecondaryConstructorImpl.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt index c02d8524ba2..49646e58cb2 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSecondaryConstructorImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirConstructorImpl.kt @@ -10,12 +10,12 @@ import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.expressions.FirBody -import org.jetbrains.kotlin.fir.expressions.FirConstructorCall +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall -class FirSecondaryConstructorImpl( +open class FirConstructorImpl( session: FirSession, psi: PsiElement?, - override val visibility: Visibility, - override val delegatedConstructor: FirConstructorCall?, + final override val visibility: Visibility, + final override val delegatedConstructor: FirDelegatedConstructorCall?, body: FirBody? ) : FirAbstractFunction(session, psi, body), FirConstructor \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt new file mode 100644 index 00000000000..e1f3d75e043 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirEnumEntryImpl.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.declarations.impl + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirEnumEntry +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.name.Name + +class FirEnumEntryImpl( + session: FirSession, + psi: PsiElement?, + name: Name +) : FirClassImpl( + session, + psi, + name, + visibility = Visibilities.UNKNOWN, + modality = Modality.FINAL, + classKind = ClassKind.ENUM_ENTRY, + isInner = false, + isCompanion = false, + isData = false +), FirEnumEntry { + override val arguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt index 40395e06b44..6c8da08576c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt @@ -6,11 +6,14 @@ package org.jetbrains.kotlin.fir.declarations.impl import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.declarations.FirImport import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.fir.transformInplace +import org.jetbrains.kotlin.fir.visitors.FirTransformer class FirFileImpl( session: FirSession, @@ -21,4 +24,10 @@ class FirFileImpl( override val imports = mutableListOf() override val declarations = mutableListOf() + + override fun transformChildren(transformer: FirTransformer, data: D): FirElement { + imports.transformInplace(transformer, data) + declarations.transformInplace(transformer, data) + return this + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt index 18b5f9ad185..0c7ebde2bcc 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt @@ -22,6 +22,7 @@ class FirMemberPropertyImpl( visibility: Visibility, modality: Modality, isOverride: Boolean, + override val isConst: Boolean, receiverType: FirType?, returnType: FirType, override val isVar: Boolean, diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt new file mode 100644 index 00000000000..e252bb246f1 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPrimaryConstructorImpl.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.declarations.impl + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall + +class FirPrimaryConstructorImpl( + session: FirSession, + psi: PsiElement?, + visibility: Visibility, + delegatedConstructor: FirDelegatedConstructorCall? +) : FirConstructorImpl(session, psi, visibility, delegatedConstructor, body = null) \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt index 6ccff3bddb0..b00469c1e44 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationCall.kt @@ -6,9 +6,11 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.types.FirType import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirAnnotationCall : FirCall { val annotationType: FirType @@ -18,7 +20,7 @@ interface FirAnnotationCall : FirCall { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitAnnotationCall(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { annotationType.accept(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationContainer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationContainer.kt index 7275026af5e..2daa5f5bf2f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationContainer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirAnnotationContainer.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirAnnotationContainer { val annotations: List - fun acceptAnnotations(visitor: FirVisitor, data: D) { + fun acceptAnnotations(visitor: FirVisitor, data: D) { for (annotation in annotations) { annotation.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBody.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBody.kt index 785469bbc64..4e19fb8997b 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBody.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirBody.kt @@ -15,7 +15,7 @@ interface FirBody : FirExpression { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitBody(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { for (statement in statements) { statement.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt index 46973e8802b..35273d8d720 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirCall.kt @@ -5,15 +5,17 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirCall : FirExpression { val arguments: List override fun accept(visitor: FirVisitor, data: D): R = visitor.visitCall(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { for (argument in arguments) { argument.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt similarity index 57% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt index ba91c54c88e..2d695948180 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirDelegatedConstructorCall.kt @@ -6,15 +6,22 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.types.FirTypeProjectionContainer import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirConstructorCall : FirCall { +interface FirDelegatedConstructorCall : FirCall, FirTypeProjectionContainer { + // Do we need 'constructedType: FirType' here? val constructedType: FirType - override fun accept(visitor: FirVisitor, data: D): R = - visitor.visitConstructorCall(this, data) + val isThis: Boolean - override fun acceptChildren(visitor: FirVisitor, data: D) { + val isSuper: Boolean + get() = !isThis + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitDelegatedConstructorCall(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { constructedType.accept(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt new file mode 100644 index 00000000000..47db99f424c --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt @@ -0,0 +1,8 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.expressions + +interface FirErrorExpression : FirExpression \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStatement.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStatement.kt index cb4ea0b9880..94403f4821f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStatement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirStatement.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirStatement : FirElement { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitStatement(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt index 10cd0595130..7eba36870cb 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirVariable.kt @@ -22,7 +22,7 @@ interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, F override fun accept(visitor: FirVisitor, data: D): R = visitor.visitVariable(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { initializer?.accept(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractCall.kt new file mode 100644 index 00000000000..9e9c768d671 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAbstractCall.kt @@ -0,0 +1,18 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.expressions.impl + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirCall +import org.jetbrains.kotlin.fir.expressions.FirExpression + +abstract class FirAbstractCall( + final override val session: FirSession, + final override val psi: PsiElement? +) : FirCall { + final override val arguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt index acc9bee9bee..74891a98009 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt @@ -13,10 +13,8 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.types.FirType class FirAnnotationCallImpl( - override val session: FirSession, - override val psi: PsiElement?, + session: FirSession, + psi: PsiElement?, override val useSiteTarget: AnnotationUseSiteTarget?, override val annotationType: FirType -) : FirAnnotationCall { - override val arguments = mutableListOf() -} \ No newline at end of file +) : FirAbstractCall(session, psi), FirAnnotationCall \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt new file mode 100644 index 00000000000..0d9b21037ab --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirDelegatedConstructorCallImpl.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.expressions.impl + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.types.FirTypeProjection + +class FirDelegatedConstructorCallImpl( + session: FirSession, + psi: PsiElement?, + override val constructedType: FirType, + override val isThis: Boolean +) : FirAbstractCall(session, psi), FirDelegatedConstructorCall { + override val typeArguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt new file mode 100644 index 00000000000..c65c88537f7 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.expressions.impl + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirErrorExpression + +class FirErrorExpressionImpl( + override val session: FirSession, + override val psi: PsiElement? +) : FirErrorExpression \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDelegatedType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDelegatedType.kt index da8574309bc..8466df9337c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDelegatedType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDelegatedType.kt @@ -16,7 +16,7 @@ interface FirDelegatedType : FirType { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitDelegatedType(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) delegate?.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt index 75f964ef00c..8e2f15a5242 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt @@ -8,6 +8,8 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirErrorType : FirType { + val reason: String + override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorType(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt index f4280b670d2..960aededd54 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt @@ -19,7 +19,7 @@ interface FirFunctionType : FirTypeWithNullability { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitFunctionType(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { receiverType?.accept(visitor, data) super.acceptChildren(visitor, data) for (parameter in valueParameters) { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirType.kt index 27b987cdfdf..3352b248f8e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirType.kt @@ -5,15 +5,17 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirType : FirElement, FirAnnotationContainer { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitType(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { acceptAnnotations(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjection.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjection.kt index 387466b7263..8b630be0665 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjection.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjection.kt @@ -5,9 +5,11 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.fir.BaseTransformedType import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.visitors.FirVisitor +@BaseTransformedType interface FirTypeProjection : FirElement { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypeProjection(this, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionContainer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionContainer.kt index 13d0036e1f0..933a9f63ecf 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionContainer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionContainer.kt @@ -6,5 +6,5 @@ package org.jetbrains.kotlin.fir.types interface FirTypeProjectionContainer { - val arguments: List + val typeArguments: List } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionWithVariance.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionWithVariance.kt index afabbe13836..8af9fa13e51 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionWithVariance.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeProjectionWithVariance.kt @@ -16,7 +16,7 @@ interface FirTypeProjectionWithVariance : FirTypeProjection { override fun accept(visitor: FirVisitor, data: D): R = visitor.visitTypeProjectionWithVariance(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { type.accept(visitor, data) super.acceptChildren(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt index af2f2270faa..47775da8ca7 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt @@ -8,16 +8,22 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.Name -interface FirUserType : FirTypeWithNullability, FirTypeProjectionContainer { +interface FirQualifierPart : FirTypeProjectionContainer { val name: Name +} + +interface FirUserType : FirTypeWithNullability { + val qualifier: List override fun accept(visitor: FirVisitor, data: D): R = visitor.visitUserType(this, data) - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { super.acceptChildren(visitor, data) - for (argument in arguments) { - argument.accept(visitor, data) + for (qualifier in qualifier.reversed()) { + for (argument in qualifier.typeArguments) { + argument.accept(visitor, data) + } } } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt index e6f88575ac9..e6678c4f89f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt @@ -18,7 +18,7 @@ class FirDelegatedTypeImpl( return super.accept(visitor, data) } - override fun acceptChildren(visitor: FirVisitor, data: D) { + override fun acceptChildren(visitor: FirVisitor, data: D) { type.acceptChildren(visitor, data) delegate?.accept(visitor, data) } diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt index 636c3542bbc..4677e4b26e5 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt @@ -13,7 +13,8 @@ import org.jetbrains.kotlin.fir.visitors.FirVisitor class FirErrorTypeImpl( session: FirSession, psi: PsiElement?, - isNullable: Boolean + isNullable: Boolean, + override val reason: String ) : FirAbstractAnnotatedType(session, psi, isNullable), FirErrorType { override fun accept(visitor: FirVisitor, data: D): R { return super.accept(visitor, data) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirQualifierPartImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirQualifierPartImpl.kt new file mode 100644 index 00000000000..f7242c8d5d9 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirQualifierPartImpl.kt @@ -0,0 +1,14 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.types.impl + +import org.jetbrains.kotlin.fir.types.FirQualifierPart +import org.jetbrains.kotlin.fir.types.FirTypeProjection +import org.jetbrains.kotlin.name.Name + +class FirQualifierPartImpl(override val name: Name) : FirQualifierPart { + override val typeArguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt index a72079365cd..60cf73c45af 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt @@ -7,15 +7,14 @@ package org.jetbrains.kotlin.fir.types.impl import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirQualifierPart import org.jetbrains.kotlin.fir.types.FirUserType -import org.jetbrains.kotlin.fir.types.FirTypeProjection -import org.jetbrains.kotlin.name.Name +import java.util.* class FirUserTypeImpl( session: FirSession, psi: PsiElement?, - isNullable: Boolean, - override val name: Name + isNullable: Boolean ) : FirAbstractAnnotatedType(session, psi, isNullable), FirUserType { - override val arguments = mutableListOf() + override val qualifier = LinkedList() } \ No newline at end of file diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt index c6000048ed5..e4a9ffcfae2 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/CompositeTransformResult.kt @@ -32,4 +32,5 @@ inline class CompositeTransformResult(val a: Any) { } } -inline fun T.compose() = CompositeTransformResult.single(this) \ No newline at end of file +@Suppress("NOTHING_TO_INLINE") +inline fun T.compose() = CompositeTransformResult.single(this) \ No newline at end of file diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt index 09f174e8378..055000807c2 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirTransformerGenerated.kt @@ -1,10 +1,10 @@ /* - * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2018 JetBrains s.r.o. 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.fir.visitors -import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.types.* @@ -26,10 +26,7 @@ abstract class FirTransformer : FirVisitor { + open fun transformAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { return transformDeclarationWithBody(anonymousInitializer, data) } @@ -101,82 +98,83 @@ abstract class FirTransformer : FirVisitor transformFile(file: E, data: D): CompositeTransformResult { + open fun transformFile(file: FirFile, data: D): CompositeTransformResult { return transformPackageFragment(file, data) } - open fun transformStatement(statement: E, data: D): CompositeTransformResult { + open fun transformStatement(statement: FirStatement, data: D): CompositeTransformResult { return transformElement(statement, data) } - open fun transformExpression(expression: E, data: D): CompositeTransformResult { + open fun transformExpression(expression: FirExpression, data: D): CompositeTransformResult { return transformStatement(expression, data) } - open fun transformBody(body: E, data: D): CompositeTransformResult { + open fun transformBody(body: FirBody, data: D): CompositeTransformResult { return transformExpression(body, data) } - open fun transformCall(call: E, data: D): CompositeTransformResult { + open fun transformCall(call: FirCall, data: D): CompositeTransformResult { return transformExpression(call, data) } - open fun transformAnnotationCall(annotationCall: E, data: D): CompositeTransformResult { + open fun transformAnnotationCall(annotationCall: FirAnnotationCall, data: D): CompositeTransformResult { return transformCall(annotationCall, data) } - open fun transformConstructorCall(constructorCall: E, data: D): CompositeTransformResult { - return transformCall(constructorCall, data) + open fun transformDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { + return transformCall(delegatedConstructorCall, data) } - open fun transformType(type: E, data: D): CompositeTransformResult { + open fun transformErrorExpression(errorExpression: FirErrorExpression, data: D): CompositeTransformResult { + return transformExpression(errorExpression, data) + } + + open fun transformType(type: FirType, data: D): CompositeTransformResult { return transformElement(type, data) } - open fun transformDelegatedType(delegatedType: E, data: D): CompositeTransformResult { + open fun transformDelegatedType(delegatedType: FirDelegatedType, data: D): CompositeTransformResult { return transformType(delegatedType, data) } - open fun transformErrorType(errorType: E, data: D): CompositeTransformResult { + open fun transformErrorType(errorType: FirErrorType, data: D): CompositeTransformResult { return transformType(errorType, data) } - open fun transformImplicitType(implicitType: E, data: D): CompositeTransformResult { + open fun transformImplicitType(implicitType: FirImplicitType, data: D): CompositeTransformResult { return transformType(implicitType, data) } - open fun transformTypeWithNullability(typeWithNullability: E, data: D): CompositeTransformResult { + open fun transformTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): CompositeTransformResult { return transformType(typeWithNullability, data) } - open fun transformDynamicType(dynamicType: E, data: D): CompositeTransformResult { + open fun transformDynamicType(dynamicType: FirDynamicType, data: D): CompositeTransformResult { return transformTypeWithNullability(dynamicType, data) } - open fun transformFunctionType(functionType: E, data: D): CompositeTransformResult { + open fun transformFunctionType(functionType: FirFunctionType, data: D): CompositeTransformResult { return transformTypeWithNullability(functionType, data) } - open fun transformResolvedType(resolvedType: E, data: D): CompositeTransformResult { + open fun transformResolvedType(resolvedType: FirResolvedType, data: D): CompositeTransformResult { return transformTypeWithNullability(resolvedType, data) } - open fun transformUserType(userType: E, data: D): CompositeTransformResult { + open fun transformUserType(userType: FirUserType, data: D): CompositeTransformResult { return transformTypeWithNullability(userType, data) } - open fun transformTypeProjection(typeProjection: E, data: D): CompositeTransformResult { + open fun transformTypeProjection(typeProjection: FirTypeProjection, data: D): CompositeTransformResult { return transformElement(typeProjection, data) } - open fun transformStarProjection(starProjection: E, data: D): CompositeTransformResult { + open fun transformStarProjection(starProjection: FirStarProjection, data: D): CompositeTransformResult { return transformTypeProjection(starProjection, data) } - open fun transformTypeProjectionWithVariance( - typeProjectionWithVariance: E, - data: D - ): CompositeTransformResult { + open fun transformTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { return transformTypeProjection(typeProjectionWithVariance, data) } @@ -192,10 +190,7 @@ abstract class FirTransformer : FirVisitor { + final override fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): CompositeTransformResult { return transformDeclarationWithBody(declarationWithBody, data) } @@ -235,10 +230,7 @@ abstract class FirTransformer : FirVisitor { + final override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): CompositeTransformResult { return transformTypeWithNullability(typeWithNullability, data) } @@ -246,8 +238,8 @@ abstract class FirTransformer : FirVisitor { - return transformConstructorCall(constructorCall, data) + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): CompositeTransformResult { + return transformDelegatedConstructorCall(delegatedConstructorCall, data) } final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): CompositeTransformResult { @@ -278,10 +270,7 @@ abstract class FirTransformer : FirVisitor { + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): CompositeTransformResult { return transformAnonymousInitializer(anonymousInitializer, data) } @@ -293,6 +282,10 @@ abstract class FirTransformer : FirVisitor { + return transformErrorExpression(errorExpression, data) + } + final override fun visitConstructor(constructor: FirConstructor, data: D): CompositeTransformResult { return transformConstructor(constructor, data) } @@ -333,10 +326,7 @@ abstract class FirTransformer : FirVisitor { + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): CompositeTransformResult { return transformTypeProjectionWithVariance(typeProjectionWithVariance, data) } diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt index 250f83f1b28..7342006c509 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -122,8 +122,12 @@ abstract class FirVisitor { return visitCall(annotationCall, data) } - open fun visitConstructorCall(constructorCall: FirConstructorCall, data: D): R { - return visitCall(constructorCall, data) + open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: D): R { + return visitCall(delegatedConstructorCall, data) + } + + open fun visitErrorExpression(errorExpression: FirErrorExpression, data: D): R { + return visitExpression(errorExpression, data) } open fun visitType(type: FirType, data: D): R { diff --git a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt index cdc6e504ee1..62f2ef571fa 100644 --- a/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -122,8 +122,12 @@ abstract class FirVisitorVoid : FirVisitor() { visitCall(annotationCall, null) } - open fun visitConstructorCall(constructorCall: FirConstructorCall) { - visitCall(constructorCall, null) + open fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall) { + visitCall(delegatedConstructorCall, null) + } + + open fun visitErrorExpression(errorExpression: FirErrorExpression) { + visitExpression(errorExpression, null) } open fun visitType(type: FirType) { @@ -234,8 +238,8 @@ abstract class FirVisitorVoid : FirVisitor() { visitAnnotationCall(annotationCall) } - final override fun visitConstructorCall(constructorCall: FirConstructorCall, data: Nothing?) { - visitConstructorCall(constructorCall) + final override fun visitDelegatedConstructorCall(delegatedConstructorCall: FirDelegatedConstructorCall, data: Nothing?) { + visitDelegatedConstructorCall(delegatedConstructorCall) } final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) { @@ -278,6 +282,10 @@ abstract class FirVisitorVoid : FirVisitor() { visitBody(body) } + final override fun visitErrorExpression(errorExpression: FirErrorExpression, data: Nothing?) { + visitErrorExpression(errorExpression) + } + final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) { visitConstructor(constructor) } diff --git a/compiler/testData/fir/rawBuilder/declarations/F.kt b/compiler/testData/fir/rawBuilder/declarations/F.kt new file mode 100644 index 00000000000..3b2748ad007 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/F.kt @@ -0,0 +1,4 @@ +open class A + + +class B : A \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/F.txt b/compiler/testData/fir/rawBuilder/declarations/F.txt new file mode 100644 index 00000000000..0e5f8855f41 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/F.txt @@ -0,0 +1,5 @@ +FILE: F.kt + unknown open class A() { + } + unknown final class B() : A { + } diff --git a/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.kt b/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.kt new file mode 100644 index 00000000000..2af76b328d1 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.kt @@ -0,0 +1,9 @@ +abstract class A { + abstract class Nested +} + +typealias TA = A + +class B : TA() { + class NestedInB : Nested() +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.txt b/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.txt new file mode 100644 index 00000000000..11ea929a8c6 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.txt @@ -0,0 +1,12 @@ +FILE: NestedOfAliasedType.kt + unknown abstract class A() { + unknown abstract class Nested() { + } + + } + unknown final typealias TA = A + unknown final class B() : TA { + unknown final class NestedInB() : Nested { + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.kt b/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.kt new file mode 100644 index 00000000000..ca28a0dc3dd --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.kt @@ -0,0 +1,13 @@ +package p + +abstract class My { + abstract class NestedOne : My() { + abstract class NestedTwo : NestedOne() { + + } + } +} + +class Your : My() { + class NestedThree : NestedOne() +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.txt b/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.txt new file mode 100644 index 00000000000..7dd6d52344b --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/NestedSuperType.txt @@ -0,0 +1,14 @@ +FILE: NestedSuperType.kt + unknown abstract class My() { + unknown abstract class NestedOne() : My { + unknown abstract class NestedTwo() : NestedOne { + } + + } + + } + unknown final class Your() : My { + unknown final class NestedThree() : NestedOne { + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/complexTypes.kt b/compiler/testData/fir/rawBuilder/declarations/complexTypes.kt new file mode 100644 index 00000000000..4ff9238e2a4 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/complexTypes.kt @@ -0,0 +1,11 @@ +package a.b + +class C { + inner class D { + + } +} + +interface Test { + val x: a.b.C.D, *> +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/complexTypes.txt b/compiler/testData/fir/rawBuilder/declarations/complexTypes.txt new file mode 100644 index 00000000000..e0cb9666f55 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/complexTypes.txt @@ -0,0 +1,11 @@ +FILE: complexTypes.kt + unknown final class C() { + unknown final class D(inner) { + } + + } + unknown final interface Test() { + unknown final property x(val): a.b.C.D, *> + unknown get(): a.b.C.D, *> + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/derivedClass.kt b/compiler/testData/fir/rawBuilder/declarations/derivedClass.kt new file mode 100644 index 00000000000..90379bd28e7 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/derivedClass.kt @@ -0,0 +1,5 @@ +open class Base(val x: T) + +class Derived(x: T) : Base(x) + +fun create(x: T): Derived = Derived(x) \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/derivedClass.txt b/compiler/testData/fir/rawBuilder/declarations/derivedClass.txt new file mode 100644 index 00000000000..6657735e32c --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/derivedClass.txt @@ -0,0 +1,12 @@ +FILE: derivedClass.kt + unknown open class Base() { + unknown constructor(x: T) + + } + unknown final class Derived() : Base { + unknown constructor(x: T)STUB + + } + unknown final function create(x: T): Derived { + STUB + } diff --git a/compiler/testData/fir/rawBuilder/declarations/enums.kt b/compiler/testData/fir/rawBuilder/declarations/enums.kt new file mode 100644 index 00000000000..d9193ae313b --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/enums.kt @@ -0,0 +1,33 @@ +import my.println + +enum class Order { + FIRST, + SECOND, + THIRD +} + +enum class Planet(val m: Double, internal val r: Double) { + MERCURY(1.0, 2.0) { + override fun sayHello() { + println("Hello!!!") + } + }, + VENERA(3.0, 4.0) { + override fun sayHello() { + println("Ola!!!") + } + }, + EARTH(5.0, 6.0) { + override fun sayHello() { + println("Privet!!!") + } + }; + + val g: Double = G * m / (r * r) + + abstract fun sayHello() + + companion object { + const val G = 6.67e-11 + } +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/enums.txt b/compiler/testData/fir/rawBuilder/declarations/enums.txt new file mode 100644 index 00000000000..faa19d4b8d4 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/enums.txt @@ -0,0 +1,45 @@ +FILE: enums.kt + unknown final enum class Order() { + unknown final enum entry FIRST() { + } + + unknown final enum entry SECOND() { + } + + unknown final enum entry THIRD() { + } + + } + unknown final enum class Planet() { + unknown constructor(m: Double, r: Double) + + unknown final enum entry MERCURY() : Planet { + unknown final override function sayHello(): { + } + + } + + unknown final enum entry VENERA() : Planet { + unknown final override function sayHello(): { + } + + } + + unknown final enum entry EARTH() : Planet { + unknown final override function sayHello(): { + } + + } + + unknown final property g(val): Double = STUB + unknown get(): Double + + unknown abstract function sayHello(): + + unknown final object Companion(companion) { + unknown final const property G(val): = STUB + unknown get(): + + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/enums2.kt b/compiler/testData/fir/rawBuilder/declarations/enums2.kt new file mode 100644 index 00000000000..8729baeccde --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/enums2.kt @@ -0,0 +1,16 @@ +interface Some + +object O1 : Some + +object O2 : Some + +enum class SomeEnum(val x: Some) { + FIRST(O1) { + override fun check(y: Some): Boolean = true + }, + SECOND(O2) { + override fun check(y: Some): Boolean = y == O2 + }; + + abstract fun check(y: Some): Boolean +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/enums2.txt b/compiler/testData/fir/rawBuilder/declarations/enums2.txt new file mode 100644 index 00000000000..42af278384a --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/enums2.txt @@ -0,0 +1,27 @@ +FILE: enums2.kt + unknown final interface Some() { + } + unknown final object O1() : Some { + } + unknown final object O2() : Some { + } + unknown final enum class SomeEnum() { + unknown constructor(x: Some) + + unknown final enum entry FIRST() : SomeEnum { + unknown final override function check(y: Some): Boolean { + STUB + } + + } + + unknown final enum entry SECOND() : SomeEnum { + unknown final override function check(y: Some): Boolean { + STUB + } + + } + + unknown abstract function check(y: Some): Boolean + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/functionTypes.kt b/compiler/testData/fir/rawBuilder/declarations/functionTypes.kt new file mode 100644 index 00000000000..60a3246170d --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/functionTypes.kt @@ -0,0 +1,8 @@ +fun simpleRun(f: (T) -> Unit): Unit = f() + +fun List.simpleMap(f: (T) -> R): R { + +} + +fun simpleWith(t: T, f: T.() -> Unit): Unit = t.f() + diff --git a/compiler/testData/fir/rawBuilder/declarations/functionTypes.txt b/compiler/testData/fir/rawBuilder/declarations/functionTypes.txt new file mode 100644 index 00000000000..fdca19abceb --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/functionTypes.txt @@ -0,0 +1,9 @@ +FILE: functionTypes.kt + unknown final function simpleRun(f: ( (: T): Unit )): Unit { + STUB + } + unknown final function simpleMapList.(f: ( (: T): R )): R { + } + unknown final function simpleWith(t: T, f: ( T.(): Unit )): Unit { + STUB + } diff --git a/compiler/testData/fir/rawBuilder/declarations/genericFunctions.kt b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.kt new file mode 100644 index 00000000000..a88e9c41a82 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.kt @@ -0,0 +1,7 @@ +interface Any + +inline fun Any.safeAs(): T? = this as? T + +abstract class Summator { + abstract fun plus(first: T, second: T): T +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt new file mode 100644 index 00000000000..b40ac57ea60 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/genericFunctions.txt @@ -0,0 +1,10 @@ +FILE: genericFunctions.kt + unknown final interface Any() { + } + unknown final inline function safeAsAny.(): T? { + STUB + } + unknown abstract class Summator() { + unknown abstract function plus(first: T, second: T): T + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/nestedClass.kt b/compiler/testData/fir/rawBuilder/declarations/nestedClass.kt new file mode 100644 index 00000000000..a85711506cb --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/nestedClass.kt @@ -0,0 +1,7 @@ +abstract class Base(val s: String) + +class Outer { + class Derived(s: String) : Base(s) + + object Obj : Base("") +} diff --git a/compiler/testData/fir/rawBuilder/declarations/nestedClass.txt b/compiler/testData/fir/rawBuilder/declarations/nestedClass.txt new file mode 100644 index 00000000000..77100615d34 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/nestedClass.txt @@ -0,0 +1,15 @@ +FILE: nestedClass.kt + unknown abstract class Base() { + unknown constructor(s: String) + + } + unknown final class Outer() { + unknown final class Derived() : Base { + unknown constructor(s: String)STUB + + } + + unknown final object Obj() : Base { + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt b/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt index 839f20704d8..851f3c6f289 100644 --- a/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt +++ b/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt @@ -14,4 +14,6 @@ class SomeClass : SomeInterface { override var bar: Boolean get() = true set(value) {} + + var fau: Double } \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt index 41cd20bbd9f..5a27f16d46c 100644 --- a/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt +++ b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt @@ -1,5 +1,5 @@ FILE: simpleClass.kt - unknown final class SomeInterface() { + unknown final interface SomeInterface() { unknown final function foo(x: Int, y: String): String unknown final property bar(val): Boolean @@ -20,4 +20,8 @@ FILE: simpleClass.kt unknown set(value: Boolean): { } + unknown final property fau(var): Double + unknown get(): Double + unknown set(value: Double): R/Unit/ + } diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.kt b/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.kt new file mode 100644 index 00000000000..00b88d1bd87 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.kt @@ -0,0 +1,5 @@ +interface B + +typealias C = B + +class D : C \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.txt b/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.txt new file mode 100644 index 00000000000..e73dd58a69f --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.txt @@ -0,0 +1,6 @@ +FILE: simpleTypeAlias.kt + unknown final interface B() { + } + unknown final typealias C = B + unknown final class D() : C { + } diff --git a/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.kt b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.kt new file mode 100644 index 00000000000..c9c9eadadb0 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.kt @@ -0,0 +1,7 @@ +open class A + +interface B + +typealias C = B + +class D : C diff --git a/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt new file mode 100644 index 00000000000..27dca8cf45c --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.txt @@ -0,0 +1,8 @@ +FILE: typeAliasWithGeneric.kt + unknown open class A() { + } + unknown final interface B() { + } + unknown final typealias C = B + unknown final class D() : C { + } diff --git a/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.kt b/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.kt new file mode 100644 index 00000000000..df1765a2f4f --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.kt @@ -0,0 +1,17 @@ +package test + +interface Some + +abstract class My { + inner class T + + abstract val x: T + + abstract fun foo(arg: T) + + abstract val y: My.T + + abstract val z: test.My.T + + class Some : T() +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.txt b/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.txt new file mode 100644 index 00000000000..0bb5993d725 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.txt @@ -0,0 +1,22 @@ +FILE: typeParameterVsNested.kt + unknown final interface Some() { + } + unknown abstract class My() { + unknown final class T(inner) { + } + + unknown abstract property x(val): T + unknown get(): T + + unknown abstract function foo(arg: T): + + unknown abstract property y(val): My.T + unknown get(): My.T + + unknown abstract property z(val): test.My.T + unknown get(): test.My.T + + unknown final class Some() : T { + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt b/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt index 310960ca93f..2b7383a4a02 100644 --- a/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt +++ b/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt @@ -1,5 +1,5 @@ FILE: typeParameters.kt - unknown final class List() { + unknown final interface List() { unknown final operator function get(index: Int): T unknown final infix function concat(other: List): List diff --git a/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java index d9aacf8605a..e9aa9dacbf3 100644 --- a/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java @@ -1,5 +1,5 @@ /* - * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ @@ -21,6 +21,10 @@ import java.util.regex.Pattern; @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCase { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doRawFirTest, TargetBackend.ANY, testDataFilePath); + } + public void testAllFilesPresentInRawBuilder() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/fir/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } @@ -29,26 +33,92 @@ public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCas @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) public static class Declarations extends AbstractRawFirBuilderTestCase { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doRawFirTest, TargetBackend.ANY, testDataFilePath); + } + public void testAllFilesPresentInDeclarations() throws Exception { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/fir/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); } + @TestMetadata("complexTypes.kt") + public void testComplexTypes() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/complexTypes.kt"); + } + + @TestMetadata("derivedClass.kt") + public void testDerivedClass() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/derivedClass.kt"); + } + + @TestMetadata("enums.kt") + public void testEnums() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/enums.kt"); + } + + @TestMetadata("enums2.kt") + public void testEnums2() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/enums2.kt"); + } + + @TestMetadata("F.kt") + public void testF() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/F.kt"); + } + + @TestMetadata("functionTypes.kt") + public void testFunctionTypes() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/functionTypes.kt"); + } + + @TestMetadata("genericFunctions.kt") + public void testGenericFunctions() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/genericFunctions.kt"); + } + + @TestMetadata("nestedClass.kt") + public void testNestedClass() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/nestedClass.kt"); + } + + @TestMetadata("NestedOfAliasedType.kt") + public void testNestedOfAliasedType() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/NestedOfAliasedType.kt"); + } + + @TestMetadata("NestedSuperType.kt") + public void testNestedSuperType() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/NestedSuperType.kt"); + } + @TestMetadata("simpleClass.kt") public void testSimpleClass() throws Exception { - String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/simpleClass.kt"); - doRawFirTest(fileName); + runTest("compiler/testData/fir/rawBuilder/declarations/simpleClass.kt"); } @TestMetadata("simpleFun.kt") public void testSimpleFun() throws Exception { - String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/simpleFun.kt"); - doRawFirTest(fileName); + runTest("compiler/testData/fir/rawBuilder/declarations/simpleFun.kt"); + } + + @TestMetadata("simpleTypeAlias.kt") + public void testSimpleTypeAlias() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/simpleTypeAlias.kt"); + } + + @TestMetadata("typeAliasWithGeneric.kt") + public void testTypeAliasWithGeneric() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/typeAliasWithGeneric.kt"); + } + + @TestMetadata("typeParameterVsNested.kt") + public void testTypeParameterVsNested() throws Exception { + runTest("compiler/testData/fir/rawBuilder/declarations/typeParameterVsNested.kt"); } @TestMetadata("typeParameters.kt") public void testTypeParameters() throws Exception { - String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/typeParameters.kt"); - doRawFirTest(fileName); + runTest("compiler/testData/fir/rawBuilder/declarations/typeParameters.kt"); } } }