From 2c626d6c5d3573219617732e770284d203b77d3f Mon Sep 17 00:00:00 2001 From: Mikhail Glukhikh Date: Wed, 14 Mar 2018 18:36:44 +0300 Subject: [PATCH] Implement raw FIR builder (initial version) All necessary FIR tree implementations were created FIR renderer & three first builder tests were added #KT-24013 Fixed --- .../kotlin/fir/builder/RawFirBuilder.kt | 387 ++++++++++++++++- .../org/jetbrains/kotlin/fir/FirElement.kt | 13 + .../org/jetbrains/kotlin/fir/FirRenderer.kt | 390 ++++++++++++++++++ .../declarations/FirAnonymousInitializer.kt | 8 +- .../fir/declarations/FirCallableMember.kt | 17 +- .../kotlin/fir/declarations/FirClass.kt | 16 + .../kotlin/fir/declarations/FirConstructor.kt | 16 +- .../kotlin/fir/declarations/FirDeclaration.kt | 7 +- .../declarations/FirDeclarationWithBody.kt | 11 +- .../kotlin/fir/declarations/FirEnumEntry.kt | 11 + .../fir/declarations/FirErrorDeclaration.kt | 4 + .../kotlin/fir/declarations/FirFile.kt | 22 +- .../kotlin/fir/declarations/FirFunction.kt | 12 + .../kotlin/fir/declarations/FirImport.kt | 10 + .../fir/declarations/FirMemberDeclaration.kt | 12 + .../fir/declarations/FirNamedDeclaration.kt | 4 + .../fir/declarations/FirNamedFunction.kt | 18 +- .../fir/declarations/FirPackageFragment.kt | 10 + .../kotlin/fir/declarations/FirProperty.kt | 15 +- .../fir/declarations/FirPropertyAccessor.kt | 14 +- .../kotlin/fir/declarations/FirTypeAlias.kt | 10 + .../fir/declarations/FirTypeParameter.kt | 12 + .../fir/declarations/FirTypedDeclaration.kt | 10 + .../fir/declarations/FirValueParameter.kt | 12 +- .../impl/FirAbstractAnnotatedDeclaration.kt | 19 + .../impl/FirAbstractCallableMember.kt | 25 ++ .../declarations/impl/FirAbstractFunction.kt | 20 + .../impl/FirAbstractMemberDeclaration.kt | 24 ++ .../FirAbstractNamedAnnotatedDeclaration.kt | 17 + .../impl/FirAnonymousInitializerImpl.kt | 17 + .../fir/declarations/impl/FirClassImpl.kt | 31 ++ .../impl/FirDefaultPropertyAccessor.kt | 38 ++ .../impl/FirDefaultSetterValueParameter.kt | 31 ++ .../fir/declarations/impl/FirFileImpl.kt | 24 ++ .../fir/declarations/impl/FirImportImpl.kt | 19 + .../impl/FirMemberFunctionImpl.kt | 34 ++ .../impl/FirMemberPropertyImpl.kt | 33 ++ .../impl/FirNamedAnnotatedDeclaration.kt | 21 + .../impl/FirPackageFragmentImpl.kt | 4 + .../impl/FirPropertyAccessorImpl.kt | 22 + .../impl/FirSecondaryConstructorImpl.kt | 21 + .../fir/declarations/impl/FirTypeAliasImpl.kt | 22 + .../declarations/impl/FirTypeParameterImpl.kt | 22 + .../impl/FirValueParameterImpl.kt | 25 ++ .../fir/expressions/FirAnnotationCall.kt | 12 +- .../fir/expressions/FirAnnotationContainer.kt | 8 + .../kotlin/fir/expressions/FirBody.kt | 15 +- .../kotlin/fir/expressions/FirCall.kt | 12 + .../fir/expressions/FirConstructorCall.kt | 9 + .../kotlin/fir/expressions/FirExpression.kt | 4 + .../kotlin/fir/expressions/FirStatement.kt | 3 + .../kotlin/fir/expressions/FirVariable.kt | 18 +- .../expressions/impl/FirAnnotationCallImpl.kt | 22 + .../fir/expressions/impl/FirBlockBodyImpl.kt | 15 + .../expressions/impl/FirExpressionBodyImpl.kt | 21 + .../fir/expressions/impl/FirExpressionStub.kt | 13 + .../kotlin/fir/types/FirDelegatedType.kt | 15 +- .../kotlin/fir/types/FirDynamicType.kt | 13 + .../{FirExplicitType.kt => FirErrorType.kt} | 6 +- .../kotlin/fir/types/FirFunctionType.kt | 29 ++ .../kotlin/fir/types/FirImplicitType.kt | 4 + .../kotlin/fir/types/FirResolvedType.kt | 6 +- .../kotlin/fir/types/FirStarProjection.kt | 7 +- .../org/jetbrains/kotlin/fir/types/FirType.kt | 11 +- .../kotlin/fir/types/FirTypeProjection.kt | 4 +- .../types/FirTypeProjectionWithVariance.kt | 11 +- .../fir/types/FirTypeWithNullability.kt | 15 + .../jetbrains/kotlin/fir/types/FirUserType.kt | 23 ++ .../types/impl/FirAbstractAnnotatedType.kt | 19 + .../fir/types/impl/FirDelegatedTypeImpl.kt | 25 ++ .../fir/types/impl/FirDynamicTypeImpl.kt | 16 + .../kotlin/fir/types/impl/FirErrorTypeImpl.kt | 21 + .../fir/types/impl/FirFunctionTypeImpl.kt | 22 + .../fir/types/impl/FirImplicitTypeImpl.kt | 19 + .../fir/types/impl/FirStarProjectionImpl.kt | 15 + .../impl/FirTypeProjectionWithVarianceImpl.kt | 19 + .../kotlin/fir/types/impl/FirUnitType.kt | 26 ++ .../kotlin/fir/types/impl/FirUserTypeImpl.kt | 21 + .../src/VisitorsGenerator.kt | 7 +- .../fir/visitors/FirVisitorGenerated.kt | 177 ++++++++ .../fir/visitors/FirVisitorVoidGenerated.kt | 341 +++++++++++++++ .../jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt | 2 + .../rawBuilder/declarations/simpleClass.kt | 17 + .../rawBuilder/declarations/simpleClass.txt | 23 ++ .../fir/rawBuilder/declarations/simpleFun.kt | 1 + .../fir/rawBuilder/declarations/simpleFun.txt | 3 + .../rawBuilder/declarations/typeParameters.kt | 16 + .../declarations/typeParameters.txt | 21 + compiler/tests-common/build.gradle.kts | 2 + compiler/tests-common/build.gradle.kts.173 | 2 + compiler/tests-common/build.gradle.kts.181 | 2 + .../builder/AbstractRawFirBuilderTestCase.kt | 72 ++++ .../RawFirBuilderTestCaseGenerated.java | 54 +++ .../generators/tests/GenerateCompilerTests.kt | 5 + 94 files changed, 2727 insertions(+), 27 deletions(-) create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractFunction.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractNamedAnnotatedDeclaration.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirNamedAnnotatedDeclaration.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPackageFragmentImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSecondaryConstructorImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockBodyImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionBodyImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDynamicType.kt rename compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/{FirExplicitType.kt => FirErrorType.kt} (50%) create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeWithNullability.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedType.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUnitType.kt create mode 100644 compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt create mode 100644 compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt create mode 100644 compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt create mode 100644 compiler/testData/fir/rawBuilder/declarations/simpleClass.kt create mode 100644 compiler/testData/fir/rawBuilder/declarations/simpleClass.txt create mode 100644 compiler/testData/fir/rawBuilder/declarations/simpleFun.kt create mode 100644 compiler/testData/fir/rawBuilder/declarations/simpleFun.txt create mode 100644 compiler/testData/fir/rawBuilder/declarations/typeParameters.kt create mode 100644 compiler/testData/fir/rawBuilder/declarations/typeParameters.txt create mode 100644 compiler/tests-common/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt create mode 100644 compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java 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 e98ef7e5401..bbaf36c1e50 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 @@ -5,5 +5,390 @@ package org.jetbrains.kotlin.fir.builder -class RawFirBuilder { +import org.jetbrains.kotlin.descriptors.ClassKind +import org.jetbrains.kotlin.descriptors.Modality +import org.jetbrains.kotlin.descriptors.Visibilities +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.* +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.types.FirType +import org.jetbrains.kotlin.fir.types.FirTypeProjection +import org.jetbrains.kotlin.fir.types.impl.* +import org.jetbrains.kotlin.lexer.KtTokens +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.psiUtil.modalityModifierType +import org.jetbrains.kotlin.psi.psiUtil.visibilityModifierType +import org.jetbrains.kotlin.types.Variance + +class RawFirBuilder(val session: FirSession) { + + fun buildFirFile(file: KtFile): FirFile { + return file.accept(Visitor(), Unit) as FirFile + } + + private val KtModifierListOwner.visibility: Visibility + get() { + val modifierType = visibilityModifierType() + return when (modifierType) { + KtTokens.PUBLIC_KEYWORD -> Visibilities.PUBLIC + KtTokens.PROTECTED_KEYWORD -> Visibilities.PROTECTED + KtTokens.INTERNAL_KEYWORD -> Visibilities.INTERNAL + KtTokens.PRIVATE_KEYWORD -> Visibilities.PRIVATE + else -> Visibilities.UNKNOWN + } + } + + private val KtDeclaration.modality: Modality + get() { + val modifierType = modalityModifierType() + return when (modifierType) { + KtTokens.FINAL_KEYWORD -> Modality.FINAL + KtTokens.SEALED_KEYWORD -> Modality.SEALED + KtTokens.ABSTRACT_KEYWORD -> Modality.ABSTRACT + KtTokens.OPEN_KEYWORD -> Modality.OPEN + else -> Modality.FINAL // FIX ME + } + } + + private inner class Visitor : KtVisitor() { + @Suppress("UNCHECKED_CAST") + private fun KtElement?.convertSafe(): R? = + this?.accept(this@Visitor, Unit) as? R + + @Suppress("UNCHECKED_CAST") + private fun KtElement.convert(): R = + this.accept(this@Visitor, Unit) as R + + private fun KtTypeReference?.toFirOrImplicitType(): FirType = + convertSafe() ?: FirImplicitTypeImpl(session, this) + + private fun KtTypeReference?.toFirOrErrorType(): FirType = + convertSafe() ?: FirErrorTypeImpl(session, this, false) + + private fun KtExpression?.toFirBody(): FirBody? = + convertSafe()?.let { it as? FirBody ?: FirExpressionBodyImpl(session, it) } + + private fun KtPropertyAccessor?.toFirPropertyAccessor( + property: KtProperty, + propertyType: FirType, + isGetter: Boolean + ): FirPropertyAccessor { + if (this == null) { + return FirDefaultPropertyAccessor(session, property, isGetter, propertyType) + } + val firAccessor = FirPropertyAccessorImpl( + session, + this, + isGetter, + visibility, + returnTypeReference.toFirOrImplicitType(), + bodyExpression.toFirBody() + ) + extractAnnotationsTo(firAccessor) + extractValueParametersTo(firAccessor, propertyType) + if (!isGetter && firAccessor.valueParameters.isEmpty()) { + firAccessor.valueParameters += FirDefaultSetterValueParameter(session, this, propertyType) + } + return firAccessor + } + + private fun KtParameter.toFirValueParameter(defaultType: FirType? = null): FirValueParameter { + val firValueParameter = FirValueParameterImpl( + session, + this, + hasValOrVar(), + nameAsSafeName, + when { + typeReference != null -> typeReference.toFirOrErrorType() + defaultType != null -> defaultType + else -> null.toFirOrErrorType() + }, + defaultValue?.convert(), + isCrossinline = hasModifier(KtTokens.CROSSINLINE_KEYWORD), + isNoinline = hasModifier(KtTokens.NOINLINE_KEYWORD), + isVararg = isVarArg + ) + extractAnnotationsTo(firValueParameter) + return firValueParameter + } + + private fun KtModifierListOwner.extractAnnotationsTo(container: FirAbstractAnnotatedDeclaration) { + for (annotationEntry in annotationEntries) { + container.annotations += annotationEntry.convert() + } + } + + private fun KtTypeParameterListOwner.extractTypeParametersTo(container: FirAbstractMemberDeclaration) { + for (typeParameter in typeParameters) { + container.typeParameters += typeParameter.convert() + } + } + + private fun KtDeclarationWithBody.extractValueParametersTo( + container: FirAbstractFunction, + defaultType: FirType? = null + ) { + for (valueParameter in valueParameters) { + container.valueParameters += valueParameter.toFirValueParameter(defaultType) + } + } + + override fun visitKtFile(file: KtFile, data: Unit): FirElement { + val firFile = FirFileImpl(session, file, file.name, file.packageFqName) + for (annotationEntry in file.annotationEntries) { + firFile.annotations += annotationEntry.convert() + } + for (importDirective in file.importDirectives) { + firFile.imports += FirImportImpl( + session, + importDirective, + importDirective.importedFqName, + importDirective.isAllUnder, + importDirective.aliasName + ) + } + for (declaration in file.declarations) { + firFile.declarations += declaration.convert() + } + return firFile + } + + override fun visitClassOrObject(classOrObject: KtClassOrObject, data: Unit): FirElement { + val classKind = when (classOrObject) { + is KtObjectDeclaration -> ClassKind.OBJECT + is KtClass -> when { + classOrObject.isInterface() -> ClassKind.INTERFACE + classOrObject.isEnum() -> ClassKind.ENUM_CLASS + classOrObject.isAnnotation() -> ClassKind.ANNOTATION_CLASS + else -> ClassKind.CLASS + } + else -> throw AssertionError("Unexpected class or object: ${classOrObject.text}") + } + val firClass = FirClassImpl( + session, + classOrObject, + classOrObject.nameAsSafeName, + classOrObject.visibility, + classOrObject.modality, + classKind, + 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() + ) + } + } + } + for (declaration in classOrObject.declarations) { + firClass.declarations += declaration.convert() + } + return firClass + } + + override fun visitTypeAlias(typeAlias: KtTypeAlias, data: Unit): FirElement { + val firTypeAlias = FirTypeAliasImpl( + session, + typeAlias, + typeAlias.nameAsSafeName, + typeAlias.visibility, + typeAlias.getTypeReference().toFirOrErrorType() + ) + typeAlias.extractAnnotationsTo(firTypeAlias) + return firTypeAlias + } + + override fun visitNamedFunction(function: KtNamedFunction, data: Unit): FirElement { + val firFunction = FirMemberFunctionImpl( + session, + function, + function.nameAsSafeName, + function.visibility, + function.modality, + function.hasModifier(KtTokens.OVERRIDE_KEYWORD), + function.hasModifier(KtTokens.OPERATOR_KEYWORD), + function.hasModifier(KtTokens.INFIX_KEYWORD), + function.hasModifier(KtTokens.INLINE_KEYWORD), + function.receiverTypeReference.convertSafe(), + function.typeReference.toFirOrImplicitType(), + function.bodyExpression.toFirBody() + ) + function.extractAnnotationsTo(firFunction) + function.extractTypeParametersTo(firFunction) + for (valueParameter in function.valueParameters) { + firFunction.valueParameters += valueParameter.convert() + } + return firFunction + } + + override fun visitSecondaryConstructor(constructor: KtSecondaryConstructor, data: Unit): FirElement { + val firConstructor = FirSecondaryConstructorImpl( + session, + constructor, + constructor.visibility, + constructor.getDelegationCall().convert(), + constructor.bodyExpression.toFirBody() + ) + constructor.extractValueParametersTo(firConstructor) + return super.visitSecondaryConstructor(constructor, data) + } + + override fun visitAnonymousInitializer(initializer: KtAnonymousInitializer, data: Unit): FirElement { + return FirAnonymousInitializerImpl( + session, + initializer, + initializer.body.toFirBody() + ) + } + + override fun visitProperty(property: KtProperty, data: Unit): FirElement { + val propertyType = property.typeReference.toFirOrImplicitType() + val firProperty = FirMemberPropertyImpl( + session, + property, + property.nameAsSafeName, + property.visibility, + property.modality, + property.hasModifier(KtTokens.OVERRIDE_KEYWORD), + property.receiverTypeReference.convertSafe(), + propertyType, + property.isVar, + property.initializer?.convert(), + property.getter.toFirPropertyAccessor(property, propertyType, isGetter = true), + property.setter.toFirPropertyAccessor(property, propertyType, isGetter = false), + property.delegateExpression?.convert() + ) + property.extractAnnotationsTo(firProperty) + property.extractTypeParametersTo(firProperty) + return firProperty + } + + override fun visitTypeReference(typeReference: KtTypeReference, data: Unit): FirElement { + val typeElement = typeReference.typeElement + val isNullable = typeElement is KtNullableType + + fun KtTypeElement?.unwrapNullable(): KtTypeElement? = + if (this is KtNullableType) this.innerType.unwrapNullable() else this + + val unwrappedElement = typeElement.unwrapNullable() + val firType = when (unwrappedElement) { + is KtDynamicType -> FirDynamicTypeImpl(session, typeReference, isNullable) + is KtUserType -> { + val referenceExpression = unwrappedElement.referenceExpression + if (referenceExpression != null) { + val userType = FirUserTypeImpl( + session, typeReference, isNullable, + referenceExpression.getReferencedNameAsName() + ) + for (typeArgument in unwrappedElement.typeArguments) { + userType.arguments += typeArgument.convert() + } + userType + } else { + FirErrorTypeImpl(session, typeReference, isNullable) + } + } + is KtFunctionType -> { + val functionType = FirFunctionTypeImpl( + session, + typeReference, + isNullable, + unwrappedElement.receiverTypeReference.convertSafe(), + unwrappedElement.returnTypeReference.toFirOrImplicitType() + ) + for (valueParameter in unwrappedElement.parameters) { + functionType.valueParameters += valueParameter.convert() + } + functionType + } + null -> FirErrorTypeImpl(session, typeReference, isNullable) + else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}") + } + + for (annotationEntry in typeReference.annotationEntries) { + firType.annotations += annotationEntry.convert() + } + return firType + } + + override fun visitAnnotationEntry(annotationEntry: KtAnnotationEntry, data: Unit): FirElement { + return FirAnnotationCallImpl( + session, + annotationEntry, + annotationEntry.useSiteTarget?.getAnnotationUseSiteTarget(), + annotationEntry.typeReference.toFirOrErrorType() + ) + } + + override fun visitTypeParameter(parameter: KtTypeParameter, data: Unit): FirElement { + val firTypeParameter = FirTypeParameterImpl( + session, + parameter, + parameter.nameAsSafeName, + parameter.variance + ) + parameter.extractAnnotationsTo(firTypeParameter) + val extendsBound = parameter.extendsBound + // TODO: handle where, here or (preferable) in parent + if (extendsBound != null) { + firTypeParameter.bounds += extendsBound.convert() + } + return firTypeParameter + } + + override fun visitTypeProjection(typeProjection: KtTypeProjection, data: Unit): FirElement { + val projectionKind = typeProjection.projectionKind + if (projectionKind == KtProjectionKind.STAR) { + return FirStarProjectionImpl(session, typeProjection) + } + val typeReference = typeProjection.typeReference + val firType = typeReference.toFirOrErrorType() + return FirTypeProjectionWithVarianceImpl( + session, + typeProjection, + when (projectionKind) { + KtProjectionKind.IN -> Variance.IN_VARIANCE + KtProjectionKind.OUT -> Variance.OUT_VARIANCE + KtProjectionKind.NONE -> Variance.INVARIANT + KtProjectionKind.STAR -> throw AssertionError("* should not be here") + }, + firType + ) + } + + override fun visitParameter(parameter: KtParameter, data: Unit): FirElement = + parameter.toFirValueParameter() + + override fun visitBlockExpression(expression: KtBlockExpression, data: Unit): FirElement { + return FirBlockBodyImpl(session, expression) + } + + override fun visitExpression(expression: KtExpression, data: Unit): FirElement { + return FirExpressionStub(session, expression) + } + } } \ No newline at end of file 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 a75403e5a0a..b95a6117490 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirElement.kt @@ -6,9 +6,22 @@ package org.jetbrains.kotlin.fir import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid interface FirElement { val psi: PsiElement? val session: FirSession + + fun accept(visitor: FirVisitor, data: D): R = + visitor.visitElement(this, data) + + fun accept(visitor: FirVisitorVoid) = + accept(visitor, null) + + fun acceptChildren(visitor: FirVisitor, data: D) {} + + fun acceptChildren(visitor: FirVisitorVoid) = + acceptChildren(visitor, null) } \ 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 new file mode 100644 index 00000000000..4c9da20d6f4 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -0,0 +1,390 @@ +/* + * Copyright 2000-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.declarations.* +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.types.* +import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid +import org.jetbrains.kotlin.types.Variance +import org.jetbrains.kotlin.utils.Printer + +class FirRenderer(builder: StringBuilder) : FirVisitorVoid() { + private val printer = Printer(builder) + + private var lineBeginning = true + + private fun print(vararg objects: Any) { + if (lineBeginning) { + lineBeginning = false + printer.print(*objects) + } else { + printer.printWithNoIndent(*objects) + } + } + + private fun println(vararg objects: Any) { + print(*objects) + printer.printlnWithNoIndent() + lineBeginning = true + } + + private fun pushIndent() { + printer.pushIndent() + } + + private fun popIndent() { + printer.popIndent() + } + + override fun visitElement(element: FirElement) { + element.acceptChildren(this) + } + + override fun visitFile(file: FirFile) { + println("FILE: ${file.name}") + pushIndent() + super.visitFile(file) + popIndent() + } + + private fun List.renderSeparated() { + for ((index, element) in this.withIndex()) { + if (index > 0) { + print(", ") + } + element.accept(this@FirRenderer) + } + } + + private fun List.renderParameters() { + print("(") + renderSeparated() + print(")") + } + + private fun List.renderAnnotations() { + for (annotation in this) { + visitAnnotationCall(annotation) + } + } + + private fun Variance.renderVariance() { + label.let { + print(it) + if (it.isNotEmpty()) { + print(" ") + } + } + } + + override fun visitCallableMember(callableMember: FirCallableMember) { + visitMemberDeclaration(callableMember) + val receiverType = callableMember.receiverType + if (receiverType != null) { + receiverType.accept(this) + print(".") + } + if (callableMember is FirFunction) { + callableMember.valueParameters.renderParameters() + } else if (callableMember is FirProperty) { + print(if (callableMember.isVar) "(var)" else "(val)") + } + print(": ") + callableMember.returnType.accept(this) + } + + override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) { + memberDeclaration.annotations.renderAnnotations() + if (memberDeclaration.typeParameters.isNotEmpty()) { + print("<") + memberDeclaration.typeParameters.renderSeparated() + print("> ") + } + print(memberDeclaration.visibility.toString() + " " + memberDeclaration.modality.name.toLowerCase() + " ") + if (memberDeclaration is FirCallableMember && memberDeclaration.isOverride) { + print("override ") + } + if (memberDeclaration is FirNamedFunction) { + if (memberDeclaration.isOperator) { + print("operator ") + } + if (memberDeclaration.isInfix) { + print("infix ") + } + if (memberDeclaration.isInline) { + print("inline ") + } + } + visitNamedDeclaration(memberDeclaration) + } + + override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) { + visitDeclaration(namedDeclaration) + print(" " + namedDeclaration.name) + } + + override fun visitDeclaration(declaration: FirDeclaration) { + print( + when (declaration) { + is FirClass -> "class" + is FirTypeAlias -> "typealias" + is FirNamedFunction -> "function" + is FirProperty -> "property" + else -> "unknown" + } + ) + } + + override fun visitEnumEntry(enumEntry: FirEnumEntry) { + visitClass(enumEntry) + } + + override fun visitClass(klass: FirClass) { + visitMemberDeclaration(klass) + val attributes = listOfNotNull( + "companion".takeIf { klass.isCompanion }, + "data".takeIf { klass.isData } + ) + print(attributes.joinToString(prefix = "(", postfix = ")")) + if (klass.superTypes.isNotEmpty()) { + print(" : ") + klass.superTypes.renderSeparated() + } + println(" {") + pushIndent() + for (declaration in klass.declarations) { + declaration.accept(this) + println() + } + popIndent() + println("}") + } + + override fun visitProperty(property: FirProperty) { + visitCallableMember(property) + property.initializer?.let { + print(" = ") + it.accept(this) + } + pushIndent() + property.delegate?.let { + print("by ") + it.accept(this) + } + println() + property.getter.accept(this) + if (property.getter.body == null) { + println() + } + if (property.isVar) { + property.setter.accept(this) + if (property.setter.body == null) { + println() + } + } + popIndent() + } + + override fun visitNamedFunction(namedFunction: FirNamedFunction) { + visitCallableMember(namedFunction) + namedFunction.body?.accept(this) + if (namedFunction.body == null) { + println() + } + } + + override fun visitConstructor(constructor: FirConstructor) { + constructor.annotations.renderAnnotations() + print(constructor.visibility.toString() + " constructor") + constructor.valueParameters.renderParameters() + constructor.delegatedConstructor?.accept(this) + constructor.body?.accept(this) + } + + override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { + propertyAccessor.annotations.renderAnnotations() + print(propertyAccessor.visibility.toString() + " ") + print(if (propertyAccessor.isGetter) "get" else "set") + propertyAccessor.valueParameters.renderParameters() + print(": ") + propertyAccessor.returnType.accept(this) + propertyAccessor.body?.accept(this) + } + + override fun visitFunction(function: FirFunction) { + function.valueParameters.renderParameters() + visitDeclarationWithBody(function) + } + + override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) { + print("init") + anonymousInitializer.body?.accept(this) + } + + override fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody) { + visitDeclaration(declarationWithBody) + declarationWithBody.body?.accept(this) + } + + override fun visitBody(body: FirBody) { + println(" {") + pushIndent() + for (statement in body.statements) { + statement.accept(this) + println() + } + popIndent() + println("}") + } + + override fun visitTypeAlias(typeAlias: FirTypeAlias) { + typeAlias.annotations.renderAnnotations() + visitMemberDeclaration(typeAlias) + print(" = ") + typeAlias.abbreviatedType.accept(this) + println() + } + + override fun visitTypeParameter(typeParameter: FirTypeParameter) { + typeParameter.annotations.renderAnnotations() + typeParameter.variance.renderVariance() + print(typeParameter.name) + if (typeParameter.bounds.isNotEmpty()) { + print(" : ") + typeParameter.bounds.renderSeparated() + } + } + + override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) { + visitDeclaration(typedDeclaration) + } + + override fun visitValueParameter(valueParameter: FirValueParameter) { + valueParameter.annotations.renderAnnotations() + if (valueParameter.isCrossinline) { + print("crossinline ") + } + if (valueParameter.isNoinline) { + print("noinline ") + } + if (valueParameter.isVararg) { + print("vararg ") + } + print(valueParameter.name.toString() + ": ") + valueParameter.returnType.accept(this) + valueParameter.defaultValue?.let { + print(" = ") + it.accept(this) + } + } + + override fun visitVariable(variable: FirVariable) { + visitDeclaration(variable) + } + + override fun visitImport(import: FirImport) { + visitElement(import) + } + + override fun visitStatement(statement: FirStatement) { + visitElement(statement) + } + + override fun visitExpression(expression: FirExpression) { + print("STUB") + } + + override fun visitCall(call: FirCall) { + visitExpression(call) + } + + override fun visitAnnotationCall(annotationCall: FirAnnotationCall) { + visitCall(annotationCall) + } + + override fun visitConstructorCall(constructorCall: FirConstructorCall) { + visitCall(constructorCall) + } + + override fun visitType(type: FirType) { + type.annotations.renderAnnotations() + visitElement(type) + } + + override fun visitDelegatedType(delegatedType: FirDelegatedType) { + delegatedType.accept(this) + print(" by ") + delegatedType.delegate?.accept(this) + } + + override fun visitErrorType(errorType: FirErrorType) { + visitType(errorType) + print("") + } + + override fun visitImplicitType(implicitType: FirImplicitType) { + print("") + } + + override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability) { + if (typeWithNullability.isNullable) { + print("?") + } + } + + override fun visitDynamicType(dynamicType: FirDynamicType) { + dynamicType.annotations.renderAnnotations() + print("") + visitTypeWithNullability(dynamicType) + } + + override fun visitFunctionType(functionType: FirFunctionType) { + print("( ") + functionType.receiverType?.let { + it.accept(this) + print(".") + } + functionType.valueParameters.renderParameters() + print(": ") + functionType.returnType.accept(this) + print(" )") + visitTypeWithNullability(functionType) + } + + override fun visitResolvedType(resolvedType: FirResolvedType) { + resolvedType.annotations.renderAnnotations() + print("R/") + print(resolvedType.type) + print("/") + visitTypeWithNullability(resolvedType) + } + + override fun visitUserType(userType: FirUserType) { + userType.annotations.renderAnnotations() + print(userType.name) + if (userType.arguments.isNotEmpty()) { + print("<") + userType.arguments.renderSeparated() + print(">") + } + visitTypeWithNullability(userType) + } + + override fun visitTypeProjection(typeProjection: FirTypeProjection) { + visitElement(typeProjection) + } + + override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) { + typeProjectionWithVariance.variance.renderVariance() + typeProjectionWithVariance.type.accept(this) + } + + override fun visitStarProjection(starProjection: FirStarProjection) { + print("*") + } + +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt index 27f11a38fb8..e577a5497d9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirAnonymousInitializer.kt @@ -5,8 +5,10 @@ package org.jetbrains.kotlin.fir.declarations -// Probably not a function -@Deprecated("May be not needed") -interface FirAnonymousInitializer : FirDeclarationWithBody { +import org.jetbrains.kotlin.fir.visitors.FirVisitor +// Probably not a function +interface FirAnonymousInitializer : FirDeclarationWithBody { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitAnonymousInitializer(this, data) } \ No newline at end of file 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 55c7f4ddf5c..224eb45b228 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 @@ -5,9 +5,22 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirVisitor // Good name needed (something with receiver, type parameters, return type, and name) -interface FirCallableMember : FirMemberDeclaration, FirTypedDeclaration { - val receiverType: FirType +interface FirCallableMember : @VisitedSupertype FirDeclaration, FirMemberDeclaration, FirTypedDeclaration { + val isOverride: Boolean + + val receiverType: FirType? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitCallableMember(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + receiverType?.accept(visitor, data) + super.acceptChildren(visitor, data) + returnType.accept(visitor, data) + } } \ No newline at end of file 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 76744c8d6b5..f3238c2a684 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 @@ -7,7 +7,10 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.ClassKind 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 interface FirClass : FirDeclarationContainer, FirMemberDeclaration { // including delegated types val superTypes: List @@ -17,4 +20,17 @@ interface FirClass : FirDeclarationContainer, FirMemberDeclaration { val isCompanion: Boolean val isData: Boolean + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitClass(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + for (superType in superTypes) { + superType.accept(visitor, data) + } + for (declaration in declarations) { + declaration.accept(visitor, data) + } + } } \ No newline at end of file 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 d55cd373e04..cee69321149 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 @@ -5,8 +5,22 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer import org.jetbrains.kotlin.fir.expressions.FirConstructorCall +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirConstructor : FirFunction { +interface FirConstructor : FirFunction, FirAnnotationContainer { val delegatedConstructor: FirConstructorCall? + + val visibility: Visibility + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitConstructor(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + delegatedConstructor?.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt index 80f5e2dcd3c..2c8d6d0db00 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclaration.kt @@ -6,5 +6,10 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirDeclaration : FirElement \ No newline at end of file +interface FirDeclaration : FirElement { + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitDeclaration(this, 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 905e19569db..a5c66aef806 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 @@ -6,7 +6,16 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.expressions.FirBody +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirDeclarationWithBody : FirDeclaration { - val body: FirBody + val body: FirBody? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitDeclarationWithBody(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + body?.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 c807af329d8..ba50acdc007 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 @@ -6,7 +6,18 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirEnumEntry : FirClass { val arguments: List + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitEnumEntry(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + for (argument in arguments) { + argument.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorDeclaration.kt index b5e562da2ae..4148fa13064 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirErrorDeclaration.kt @@ -5,6 +5,10 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.visitors.FirVisitor + // Is it necessary? interface FirErrorDeclaration : FirDeclaration { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitErrorDeclaration(this, 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 b85bdd29285..6e546456a24 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,6 +5,26 @@ package org.jetbrains.kotlin.fir.declarations -interface FirFile : FirPackageFragment { +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 + +interface FirFile : @VisitedSupertype FirPackageFragment, FirDeclaration, FirAnnotationContainer { + val name: String + + val packageFqName: FqName + val imports: List + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitFile(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + for (import in imports) { + import.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 b959657e201..6bfabaabdf1 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 @@ -6,8 +6,20 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer +import org.jetbrains.kotlin.fir.visitors.FirVisitor // May be should inherit FirTypeParameterContainer interface FirFunction : FirDeclarationWithBody, FirAnnotationContainer { val valueParameters: List + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitFunction(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirImport.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirImport.kt index d8874eb01c2..a87038302ea 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirImport.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirImport.kt @@ -6,6 +6,16 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.name.FqName interface FirImport : FirElement { + val importedFqName: FqName? + + val isAllUnder: Boolean + + val aliasName: String? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitImport(this, data) } \ No newline at end of file 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 2987b957563..0d1ca54cd43 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 @@ -8,9 +8,21 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.Modality import org.jetbrains.kotlin.descriptors.Visibility import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirMemberDeclaration : FirTypeParameterContainer, FirNamedDeclaration, FirAnnotationContainer { val visibility: Visibility val modality: Modality + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitMemberDeclaration(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + for (typeParameter in typeParameters) { + typeParameter.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedDeclaration.kt index 498c6eaad6d..9073be756a0 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedDeclaration.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirNamedDeclaration.kt @@ -5,8 +5,12 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.name.Name interface FirNamedDeclaration : FirDeclaration { val name: Name + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitNamedDeclaration(this, data) } \ No newline at end of file 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 9500c4b41a4..50830354082 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,5 +5,21 @@ package org.jetbrains.kotlin.fir.declarations -interface FirNamedFunction : FirFunction, FirCallableMember { +import org.jetbrains.kotlin.fir.VisitedSupertype +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirNamedFunction : @VisitedSupertype FirFunction, FirCallableMember { + val isOperator: Boolean + + val isInfix: Boolean + + val isInline: Boolean + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitNamedFunction(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + 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/FirPackageFragment.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirPackageFragment.kt index 877e987c3c5..c0b5a282a76 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 @@ -6,6 +6,16 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirPackageFragment : FirElement, FirDeclarationContainer { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitPackageFragment(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + for (declaration in declarations) { + declaration.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 1d2e11bb8e8..8e591e11209 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,15 +5,28 @@ package org.jetbrains.kotlin.fir.declarations +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 -interface FirProperty : FirCallableMember, FirVariable { +interface FirProperty : @VisitedSupertype FirDeclaration, FirCallableMember, FirVariable { // Should it be nullable or have some default? val getter: FirPropertyAccessor val setter: FirPropertyAccessor val delegate: FirExpression? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitProperty(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + initializer?.accept(visitor, data) + delegate?.accept(visitor, data) + getter.accept(visitor, data) + setter.accept(visitor, data) + } } \ No newline at end of file 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 ec9c1745d59..85e7857a6d8 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 @@ -6,9 +6,21 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.VisitedSupertype +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirPropertyAccessor : FirFunction { +interface FirPropertyAccessor : @VisitedSupertype FirFunction, FirTypedDeclaration { val isGetter: Boolean + val isSetter: Boolean get() = !isGetter + val visibility: Visibility + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitPropertyAccessor(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + 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/FirTypeAlias.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirTypeAlias.kt index 4d4c98b9f58..de63da900c7 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 @@ -7,7 +7,17 @@ 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 { 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) + super.acceptChildren(visitor, data) + abbreviatedType.accept(visitor, data) + } } \ No newline at end of file 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 df18ff16685..e4acaf9f969 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 @@ -7,10 +7,22 @@ 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 import org.jetbrains.kotlin.types.Variance interface FirTypeParameter : FirNamedDeclaration, FirAnnotationContainer { val variance: Variance val bounds: List + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitTypeParameter(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + super.acceptChildren(visitor, data) + for (bound in bounds) { + bound.accept(visitor, data) + } + } } \ No newline at end of file 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 b2961a255cf..ad52c011de2 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 @@ -7,7 +7,17 @@ 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 FirTypedDeclaration : FirDeclaration, FirAnnotationContainer { val returnType: FirType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitTypedDeclaration(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + super.acceptChildren(visitor, data) + returnType.accept(visitor, data) + } } \ No newline at end of file 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 d9cec6cc83f..8fb29d03ddb 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,9 +5,11 @@ package org.jetbrains.kotlin.fir.declarations +import org.jetbrains.kotlin.fir.VisitedSupertype import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirValueParameter : FirTypedDeclaration, FirNamedDeclaration { +interface FirValueParameter : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration { val isCrossinline: Boolean val isNoinline: Boolean @@ -15,4 +17,12 @@ interface FirValueParameter : FirTypedDeclaration, FirNamedDeclaration { val isVararg: Boolean val defaultValue: FirExpression? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitValueParameter(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + defaultValue?.accept(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt new file mode 100644 index 00000000000..4578c66387f --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractAnnotatedDeclaration.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer + +abstract class FirAbstractAnnotatedDeclaration( + final override val session: FirSession, + final override val psi: PsiElement? +) : FirAnnotationContainer, FirDeclaration { + final override val annotations = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt new file mode 100644 index 00000000000..b7ba0f110ba --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractCallableMember.kt @@ -0,0 +1,25 @@ +/* + * Copyright 2000-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.Modality +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirCallableMember +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +abstract class FirAbstractCallableMember( + session: FirSession, + psi: PsiElement?, + name: Name, + visibility: Visibility, + modality: Modality, + final override val isOverride: Boolean, + final override val receiverType: FirType?, + final override val returnType: FirType +) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality), FirCallableMember \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractFunction.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractFunction.kt new file mode 100644 index 00000000000..e2581d4690a --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractFunction.kt @@ -0,0 +1,20 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirFunction +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirBody + +abstract class FirAbstractFunction( + session: FirSession, + psi: PsiElement?, + final override val body: FirBody? +) : FirAbstractAnnotatedDeclaration(session, psi), FirFunction { + final override val valueParameters = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt new file mode 100644 index 00000000000..da233832a0b --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractMemberDeclaration.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2000-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.Modality +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.name.Name + +abstract class FirAbstractMemberDeclaration( + session: FirSession, + psi: PsiElement?, + name: Name, + final override val visibility: Visibility, + final override val modality: Modality +) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirMemberDeclaration { + final override val typeParameters = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractNamedAnnotatedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractNamedAnnotatedDeclaration.kt new file mode 100644 index 00000000000..fd5c359a1b3 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAbstractNamedAnnotatedDeclaration.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration +import org.jetbrains.kotlin.name.Name + +abstract class FirAbstractNamedAnnotatedDeclaration( + session: FirSession, + psi: PsiElement?, + final override val name: Name +) : FirAbstractAnnotatedDeclaration(session, psi), FirNamedDeclaration \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt new file mode 100644 index 00000000000..812e10e98b0 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirAnonymousInitializerImpl.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirAnonymousInitializer +import org.jetbrains.kotlin.fir.expressions.FirBody + +class FirAnonymousInitializerImpl( + override val session: FirSession, + override val psi: PsiElement?, + override val body: FirBody? +) : FirAnonymousInitializer \ No newline at end of file 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 new file mode 100644 index 00000000000..d7e487cc79c --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirClassImpl.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2000-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.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.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirClassImpl( + session: FirSession, + psi: PsiElement?, + name: Name, + visibility: Visibility, + modality: Modality, + override val classKind: ClassKind, + override val isCompanion: Boolean, + override val isData: Boolean +) : FirAbstractMemberDeclaration(session, psi, name, visibility, modality), FirClass { + override val superTypes = mutableListOf() + + override val declarations = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt new file mode 100644 index 00000000000..fe668d9fd20 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultPropertyAccessor.kt @@ -0,0 +1,38 @@ +/* + * Copyright 2000-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.Visibilities +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirBody +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.types.impl.FirUnitType + +class FirDefaultPropertyAccessor( + override val session: FirSession, + override val psi: PsiElement?, + override val isGetter: Boolean, + propertyType: FirType +) : FirPropertyAccessor { + override val visibility = + Visibilities.UNKNOWN + + override val valueParameters: List = + if (isGetter) emptyList() else listOf(FirDefaultSetterValueParameter(session, psi, propertyType)) + + override val returnType: FirType = + if (isGetter) propertyType else FirUnitType(session, psi) + + override val body: FirBody? = + null + + override val annotations: List + get() = emptyList() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt new file mode 100644 index 00000000000..36c493e3023 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDefaultSetterValueParameter.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirDefaultSetterValueParameter( + session: FirSession, + psi: PsiElement?, + override val returnType: FirType +) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter { + override val isCrossinline = false + + override val isNoinline = false + + override val isVararg = false + + override val defaultValue: FirExpression? = null + + companion object { + val name = Name.identifier("value") + } +} \ 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 new file mode 100644 index 00000000000..40395e06b44 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirFileImpl.kt @@ -0,0 +1,24 @@ +/* + * Copyright 2000-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.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 + +class FirFileImpl( + session: FirSession, + psi: PsiElement?, + override val name: String, + override val packageFqName: FqName +) : FirAbstractAnnotatedDeclaration(session, psi), FirFile { + override val imports = mutableListOf() + + override val declarations = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt new file mode 100644 index 00000000000..b923e3c6519 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirImportImpl.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirImport +import org.jetbrains.kotlin.name.FqName + +class FirImportImpl( + override val session: FirSession, + override val psi: PsiElement?, + override val importedFqName: FqName?, + override val isAllUnder: Boolean, + override val aliasName: String? +) : FirImport \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt new file mode 100644 index 00000000000..300782b64aa --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberFunctionImpl.kt @@ -0,0 +1,34 @@ +/* + * Copyright 2000-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.Modality +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirNamedFunction +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirBody +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirMemberFunctionImpl( + session: FirSession, + psi: PsiElement?, + name: Name, + visibility: Visibility, + modality: Modality, + isOverride: Boolean, + override val isOperator: Boolean, + override val isInfix: Boolean, + override val isInline: Boolean, + receiverType: FirType?, + returnType: FirType, + override val body: FirBody? +) : FirAbstractCallableMember(session, psi, name, visibility, modality, isOverride, receiverType, returnType), + FirNamedFunction { + override val valueParameters = mutableListOf() +} \ 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 new file mode 100644 index 00000000000..18b5f9ad185 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirMemberPropertyImpl.kt @@ -0,0 +1,33 @@ +/* + * Copyright 2000-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.Modality +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirPropertyAccessor +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirMemberPropertyImpl( + session: FirSession, + psi: PsiElement?, + name: Name, + visibility: Visibility, + modality: Modality, + isOverride: Boolean, + receiverType: FirType?, + returnType: FirType, + override val isVar: Boolean, + override val initializer: FirExpression?, + override val getter: FirPropertyAccessor, + override val setter: FirPropertyAccessor, + override val delegate: FirExpression? +) : FirAbstractCallableMember(session, psi, name, visibility, modality, isOverride, receiverType, returnType), + FirProperty \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirNamedAnnotatedDeclaration.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirNamedAnnotatedDeclaration.kt new file mode 100644 index 00000000000..b71f8e6db53 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirNamedAnnotatedDeclaration.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer +import org.jetbrains.kotlin.name.Name + +class FirAbstractNamedDeclaration( + override val session: FirSession, + override val psi: PsiElement?, + override val name: Name +) : FirNamedDeclaration, FirAnnotationContainer { + override val annotations = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPackageFragmentImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPackageFragmentImpl.kt new file mode 100644 index 00000000000..fad13b1770b --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPackageFragmentImpl.kt @@ -0,0 +1,4 @@ +package org.jetbrains.kotlin.fir.declarations.impl + +class FirPackageFragmentImpl { +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt new file mode 100644 index 00000000000..a97eb639a9c --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirPropertyAccessorImpl.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2000-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.declarations.FirPropertyAccessor +import org.jetbrains.kotlin.fir.expressions.FirBody +import org.jetbrains.kotlin.fir.types.FirType + +class FirPropertyAccessorImpl( + session: FirSession, + psi: PsiElement?, + override val isGetter: Boolean, + override val visibility: Visibility, + override val returnType: FirType, + body: FirBody? +) : FirAbstractFunction(session, psi, body), FirPropertyAccessor \ 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/FirSecondaryConstructorImpl.kt new file mode 100644 index 00000000000..c02d8524ba2 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirSecondaryConstructorImpl.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2000-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.declarations.FirConstructor +import org.jetbrains.kotlin.fir.expressions.FirBody +import org.jetbrains.kotlin.fir.expressions.FirConstructorCall + +class FirSecondaryConstructorImpl( + session: FirSession, + psi: PsiElement?, + override val visibility: Visibility, + override val delegatedConstructor: FirConstructorCall?, + 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/FirTypeAliasImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt new file mode 100644 index 00000000000..80f058b4131 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeAliasImpl.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2000-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.Modality +import org.jetbrains.kotlin.descriptors.Visibility +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirTypeAlias +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirTypeAliasImpl( + session: FirSession, + psi: PsiElement?, + name: Name, + visibility: Visibility, + override val abbreviatedType: FirType +) : FirAbstractMemberDeclaration(session, psi, name, visibility, Modality.FINAL), FirTypeAlias \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt new file mode 100644 index 00000000000..5c2ee988c30 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirTypeParameterImpl.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirTypeParameter +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.types.Variance + +class FirTypeParameterImpl( + session: FirSession, + psi: PsiElement?, + name: Name, + override val variance: Variance +) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirTypeParameter { + override val bounds = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt new file mode 100644 index 00000000000..54203b2b82d --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirValueParameterImpl.kt @@ -0,0 +1,25 @@ +/* + * Copyright 2000-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.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.name.Name + +class FirValueParameterImpl( + session: FirSession, + psi: PsiElement?, + val isProperty: Boolean, + name: Name, + override val returnType: FirType, + override val defaultValue: FirExpression?, + override val isCrossinline: Boolean, + override val isNoinline: Boolean, + override val isVararg: Boolean +) : FirAbstractNamedAnnotatedDeclaration(session, psi, name), FirValueParameter \ 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 6d667fcdbaf..6ccff3bddb0 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 @@ -7,9 +7,19 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirAnnotationCall : FirCall { val annotationType: FirType - val useSiteTarget: AnnotationUseSiteTarget + // May be should be not-null (with correct default target) + val useSiteTarget: AnnotationUseSiteTarget? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitAnnotationCall(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + annotationType.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 75572e44eb3..7275026af5e 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 @@ -5,6 +5,14 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.visitors.FirVisitor + interface FirAnnotationContainer { val annotations: List + + fun acceptAnnotations(visitor: FirVisitor, data: D) { + for (annotation in annotations) { + annotation.accept(visitor, data) + } + } } \ No newline at end of file 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 553d89a0f3d..785469bbc64 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 @@ -5,7 +5,20 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.visitors.FirVisitor + // Should we have FirBlockBody / FirExpressionBody? -interface FirBody { +// Is it FirExpression or just FirElement? +interface FirBody : FirExpression { val statements: List + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitBody(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + for (statement in statements) { + statement.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 7e0ecc8a849..46973e8802b 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,6 +5,18 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.visitors.FirVisitor + 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) { + for (argument in arguments) { + argument.accept(visitor, data) + } + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt index 54da3020f44..ba91c54c88e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirConstructorCall.kt @@ -6,7 +6,16 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirConstructorCall : FirCall { val constructedType: FirType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitConstructorCall(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + constructedType.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt index 011eaca81cf..8ed4cfb634e 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpression.kt @@ -5,5 +5,9 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.visitors.FirVisitor + interface FirExpression : FirStatement { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitExpression(this, data) } \ 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 ecca4f0d630..cb4ea0b9880 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 @@ -6,6 +6,9 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirStatement : FirElement { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitStatement(this, data) } \ No newline at end of file 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 b08a95c259a..10cd0595130 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 @@ -5,9 +5,25 @@ package org.jetbrains.kotlin.fir.expressions +import org.jetbrains.kotlin.fir.VisitedSupertype +import org.jetbrains.kotlin.fir.declarations.FirDeclaration import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration import org.jetbrains.kotlin.fir.declarations.FirNamedDeclaration +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirVariable : @VisitedSupertype FirDeclaration, FirTypedDeclaration, FirNamedDeclaration, FirStatement { + val isVar: Boolean + + val isVal: Boolean + get() = !isVar -interface FirVariable : FirTypedDeclaration, FirNamedDeclaration, FirStatement { val initializer: FirExpression? + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitVariable(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + initializer?.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ 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 new file mode 100644 index 00000000000..acc9bee9bee --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirAnnotationCallImpl.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2000-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.descriptors.annotations.AnnotationUseSiteTarget +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.types.FirType + +class FirAnnotationCallImpl( + override val session: FirSession, + override val psi: PsiElement?, + override val useSiteTarget: AnnotationUseSiteTarget?, + override val annotationType: FirType +) : FirAnnotationCall { + override val arguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockBodyImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockBodyImpl.kt new file mode 100644 index 00000000000..08cc93d0a46 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirBlockBodyImpl.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2000-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.FirBody +import org.jetbrains.kotlin.fir.expressions.FirStatement + +class FirBlockBodyImpl(override val session: FirSession, override val psi: PsiElement?) : FirBody { + override val statements = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionBodyImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionBodyImpl.kt new file mode 100644 index 00000000000..e8fb87e2f20 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionBodyImpl.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2000-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.FirBody +import org.jetbrains.kotlin.fir.expressions.FirExpression + +class FirExpressionBodyImpl( + override val session: FirSession, + private val expression: FirExpression +) : FirBody { + override val statements = listOf(expression) + + override val psi: PsiElement? + get() = expression.psi +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt new file mode 100644 index 00000000000..258086b6de5 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirExpressionStub.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2000-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.FirExpression + +@Deprecated("Temporary class until we have normal expressions") +class FirExpressionStub(override val session: FirSession, override val psi: PsiElement?) : FirExpression \ 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 577d0c8822d..da8574309bc 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 @@ -6,7 +6,18 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirDelegatedType : FirExplicitType { - val delegate: FirExpression +interface FirDelegatedType : FirType { + val delegate: FirExpression? + + val type: FirType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitDelegatedType(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + delegate?.accept(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDynamicType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDynamicType.kt new file mode 100644 index 00000000000..f3c289f2a4d --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirDynamicType.kt @@ -0,0 +1,13 @@ +/* + * Copyright 2000-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 + +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirDynamicType : FirTypeWithNullability { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitDynamicType(this, data) +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirExplicitType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt similarity index 50% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirExplicitType.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt index 16da2d56a2d..75f964ef00c 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirExplicitType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirErrorType.kt @@ -5,5 +5,9 @@ package org.jetbrains.kotlin.fir.types -interface FirExplicitType : FirType, FirTypeProjectionContainer { +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirErrorType : FirType { + 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 new file mode 100644 index 00000000000..f4280b670d2 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirFunctionType.kt @@ -0,0 +1,29 @@ +/* + * Copyright 2000-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 + +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirFunctionType : FirTypeWithNullability { + val receiverType: FirType? + + // May be it should inherit FirFunction? + val valueParameters: List + + val returnType: FirType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitFunctionType(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + receiverType?.accept(visitor, data) + super.acceptChildren(visitor, data) + for (parameter in valueParameters) { + parameter.accept(visitor, data) + } + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirImplicitType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirImplicitType.kt index 5839234ec6b..c477e18e53a 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirImplicitType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirImplicitType.kt @@ -5,5 +5,9 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.fir.visitors.FirVisitor + interface FirImplicitType : FirType { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitImplicitType(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt index d6cf7250abc..42f85ca73dc 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirResolvedType.kt @@ -5,8 +5,12 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.types.KotlinType -interface FirResolvedType : FirType { +interface FirResolvedType : FirTypeWithNullability { val type: KotlinType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitResolvedType(this, data) } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirStarProjection.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirStarProjection.kt index bbc4254dc29..21fa5156018 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirStarProjection.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirStarProjection.kt @@ -5,4 +5,9 @@ package org.jetbrains.kotlin.fir.types -interface FirStarProjection : FirTypeProjection \ No newline at end of file +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirStarProjection : FirTypeProjection { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitStarProjection(this, data) +} \ No newline at end of file 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 5c6b59c98f7..27b987cdfdf 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 @@ -6,6 +6,15 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.expressions.FirAnnotationContainer +import org.jetbrains.kotlin.fir.visitors.FirVisitor -interface FirType : FirElement { +interface FirType : FirElement, FirAnnotationContainer { + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitType(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + acceptAnnotations(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file 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 a2079f71090..387466b7263 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 @@ -6,7 +6,9 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.FirElement +import org.jetbrains.kotlin.fir.visitors.FirVisitor interface FirTypeProjection : FirElement { - + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitTypeProjection(this, data) } \ 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 27688746dd3..afabbe13836 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 @@ -5,10 +5,19 @@ package org.jetbrains.kotlin.fir.types +import org.jetbrains.kotlin.fir.visitors.FirVisitor import org.jetbrains.kotlin.types.Variance -interface FirTypeProjectionWithVariance { +interface FirTypeProjectionWithVariance : FirTypeProjection { val variance: Variance val type: FirType + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitTypeProjectionWithVariance(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + type.accept(visitor, data) + super.acceptChildren(visitor, data) + } } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeWithNullability.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeWithNullability.kt new file mode 100644 index 00000000000..46e80f00276 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirTypeWithNullability.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2000-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 + +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +interface FirTypeWithNullability : FirType { + val isNullable: Boolean + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitTypeWithNullability(this, data) +} \ No newline at end of file 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 new file mode 100644 index 00000000000..af2f2270faa --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/FirUserType.kt @@ -0,0 +1,23 @@ +/* + * Copyright 2000-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 + +import org.jetbrains.kotlin.fir.visitors.FirVisitor +import org.jetbrains.kotlin.name.Name + +interface FirUserType : FirTypeWithNullability, FirTypeProjectionContainer { + val name: Name + + override fun accept(visitor: FirVisitor, data: D): R = + visitor.visitUserType(this, data) + + override fun acceptChildren(visitor: FirVisitor, data: D) { + super.acceptChildren(visitor, data) + for (argument in arguments) { + argument.accept(visitor, data) + } + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedType.kt new file mode 100644 index 00000000000..d829d4e254e --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirAbstractAnnotatedType.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.types.FirTypeWithNullability + +abstract class FirAbstractAnnotatedType( + final override val session: FirSession, + final override val psi: PsiElement?, + final override val isNullable: Boolean +) : FirTypeWithNullability { + override val annotations = mutableListOf() +} \ 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 new file mode 100644 index 00000000000..e6f88575ac9 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDelegatedTypeImpl.kt @@ -0,0 +1,25 @@ +/* + * Copyright 2000-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.expressions.FirExpression +import org.jetbrains.kotlin.fir.types.FirDelegatedType +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +class FirDelegatedTypeImpl( + override val type: FirType, + override val delegate: FirExpression? +) : FirType by type, FirDelegatedType { + override fun accept(visitor: FirVisitor, data: D): R { + return super.accept(visitor, data) + } + + override fun acceptChildren(visitor: FirVisitor, data: D) { + type.acceptChildren(visitor, data) + delegate?.accept(visitor, data) + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeImpl.kt new file mode 100644 index 00000000000..881727043f3 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirDynamicTypeImpl.kt @@ -0,0 +1,16 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirDynamicType + +class FirDynamicTypeImpl( + session: FirSession, + psi: PsiElement?, + isNullable: Boolean +) : FirAbstractAnnotatedType(session, psi, isNullable), FirDynamicType \ No newline at end of file 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 new file mode 100644 index 00000000000..636c3542bbc --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeImpl.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirErrorType +import org.jetbrains.kotlin.fir.visitors.FirVisitor + +class FirErrorTypeImpl( + session: FirSession, + psi: PsiElement?, + isNullable: Boolean +) : FirAbstractAnnotatedType(session, psi, isNullable), FirErrorType { + override fun accept(visitor: FirVisitor, data: D): R { + return super.accept(visitor, data) + } +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt new file mode 100644 index 00000000000..6a8225aaf3f --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirFunctionTypeImpl.kt @@ -0,0 +1,22 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.types.FirFunctionType +import org.jetbrains.kotlin.fir.types.FirType + +class FirFunctionTypeImpl( + session: FirSession, + psi: PsiElement?, + isNullable: Boolean, + override val receiverType: FirType?, + override val returnType: FirType +) : FirAbstractAnnotatedType(session, psi, isNullable), FirFunctionType { + override val valueParameters = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeImpl.kt new file mode 100644 index 00000000000..5174d6897eb --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirImplicitTypeImpl.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.types.FirImplicitType + +class FirImplicitTypeImpl( + override val session: FirSession, + override val psi: PsiElement? +) : FirImplicitType { + override val annotations: List + get() = emptyList() +} \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt new file mode 100644 index 00000000000..b4be9b8969b --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirStarProjectionImpl.kt @@ -0,0 +1,15 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirStarProjection + +class FirStarProjectionImpl( + override val session: FirSession, + override val psi: PsiElement? +) : FirStarProjection \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt new file mode 100644 index 00000000000..f63c48c18b2 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirTypeProjectionWithVarianceImpl.kt @@ -0,0 +1,19 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirType +import org.jetbrains.kotlin.fir.types.FirTypeProjectionWithVariance +import org.jetbrains.kotlin.types.Variance + +class FirTypeProjectionWithVarianceImpl( + override val session: FirSession, + override val psi: PsiElement?, + override val variance: Variance, + override val type: FirType +) : FirTypeProjectionWithVariance \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUnitType.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUnitType.kt new file mode 100644 index 00000000000..d2c0ddf3a13 --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUnitType.kt @@ -0,0 +1,26 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.builtins.DefaultBuiltIns +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall +import org.jetbrains.kotlin.fir.types.FirResolvedType +import org.jetbrains.kotlin.types.KotlinType + +class FirUnitType( + override val session: FirSession, + override val psi: PsiElement? +) : FirResolvedType { + override val type: KotlinType + get() = DefaultBuiltIns.Instance.unitType + + override val isNullable = false + + override val annotations: List + get() = emptyList() +} \ 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 new file mode 100644 index 00000000000..a72079365cd --- /dev/null +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/types/impl/FirUserTypeImpl.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2000-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 com.intellij.psi.PsiElement +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.fir.types.FirUserType +import org.jetbrains.kotlin.fir.types.FirTypeProjection +import org.jetbrains.kotlin.name.Name + +class FirUserTypeImpl( + session: FirSession, + psi: PsiElement?, + isNullable: Boolean, + override val name: Name +) : FirAbstractAnnotatedType(session, psi, isNullable), FirUserType { + override val arguments = mutableListOf() +} \ No newline at end of file diff --git a/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt b/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt index 70cd0eca6f9..2780586d5aa 100644 --- a/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt +++ b/compiler/fir/tree/visitors-generator/src/VisitorsGenerator.kt @@ -188,7 +188,7 @@ abstract class AbstractVisitorGenerator(val referencesData: DataCollector.Refere class SimpleVisitorGenerator(referencesData: DataCollector.ReferencesData) : AbstractVisitorGenerator(referencesData) { override fun Printer.generateContent() { - println("abstract class $SIMPLE_VISITOR_NAME {") + println("abstract class $SIMPLE_VISITOR_NAME {") indented { generateFunction( "visitElement", @@ -242,7 +242,10 @@ class UnitVisitorGenerator(referencesData: DataCollector.ReferencesData) : Abstr generateVisit(klass, parent) } - referencesData.back.keys.forEach { + val trampolines = referencesData.back.let { + it.keys + it.values.flatten() + }.distinct() + trampolines.forEach { generateTrampolineVisit(it) } 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 new file mode 100644 index 00000000000..7ca80219e4d --- /dev/null +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorGenerated.kt @@ -0,0 +1,177 @@ +/* + * 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.declarations.* +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.types.* + + +/** This file generated by :compiler:fir:tree:generateVisitors. DO NOT MODIFY MANUALLY! */ +abstract class FirVisitor { + abstract fun visitElement(element: FirElement, data: D): R + + open fun visitDeclaration(declaration: FirDeclaration, data: D): R { + return visitElement(declaration, data) + } + + open fun visitCallableMember(callableMember: FirCallableMember, data: D): R { + return visitDeclaration(callableMember, data) + } + + open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: D): R { + return visitDeclaration(declarationWithBody, data) + } + + open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: D): R { + return visitDeclarationWithBody(anonymousInitializer, data) + } + + open fun visitFunction(function: FirFunction, data: D): R { + return visitDeclarationWithBody(function, data) + } + + open fun visitConstructor(constructor: FirConstructor, data: D): R { + return visitFunction(constructor, data) + } + + open fun visitNamedFunction(namedFunction: FirNamedFunction, data: D): R { + return visitFunction(namedFunction, data) + } + + open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: D): R { + return visitFunction(propertyAccessor, data) + } + + open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: D): R { + return visitDeclaration(errorDeclaration, data) + } + + open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: D): R { + return visitDeclaration(namedDeclaration, data) + } + + open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: D): R { + return visitNamedDeclaration(memberDeclaration, data) + } + + open fun visitClass(klass: FirClass, data: D): R { + return visitMemberDeclaration(klass, data) + } + + open fun visitEnumEntry(enumEntry: FirEnumEntry, data: D): R { + return visitClass(enumEntry, data) + } + + open fun visitTypeAlias(typeAlias: FirTypeAlias, data: D): R { + return visitMemberDeclaration(typeAlias, data) + } + + open fun visitTypeParameter(typeParameter: FirTypeParameter, data: D): R { + return visitNamedDeclaration(typeParameter, data) + } + + open fun visitProperty(property: FirProperty, data: D): R { + return visitDeclaration(property, data) + } + + open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: D): R { + return visitDeclaration(typedDeclaration, data) + } + + open fun visitValueParameter(valueParameter: FirValueParameter, data: D): R { + return visitDeclaration(valueParameter, data) + } + + open fun visitVariable(variable: FirVariable, data: D): R { + return visitDeclaration(variable, data) + } + + open fun visitImport(import: FirImport, data: D): R { + return visitElement(import, data) + } + + open fun visitPackageFragment(packageFragment: FirPackageFragment, data: D): R { + return visitElement(packageFragment, data) + } + + open fun visitFile(file: FirFile, data: D): R { + return visitPackageFragment(file, data) + } + + open fun visitStatement(statement: FirStatement, data: D): R { + return visitElement(statement, data) + } + + open fun visitExpression(expression: FirExpression, data: D): R { + return visitStatement(expression, data) + } + + open fun visitBody(body: FirBody, data: D): R { + return visitExpression(body, data) + } + + open fun visitCall(call: FirCall, data: D): R { + return visitExpression(call, data) + } + + open fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: D): R { + return visitCall(annotationCall, data) + } + + open fun visitConstructorCall(constructorCall: FirConstructorCall, data: D): R { + return visitCall(constructorCall, data) + } + + open fun visitType(type: FirType, data: D): R { + return visitElement(type, data) + } + + open fun visitDelegatedType(delegatedType: FirDelegatedType, data: D): R { + return visitType(delegatedType, data) + } + + open fun visitErrorType(errorType: FirErrorType, data: D): R { + return visitType(errorType, data) + } + + open fun visitImplicitType(implicitType: FirImplicitType, data: D): R { + return visitType(implicitType, data) + } + + open fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: D): R { + return visitType(typeWithNullability, data) + } + + open fun visitDynamicType(dynamicType: FirDynamicType, data: D): R { + return visitTypeWithNullability(dynamicType, data) + } + + open fun visitFunctionType(functionType: FirFunctionType, data: D): R { + return visitTypeWithNullability(functionType, data) + } + + open fun visitResolvedType(resolvedType: FirResolvedType, data: D): R { + return visitTypeWithNullability(resolvedType, data) + } + + open fun visitUserType(userType: FirUserType, data: D): R { + return visitTypeWithNullability(userType, data) + } + + open fun visitTypeProjection(typeProjection: FirTypeProjection, data: D): R { + return visitElement(typeProjection, data) + } + + open fun visitStarProjection(starProjection: FirStarProjection, data: D): R { + return visitTypeProjection(starProjection, data) + } + + open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: D): R { + return visitTypeProjection(typeProjectionWithVariance, data) + } + +} 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 new file mode 100644 index 00000000000..c2e798103af --- /dev/null +++ b/compiler/fir/tree/visitors/org/jetbrains/kotlin/fir/visitors/FirVisitorVoidGenerated.kt @@ -0,0 +1,341 @@ +/* + * 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.declarations.* +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.types.* + + +/** This file generated by :compiler:fir:tree:generateVisitors. DO NOT MODIFY MANUALLY! */ +abstract class FirVisitorVoid : FirVisitor() { + abstract fun visitElement(element: FirElement) + + open fun visitDeclaration(declaration: FirDeclaration) { + visitElement(declaration, null) + } + + open fun visitCallableMember(callableMember: FirCallableMember) { + visitDeclaration(callableMember, null) + } + + open fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody) { + visitDeclaration(declarationWithBody, null) + } + + open fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer) { + visitDeclarationWithBody(anonymousInitializer, null) + } + + open fun visitFunction(function: FirFunction) { + visitDeclarationWithBody(function, null) + } + + open fun visitConstructor(constructor: FirConstructor) { + visitFunction(constructor, null) + } + + open fun visitNamedFunction(namedFunction: FirNamedFunction) { + visitFunction(namedFunction, null) + } + + open fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) { + visitFunction(propertyAccessor, null) + } + + open fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration) { + visitDeclaration(errorDeclaration, null) + } + + open fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration) { + visitDeclaration(namedDeclaration, null) + } + + open fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration) { + visitNamedDeclaration(memberDeclaration, null) + } + + open fun visitClass(klass: FirClass) { + visitMemberDeclaration(klass, null) + } + + open fun visitEnumEntry(enumEntry: FirEnumEntry) { + visitClass(enumEntry, null) + } + + open fun visitTypeAlias(typeAlias: FirTypeAlias) { + visitMemberDeclaration(typeAlias, null) + } + + open fun visitTypeParameter(typeParameter: FirTypeParameter) { + visitNamedDeclaration(typeParameter, null) + } + + open fun visitProperty(property: FirProperty) { + visitDeclaration(property, null) + } + + open fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration) { + visitDeclaration(typedDeclaration, null) + } + + open fun visitValueParameter(valueParameter: FirValueParameter) { + visitDeclaration(valueParameter, null) + } + + open fun visitVariable(variable: FirVariable) { + visitDeclaration(variable, null) + } + + open fun visitImport(import: FirImport) { + visitElement(import, null) + } + + open fun visitPackageFragment(packageFragment: FirPackageFragment) { + visitElement(packageFragment, null) + } + + open fun visitFile(file: FirFile) { + visitPackageFragment(file, null) + } + + open fun visitStatement(statement: FirStatement) { + visitElement(statement, null) + } + + open fun visitExpression(expression: FirExpression) { + visitStatement(expression, null) + } + + open fun visitBody(body: FirBody) { + visitExpression(body, null) + } + + open fun visitCall(call: FirCall) { + visitExpression(call, null) + } + + open fun visitAnnotationCall(annotationCall: FirAnnotationCall) { + visitCall(annotationCall, null) + } + + open fun visitConstructorCall(constructorCall: FirConstructorCall) { + visitCall(constructorCall, null) + } + + open fun visitType(type: FirType) { + visitElement(type, null) + } + + open fun visitDelegatedType(delegatedType: FirDelegatedType) { + visitType(delegatedType, null) + } + + open fun visitErrorType(errorType: FirErrorType) { + visitType(errorType, null) + } + + open fun visitImplicitType(implicitType: FirImplicitType) { + visitType(implicitType, null) + } + + open fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability) { + visitType(typeWithNullability, null) + } + + open fun visitDynamicType(dynamicType: FirDynamicType) { + visitTypeWithNullability(dynamicType, null) + } + + open fun visitFunctionType(functionType: FirFunctionType) { + visitTypeWithNullability(functionType, null) + } + + open fun visitResolvedType(resolvedType: FirResolvedType) { + visitTypeWithNullability(resolvedType, null) + } + + open fun visitUserType(userType: FirUserType) { + visitTypeWithNullability(userType, null) + } + + open fun visitTypeProjection(typeProjection: FirTypeProjection) { + visitElement(typeProjection, null) + } + + open fun visitStarProjection(starProjection: FirStarProjection) { + visitTypeProjection(starProjection, null) + } + + open fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance) { + visitTypeProjection(typeProjectionWithVariance, null) + } + + final override fun visitDeclarationWithBody(declarationWithBody: FirDeclarationWithBody, data: Nothing?) { + visitDeclarationWithBody(declarationWithBody) + } + + final override fun visitDeclaration(declaration: FirDeclaration, data: Nothing?) { + visitDeclaration(declaration) + } + + final override fun visitMemberDeclaration(memberDeclaration: FirMemberDeclaration, data: Nothing?) { + visitMemberDeclaration(memberDeclaration) + } + + final override fun visitFunction(function: FirFunction, data: Nothing?) { + visitFunction(function) + } + + final override fun visitElement(element: FirElement, data: Nothing?) { + visitElement(element) + } + + final override fun visitClass(klass: FirClass, data: Nothing?) { + visitClass(klass) + } + + final override fun visitPackageFragment(packageFragment: FirPackageFragment, data: Nothing?) { + visitPackageFragment(packageFragment) + } + + final override fun visitNamedDeclaration(namedDeclaration: FirNamedDeclaration, data: Nothing?) { + visitNamedDeclaration(namedDeclaration) + } + + final override fun visitCall(call: FirCall, data: Nothing?) { + visitCall(call) + } + + final override fun visitExpression(expression: FirExpression, data: Nothing?) { + visitExpression(expression) + } + + final override fun visitStatement(statement: FirStatement, data: Nothing?) { + visitStatement(statement) + } + + final override fun visitType(type: FirType, data: Nothing?) { + visitType(type) + } + + final override fun visitTypeWithNullability(typeWithNullability: FirTypeWithNullability, data: Nothing?) { + visitTypeWithNullability(typeWithNullability) + } + + final override fun visitTypeProjection(typeProjection: FirTypeProjection, data: Nothing?) { + visitTypeProjection(typeProjection) + } + + final override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: Nothing?) { + visitAnonymousInitializer(anonymousInitializer) + } + + final override fun visitCallableMember(callableMember: FirCallableMember, data: Nothing?) { + visitCallableMember(callableMember) + } + + final override fun visitErrorDeclaration(errorDeclaration: FirErrorDeclaration, data: Nothing?) { + visitErrorDeclaration(errorDeclaration) + } + + final override fun visitProperty(property: FirProperty, data: Nothing?) { + visitProperty(property) + } + + final override fun visitTypedDeclaration(typedDeclaration: FirTypedDeclaration, data: Nothing?) { + visitTypedDeclaration(typedDeclaration) + } + + final override fun visitValueParameter(valueParameter: FirValueParameter, data: Nothing?) { + visitValueParameter(valueParameter) + } + + final override fun visitVariable(variable: FirVariable, data: Nothing?) { + visitVariable(variable) + } + + final override fun visitTypeAlias(typeAlias: FirTypeAlias, data: Nothing?) { + visitTypeAlias(typeAlias) + } + + final override fun visitConstructor(constructor: FirConstructor, data: Nothing?) { + visitConstructor(constructor) + } + + final override fun visitNamedFunction(namedFunction: FirNamedFunction, data: Nothing?) { + visitNamedFunction(namedFunction) + } + + final override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor, data: Nothing?) { + visitPropertyAccessor(propertyAccessor) + } + + final override fun visitImport(import: FirImport, data: Nothing?) { + visitImport(import) + } + + final override fun visitEnumEntry(enumEntry: FirEnumEntry, data: Nothing?) { + visitEnumEntry(enumEntry) + } + + final override fun visitFile(file: FirFile, data: Nothing?) { + visitFile(file) + } + + final override fun visitTypeParameter(typeParameter: FirTypeParameter, data: Nothing?) { + visitTypeParameter(typeParameter) + } + + final override fun visitAnnotationCall(annotationCall: FirAnnotationCall, data: Nothing?) { + visitAnnotationCall(annotationCall) + } + + final override fun visitConstructorCall(constructorCall: FirConstructorCall, data: Nothing?) { + visitConstructorCall(constructorCall) + } + + final override fun visitBody(body: FirBody, data: Nothing?) { + visitBody(body) + } + + final override fun visitDelegatedType(delegatedType: FirDelegatedType, data: Nothing?) { + visitDelegatedType(delegatedType) + } + + final override fun visitErrorType(errorType: FirErrorType, data: Nothing?) { + visitErrorType(errorType) + } + + final override fun visitImplicitType(implicitType: FirImplicitType, data: Nothing?) { + visitImplicitType(implicitType) + } + + final override fun visitDynamicType(dynamicType: FirDynamicType, data: Nothing?) { + visitDynamicType(dynamicType) + } + + final override fun visitFunctionType(functionType: FirFunctionType, data: Nothing?) { + visitFunctionType(functionType) + } + + final override fun visitResolvedType(resolvedType: FirResolvedType, data: Nothing?) { + visitResolvedType(resolvedType) + } + + final override fun visitUserType(userType: FirUserType, data: Nothing?) { + visitUserType(userType) + } + + final override fun visitStarProjection(starProjection: FirStarProjection, data: Nothing?) { + visitStarProjection(starProjection) + } + + final override fun visitTypeProjectionWithVariance(typeProjectionWithVariance: FirTypeProjectionWithVariance, data: Nothing?) { + visitTypeProjectionWithVariance(typeProjectionWithVariance) + } + +} diff --git a/compiler/psi/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt b/compiler/psi/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt index c4a6074ed37..332de5ccf23 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt +++ b/compiler/psi/src/org/jetbrains/kotlin/psi/psiUtil/ktPsiUtil.kt @@ -455,6 +455,8 @@ fun KtModifierListOwner.visibilityModifierTypeOrDefault(): KtModifierKeywordToke fun KtDeclaration.modalityModifier() = modifierFromTokenSet(MODALITY_MODIFIERS) +fun KtDeclaration.modalityModifierType(): KtModifierKeywordToken? = modalityModifier()?.node?.elementType as KtModifierKeywordToken? + fun KtStringTemplateExpression.isPlain() = entries.all { it is KtLiteralStringTemplateEntry } fun KtStringTemplateExpression.isPlainWithEscapes() = entries.all { it is KtLiteralStringTemplateEntry || it is KtEscapeStringTemplateEntry } diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt b/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt new file mode 100644 index 00000000000..839f20704d8 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleClass.kt @@ -0,0 +1,17 @@ +interface SomeInterface { + fun foo(x: Int, y: String): String + + val bar: Boolean +} + +class SomeClass : SomeInterface { + private val baz = 42 + + override fun foo(x: Int, y: String): String { + return y + x + baz + } + + override var bar: Boolean + get() = true + set(value) {} +} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt new file mode 100644 index 00000000000..41cd20bbd9f --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleClass.txt @@ -0,0 +1,23 @@ +FILE: simpleClass.kt + unknown final class SomeInterface() { + unknown final function foo(x: Int, y: String): String + + unknown final property bar(val): Boolean + unknown get(): Boolean + + } + unknown final class SomeClass() : SomeInterface { + private final property baz(val): = STUB + unknown get(): + + unknown final override function foo(x: Int, y: String): String { + } + + unknown final override property bar(var): Boolean + unknown get(): { + STUB + } + unknown set(value: Boolean): { + } + + } diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleFun.kt b/compiler/testData/fir/rawBuilder/declarations/simpleFun.kt new file mode 100644 index 00000000000..59281f1b0bb --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleFun.kt @@ -0,0 +1 @@ +fun foo() {} \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/simpleFun.txt b/compiler/testData/fir/rawBuilder/declarations/simpleFun.txt new file mode 100644 index 00000000000..f8b2fb8c0e5 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/simpleFun.txt @@ -0,0 +1,3 @@ +FILE: simpleFun.kt + unknown final function foo(): { + } \ No newline at end of file diff --git a/compiler/testData/fir/rawBuilder/declarations/typeParameters.kt b/compiler/testData/fir/rawBuilder/declarations/typeParameters.kt new file mode 100644 index 00000000000..e267b1ada73 --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeParameters.kt @@ -0,0 +1,16 @@ +interface List { + operator fun get(index: Int): T + + infix fun concat(other: List): List +} + +typealias StringList = List +typealias AnyList = List<*> + +abstract class AbstractList : List + +class SomeList : AbstractList() { + override fun get(index: Int): Int = 42 + + override fun concat(other: List): List = this +} diff --git a/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt b/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt new file mode 100644 index 00000000000..310960ca93f --- /dev/null +++ b/compiler/testData/fir/rawBuilder/declarations/typeParameters.txt @@ -0,0 +1,21 @@ +FILE: typeParameters.kt + unknown final class List() { + unknown final operator function get(index: Int): T + + unknown final infix function concat(other: List): List + + } + unknown final typealias StringList = List + unknown final typealias AnyList = List<*> + unknown abstract class AbstractList() : List { + } + unknown final class SomeList() : AbstractList { + unknown final override function get(index: Int): Int { + STUB + } + + unknown final override function concat(other: List): List { + STUB + } + + } diff --git a/compiler/tests-common/build.gradle.kts b/compiler/tests-common/build.gradle.kts index 376a83682cb..7f1b37d8379 100644 --- a/compiler/tests-common/build.gradle.kts +++ b/compiler/tests-common/build.gradle.kts @@ -10,6 +10,8 @@ dependencies { testCompile(project(":core:deserialization")) testCompile(project(":compiler:util")) testCompile(project(":compiler:backend")) + testCompile(project(":compiler:fir:tree")) + testCompile(project(":compiler:fir:psi2fir")) testCompile(project(":compiler:ir.ir2cfg")) testCompile(project(":compiler:frontend")) testCompile(project(":compiler:frontend.java")) diff --git a/compiler/tests-common/build.gradle.kts.173 b/compiler/tests-common/build.gradle.kts.173 index 4aa86a387c3..0a012972bf9 100644 --- a/compiler/tests-common/build.gradle.kts.173 +++ b/compiler/tests-common/build.gradle.kts.173 @@ -10,6 +10,8 @@ dependencies { testCompile(project(":core:deserialization")) testCompile(project(":compiler:util")) testCompile(project(":compiler:backend")) + testCompile(project(":compiler:fir:tree")) + testCompile(project(":compiler:fir:psi2fir")) testCompile(project(":compiler:ir.ir2cfg")) testCompile(project(":compiler:frontend")) testCompile(project(":compiler:frontend.java")) diff --git a/compiler/tests-common/build.gradle.kts.181 b/compiler/tests-common/build.gradle.kts.181 index bd3c2936438..e166a4cd7bc 100644 --- a/compiler/tests-common/build.gradle.kts.181 +++ b/compiler/tests-common/build.gradle.kts.181 @@ -10,6 +10,8 @@ dependencies { testCompile(project(":core:deserialization")) testCompile(project(":compiler:util")) testCompile(project(":compiler:backend")) + testCompile(project(":compiler:fir:tree")) + testCompile(project(":compiler:fir:psi2fir")) testCompile(project(":compiler:ir.ir2cfg")) testCompile(project(":compiler:frontend")) testCompile(project(":compiler:frontend.java")) diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt new file mode 100644 index 00000000000..fca25869bcb --- /dev/null +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/builder/AbstractRawFirBuilderTestCase.kt @@ -0,0 +1,72 @@ +/* + * Copyright 2000-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.builder + +import com.intellij.openapi.fileTypes.FileTypeManager +import com.intellij.openapi.fileTypes.FileTypeRegistry +import com.intellij.openapi.util.Getter +import com.intellij.openapi.util.io.FileUtil +import com.intellij.openapi.util.io.FileUtilRt +import com.intellij.psi.PsiFile +import com.intellij.psi.tree.IElementType +import com.intellij.util.PathUtil +import org.jetbrains.kotlin.KtNodeTypes +import org.jetbrains.kotlin.cli.common.script.CliScriptDefinitionProvider +import org.jetbrains.kotlin.fir.FirRenderer +import org.jetbrains.kotlin.fir.FirSession +import org.jetbrains.kotlin.parsing.KotlinParserDefinition +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtPsiFactory +import org.jetbrains.kotlin.script.ScriptDefinitionProvider +import org.jetbrains.kotlin.test.KotlinTestUtils +import org.jetbrains.kotlin.test.testFramework.KtParsingTestCase +import java.io.File + +abstract class AbstractRawFirBuilderTestCase : KtParsingTestCase( + ".", + "kt", + KotlinParserDefinition() +) { + override fun setUp() { + super.setUp() + project.registerService(ScriptDefinitionProvider::class.java, CliScriptDefinitionProvider::class.java) + } + + override fun getTestDataPath() = KotlinTestUtils.getHomeDirectory() + + private fun createFile(filePath: String, fileType: IElementType): PsiFile { + val psiFactory = KtPsiFactory(myProject) + return when (fileType) { + KtNodeTypes.EXPRESSION_CODE_FRAGMENT -> + psiFactory.createExpressionCodeFragment(loadFile(filePath), null) + KtNodeTypes.BLOCK_CODE_FRAGMENT -> + psiFactory.createBlockCodeFragment(loadFile(filePath), null) + else -> + createPsiFile(FileUtil.getNameWithoutExtension(PathUtil.getFileName(filePath)), loadFile(filePath)) + } + } + + protected fun doRawFirTest(filePath: String) { + doBaseTest(filePath, KtNodeTypes.KT_FILE) + } + + private fun doBaseTest(filePath: String, fileType: IElementType) { + myFileExt = FileUtilRt.getExtension(PathUtil.getFileName(filePath)) + val file = createFile(filePath, fileType) as KtFile + myFile = file + + val firFile = RawFirBuilder(object : FirSession {}).buildFirFile(file) + val firFileDump = StringBuilder().also { FirRenderer(it).visitFile(firFile) }.toString() + val expectedPath = filePath.replace(".kt", ".txt") + KotlinTestUtils.assertEqualsToFile(File(expectedPath), firFileDump) + } + + override fun tearDown() { + super.tearDown() + FileTypeRegistry.ourInstanceGetter = Getter { FileTypeManager.getInstance() } + } + +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java b/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java new file mode 100644 index 00000000000..d9aacf8605a --- /dev/null +++ b/compiler/tests/org/jetbrains/kotlin/fir/builder/RawFirBuilderTestCaseGenerated.java @@ -0,0 +1,54 @@ +/* + * Copyright 2000-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.builder; + +import com.intellij.testFramework.TestDataPath; +import org.jetbrains.kotlin.test.JUnit3RunnerWithInners; +import org.jetbrains.kotlin.test.KotlinTestUtils; +import org.jetbrains.kotlin.test.TargetBackend; +import org.jetbrains.kotlin.test.TestMetadata; +import org.junit.runner.RunWith; + +import java.io.File; +import java.util.regex.Pattern; + +/** This class is generated by {@link org.jetbrains.kotlin.generators.tests.TestsPackage}. DO NOT MODIFY MANUALLY */ +@SuppressWarnings("all") +@TestMetadata("compiler/testData/fir/rawBuilder") +@TestDataPath("$PROJECT_ROOT") +@RunWith(JUnit3RunnerWithInners.class) +public class RawFirBuilderTestCaseGenerated extends AbstractRawFirBuilderTestCase { + public void testAllFilesPresentInRawBuilder() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/fir/rawBuilder"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("compiler/testData/fir/rawBuilder/declarations") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Declarations extends AbstractRawFirBuilderTestCase { + public void testAllFilesPresentInDeclarations() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/fir/rawBuilder/declarations"), Pattern.compile("^(.+)\\.kt$"), TargetBackend.ANY, true); + } + + @TestMetadata("simpleClass.kt") + public void testSimpleClass() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/simpleClass.kt"); + doRawFirTest(fileName); + } + + @TestMetadata("simpleFun.kt") + public void testSimpleFun() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/simpleFun.kt"); + doRawFirTest(fileName); + } + + @TestMetadata("typeParameters.kt") + public void testTypeParameters() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/fir/rawBuilder/declarations/typeParameters.kt"); + doRawFirTest(fileName); + } + } +} diff --git a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt index ccecb4f549d..f944333a8c5 100644 --- a/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt +++ b/compiler/tests/org/jetbrains/kotlin/generators/tests/GenerateCompilerTests.kt @@ -17,6 +17,7 @@ import org.jetbrains.kotlin.codegen.* import org.jetbrains.kotlin.codegen.defaultConstructor.AbstractDefaultArgumentsReflectionTest import org.jetbrains.kotlin.codegen.flags.AbstractWriteFlagsTest import org.jetbrains.kotlin.codegen.ir.* +import org.jetbrains.kotlin.fir.builder.AbstractRawFirBuilderTestCase import org.jetbrains.kotlin.generators.tests.generator.testGroup import org.jetbrains.kotlin.generators.util.KT_OR_KTS_WITHOUT_DOTS_IN_NAME import org.jetbrains.kotlin.integration.AbstractAntTaskTest @@ -197,6 +198,10 @@ fun main(args: Array) { model("ir/sourceRanges") } + testClass { + model("fir/rawBuilder", testMethod = "doRawFirTest") + } + testClass { model("codegen/bytecodeListing") }