From c20e537b81430b94c98c6cb6a33a2a596ce62e72 Mon Sep 17 00:00:00 2001 From: Ilya Kirillov Date: Mon, 18 Feb 2019 10:30:21 +0300 Subject: [PATCH] New J2K: Preserve comments and line breaks --- .../kotlin/nj2k/ConversionsRunner.kt | 3 +- .../kotlin/nj2k/JavaToJKTreeBuilder.kt | 385 ++++-- .../jetbrains/kotlin/nj2k/NewCodeBuilder.kt | 318 ++--- .../src/org/jetbrains/kotlin/nj2k/TreeCopy.kt | 3 +- ...enthesisForLineBreaksInBinaryExpression.kt | 31 + .../conversions/AnnotationClassConversion.kt | 6 +- .../AssignmentStatementSplitAlsoConversion.kt | 8 +- ...ssignmentStatementValCreationConversion.kt | 6 +- .../nj2k/conversions/BlockToRunConversion.kt | 7 +- .../BoxedTypeOperationsConversion.kt | 2 +- .../conversions/BuiltinMembersConversion.kt | 10 +- .../ClassToObjectPromotionConversion.kt | 9 +- .../nj2k/conversions/ConstructorConversion.kt | 11 +- .../conversions/DefaultArgumentsConversion.kt | 18 +- .../conversions/FieldToPropertyConversion.kt | 9 +- .../kotlin/nj2k/conversions/ForConversion.kt | 6 +- .../nj2k/conversions/InnerClassConversion.kt | 7 +- ...sertDefaultPrimaryConstructorConversion.kt | 5 +- ...on.kt => InternalDeclarationConversion.kt} | 12 +- .../JavaMethodToKotlinFunctionConversion.kt | 15 +- .../conversions/JavaModifiersConversion.kt | 37 +- .../nj2k/conversions/ModalityConversion.kt | 10 +- .../conversions/NonCodeElementsConversion.kt | 21 + .../OperatorExpressionConversion.kt | 4 +- ...eterModificationInMethodCallsConversion.kt | 12 +- .../PrimaryConstructorDetectConversion.kt | 11 +- .../nj2k/conversions/PrintlnConversion.kt | 6 +- .../StaticInitDeclarationConversion.kt | 7 +- .../StaticMemberAccessConversion.kt | 2 +- .../StaticsToCompanionExtractConversion.kt | 6 +- .../conversions/SwitchStatementConversion.kt | 2 +- .../SynchronizedStatementConversion.kt | 3 +- .../conversions/TryStatementConversion.kt | 10 +- .../nj2k/conversions/TypeMappingConversion.kt | 4 +- .../org/jetbrains/kotlin/nj2k/expressions.kt | 26 +- .../jetbrains/kotlin/nj2k/tree/impl/base.kt | 12 +- .../org/jetbrains/kotlin/nj2k/tree/impl/j.kt | 76 +- .../org/jetbrains/kotlin/nj2k/tree/impl/jk.kt | 135 +- .../org/jetbrains/kotlin/nj2k/tree/impl/k.kt | 73 +- .../jetbrains/kotlin/nj2k/tree/impl/tokens.kt | 21 + nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt | 81 +- nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt | 213 ++-- nj2k/src/org/jetbrains/kotlin/nj2k/tree/k.kt | 45 +- .../org/jetbrains/kotlin/nj2k/tree/tokens.kt | 54 + .../GenerateJKTreeVisitorAndTransformer.kts | 49 +- .../kotlin/nj2k/tree/visitors/JKVisitor.kt | 8 +- .../nj2k/tree/visitors/JKVisitorVoid.kt | 14 +- .../visitors/JKVisitorWithCommentsPrinting.kt | 1088 +++++++++++++++++ 48 files changed, 2304 insertions(+), 597 deletions(-) create mode 100644 nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddParenthesisForLineBreaksInBinaryExpression.kt rename nj2k/src/org/jetbrains/kotlin/nj2k/conversions/{InternalClassConversion.kt => InternalDeclarationConversion.kt} (68%) create mode 100644 nj2k/src/org/jetbrains/kotlin/nj2k/conversions/NonCodeElementsConversion.kt create mode 100644 nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/tokens.kt create mode 100644 nj2k/src/org/jetbrains/kotlin/nj2k/tree/tokens.kt create mode 100644 nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/ConversionsRunner.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/ConversionsRunner.kt index a4132783f6e..0b4639b98d9 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/ConversionsRunner.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/ConversionsRunner.kt @@ -24,6 +24,7 @@ object ConversionsRunner { private fun createRootConversion(context: ConversionContext) = batchPipe { //Java --> Kotlin conversions + +NonCodeElementsConversion() +JavaModifiersConversion(context) +JavaAnnotationsConversion(context) +AnnotationClassConversion(context) @@ -75,7 +76,7 @@ object ConversionsRunner { +ImplicitCastsConversion(context) +DefaultNullabilityToNullableConversion() +NullableQualifierConversion(context) - +InternalClassConversion() + +InternalDeclarationConversion() //Kotlin --> Kotlin conversions +InnerClassConversion() diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt index 15004456da8..d1ca5eb8862 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt @@ -22,6 +22,7 @@ import com.intellij.psi.* import com.intellij.psi.JavaTokenType.SUPER_KEYWORD import com.intellij.psi.JavaTokenType.THIS_KEYWORD import com.intellij.psi.impl.source.tree.ChildRole +import com.intellij.psi.impl.source.tree.CompositeElement import com.intellij.psi.impl.source.tree.java.PsiClassObjectAccessExpressionImpl import com.intellij.psi.impl.source.tree.java.PsiLabeledStatementImpl import com.intellij.psi.impl.source.tree.java.PsiLiteralExpressionImpl @@ -34,6 +35,7 @@ import org.jetbrains.kotlin.asJava.classes.KtLightClassForFacade import org.jetbrains.kotlin.asJava.elements.KtLightField import org.jetbrains.kotlin.asJava.elements.KtLightMethod import org.jetbrains.kotlin.idea.caches.lightClasses.KtLightClassForDecompiledDeclaration +import org.jetbrains.kotlin.idea.j2k.IdeaDocCommentConverter import org.jetbrains.kotlin.idea.j2k.content import org.jetbrains.kotlin.j2k.ReferenceSearcher import org.jetbrains.kotlin.j2k.ast.Nullability @@ -69,6 +71,10 @@ class JavaToJKTreeBuilder( private fun PsiPackageStatement.toJK(): JKPackageDeclaration = JKPackageDeclarationImpl(JKNameIdentifierImpl(packageName)) + .also { + it.assignNonCodeElements(this) + } + private fun PsiImportStatement.toJK(): JKImportStatementImpl { val target = resolve() @@ -77,8 +83,18 @@ class JavaToJKTreeBuilder( if (target is KtLightClassForFacade) rawName.replaceAfterLast('.', "*") else rawName return JKImportStatementImpl(JKNameIdentifierImpl(name)) + .also { + it.assignNonCodeElements(this) + } } + private fun PsiIdentifier?.toJK(): JKNameIdentifier = + this?.let { + JKNameIdentifierImpl(it.text).also { + it.assignNonCodeElements(this) + } + } ?: JKNameIdentifierImpl("") + private inner class ExpressionTreeMapper { fun PsiExpression?.toJK(): JKExpression { @@ -118,7 +134,10 @@ class JavaToJKTreeBuilder( throw RuntimeException("Not supported: ${this::class}") } }.also { - if (this != null) (it as PsiOwner).psi = this + if (this != null) { + (it as PsiOwner).psi = this + it.assignNonCodeElements(this) + } } } @@ -131,19 +150,25 @@ class JavaToJKTreeBuilder( is JKJavaVoidType -> JKClassLiteralExpression.LiteralType.JAVA_VOID_TYPE else -> JKClassLiteralExpression.LiteralType.JAVA_CLASS } - ) + ).also { + it.assignNonCodeElements(this) + } } fun PsiInstanceOfExpression.toJK(): JKKtIsExpression = JKKtIsExpressionImpl(operand.toJK(), JKTypeElementImpl(checkType?.type?.toJK(symbolProvider) ?: JKNoTypeImpl)) - + .also { + it.assignNonCodeElements(this) + } fun PsiAssignmentExpression.toJK(): JKJavaAssignmentExpression { return JKJavaAssignmentExpressionImpl( lExpression.toJK() as? JKAssignableExpression ?: error("Its possible? ${lExpression.toJK().prettyDebugPrintTree()}"), rExpression.toJK(), operationSign.tokenType.toJK() - ) + ).also { + it.assignNonCodeElements(this) + } } fun PsiBinaryExpression.toJK(): JKExpression { @@ -157,6 +182,9 @@ class JavaToJKTreeBuilder( else -> operationSign.tokenType } return JKBinaryExpressionImpl(lOperand.toJK(), rOperand.toJK(), token.toJK()) + .also { + it.assignNonCodeElements(this) + } } fun PsiLiteralExpression.toJK(): JKLiteralExpression { @@ -173,6 +201,8 @@ class JavaToJKTreeBuilder( JavaTokenType.FLOAT_LITERAL -> JKJavaLiteralExpressionImpl(text, FLOAT) JavaTokenType.DOUBLE_LITERAL -> JKJavaLiteralExpressionImpl(text, DOUBLE) else -> error("Unknown literal element type: ${this.literalElementType}") + }.also { + it.assignNonCodeElements(this) } } @@ -188,11 +218,15 @@ class JavaToJKTreeBuilder( (it.expression as JKLiteralExpression).type ) } else it + }.also { + it.assignNonCodeElements(this) } } fun PsiPostfixExpression.toJK(): JKExpression { - return JKPostfixExpressionImpl(operand.toJK(), operationSign.tokenType.toJK()) + return JKPostfixExpressionImpl(operand.toJK(), operationSign.tokenType.toJK()).also { + it.assignNonCodeElements(this) + } } fun PsiLambdaExpression.toJK(): JKExpression { @@ -201,11 +235,13 @@ class JavaToJKTreeBuilder( when (it) { is PsiExpression -> JKExpressionStatementImpl(it.toJK()) is PsiCodeBlock -> JKBlockStatementImpl(with(declarationMapper) { it.toJK() }) - else -> JKBlockStatementImpl(JKBodyStub) + else -> JKBlockStatementImpl(JKBodyStubImpl) } }, with(declarationMapper) { parameterList.parameters.map { it.toJK() } } - ) + ).also { + it.assignNonCodeElements(this) + } } private fun JKExpression.qualified(qualifier: JKExpression?) = @@ -296,6 +332,8 @@ class JavaToJKTreeBuilder( symbol is JKFieldSymbol -> JKFieldAccessExpressionImpl(symbol).qualified(qualifier) else -> TODO(text) + }.also { + it.assignNonCodeElements(this) } } @@ -316,14 +354,18 @@ class JavaToJKTreeBuilder( is JKClassSymbol -> JKClassAccessExpressionImpl(symbol) is JKFieldSymbol -> JKFieldAccessExpressionImpl(symbol) else -> TODO() - }.qualified(qualifierExpression?.toJK()) + }.qualified(qualifierExpression?.toJK()).also { + it.assignNonCodeElements(this) + } } fun PsiArrayInitializerExpression.toJK(): JKExpression { return JKJavaNewArrayImpl( initializers.map { it.toJK() }, JKTypeElementImpl(type?.toJK(symbolProvider).safeAs()?.type ?: JKContextType) - ) + ).also { + it.assignNonCodeElements(this) + } } fun PsiNewExpression.toJK(): JKExpression { @@ -371,23 +413,37 @@ class JavaToJKTreeBuilder( with(declarationMapper) { anonymousClass?.createClassBody() } ?: JKEmptyClassBodyImpl() ) } - return qualifier?.let { JKQualifiedExpressionImpl(it.toJK(), JKJavaQualifierImpl.DOT, newExpression) } ?: newExpression + return qualifier?.let { + JKQualifiedExpressionImpl(it.toJK(), JKJavaQualifierImpl.DOT, newExpression) + } ?: newExpression } fun PsiReferenceParameterList.toJK(): JKTypeArgumentList = JKTypeArgumentListImpl(this.typeArguments.map { JKTypeElementImpl(it.toJK(symbolProvider)) }) + .also { + it.assignNonCodeElements(this) + } fun PsiArrayAccessExpression.toJK(): JKExpression { return JKArrayAccessExpressionImpl(arrayExpression.toJK(), indexExpression?.toJK() ?: TODO()) + .also { + it.assignNonCodeElements(this) + } } fun PsiTypeCastExpression.toJK(): JKExpression { return JKTypeCastExpressionImpl(operand?.toJK() ?: TODO(), castType?.type?.toJK(symbolProvider)?.asTypeElement() ?: TODO()) + .also { + it.assignNonCodeElements(this) + } } fun PsiParenthesizedExpression.toJK(): JKExpression { return JKParenthesizedExpressionImpl(expression?.toJK() ?: TODO()) + .also { + it.assignNonCodeElements(this) + } } fun PsiExpressionList.toJK(): JKArgumentList { @@ -402,10 +458,14 @@ class JavaToJKTreeBuilder( JKPrefixExpressionImpl( jkExpressions.last(), JKKtSpreadOperator - ) + ).withNonCodeElementsFrom(jkExpressions.last()) jkExpressions.dropLast(1) + staredExpression } else jkExpressions - } ?: jkExpressions).let { it.toArgumentList() } + } ?: jkExpressions) + .toArgumentList() + .also { + it.assignNonCodeElements(this) + } } } @@ -413,10 +473,17 @@ class JavaToJKTreeBuilder( private inner class DeclarationMapper(val expressionTreeMapper: ExpressionTreeMapper) { fun PsiTypeParameterList.toJK(): JKTypeParameterList = JKTypeParameterListImpl(typeParameters.map { it.toJK() }) + .also { + it.assignNonCodeElements(this) + } fun PsiTypeParameter.toJK(): JKTypeParameter = - JKTypeParameterImpl(JKNameIdentifierImpl(name!!), - extendsListTypes.map { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) }) + JKTypeParameterImpl( + nameIdentifier.toJK(), + extendsListTypes.map { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) } + ).also { + it.assignNonCodeElements(this) + } fun PsiClass.toJK(): JKClass { val classKind: JKClass.ClassKind = when { @@ -427,26 +494,39 @@ class JavaToJKTreeBuilder( } fun PsiReferenceList.mapTypes() = - this.referencedTypes.map { with(expressionTreeMapper) { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) } } + this.referencedTypes.map { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) } - val implTypes = this.implementsList?.mapTypes().orEmpty() - val extensionType = this.extendsList?.mapTypes().orEmpty() return JKClassImpl( - JKNameIdentifierImpl(name!!), - JKInheritanceInfoImpl(extensionType, implTypes), + nameIdentifier.toJK(), + inheritanceInfo(), classKind, typeParameterList?.toJK() ?: JKTypeParameterListImpl(), createClassBody(), annotationList(this), - modifiers(), + extraModifiers(), visibility(), modality() ).also { jkClassImpl -> jkClassImpl.psi = this symbolProvider.provideUniverseSymbol(this, jkClassImpl) + }.also { + it.assignNonCodeElements(this) } } + fun PsiClass.inheritanceInfo(): JKInheritanceInfo { + val implTypes = + implementsList?.referencedTypes?.map { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) }.orEmpty() + val extensionType = + extendsList?.referencedTypes?.map { JKTypeElementImpl(it.toJK(symbolProvider, Nullability.Default)) }.orEmpty() + return JKInheritanceInfoImpl(extensionType, implTypes) + .also { + if (implementsList != null) { + it.assignNonCodeElements(implementsList!!) + } + } + } + fun PsiClass.createClassBody() = JKClassBodyImpl( children.mapNotNull { @@ -460,42 +540,80 @@ class JavaToJKTreeBuilder( else -> null } } - ) + ).also { + it.leftBrace.assignNonCodeElements(lBrace) + it.rightBrace.assignNonCodeElements(rBrace) + } fun PsiClassInitializer.toJK(): JKDeclaration = - if (hasModifier(JvmModifier.STATIC)) + (if (hasModifier(JvmModifier.STATIC)) JKJavaStaticInitDeclarationImpl(body.toJK()) - else JKKtInitDeclarationImpl(body.toJK()) + else JKKtInitDeclarationImpl(body.toJK())) + .also { + it.assignNonCodeElements(this) + } fun PsiEnumConstant.toJK(): JKEnumConstant = JKEnumConstantImpl( - JKNameIdentifierImpl(name), + nameIdentifier.toJK(), with(expressionTreeMapper) { argumentList?.toJK() ?: JKArgumentListImpl() }, initializingClass?.createClassBody() ?: JKEmptyClassBodyImpl(), JKTypeElementImpl(JKClassTypeImpl(symbolProvider.provideDirectSymbol(containingClass!!) as JKClassSymbol, emptyList())) ).also { symbolProvider.provideUniverseSymbol(this, it) it.psi = this + }.also { + it.assignNonCodeElements(this) } + fun PsiMember.modality() = - when { - modifierList == null -> Modality.OPEN - hasModifierProperty(PsiModifier.FINAL) -> Modality.FINAL - hasModifierProperty(PsiModifier.ABSTRACT) -> Modality.ABSTRACT - else -> Modality.OPEN - } + modifierList?.children?.mapNotNull { child -> + if (child !is PsiKeyword) return@mapNotNull null + when (child.text) { + PsiModifier.FINAL -> Modality.FINAL + PsiModifier.ABSTRACT -> Modality.ABSTRACT + + else -> null + }?.let { + JKModalityModifierElementImpl(it).withAssignedNonCodeElements(child) + } + }?.firstOrNull() ?: JKModalityModifierElementImpl(Modality.OPEN) + + + fun PsiMember.extraModifiers() = + modifierList?.children?.mapNotNull { child -> + if (child !is PsiKeyword) return@mapNotNull null + when (child.text) { + PsiModifier.NATIVE -> ExtraModifier.NATIVE + PsiModifier.STATIC -> ExtraModifier.STATIC + PsiModifier.STRICTFP -> ExtraModifier.STRICTFP + PsiModifier.SYNCHRONIZED -> ExtraModifier.SYNCHRONIZED + PsiModifier.TRANSIENT -> ExtraModifier.TRANSIENT + PsiModifier.VOLATILE -> ExtraModifier.VOLATILE + + else -> null + }?.let { + JKExtraModifierElementImpl(it).withAssignedNonCodeElements(child) + } + }.orEmpty() fun PsiMember.visibility() = - when { - modifierList == null -> Visibility.PACKAGE_PRIVATE - hasModifierProperty(PsiModifier.PACKAGE_LOCAL) -> Visibility.PACKAGE_PRIVATE - hasModifierProperty(PsiModifier.PRIVATE) -> Visibility.PRIVATE - hasModifierProperty(PsiModifier.PROTECTED) -> handleProtectedVisibility() - hasModifierProperty(PsiModifier.PUBLIC) -> Visibility.PUBLIC - else -> Visibility.PACKAGE_PRIVATE - } + modifierList?.children?.mapNotNull { child -> + if (child !is PsiKeyword) return@mapNotNull null + when (child.text) { + PsiModifier.PACKAGE_LOCAL -> Visibility.PACKAGE_PRIVATE + PsiModifier.PRIVATE -> Visibility.PRIVATE + PsiModifier.PROTECTED -> handleProtectedVisibility() + PsiModifier.PUBLIC -> Visibility.PUBLIC + + else -> null + }?.let { + JKVisibilityModifierElementImpl(it).withAssignedNonCodeElements(child) + } + }?.firstOrNull() ?: JKVisibilityModifierElementImpl(Visibility.PACKAGE_PRIVATE) + private fun PsiMember.handleProtectedVisibility(): Visibility { val originalClass = containingClass ?: return Visibility.PROTECTED @@ -532,44 +650,21 @@ class JavaToJKTreeBuilder( } - fun PsiMember.modifiers() = - if (modifierList == null) emptyList() - else - PsiModifier.MODIFIERS - .filter { this.modifierList!!.hasExplicitModifier(it) } - .mapNotNull { - when (it) { - PsiModifier.NATIVE -> ExtraModifier.NATIVE - PsiModifier.STATIC -> ExtraModifier.STATIC - PsiModifier.STRICTFP -> ExtraModifier.STRICTFP - PsiModifier.SYNCHRONIZED -> ExtraModifier.SYNCHRONIZED - PsiModifier.TRANSIENT -> ExtraModifier.TRANSIENT - PsiModifier.VOLATILE -> ExtraModifier.VOLATILE - - PsiModifier.PROTECTED -> null - PsiModifier.PUBLIC -> null - PsiModifier.PRIVATE -> null - PsiModifier.FINAL -> null - PsiModifier.ABSTRACT -> null - - else -> TODO("Not yet supported") - } - } - - fun PsiField.toJK(): JKJavaField { return JKJavaFieldImpl( - JKTypeElementImpl(type.toJK(symbolProvider)), - JKNameIdentifierImpl(name), + JKTypeElementImpl(type.toJK(symbolProvider)).withAssignedNonCodeElements(typeElement), + nameIdentifier.toJK(), with(expressionTreeMapper) { initializer.toJK() }, annotationList(this), - modifiers(), + extraModifiers(), visibility(), modality(), - Mutability.UNKNOWN + JKMutabilityModifierElementImpl(Mutability.UNKNOWN) ).also { symbolProvider.provideUniverseSymbol(this, it) it.psi = this + }.also { + it.assignNonCodeElements(this) } } @@ -598,7 +693,9 @@ class JavaToJKTreeBuilder( ) } } - ) + ).also { + it.assignNonCodeElements(this) + } fun PsiDocComment.deprecatedAnnotation(): JKAnnotation? = findTagByName("deprecated")?.let { tag -> @@ -619,6 +716,8 @@ class JavaToJKTreeBuilder( initializers.map { it.toJK() } ) else -> TODO(this::class.toString()) + }.also { + it.assignNonCodeElements(this) } fun PsiAnnotationMethod.toJK(): JKJavaAnnotationMethod = @@ -626,31 +725,40 @@ class JavaToJKTreeBuilder( returnType?.toJK(symbolProvider)?.asTypeElement() ?: JKTypeElementImpl(JKJavaVoidType).takeIf { isConstructor } ?: TODO(), - JKNameIdentifierImpl(name), + nameIdentifier.toJK(), defaultValue?.toJK() ?: JKStubExpressionImpl() ).also { it.psi = this symbolProvider.provideUniverseSymbol(this, it) + }.also { + it.assignNonCodeElements(this) } + fun PsiMethod.toJK(): JKJavaMethod { return JKJavaMethodImpl( returnType?.toJK(symbolProvider)?.asTypeElement() ?: JKTypeElementImpl(JKJavaVoidType).takeIf { isConstructor } ?: TODO(), - JKNameIdentifierImpl(name), + nameIdentifier.toJK(), parameterList.parameters.map { it.toJK() }, - body?.toJK() ?: JKBodyStub, + body?.toJK() ?: JKBodyStubImpl, typeParameterList?.toJK() ?: JKTypeParameterListImpl(), annotationList(this), throwsList.referencedTypes.map { JKTypeElementImpl(it.toJK(symbolProvider)) }, - modifiers(), + extraModifiers(), visibility(), modality() - ).also { - it.psi = this - symbolProvider.provideUniverseSymbol(this, it) - } + ).also { jkMethod -> + jkMethod.psi = this + symbolProvider.provideUniverseSymbol(this, jkMethod) + parameterList.node + ?.safeAs() + ?.also { + jkMethod.leftParen.assignNonCodeElements(it.findChildByRoleAsPsiElement(ChildRole.LPARENTH)) + jkMethod.rightParen.assignNonCodeElements(it.findChildByRoleAsPsiElement(ChildRole.RPARENTH)) + } + }.withAssignedNonCodeElements(this) } fun PsiParameter.toJK(): JKParameter { @@ -660,28 +768,40 @@ class JavaToJKTreeBuilder( else rawType.asTypeElement() return JKParameterImpl( type, - JKNameIdentifierImpl(name!!), + nameIdentifier.toJK(), isVarArgs ).also { symbolProvider.provideUniverseSymbol(this, it) it.psi = this + }.also { + it.assignNonCodeElements(this) } } - fun PsiCodeBlock.toJK(): JKBlock { - return JKBlockImpl(statements.map { it.toJK() }) - } + fun PsiCodeBlock.toJK(): JKBlock = + JKBlockImpl(statements.map { it.toJK() }) + .withAssignedNonCodeElements(this) + .also { + it.leftBrace.assignNonCodeElements(lBrace) + it.rightBrace.assignNonCodeElements(rBrace) + } + fun PsiLocalVariable.toJK(): JKLocalVariable = JKLocalVariableImpl( - JKTypeElementImpl(type.toJK(symbolProvider)), - JKNameIdentifierImpl(this.name ?: TODO()), + JKTypeElementImpl(type.toJK(symbolProvider)).withAssignedNonCodeElements(typeElement), + nameIdentifier.toJK(), with(expressionTreeMapper) { initializer.toJK() }, - if (hasModifierProperty(PsiModifier.FINAL)) Mutability.IMMUTABLE else Mutability.UNKNOWN, + JKMutabilityModifierElementImpl( + if (hasModifierProperty(PsiModifier.FINAL)) Mutability.IMMUTABLE + else Mutability.UNKNOWN + ), annotationList(null) ).also { i -> symbolProvider.provideUniverseSymbol(this, i) i.psi = this + }.also { + it.assignNonCodeElements(this) } fun PsiStatement?.toJK(): JKStatement { @@ -735,12 +855,12 @@ class JavaToJKTreeBuilder( when (statement) { is PsiSwitchLabelStatement -> cases += if (statement.isDefaultCase) - JKJavaDefaultSwitchCaseImpl(emptyList()) + JKJavaDefaultSwitchCaseImpl(emptyList()).withAssignedNonCodeElements(statement) else JKJavaLabelSwitchCaseImpl( with(expressionTreeMapper) { statement.caseValue.toJK() }, emptyList() - ) + ).withAssignedNonCodeElements(statement) else -> //TODO Handle case then there is no last case cases.lastOrNull()?.also { it.statements = it.statements + statement.toJK() } @@ -762,7 +882,7 @@ class JavaToJKTreeBuilder( } is PsiLabeledStatement -> { val (labels, statement) = collectLabels() - JKLabeledStatementImpl(statement.toJK(), labels.map { JKNameIdentifierImpl(it.text) }) + JKLabeledStatementImpl(statement.toJK(), labels.map { JKNameIdentifierImpl(it.text) }).asStatement() } is PsiEmptyStatement -> JKEmptyStatementImpl() is PsiThrowStatement -> @@ -770,24 +890,31 @@ class JavaToJKTreeBuilder( is PsiTryStatement -> JKJavaTryStatementImpl( resourceList?.toList()?.map { (it as PsiLocalVariable).toJK() }.orEmpty(), - tryBlock?.toJK() ?: JKBodyStub, - finallyBlock?.toJK() ?: JKBodyStub, + tryBlock?.toJK() ?: JKBodyStubImpl, + finallyBlock?.toJK() ?: JKBodyStubImpl, catchSections.map { it.toJK() } ) is PsiSynchronizedStatement -> JKJavaSynchronizedStatementImpl( with(expressionTreeMapper) { lockExpression?.toJK() } ?: JKStubExpressionImpl(), - body?.toJK() ?: JKBodyStub + body?.toJK() ?: JKBodyStubImpl ) else -> TODO("for ${this::class}") }.also { - if (this != null) (it as PsiOwner).psi = this + if (this != null) { + (it as PsiOwner).psi = this + it.assignNonCodeElements(this) + } } } fun PsiCatchSection.toJK(): JKJavaTryCatchSection = - JKJavaTryCatchSectionImpl(parameter?.toJK()!!, catchBlock?.toJK() ?: JKBodyStub) - .also { it.psi = this } + JKJavaTryCatchSectionImpl(parameter?.toJK()!!, catchBlock?.toJK() ?: JKBodyStubImpl) + .also { + it.psi = this + }.also { + it.assignNonCodeElements(this) + } } //TODO better way than generateSequence.last?? @@ -804,5 +931,79 @@ class JavaToJKTreeBuilder( else -> error("Cannot convert non-java file") } + private val tokenCache = mutableMapOf() + + private fun PsiElement.collectNonCodeElements(): Pair, List> { + fun PsiElement.toToken(): JKNonCodeElement? { + if (this in tokenCache) return tokenCache[this]!! + val token = when { + this is PsiDocComment -> + JKCommentElementImpl(IdeaDocCommentConverter.convertDocComment(this)) + this is PsiComment -> JKCommentElementImpl(text) + this is PsiWhiteSpace -> JKSpaceElementImpl(text) + text == ";" -> null + text == "" -> null + else -> error("Token should be either token or whitespace") + } ?: return null + tokenCache[this] = token + return token + } + + fun Sequence.toNonCodeElements(): List = + takeWhile { it is PsiComment || it is PsiWhiteSpace || it.text == ";" } + .mapNotNull { it.toToken() } + .toList() + + fun PsiElement.isNonCodeElement() = + this is PsiComment || this is PsiWhiteSpace || text == ";" || text == "" + + fun PsiElement.nextNonCodeElements() = + generateSequence(nextSibling) { it.nextSibling } + .takeWhile { it.isNonCodeElement() } + + fun PsiElement.prevNonCodeElements() = + generateSequence(prevSibling) { it.prevSibling } + .takeWhile { it.isNonCodeElement() } + + + fun PsiElement.nextNonCodeElementsWithParent(): Sequence { + val innerElements = nextNonCodeElements() + return (if (innerElements.lastOrNull()?.nextSibling == null && this is PsiKeyword) + innerElements + parent?.nextNonCodeElements().orEmpty() + else innerElements).mapNotNull { it.toToken() } + } + + fun PsiElement.prevNonCodeElementsWithParent(): Sequence { + val innerElements = prevNonCodeElements() + return (if (innerElements.firstOrNull()?.prevSibling == null && this is PsiKeyword) + innerElements + parent?.prevNonCodeElements().orEmpty() + else innerElements).mapNotNull { it.toToken() } + } + + + val leftInnerTokens = children.asSequence().toNonCodeElements() + val rightInnerTokens = + if (children.isEmpty()) emptyList() + else generateSequence(children.last()) { it.prevSibling } + .toNonCodeElements() + .reversed() + + + val leftTokens = generateSequence(prevSibling) { it.prevSibling } + .toNonCodeElements() + .reversed() + + return (leftInnerTokens + prevNonCodeElementsWithParent()) to (rightInnerTokens + nextNonCodeElementsWithParent()) + } + + private fun JKNonCodeElementsListOwner.assignNonCodeElements(psi: PsiElement?) { + if (psi == null) return + val (leftTokens, rightTokens) = psi.collectNonCodeElements() + this.leftNonCodeElements = leftTokens + this.rightNonCodeElements = rightTokens + } + + private inline fun T.withAssignedNonCodeElements(psi: PsiElement?): T = + also { it.assignNonCodeElements(psi) } } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt index 7e62621e4dd..15cae2d2e82 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt @@ -24,8 +24,9 @@ import org.jetbrains.kotlin.nj2k.NewCodeBuilder.ParenthesisKind.* import org.jetbrains.kotlin.nj2k.conversions.parentOfType import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.* -import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitorVoid +import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitorWithCommentsPrinting import org.jetbrains.kotlin.utils.Printer +import org.jetbrains.kotlin.utils.addToStdlib.safeAs class NewCodeBuilder { @@ -41,7 +42,57 @@ class NewCodeBuilder { JKClass.ClassKind.COMPANION -> "companion object" } - inner class Visitor : JKVisitorVoid { + inner class Visitor : JKVisitorWithCommentsPrinting { + private val printedTokens = mutableSetOf() + + private fun JKNonCodeElement.createText() = + if (this !in printedTokens) { + printedTokens += this + text + } else "" + + + private fun List.createText(): String { + val text = joinToString("") { token -> token.createText() } + val needNewLine = text.lastIndexOf('\n') < text.lastIndexOf("//") + return text +"\n".takeIf { needNewLine }.orEmpty() + } + + private fun JKNonCodeElementsListOwner.needPreserveSpacesAfterLastCommit() = + this is JKArgument + || this is JKParameter + || safeAs()?.parent is JKArgument + || safeAs()?.parent is JKBinaryExpression + + override fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner) { + val text = element.leftNonCodeElements + .let { + if (element.needPreserveSpacesAfterLastCommit()) it + else it.dropWhile { it is JKSpaceElement } + }.createText() + printer.printWithNoIndent(text) + } + + + override fun printRightNonCodeElements(element: JKNonCodeElementsListOwner) { + val text = element.rightNonCodeElements + .let { + if (element.needPreserveSpacesAfterLastCommit()) it + else it.dropLastWhile { it is JKSpaceElement } + }.createText() + printer.printWithNoIndent(text) + } + + private fun renderTokenElement(tokenElement: JKTokenElement) { + printLeftNonCodeElements(tokenElement) + printer.printWithNoIndent(tokenElement.text) + printRightNonCodeElements(tokenElement) + } + + override fun visitModifierElementRaw(modifierElement: JKModifierElement) { + printer.printWithNoIndent(modifierElement.modifier.text) + } + private fun renderExtraTypeParametersUpperBounds(typeParameterList: JKTypeParameterList) { val extraTypeBounds = typeParameterList.typeParameters .filter { it.upperBounds.size > 1 } @@ -61,33 +112,29 @@ class NewCodeBuilder { } } - override fun visitTreeElement(treeElement: JKTreeElement) { + override fun visitTreeElementRaw(treeElement: JKTreeElement) { printer.print("/* !!! Hit visitElement for element type: ${treeElement::class} !!! */") } - override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) { + override fun visitKtTryExpressionRaw(ktTryExpression: JKKtTryExpression) { printer.printWithNoIndent("try ") - if (ktTryExpression.tryBlock != JKBodyStub) { - printer.block { ktTryExpression.tryBlock.accept(this) } - } + ktTryExpression.tryBlock.accept(this) ktTryExpression.catchSections.forEach { it.accept(this) } - if (ktTryExpression.finallyBlock != JKBodyStub) { + if (ktTryExpression.finallyBlock != JKBodyStubImpl) { printer.printWithNoIndent("finally ") - printer.block { ktTryExpression.finallyBlock.accept(this) } + ktTryExpression.finallyBlock.accept(this) } } - override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) { + override fun visitKtTryCatchSectionRaw(ktTryCatchSection: JKKtTryCatchSection) { printer.printWithNoIndent("catch ") printer.par { ktTryCatchSection.parameter.accept(this) } - if (ktTryCatchSection.block != JKBodyStub) { - printer.block { ktTryCatchSection.block.accept(this) } - } + ktTryCatchSection.block.accept(this) } - override fun visitForInStatement(forInStatement: JKForInStatement) { + override fun visitForInStatementRaw(forInStatement: JKForInStatement) { printer.printWithNoIndent("for (") forInStatement.declaration.accept(this) printer.printWithNoIndent(" in ") @@ -100,12 +147,12 @@ class NewCodeBuilder { } } - override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) { + override fun visitKtThrowExpressionRaw(ktThrowExpression: JKKtThrowExpression) { printer.printWithNoIndent("throw ") ktThrowExpression.exception.accept(this) } - override fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement) { + override fun visitDoWhileStatementRaw(doWhileStatement: JKDoWhileStatement) { printer.printWithNoIndent("do ") doWhileStatement.body.accept(this) printer.printWithNoIndent(" while (") @@ -113,11 +160,11 @@ class NewCodeBuilder { printer.printWithNoIndent(")") } - override fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) { + override fun visitClassAccessExpressionRaw(classAccessExpression: JKClassAccessExpression) { printer.printWithNoIndent(classAccessExpression.identifier.displayName().escaped()) } - override fun visitFile(file: JKFile) { + override fun visitFileRaw(file: JKFile) { if (file.packageDeclaration.packageName.value.isNotEmpty()) { file.packageDeclaration.accept(this) } @@ -130,32 +177,32 @@ class NewCodeBuilder { .map { it.escaped() } .joinToString(".") { it } - override fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) { + override fun visitPackageDeclarationRaw(packageDeclaration: JKPackageDeclaration) { printer.printWithNoIndent("package ") val packageNameEscaped = packageDeclaration.packageName.value.escapedAsQualifiedName() printer.printlnWithNoIndent(packageNameEscaped) } - override fun visitImportStatement(importStatement: JKImportStatement) { + override fun visitImportStatementRaw(importStatement: JKImportStatement) { printer.printWithNoIndent("import ") val importNameEscaped = importStatement.name.value.escapedAsQualifiedName() printer.printlnWithNoIndent(importNameEscaped) } - override fun visitBreakStatement(breakStatement: JKBreakStatement) { + override fun visitBreakStatementRaw(breakStatement: JKBreakStatement) { printer.printWithNoIndent("break") } - override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) { + override fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) { printer.printWithNoIndent("break@") breakWithLabelStatement.label.accept(this) } private fun renderModifiersList(modifiersList: JKModifiersListOwner) { - renderList(modifiersList.modifiers(), " ") { - printer.printWithNoIndent(it.text) + renderList(modifiersList.modifierElements(), " ") { + it.accept(this) } } @@ -171,7 +218,7 @@ class NewCodeBuilder { } } - override fun visitClass(klass: JKClass) { + override fun visitClassRaw(klass: JKClass) { klass.annotationList.accept(this) if (klass.annotationList.annotations.isNotEmpty()) { printer.println() @@ -199,7 +246,7 @@ class NewCodeBuilder { klass.classBody.accept(this) } - override fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo) { + override fun visitInheritanceInfoRaw(inheritanceInfo: JKInheritanceInfo) { val parentClass = inheritanceInfo.parentOfType()!! val isInInterface = parentClass.classKind == JKClass.ClassKind.INTERFACE val extendTypes = inheritanceInfo.extends.map { it.type.updateNullability(Nullability.NotNull) } @@ -243,7 +290,7 @@ class NewCodeBuilder { } - override fun visitKtProperty(ktProperty: JKKtProperty) { + override fun visitKtPropertyRaw(ktProperty: JKKtProperty) { ktProperty.annotationList.accept(this) if (ktProperty.annotationList.annotations.isNotEmpty()) { printer.println() @@ -270,7 +317,7 @@ class NewCodeBuilder { } } - override fun visitEnumConstant(enumConstant: JKEnumConstant) { + override fun visitEnumConstantRaw(enumConstant: JKEnumConstant) { enumConstant.name.accept(this) if (enumConstant.arguments.arguments.isNotEmpty()) { printer.par { @@ -282,22 +329,20 @@ class NewCodeBuilder { } } - override fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration) { + override fun visitKtInitDeclarationRaw(ktInitDeclaration: JKKtInitDeclaration) { if (ktInitDeclaration.block.statements.isNotEmpty()) { printer.print("init ") - printer.block(multiline = true) { - ktInitDeclaration.block.accept(this) - } + ktInitDeclaration.block.accept(this) } } - override fun visitKtIsExpression(ktIsExpression: JKKtIsExpression) { + override fun visitKtIsExpressionRaw(ktIsExpression: JKKtIsExpression) { ktIsExpression.expression.accept(this) printer.printWithNoIndent(" is ") ktIsExpression.type.accept(this) } - override fun visitParameter(parameter: JKParameter) { + override fun visitParameterRaw(parameter: JKParameter) { renderModifiersList(parameter) printer.printWithNoIndent(" ") parameter.annotationList.accept(this) @@ -321,7 +366,7 @@ class NewCodeBuilder { } } - override fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) { + override fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) { printer.print("[") renderList(ktAnnotationArrayInitializerExpression.initializers) { it.accept(this) @@ -329,7 +374,7 @@ class NewCodeBuilder { printer.print("]") } - override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) { + override fun visitForLoopVariableRaw(forLoopVariable: JKForLoopVariable) { forLoopVariable.name.accept(this) if (forLoopVariable.type.present() && forLoopVariable.type.type !is JKContextType) { printer.printWithNoIndent(": ") @@ -337,7 +382,7 @@ class NewCodeBuilder { } } - override fun visitKtFunction(ktFunction: JKKtFunction) { + override fun visitKtFunctionRaw(ktFunction: JKKtFunction) { printer.printIndent() if (ktFunction.annotationList.annotations.isNotEmpty()) { ktFunction.annotationList.accept(this) @@ -347,21 +392,18 @@ class NewCodeBuilder { printer.printWithNoIndent(" fun ") ktFunction.typeParameterList.accept(this) ktFunction.name.accept(this) - printer.printWithNoIndent("(") + renderTokenElement(ktFunction.leftParen) renderList(ktFunction.parameters) { it.accept(this) } - printer.printWithNoIndent(")", ": ") + renderTokenElement(ktFunction.rightParen) + printer.printWithNoIndent(": ") ktFunction.returnType.accept(this) renderExtraTypeParametersUpperBounds(ktFunction.typeParameterList) - if (ktFunction.block !== JKBodyStub) { - printer.block(multiline = ktFunction.block.statements.isNotEmpty()) { - ktFunction.block.accept(this) - } - } + ktFunction.block.accept(this) } - override fun visitIfElseExpression(ifElseExpression: JKIfElseExpression) { + override fun visitIfElseExpressionRaw(ifElseExpression: JKIfElseExpression) { printer.printWithNoIndent("if (") ifElseExpression.condition.accept(this) printer.printWithNoIndent(")") @@ -370,34 +412,24 @@ class NewCodeBuilder { ifElseExpression.elseBranch.accept(this) } - override fun visitIfStatement(ifStatement: JKIfStatement) { + override fun visitIfStatementRaw(ifStatement: JKIfStatement) { printer.printWithNoIndent("if (") ifStatement.condition.accept(this) printer.printWithNoIndent(")") if (ifStatement.thenBranch.isEmpty()) { printer.printWithNoIndent(";") } else { - renderStatementOrBlock(ifStatement.thenBranch) + ifStatement.thenBranch.accept(this) } } - override fun visitIfElseStatement(ifElseStatement: JKIfElseStatement) { + override fun visitIfElseStatementRaw(ifElseStatement: JKIfElseStatement) { visitIfStatement(ifElseStatement) printer.printWithNoIndent(" else ") - renderStatementOrBlock(ifElseStatement.elseBranch) + ifElseStatement.elseBranch.accept(this) } - private fun renderStatementOrBlock(statement: JKStatement, multiline: Boolean = false) { - if (statement is JKBlockStatement) { - printer.block(multiline) { - statement.block.accept(this) - } - } else { - statement.accept(this) - } - } - - override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) { + override fun visitKtGetterOrSetterRaw(ktGetterOrSetter: JKKtGetterOrSetter) { printer.indented { renderModifiersList(ktGetterOrSetter) printer.printWithNoIndent(" ") @@ -416,11 +448,11 @@ class NewCodeBuilder { printer.printlnWithNoIndent() } - override fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) { + override fun visitKtEmptyGetterOrSetterRaw(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) { } - override fun visitBinaryExpression(binaryExpression: JKBinaryExpression) { + override fun visitBinaryExpressionRaw(binaryExpression: JKBinaryExpression) { binaryExpression.left.accept(this) printer.printWithNoIndent(" ") printer.printWithNoIndent(binaryExpression.operator.token.text) @@ -428,7 +460,7 @@ class NewCodeBuilder { binaryExpression.right.accept(this) } - override fun visitTypeParameterList(typeParameterList: JKTypeParameterList) { + override fun visitTypeParameterListRaw(typeParameterList: JKTypeParameterList) { if (typeParameterList.typeParameters.isNotEmpty()) { printer.par(ANGLE) { renderList(typeParameterList.typeParameters) { @@ -438,7 +470,7 @@ class NewCodeBuilder { } } - override fun visitTypeParameter(typeParameter: JKTypeParameter) { + override fun visitTypeParameterRaw(typeParameter: JKTypeParameter) { typeParameter.name.accept(this) if (typeParameter.upperBounds.size == 1) { printer.printWithNoIndent(" : ") @@ -446,42 +478,42 @@ class NewCodeBuilder { } } - override fun visitLiteralExpression(literalExpression: JKLiteralExpression) { + override fun visitLiteralExpressionRaw(literalExpression: JKLiteralExpression) { printer.printWithNoIndent(literalExpression.literal) } - override fun visitPrefixExpression(prefixExpression: JKPrefixExpression) { + override fun visitPrefixExpressionRaw(prefixExpression: JKPrefixExpression) { printer.printWithNoIndent(prefixExpression.operator.token.text) prefixExpression.expression.accept(this) } - override fun visitThisExpression(thisExpression: JKThisExpression) { + override fun visitThisExpressionRaw(thisExpression: JKThisExpression) { printer.printWithNoIndent("this") thisExpression.qualifierLabel.accept(this) } - override fun visitSuperExpression(superExpression: JKSuperExpression) { + override fun visitSuperExpressionRaw(superExpression: JKSuperExpression) { printer.printWithNoIndent("super") superExpression.qualifierLabel.accept(this) } - override fun visitContinueStatement(continueStatement: JKContinueStatement) { + override fun visitContinueStatementRaw(continueStatement: JKContinueStatement) { printer.printWithNoIndent("continue") continueStatement.label.accept(this) - printer.printlnWithNoIndent(" ") + printer.printWithNoIndent(" ") } - override fun visitLabelEmpty(labelEmpty: JKLabelEmpty) { + override fun visitLabelEmptyRaw(labelEmpty: JKLabelEmpty) { } - override fun visitLabelText(labelText: JKLabelText) { + override fun visitLabelTextRaw(labelText: JKLabelText) { printer.printWithNoIndent("@") labelText.label.accept(this) printer.printWithNoIndent(" ") } - override fun visitLabeledStatement(labeledStatement: JKLabeledStatement) { + override fun visitLabeledStatementRaw(labeledStatement: JKLabeledStatement) { for (label in labeledStatement.labels) { label.accept(this) printer.printWithNoIndent("@") @@ -489,16 +521,16 @@ class NewCodeBuilder { labeledStatement.statement.accept(this) } - override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) { + override fun visitNameIdentifierRaw(nameIdentifier: JKNameIdentifier) { printer.printWithNoIndent(nameIdentifier.value.escaped()) } - override fun visitPostfixExpression(postfixExpression: JKPostfixExpression) { + override fun visitPostfixExpressionRaw(postfixExpression: JKPostfixExpression) { postfixExpression.expression.accept(this) printer.printWithNoIndent(postfixExpression.operator.token.text) } - override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) { + override fun visitQualifiedExpressionRaw(qualifiedExpression: JKQualifiedExpression) { qualifiedExpression.receiver.accept(this) printer.printWithNoIndent( when (qualifiedExpression.operator) { @@ -510,26 +542,26 @@ class NewCodeBuilder { qualifiedExpression.selector.accept(this) } - override fun visitExpressionList(expressionList: JKExpressionList) { + override fun visitExpressionListRaw(expressionList: JKExpressionList) { renderList(expressionList.expressions) { it.accept(this) } } - override fun visitArgumentList(argumentList: JKArgumentList) { + override fun visitArgumentListRaw(argumentList: JKArgumentList) { renderList(argumentList.arguments) { it.accept(this) } } - override fun visitArgument(argument: JKArgument) { + override fun visitArgumentRaw(argument: JKArgument) { argument.value.accept(this) } - override fun visitNamedArgument(namedArgument: JKNamedArgument) { + override fun visitNamedArgumentRaw(namedArgument: JKNamedArgument) { namedArgument.name.accept(this) printer.printWithNoIndent(" = ") namedArgument.value.accept(this) } - override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) { + override fun visitMethodCallExpressionRaw(methodCallExpression: JKMethodCallExpression) { printer.printWithNoIndent(FqName(methodCallExpression.identifier.fqName).shortName().asString().escaped()) methodCallExpression.typeArgumentList.accept(this) printer.par { @@ -537,7 +569,7 @@ class NewCodeBuilder { } } - override fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList) { + override fun visitTypeArgumentListRaw(typeArgumentList: JKTypeArgumentList) { if (typeArgumentList.typeArguments.isNotEmpty()) { printer.par(ANGLE) { renderList(typeArgumentList.typeArguments) { @@ -547,36 +579,36 @@ class NewCodeBuilder { } } - override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) { + override fun visitParenthesizedExpressionRaw(parenthesizedExpression: JKParenthesizedExpression) { printer.par { parenthesizedExpression.expression.accept(this) } } - override fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement) { + override fun visitDeclarationStatementRaw(declarationStatement: JKDeclarationStatement) { renderList(declarationStatement.declaredStatements, { printer.println() }) { it.accept(this) } } - override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) { + override fun visitTypeCastExpressionRaw(typeCastExpression: JKTypeCastExpression) { typeCastExpression.expression.accept(this) printer.printWithNoIndent(" as ") typeCastExpression.type.accept(this) } - override fun visitWhileStatement(whileStatement: JKWhileStatement) { + override fun visitWhileStatementRaw(whileStatement: JKWhileStatement) { printer.print("while(") whileStatement.condition.accept(this) printer.printWithNoIndent(")") if (whileStatement.body.isEmpty()) { printer.printWithNoIndent(";") } else { - renderStatementOrBlock(whileStatement.body, multiline = true) + whileStatement.body.accept(this) } } - override fun visitLocalVariable(localVariable: JKLocalVariable) { + override fun visitLocalVariableRaw(localVariable: JKLocalVariable) { printer.printWithNoIndent(" ") localVariable.annotationList.accept(this) printer.printWithNoIndent(" ") @@ -593,13 +625,13 @@ class NewCodeBuilder { } } - override fun visitEmptyStatement(emptyStatement: JKEmptyStatement) { + override fun visitEmptyStatementRaw(emptyStatement: JKEmptyStatement) { } - override fun visitStubExpression(stubExpression: JKStubExpression) { + override fun visitStubExpressionRaw(stubExpression: JKStubExpression) { } - override fun visitKtConvertedFromForLoopSyntheticWhileStatement( + override fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw( ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement ) { ktConvertedFromForLoopSyntheticWhileStatement.variableDeclaration.accept(this) @@ -638,7 +670,7 @@ class NewCodeBuilder { } } - override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) { + override fun visitJavaNewExpressionRaw(javaNewExpression: JKJavaNewExpression) { if (javaNewExpression.isAnonymousClass()) { printer.printWithNoIndent("object : ") } @@ -655,62 +687,65 @@ class NewCodeBuilder { } - override fun visitClassBody(classBody: JKClassBody) { + override fun visitClassBodyRaw(classBody: JKClassBody) { val declarationsToPrint = classBody.declarations.filterNot { it is JKKtPrimaryConstructor } - printer.block(multiline = true) { - val enumConstants = declarationsToPrint.filterIsInstance() - val otherDeclarations = declarationsToPrint.filterNot { it is JKEnumConstant } - renderEnumConstants(enumConstants) - if ((classBody.parent as? JKClass)?.classKind == JKClass.ClassKind.ENUM - && otherDeclarations.isNotEmpty() - ) { - printer.printlnWithNoIndent(";") - } - if (enumConstants.isNotEmpty() && otherDeclarations.isNotEmpty()) { - printer.println() - } - renderNonEnumClassDeclarations(otherDeclarations) + renderTokenElement(classBody.leftBrace) + val enumConstants = declarationsToPrint.filterIsInstance() + val otherDeclarations = declarationsToPrint.filterNot { it is JKEnumConstant } + renderEnumConstants(enumConstants) + if ((classBody.parent as? JKClass)?.classKind == JKClass.ClassKind.ENUM + && otherDeclarations.isNotEmpty() + ) { + printer.printlnWithNoIndent(";") } + if (enumConstants.isNotEmpty() && otherDeclarations.isNotEmpty()) { + printer.println() + } + renderNonEnumClassDeclarations(otherDeclarations) + renderTokenElement(classBody.rightBrace) } - override fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody) {} + override fun visitEmptyClassBodyRaw(emptyClassBody: JKEmptyClassBody) {} - override fun visitTypeElement(typeElement: JKTypeElement) { + override fun visitTypeElementRaw(typeElement: JKTypeElement) { renderType(typeElement.type) } - override fun visitBlock(block: JKBlock) { + override fun visitBlockRaw(block: JKBlock) { + renderTokenElement(block.leftBrace) renderList(block.statements, { printer.println() }) { it.accept(this) } + renderTokenElement(block.rightBrace) + } + + override fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) { + renderList(blockStatementWithoutBrackets.statements, { printer.println() }) { + it.accept(this) + } } - override fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) { - blockStatementWithoutBrackets.block.accept(this) - } - - override fun visitExpressionStatement(expressionStatement: JKExpressionStatement) { - printer.printIndent() + override fun visitExpressionStatementRaw(expressionStatement: JKExpressionStatement) { expressionStatement.expression.accept(this) } - override fun visitReturnStatement(returnStatement: JKReturnStatement) { + override fun visitReturnStatementRaw(returnStatement: JKReturnStatement) { printer.print("return") returnStatement.label.accept(this) printer.print(" ") returnStatement.expression.accept(this) } - override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) { + override fun visitFieldAccessExpressionRaw(fieldAccessExpression: JKFieldAccessExpression) { printer.printWithNoIndent(fieldAccessExpression.identifier.name.escaped()) } - override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) { + override fun visitArrayAccessExpressionRaw(arrayAccessExpression: JKArrayAccessExpression) { arrayAccessExpression.expression.accept(this) printer.par(SQUARE) { arrayAccessExpression.indexExpression.accept(this) } } - override fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) { + override fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) { delegationConstructorCall.expression.accept(this) printer.par { delegationConstructorCall.arguments.accept(this) @@ -725,7 +760,7 @@ class NewCodeBuilder { } } - override fun visitKtConstructor(ktConstructor: JKKtConstructor) { + override fun visitKtConstructorRaw(ktConstructor: JKKtConstructor) { ktConstructor.annotationList.accept(this) if (ktConstructor.annotationList.annotations.isNotEmpty()) { printer.println() @@ -737,14 +772,10 @@ class NewCodeBuilder { builder.append(" : ") ktConstructor.delegationCall.accept(this) } - if (ktConstructor.block !== JKBodyStub) { - printer.block(multiline = true) { - ktConstructor.block.accept(this) - } - } + ktConstructor.block.accept(this) } - override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) { + override fun visitKtPrimaryConstructorRaw(ktPrimaryConstructor: JKKtPrimaryConstructor) { ktPrimaryConstructor.annotationList.accept(this) printer.printWithNoIndent(" ") renderModifiersList(ktPrimaryConstructor) @@ -756,6 +787,9 @@ class NewCodeBuilder { } } + override fun visitBodyStub(bodyStub: JKBodyStub) { + } + private inline fun Printer.indented(block: () -> Unit) { this.pushIndent() block() @@ -764,7 +798,6 @@ class NewCodeBuilder { private inline fun Printer.block(multiline: Boolean = false, crossinline body: () -> Unit) { par(CURVED) { - if (multiline) printer.printWithNoIndent("\n") indented(body) } } @@ -775,7 +808,7 @@ class NewCodeBuilder { this.printWithNoIndent(kind.close) } - override fun visitLambdaExpression(lambdaExpression: JKLambdaExpression) { + override fun visitLambdaExpressionRaw(lambdaExpression: JKLambdaExpression) { printer.par(CURVED) { if (lambdaExpression.statement.statements.size > 1) printer.println() @@ -787,7 +820,7 @@ class NewCodeBuilder { val statement = lambdaExpression.statement if (statement is JKBlockStatement) { - statement.block.accept(this) + renderList(statement.block.statements, { printer.println() }) { it.accept(this) } } else { statement.accept(this) } @@ -796,13 +829,11 @@ class NewCodeBuilder { } } - override fun visitBlockStatement(blockStatement: JKBlockStatement) { - printer.par(CURVED) { - blockStatement.block.accept(this) - } + override fun visitBlockStatementRaw(blockStatement: JKBlockStatement) { + blockStatement.block.accept(this) } - override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement) { + override fun visitKtAssignmentStatementRaw(ktAssignmentStatement: JKKtAssignmentStatement) { ktAssignmentStatement.field.accept(this) printer.printWithNoIndent(" ") printer.printWithNoIndent(ktAssignmentStatement.operator.token.text) @@ -810,7 +841,7 @@ class NewCodeBuilder { ktAssignmentStatement.expression.accept(this) } - override fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) { + override fun visitKtWhenStatementRaw(ktWhenStatement: JKKtWhenStatement) { printer.printWithNoIndent("when(") ktWhenStatement.expression.accept(this) printer.printWithNoIndent(")") @@ -821,13 +852,13 @@ class NewCodeBuilder { } } - override fun visitAnnotationList(annotationList: JKAnnotationList) { + override fun visitAnnotationListRaw(annotationList: JKAnnotationList) { renderList(annotationList.annotations, " ") { it.accept(this) } } - override fun visitAnnotation(annotation: JKAnnotation) { + override fun visitAnnotationRaw(annotation: JKAnnotation) { printer.printWithNoIndent("@") printer.printWithNoIndent(annotation.classSymbol.displayName().escapedAsQualifiedName()) if (annotation.arguments.isNotEmpty()) { @@ -837,17 +868,17 @@ class NewCodeBuilder { } } - override fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) { + override fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) { annotationNameParameter.name.accept(this) printer.print(" = ") annotationNameParameter.value.accept(this) } - override fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter) { + override fun visitAnnotationParameterRaw(annotationParameter: JKAnnotationParameter) { annotationParameter.value.accept(this) } - override fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) { + override fun visitClassLiteralExpressionRaw(classLiteralExpression: JKClassLiteralExpression) { if (classLiteralExpression.literalType == JKClassLiteralExpression.LiteralType.JAVA_VOID_TYPE) { printer.printWithNoIndent("Void.TYPE") } else { @@ -861,7 +892,7 @@ class NewCodeBuilder { } } - override fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) { + override fun visitKtWhenCaseRaw(ktWhenCase: JKKtWhenCase) { renderList(ktWhenCase.labels, ", ") { it.accept(this) } @@ -869,11 +900,11 @@ class NewCodeBuilder { ktWhenCase.statement.accept(this) } - override fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) { + override fun visitKtElseWhenLabelRaw(ktElseWhenLabel: JKKtElseWhenLabel) { printer.printWithNoIndent("else") } - override fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) { + override fun visitKtValueWhenLabelRaw(ktValueWhenLabel: JKKtValueWhenLabel) { ktValueWhenLabel.expression.accept(this) } } @@ -889,7 +920,6 @@ class NewCodeBuilder { } } - private inline fun List.headTail(): Pair?> { val head = this.firstOrNull() val tail = if (size <= 1) null else subList(1, size) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/TreeCopy.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/TreeCopy.kt index c0e9e558736..a71c6d523e9 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/TreeCopy.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/TreeCopy.kt @@ -7,11 +7,12 @@ package org.jetbrains.kotlin.nj2k import org.jetbrains.kotlin.nj2k.tree.JKElement import org.jetbrains.kotlin.nj2k.tree.impl.JKElementBase +import org.jetbrains.kotlin.nj2k.tree.withNonCodeElementsFrom fun T.copyTree(): T = when (this) { is JKElementBase -> - this.copy() as T + this.copy().withNonCodeElementsFrom(this) as T else -> TODO("Not supported+$this.toString()") } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddParenthesisForLineBreaksInBinaryExpression.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddParenthesisForLineBreaksInBinaryExpression.kt new file mode 100644 index 00000000000..07c5bf7fa96 --- /dev/null +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AddParenthesisForLineBreaksInBinaryExpression.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2019 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.nj2k.conversions + +import org.jetbrains.kotlin.nj2k.tree.* +import org.jetbrains.kotlin.nj2k.tree.impl.JKBinaryExpressionImpl +import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl + + +class AddParenthesisForLineBreaksInBinaryExpression : RecursiveApplicableConversionBase() { + override fun applyToElement(element: JKTreeElement): JKTreeElement { + if (element !is JKBinaryExpression) return recurse(element) + if (element.parent is JKBinaryExpression) return recurse(element) + if (element.left.rightNonCodeElements.any { + it is JKSpaceElement && '\n' in it.text + }) { + return JKParenthesizedExpressionImpl( + JKBinaryExpressionImpl( + element::left.detached(), + element::right.detached(), + element.operator + ).withNonCodeElementsFrom(element) + ) + } + return recurse(element) + } + +} \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationClassConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationClassConversion.kt index 7bbf0e7431b..f1097344438 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationClassConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AnnotationClassConversion.kt @@ -5,8 +5,8 @@ package org.jetbrains.kotlin.nj2k.conversions -import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.j2k.ast.Nullability +import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.nj2k.toExpression import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.* @@ -24,8 +24,8 @@ class AnnotationClassConversion(private val context: ConversionContext) : Recurs JKStubExpressionImpl(), JKAnnotationListImpl(), emptyList(), - Visibility.PUBLIC, - Modality.FINAL + JKVisibilityModifierElementImpl(Visibility.PUBLIC), + JKModalityModifierElementImpl(Modality.FINAL) ) element.modality = Modality.FINAL element.classBody.declarations += constructor diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementSplitAlsoConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementSplitAlsoConversion.kt index 6991c9637c0..0c632150dfa 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementSplitAlsoConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementSplitAlsoConversion.kt @@ -28,7 +28,7 @@ class AssignmentStatementSplitAlsoConversion : RecursiveApplicableConversionBase if (statements.size == 1) statements.map { it.detached(this) } else statements } - ) + ).withNonCodeElementsFrom(this) } else null } @@ -58,8 +58,8 @@ class AssignmentStatementSplitAlsoConversion : RecursiveApplicableConversionBase variable::type.detached(), variable::name.detached(), innerAssignmentStatement.field.copyTreeAndDetach(), - variable.mutability - ) + variable::mutabilityElement.detached() + ).withNonCodeElementsFrom(variable) ) ) } @@ -72,7 +72,7 @@ class AssignmentStatementSplitAlsoConversion : RecursiveApplicableConversionBase qualifiedExpression::receiver.detached(), innerAssignmentStatement.operator ), - secondAssignment + secondAssignment.withNonCodeElementsFrom(this) ) } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt index 664349dc9ff..04de7380cf5 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/AssignmentStatementValCreationConversion.kt @@ -27,14 +27,14 @@ class AssignmentStatementValCreationConversion(val context: ConversionContext) : JKTypeElementImpl(JKJavaVoidType/*TODO*/), JKNameIdentifierImpl("arr"), ex1, - Mutability.IMMUTABLE + JKMutabilityModifierElementImpl(Mutability.IMMUTABLE) ).also { assignableExpr.expression = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it)) }, JKLocalVariableImpl( JKTypeElementImpl(JKJavaVoidType/*TODO*/), JKNameIdentifierImpl("i"), ex2, - Mutability.UNKNOWN + JKMutabilityModifierElementImpl(Mutability.UNKNOWN) ).also { assignableExpr.indexExpression = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it)) @@ -53,7 +53,7 @@ class AssignmentStatementValCreationConversion(val context: ConversionContext) : JKTypeElementImpl(JKJavaVoidType/*TODO*/), JKNameIdentifierImpl("arg"), ex, - Mutability.UNKNOWN + JKMutabilityModifierElementImpl(Mutability.UNKNOWN) ).also { assignableExpr.receiver = JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(it)) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt index 72024a3619d..6f6469abcd7 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt @@ -6,10 +6,7 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.ConversionContext -import org.jetbrains.kotlin.nj2k.tree.JKBlock -import org.jetbrains.kotlin.nj2k.tree.JKBlockStatement -import org.jetbrains.kotlin.nj2k.tree.JKDeclaration -import org.jetbrains.kotlin.nj2k.tree.JKTreeElement +import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.* class BlockToRunConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { @@ -28,7 +25,7 @@ class BlockToRunConversion(private val context: ConversionContext) : RecursiveAp emptyList() ) val call = JKKtCallExpressionImpl(context.symbolProvider.provideByFqName("kotlin.run", true), JKArgumentListImpl(lambda)) - return recurse(JKExpressionStatementImpl(call)) + return recurse(JKExpressionStatementImpl(call).withNonCodeElementsFrom(element)) } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt index 672204f5816..ba55e8be601 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt @@ -43,7 +43,7 @@ class BoxedTypeOperationsConversion(private val context: ConversionContext) : Re "kotlin.${primitiveTypeName.capitalize()}.to${operationType.capitalize()}" ), JKArgumentListImpl() - ) + ).withNonCodeElementsFrom(methodCallExpression) } companion object { diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt index 6371a707438..85b67da9c1b 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt @@ -66,13 +66,13 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi context.symbolProvider.provideByFqNameMulti(fqName), argumentsProvider(from::arguments.detached()), from::typeArgumentList.detached() - ) + ).withNonCodeElementsFrom(from) is JKFieldAccessExpression -> JKKtCallExpressionImpl( context.symbolProvider.provideByFqNameMulti(fqName), JKArgumentListImpl(), JKTypeArgumentListImpl() - ) + ).withNonCodeElementsFrom(from) else -> error("Bad conversion") } } @@ -85,11 +85,11 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi is JKMethodCallExpression -> JKFieldAccessExpressionImpl( context.symbolProvider.provideByFqNameMulti(fqName) - ) + ).withNonCodeElementsFrom(from) is JKFieldAccessExpression -> JKFieldAccessExpressionImpl( context.symbolProvider.provideByFqNameMulti(fqName) - ) + ).withNonCodeElementsFrom(from) else -> error("Bad conversion") } } @@ -109,7 +109,7 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi JKArgumentListImpl(arguments.drop(1)), from::typeArgumentList.detached() ) - ) + ).withNonCodeElementsFrom(from) } else -> error("Bad conversion") } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ClassToObjectPromotionConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ClassToObjectPromotionConversion.kt index 350f18bca28..68f1b41aa2a 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ClassToObjectPromotionConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ClassToObjectPromotionConversion.kt @@ -10,6 +10,7 @@ import org.jetbrains.kotlin.nj2k.getCompanion import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.JKAnnotationListImpl import org.jetbrains.kotlin.nj2k.tree.impl.JKClassImpl +import org.jetbrains.kotlin.nj2k.tree.impl.JKModalityModifierElementImpl import org.jetbrains.kotlin.nj2k.tree.impl.psi class ClassToObjectPromotionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { @@ -49,10 +50,10 @@ class ClassToObjectPromotionConversion(private val context: ConversionContext) : }.map { it.detached(element.classBody) } }, JKAnnotationListImpl(), - element.extraModifiers, - element.visibility, - Modality.FINAL - ) + element.extraModifierElements, + element.visibilityElement, + JKModalityModifierElementImpl(Modality.FINAL) + ).withNonCodeElementsFrom(element) ) } } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ConstructorConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ConstructorConversion.kt index ab80b59f5da..ce56b12bdf4 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ConstructorConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ConstructorConversion.kt @@ -7,7 +7,8 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.nj2k.tree.* -import org.jetbrains.kotlin.nj2k.tree.impl.* +import org.jetbrains.kotlin.nj2k.tree.impl.JKKtConstructorImpl +import org.jetbrains.kotlin.nj2k.tree.impl.JKStubExpressionImpl class ConstructorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { override fun applyToElement(element: JKTreeElement): JKTreeElement { @@ -24,12 +25,12 @@ class ConstructorConversion(private val context: ConversionContext) : RecursiveA element.block, delegationCall, element.annotationList, - element.extraModifiers, - element.visibility, - element.modality + element.extraModifierElements, + element.visibilityElement, + element.modalityElement ).also { context.symbolProvider.transferSymbol(it, element) - } + }.withNonCodeElementsFrom(element) } private fun lookupDelegationCall(block: JKBlock): JKDelegationConstructorCall? { diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt index 07641919ff0..03ce66a77f8 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt @@ -16,10 +16,12 @@ import org.jetbrains.kotlin.utils.addToStdlib.safeAs class DefaultArgumentsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { private fun JKMethod.canNotBeMerged(): Boolean = - modality == Modality.ABSTRACT || - modality == Modality.OVERRIDE || - context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi()!!) || - annotationList.annotations.isNotEmpty() + modality == Modality.ABSTRACT + || modality == Modality.OVERRIDE + || hasExtraModifier(ExtraModifier.NATIVE) + || hasExtraModifier(ExtraModifier.SYNCHRONIZED) + || context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi()!!) + || annotationList.annotations.isNotEmpty() override fun applyToElement(element: JKTreeElement): JKTreeElement { @@ -39,13 +41,13 @@ class DefaultArgumentsConversion(private val context: ConversionContext) : Recur if (calledMethod.parent != method.parent || callee.name != method.name.value || calledMethod.returnType.type != method.returnType.type - || call.arguments.expressions.size <= method.parameters.size + || call.arguments.arguments.size <= method.parameters.size ) { continue } - // TODO: Filter by annotations, visibility, modality, modifiers like synchronized + // TODO: Filter by annotations, visibility, modality, extraModifiers like synchronized if (calledMethod.visibility != method.visibility) continue@checkMethod if (calledMethod.canNotBeMerged()) continue @@ -54,8 +56,8 @@ class DefaultArgumentsConversion(private val context: ConversionContext) : Recur val targetParameter = calledMethod.parameters[i] val argument = call.arguments.arguments[i].value if (parameter.name.value != targetParameter.name.value) continue@checkMethod -// if (parameter.type.type != targetParameter.type.type) continue@checkMethod -// if (argument !is JKFieldAccessExpression || argument.identifier.target != parameter) continue@checkMethod + if (parameter.type.type != targetParameter.type.type) continue@checkMethod + if (argument !is JKFieldAccessExpression || argument.identifier.target != parameter) continue@checkMethod } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/FieldToPropertyConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/FieldToPropertyConversion.kt index a5de26464c1..108911b4944 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/FieldToPropertyConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/FieldToPropertyConversion.kt @@ -23,12 +23,13 @@ class FieldToPropertyConversion : RecursiveApplicableConversionBase() { JKKtEmptyGetterOrSetterImpl(), JKKtEmptyGetterOrSetterImpl(), element.annotationList, - element.extraModifiers, - element.visibility, - Modality.FINAL, - mutability + element.extraModifierElements, + element.visibilityElement, + JKModalityModifierElementImpl(Modality.FINAL), + JKMutabilityModifierElementImpl(mutability).withNonCodeElementsFrom(element.modalityElement) ).also { it.psi = element.psi + it.takeNonCodeElementsFrom(element) } ) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt index ecc02d70293..d8d1f4cee9a 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt @@ -23,8 +23,8 @@ class ForConversion(private val context: ConversionContext) : RecursiveApplicabl override fun applyToElement(element: JKTreeElement): JKTreeElement { if (element !is JKJavaForLoopStatement) return recurse(element) - convertToForeach(element)?.also { return recurse(it) } - convertToWhile(element)?.also { return recurse(it) } + convertToForeach(element)?.also { return recurse(it.withNonCodeElementsFrom(element)) } + convertToWhile(element)?.also { return recurse(it.withNonCodeElementsFrom(element)) } return recurse(element) } @@ -69,7 +69,7 @@ class ForConversion(private val context: ConversionContext) : RecursiveApplicabl if (elementPsi.findContinuedStatement()?.toContinuedLoop() != loopStatement.psi()) return recurse(element) val statements = loopStatement.updaters.map { it.copyTreeAndDetach() } + element.copyTreeAndDetach() return if (element.parent is JKBlock) - JKBlockStatementWithoutBracketsImpl(JKBlockImpl(statements)) + JKBlockStatementWithoutBracketsImpl(statements) else JKBlockStatementImpl(JKBlockImpl(statements)) } } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InnerClassConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InnerClassConversion.kt index 14b02b89a79..7d47fde2c79 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InnerClassConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InnerClassConversion.kt @@ -8,6 +8,7 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.tree.ExtraModifier import org.jetbrains.kotlin.nj2k.tree.JKClass import org.jetbrains.kotlin.nj2k.tree.JKTreeElement +import org.jetbrains.kotlin.nj2k.tree.impl.JKExtraModifierElementImpl import org.jetbrains.kotlin.nj2k.tree.isLocalClass class InnerClassConversion : RecursiveApplicableConversionBase() { @@ -25,14 +26,14 @@ class InnerClassConversion : RecursiveApplicableConversionBase() { if (element.classKind == JKClass.ClassKind.COMPANION) return recurseArmed(element, outer) if (element.isLocalClass()) return recurseArmed(element, outer) - val static = element.extraModifiers.find { it == ExtraModifier.STATIC } + val static = element.extraModifierElements.find { it.extraModifier == ExtraModifier.STATIC } if (static != null) { - element.extraModifiers -= static + element.extraModifierElements -= static } else if (element.classKind != JKClass.ClassKind.INTERFACE && outer.classKind != JKClass.ClassKind.INTERFACE && element.classKind != JKClass.ClassKind.ENUM ) { - element.extraModifiers += ExtraModifier.INNER + element.extraModifierElements += JKExtraModifierElementImpl(ExtraModifier.INNER) } return recurseArmed(element, element) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt index c66da72fe7f..abff7a1fb7b 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt @@ -22,9 +22,8 @@ class InsertDefaultPrimaryConstructorConversion(private val context: ConversionC JKStubExpressionImpl(), JKAnnotationListImpl(), emptyList(), - Visibility.PUBLIC, - Modality.FINAL - + JKVisibilityModifierElementImpl(Visibility.PUBLIC), + JKModalityModifierElementImpl(Modality.FINAL) ) element.classBody.declarations += constructor diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalClassConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalDeclarationConversion.kt similarity index 68% rename from nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalClassConversion.kt rename to nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalDeclarationConversion.kt index bf37ebb8b44..10cd048806d 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalClassConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InternalDeclarationConversion.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.tree.* -class InternalClassConversion : RecursiveApplicableConversionBase() { +class InternalDeclarationConversion : RecursiveApplicableConversionBase() { override fun applyToElement(element: JKTreeElement): JKTreeElement { if (element !is JKVisibilityOwner || element !is JKModalityOwner) return recurse(element) val containingClass = element.parentOfType() ?: return recurse(element) @@ -19,6 +19,16 @@ class InternalClassConversion : RecursiveApplicableConversionBase() { ) { element.visibility = Visibility.PUBLIC } + + if (containingClass.classKind == JKClass.ClassKind.INTERFACE) { + element.visibility = Visibility.PUBLIC + } + + if (containingClass.classKind == JKClass.ClassKind.ENUM + && element is JKKtPrimaryConstructor + ) { + element.visibility = Visibility.PRIVATE + } return recurse(element) } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaMethodToKotlinFunctionConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaMethodToKotlinFunctionConversion.kt index 0e8eb70f16d..b966f5e3799 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaMethodToKotlinFunctionConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaMethodToKotlinFunctionConversion.kt @@ -19,12 +19,9 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.j2k.ast.Nullability import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.nj2k.throwAnnotation -import org.jetbrains.kotlin.nj2k.tree.JKClassBody -import org.jetbrains.kotlin.nj2k.tree.JKJavaMethod -import org.jetbrains.kotlin.nj2k.tree.JKTreeElement +import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.JKKtFunctionImpl import org.jetbrains.kotlin.nj2k.tree.impl.psi -import org.jetbrains.kotlin.nj2k.tree.updateNullabilityRecursively class JavaMethodToKotlinFunctionConversion(private val context: ConversionContext) : TransformerBasedConversion() { override fun visitTreeElement(element: JKTreeElement) { @@ -53,13 +50,15 @@ class JavaMethodToKotlinFunctionConversion(private val context: ConversionContex ) } }, - declaration.extraModifiers, - declaration.visibility, - declaration.modality + declaration.extraModifierElements, + declaration.visibilityElement, + declaration.modalityElement ).also { it.psi = declaration.psi context.symbolProvider.transferSymbol(it, declaration) - } + it.leftParen.takeNonCodeElementsFrom(declaration.leftParen) + it.rightParen.takeNonCodeElementsFrom(declaration.rightParen) + }.withNonCodeElementsFrom(declaration) } else { declaration } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaModifiersConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaModifiersConversion.kt index 7109b7eb381..8795630e17a 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaModifiersConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/JavaModifiersConversion.kt @@ -29,25 +29,32 @@ class JavaModifiersConversion(private val context: ConversionContext) : Recursiv } } if (element is JKExtraModifiersOwner && element is JKAnnotationListOwner) { - if (ExtraModifier.VOLATILE in element.extraModifiers) { - element.extraModifiers -= ExtraModifier.VOLATILE - element.annotationList.annotations += jvmAnnotation("Volatile", context.symbolProvider) + element.elementByModifier(ExtraModifier.VOLATILE)?.also { modifierElement -> + element.extraModifierElements -= modifierElement + element.annotationList.annotations += + jvmAnnotation("Volatile", context.symbolProvider).withNonCodeElementsFrom(modifierElement) } - if (ExtraModifier.TRANSIENT in element.extraModifiers) { - element.extraModifiers -= ExtraModifier.TRANSIENT - element.annotationList.annotations += jvmAnnotation("Transient", context.symbolProvider) + + element.elementByModifier(ExtraModifier.TRANSIENT)?.also { modifierElement -> + element.extraModifierElements -= modifierElement + element.annotationList.annotations += + jvmAnnotation("Transient", context.symbolProvider).withNonCodeElementsFrom(modifierElement) } - if (ExtraModifier.STRICTFP in element.extraModifiers) { - element.extraModifiers -= ExtraModifier.STRICTFP - element.annotationList.annotations += jvmAnnotation("Strictfp", context.symbolProvider) + + element.elementByModifier(ExtraModifier.STRICTFP)?.also { modifierElement -> + element.extraModifierElements -= modifierElement + element.annotationList.annotations += + jvmAnnotation("Strictfp", context.symbolProvider).withNonCodeElementsFrom(modifierElement) } - if (ExtraModifier.SYNCHRONIZED in element.extraModifiers) { - element.extraModifiers -= ExtraModifier.SYNCHRONIZED - element.annotationList.annotations += jvmAnnotation("Synchronized", context.symbolProvider) + + element.elementByModifier(ExtraModifier.SYNCHRONIZED)?.also { modifierElement -> + element.extraModifierElements -= modifierElement + element.annotationList.annotations += + jvmAnnotation("Synchronized", context.symbolProvider).withNonCodeElementsFrom(modifierElement) } - if (ExtraModifier.NATIVE in element.extraModifiers) { - element.extraModifiers -= ExtraModifier.NATIVE - element.extraModifiers += ExtraModifier.EXTERNAL + + element.elementByModifier(ExtraModifier.NATIVE)?.also { modifierElement -> + modifierElement.extraModifier = ExtraModifier.EXTERNAL } } return recurse(element) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ModalityConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ModalityConversion.kt index b0800271eb0..084bdb6e733 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ModalityConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ModalityConversion.kt @@ -23,8 +23,7 @@ class ModalityConversion(private val context: ConversionContext) : RecursiveAppl private fun processClass(klass: JKClass) { klass.modality = when { klass.classKind == JKClass.ClassKind.ENUM -> Modality.FINAL - klass.modality == Modality.OPEN - && context.converter.settings.openByDefault -> Modality.OPEN + klass.classKind == JKClass.ClassKind.INTERFACE -> Modality.OPEN klass.modality == Modality.OPEN && context.converter.settings.openByDefault -> Modality.OPEN klass.modality == Modality.OPEN @@ -37,16 +36,17 @@ class ModalityConversion(private val context: ConversionContext) : RecursiveAppl private fun processMethod(method: JKJavaMethod) { val psi = method.psi()!! - val containingClass = method.parentOfType() + val containingClass = method.parentOfType()!! method.modality = when { method.modality != Modality.ABSTRACT - && (method.psi!! as PsiMethod).findSuperMethods().isNotEmpty() -> Modality.OVERRIDE + && psi.findSuperMethods().isNotEmpty() -> Modality.OVERRIDE method.modality == Modality.OPEN && context.converter.settings.openByDefault - && containingClass?.modality == Modality.OPEN + && containingClass.modality == Modality.OPEN && method.visibility != Visibility.PRIVATE -> Modality.OPEN method.modality == Modality.OPEN + && containingClass.classKind != JKClass.ClassKind.INTERFACE && !context.converter.converterServices.oldServices.referenceSearcher.hasOverrides(psi) -> Modality.FINAL else -> method.modality } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/NonCodeElementsConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/NonCodeElementsConversion.kt new file mode 100644 index 00000000000..5e4a8a4d3bf --- /dev/null +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/NonCodeElementsConversion.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2019 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.nj2k.conversions + +import org.jetbrains.kotlin.nj2k.tree.JKClass +import org.jetbrains.kotlin.nj2k.tree.JKTreeElement + +class NonCodeElementsConversion : RecursiveApplicableConversionBase() { + override fun applyToElement(element: JKTreeElement): JKTreeElement { + when (element) { + is JKClass -> { + element.name.rightNonCodeElements += element.inheritance.leftNonCodeElements + element.inheritance.leftNonCodeElements = emptyList() + } + } + return recurse(element) + } +} \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt index 03c0d14e461..18c3e77a941 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt @@ -25,7 +25,7 @@ class OperatorExpressionConversion(private val context: ConversionContext) : Rec val operatorToken = operator.token.toKtToken() val left = applyToElement(element::left.detached()) as JKExpression val right = applyToElement(element::right.detached()) as JKExpression - recurse(convertBinaryExpression(left, right, operatorToken)) + recurse(convertBinaryExpression(left, right, operatorToken).withNonCodeElementsFrom(element)) } is JKPrefixExpression -> { val operand = applyToElement(element::expression.detached()) as JKExpression @@ -37,7 +37,7 @@ class OperatorExpressionConversion(private val context: ConversionContext) : Rec recurse(kotlinPostfixExpression(operand, operatorToken, context.symbolProvider)) } else -> TODO(element.javaClass.toString()) - } ?: recurse(element) + }.withNonCodeElementsFrom(element) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ParameterModificationInMethodCallsConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ParameterModificationInMethodCallsConversion.kt index dae7c8b721f..a52aeccd6f6 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ParameterModificationInMethodCallsConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ParameterModificationInMethodCallsConversion.kt @@ -6,10 +6,10 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.ConversionContext -import org.jetbrains.kotlin.nj2k.asAssignmentFromTarget -import org.jetbrains.kotlin.nj2k.findUsages import org.jetbrains.kotlin.nj2k.hasWritableUsages -import org.jetbrains.kotlin.nj2k.tree.* +import org.jetbrains.kotlin.nj2k.tree.JKMethod +import org.jetbrains.kotlin.nj2k.tree.JKTreeElement +import org.jetbrains.kotlin.nj2k.tree.Mutability import org.jetbrains.kotlin.nj2k.tree.impl.* @@ -23,11 +23,13 @@ class ParameterModificationInMethodCallsConversion(private val context: Conversi JKTypeElementImpl(parameter.type.type), JKNameIdentifierImpl(parameter.name.value), JKFieldAccessExpressionImpl(context.symbolProvider.provideUniverseSymbol(parameter)), - Mutability.MUTABLE + JKMutabilityModifierElementImpl(Mutability.MUTABLE) ) } else null } - element.block.statements = listOf(JKDeclarationStatementImpl(newVariables)) + element.block.statements + if (newVariables.isNotEmpty()) { + element.block.statements = listOf(JKDeclarationStatementImpl(newVariables)) + element.block.statements + } return recurse(element) } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrimaryConstructorDetectConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrimaryConstructorDetectConversion.kt index a36a933a542..b69402dbaea 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrimaryConstructorDetectConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrimaryConstructorDetectConversion.kt @@ -32,8 +32,9 @@ class PrimaryConstructorDetectConversion(private val context: ConversionContext) primaryConstructorCandidate.invalidate() if (primaryConstructorCandidate.block.statements.isNotEmpty()) { val initDeclaration = JKKtInitDeclarationImpl(primaryConstructorCandidate.block) + .withNonCodeElementsFrom(primaryConstructorCandidate) element.classBody.declarations = - element.classBody.declarations.replace(primaryConstructorCandidate, initDeclaration) + element.classBody.declarations.replace(primaryConstructorCandidate, initDeclaration) } else { element.classBody.declarations -= primaryConstructorCandidate } @@ -44,10 +45,10 @@ class PrimaryConstructorDetectConversion(private val context: ConversionContext) primaryConstructorCandidate.parameters, primaryConstructorCandidate.delegationCall, primaryConstructorCandidate.annotationList, - primaryConstructorCandidate.extraModifiers, - primaryConstructorCandidate.visibility, - primaryConstructorCandidate.modality - ) + primaryConstructorCandidate.extraModifierElements, + primaryConstructorCandidate.visibilityElement, + primaryConstructorCandidate.modalityElement + ).withNonCodeElementsFrom(primaryConstructorCandidate) context.symbolProvider.transferSymbol(primaryConstructor, primaryConstructorCandidate) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrintlnConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrintlnConversion.kt index e0c5cbdf871..58b5412b722 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrintlnConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/PrintlnConversion.kt @@ -5,12 +5,12 @@ package org.jetbrains.kotlin.nj2k.conversions +import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.JKKtCallExpressionImpl import org.jetbrains.kotlin.nj2k.tree.impl.JKMethodSymbol import org.jetbrains.kotlin.nj2k.tree.impl.psi -import org.jetbrains.kotlin.name.ClassId // TODO: Full special methods conversion class PrintlnConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { @@ -41,7 +41,9 @@ class PrintlnConversion(private val context: ConversionContext) : RecursiveAppli return JKKtCallExpressionImpl( context.symbolProvider.provideDirectSymbol(targetElements.first()) as JKMethodSymbol, selector.arguments - ) + ).withNonCodeElementsFrom(element).also { + it.leftNonCodeElements += element.receiver.commentsFromInside() + } } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticInitDeclarationConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticInitDeclarationConversion.kt index 41f658dd3a1..0dc1e9bf0ed 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticInitDeclarationConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticInitDeclarationConversion.kt @@ -8,10 +8,7 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.createCompanion import org.jetbrains.kotlin.nj2k.getCompanion import org.jetbrains.kotlin.nj2k.replace -import org.jetbrains.kotlin.nj2k.tree.JKClass -import org.jetbrains.kotlin.nj2k.tree.JKJavaStaticInitDeclaration -import org.jetbrains.kotlin.nj2k.tree.JKTreeElement -import org.jetbrains.kotlin.nj2k.tree.detached +import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.JKKtInitDeclarationImpl class StaticInitDeclarationConversion : RecursiveApplicableConversionBase() { @@ -36,5 +33,5 @@ class StaticInitDeclarationConversion : RecursiveApplicableConversionBase() { } private fun JKJavaStaticInitDeclaration.toKtInitDeclaration() = - JKKtInitDeclarationImpl(::block.detached()) + JKKtInitDeclarationImpl(::block.detached()).withNonCodeElementsFrom(this) } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt index 0881e984665..c902641e10f 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticMemberAccessConversion.kt @@ -53,7 +53,7 @@ class StaticMemberAccessConversion(private val context: ConversionContext) : Rec ?.safeAs() ?.isCompanion() == true is JKTreeElement -> - target.safeAs()?.modifiers()?.contains(ExtraModifier.STATIC) == true + target.safeAs()?.hasExtraModifier(ExtraModifier.STATIC) == true || target.parentOfType()?.classKind == JKClass.ClassKind.OBJECT else -> false } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticsToCompanionExtractConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticsToCompanionExtractConversion.kt index d3d9428ee97..a8ea469d2ba 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticsToCompanionExtractConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/StaticsToCompanionExtractConversion.kt @@ -7,15 +7,13 @@ package org.jetbrains.kotlin.nj2k.conversions import org.jetbrains.kotlin.nj2k.getOrCreateCompainonObject import org.jetbrains.kotlin.nj2k.tree.* -import org.jetbrains.kotlin.nj2k.tree.impl.* class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase() { override fun applyToElement(element: JKTreeElement): JKTreeElement { if (element !is JKClass) return recurse(element) if (element.classKind == JKClass.ClassKind.COMPANION || element.classKind == JKClass.ClassKind.OBJECT) return element val statics = element.declarationList.filter { declaration -> - declaration is JKExtraModifiersOwner && - declaration.extraModifiers.any { it == ExtraModifier.STATIC } + declaration is JKExtraModifiersOwner && declaration.hasExtraModifier(ExtraModifier.STATIC) } if (statics.isEmpty()) return recurse(element) val companion = element.getOrCreateCompainonObject() @@ -23,7 +21,7 @@ class StaticsToCompanionExtractConversion : RecursiveApplicableConversionBase() element.classBody.declarations -= statics companion.classBody.declarations += statics.onEach { declaration -> (declaration as JKExtraModifiersOwner) - declaration.extraModifiers -= ExtraModifier.STATIC + declaration.extraModifierElements -= declaration.elementByModifier(ExtraModifier.STATIC)!! } return recurse(element) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SwitchStatementConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SwitchStatementConversion.kt index 6a063649d28..2e3498f678c 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SwitchStatementConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SwitchStatementConversion.kt @@ -49,7 +49,7 @@ class SwitchStatementConversion(private val context: ConversionContext) : Recurs statement.block.statements .takeWhile { !isSwitchBreak(it) } .map { it.copyTreeAndDetach() } - ) + ).withNonCodeElementsFrom(statement) isSwitchBreak(statement) -> null else -> statement.copyTreeAndDetach() } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt index f605dbd147b..c9727f29a99 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt @@ -9,6 +9,7 @@ import org.jetbrains.kotlin.nj2k.ConversionContext import org.jetbrains.kotlin.nj2k.tree.JKJavaSynchronizedStatement import org.jetbrains.kotlin.nj2k.tree.JKTreeElement import org.jetbrains.kotlin.nj2k.tree.impl.* +import org.jetbrains.kotlin.nj2k.tree.withNonCodeElementsFrom class SynchronizedStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { @@ -26,7 +27,7 @@ class SynchronizedStatementConversion(private val context: ConversionContext) : element.lockExpression, lambdaBody ) - ) + ).withNonCodeElementsFrom(element) return recurse(JKExpressionStatementImpl(synchronizedCall)) } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TryStatementConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TryStatementConversion.kt index 5f09bb56882..046128501a6 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TryStatementConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TryStatementConversion.kt @@ -5,10 +5,12 @@ package org.jetbrains.kotlin.nj2k.conversions -import org.jetbrains.kotlin.nj2k.* import org.jetbrains.kotlin.j2k.ast.Nullability +import org.jetbrains.kotlin.nj2k.ConversionContext +import org.jetbrains.kotlin.nj2k.copyTreeAndDetach import org.jetbrains.kotlin.nj2k.tree.* import org.jetbrains.kotlin.nj2k.tree.impl.* +import org.jetbrains.kotlin.nj2k.useExpression class TryStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() { @@ -26,7 +28,7 @@ class TryStatementConversion(private val context: ConversionContext) : Recursive tryStatement::finallyBlock.detached(), tryStatement.catchSections.flatMap(::convertCatchSection) ) - ) + ).withNonCodeElementsFrom(tryStatement) private fun convertTryStatementWithResources(tryStatement: JKJavaTryStatement): JKStatement { val body = @@ -41,7 +43,7 @@ class TryStatementConversion(private val context: ConversionContext) : Recursive tryStatement::finallyBlock.detached(), tryStatement.catchSections.flatMap(::convertCatchSection) ) - ) + ).withNonCodeElementsFrom(tryStatement) } else body } @@ -74,7 +76,7 @@ class TryStatementConversion(private val context: ConversionContext) : Recursive JKKtTryCatchSectionImpl( parameter, javaCatchSection.block.copyTreeAndDetach() - ) + ).withNonCodeElementsFrom(javaCatchSection) } } } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt index 0d8e7a98f71..a20b7aebc02 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/conversions/TypeMappingConversion.kt @@ -39,7 +39,7 @@ class TypeMappingConversion(val context: ConversionContext) : RecursiveApplicabl .fixRawType(element) .mapType(element) .refineNullability(element) - JKTypeElementImpl(newType) + JKTypeElementImpl(newType).withNonCodeElementsFrom(element) } is JKJavaNewExpression -> { val newClassSymbol = element.classSymbol.mapClassSymbol(null) @@ -49,7 +49,7 @@ class TypeMappingConversion(val context: ConversionContext) : RecursiveApplicabl element::arguments.detached(), element::typeArgumentList.detached().fixTypeArguments(newClassSymbol), element::classBody.detached() - ) + ).withNonCodeElementsFrom(element) ) } else -> recurse(element) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt index a611ed14ce1..80c144e46f4 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt @@ -384,8 +384,7 @@ fun JKLiteralExpression.fixLiteral(expectedType: JKLiteralExpression.LiteralType JKLiteralExpression.LiteralType.CHAR -> convertCharLiteral(literal) JKLiteralExpression.LiteralType.STRING -> convertStringLiteral(literal) else -> this - } - + }.withNonCodeElementsFrom(this) private fun convertDoubleLiteral(text: String): JKKtLiteralExpression { var newText = @@ -400,6 +399,7 @@ private fun convertDoubleLiteral(text: String): JKKtLiteralExpression { if (newText.endsWith(".")) newText += "0" + return JKKtLiteralExpressionImpl( newText, JKLiteralExpression.LiteralType.DOUBLE @@ -491,8 +491,8 @@ fun createCompanion(declarations: List): JKClass = JKClassBodyImpl(declarations), JKAnnotationListImpl(), emptyList(), - Visibility.PUBLIC, - Modality.FINAL + JKVisibilityModifierElementImpl(Visibility.PUBLIC), + JKModalityModifierElementImpl(Modality.FINAL) ) fun JKClass.getCompanion(): JKClass? = @@ -508,8 +508,8 @@ fun JKClass.getOrCreateCompainonObject(): JKClass = JKClassBodyImpl(), JKAnnotationListImpl(), emptyList(), - Visibility.PUBLIC, - Modality.FINAL + JKVisibilityModifierElementImpl(Visibility.PUBLIC), + JKModalityModifierElementImpl(Modality.FINAL) ).also { classBody.declarations += it } fun runExpression(body: JKStatement, symbolProvider: JKSymbolProvider): JKExpression { @@ -523,6 +523,9 @@ fun runExpression(body: JKStatement, symbolProvider: JKSymbolProvider): JKExpres ) } +fun JKTreeElement.asQualifierWithThisAsSelector(): JKQualifiedExpression? = + parent?.safeAs() + ?.takeIf { it.selector == this } fun JKAnnotationMemberValue.toExpression(symbolProvider: JKSymbolProvider): JKExpression { fun handleAnnotationParameter(element: JKTreeElement): JKTreeElement = @@ -563,6 +566,17 @@ fun JKAnnotationMemberValue.toExpression(symbolProvider: JKSymbolProvider): JKEx ) as JKExpression } + +fun JKExpression.asLiteralTextWithPrefix(): String? = + when { + this is JKPrefixExpression + && (operator.token.text == "+" || operator.token.text == "-") + && expression is JKLiteralExpression + -> operator.token.text + expression.cast().literal + this is JKLiteralExpression -> literal + else -> null + } + inline fun JKClass.primaryConstructor(): JKKtPrimaryConstructor? = classBody.declarations.firstIsInstanceOrNull() diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt index 9e9bb22a47d..6db3a11f2c7 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/base.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.nj2k.tree.impl import org.jetbrains.kotlin.nj2k.tree.JKBranchElement import org.jetbrains.kotlin.nj2k.tree.JKElement +import org.jetbrains.kotlin.nj2k.tree.JKNonCodeElement import org.jetbrains.kotlin.nj2k.tree.JKTreeElement import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor import kotlin.properties.ReadWriteProperty @@ -38,9 +39,12 @@ private class JKListChild(val value: Int) : ReadWriteProperty = emptyList() + override var rightNonCodeElements: List = emptyList() + override var parent: JKElement? = null - final override fun detach(from: JKElement) { + override fun detach(from: JKElement) { val prevParent = parent require(from == prevParent) parent = null @@ -51,7 +55,7 @@ abstract class JKElementBase : JKTreeElement, Cloneable { } - final override fun attach(to: JKElement) { + override fun attach(to: JKElement) { check(parent == null) parent = to onAttach() @@ -71,13 +75,13 @@ abstract class JKElementBase : JKTreeElement, Cloneable { abstract class JKBranchElementBase : JKElementBase(), JKBranchElement { private var childNum = 0 + protected fun child(v: U): ReadWriteProperty { children.add(childNum, v) v.attach(this) return JKChild(childNum++) } - protected inline fun children(): ReadWriteProperty> { return children(emptyList()) } @@ -88,7 +92,7 @@ abstract class JKBranchElementBase : JKElementBase(), JKBranchElement { return JKListChild(childNum++) } - final override fun acceptChildren(visitor: JKVisitor, data: D) { + override fun acceptChildren(visitor: JKVisitor, data: D) { forEachChild { it.accept(visitor, data) } } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt index 697cc6b179b..20c3bb9770a 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt @@ -31,18 +31,22 @@ class JKJavaFieldImpl( name: JKNameIdentifier, initializer: JKExpression, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality, - override var mutability: Mutability -) : JKJavaField, - JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement, + mutabilityElement: JKMutabilityModifierElement +) : JKJavaField(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaField(this, data) override var annotationList: JKAnnotationList by child(annotationList) override var initializer: JKExpression by child(initializer) override var type by child(type) override var name: JKNameIdentifier by child(name) + + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) + override var mutabilityElement by child(mutabilityElement) } class JKJavaMethodImpl( @@ -53,10 +57,10 @@ class JKJavaMethodImpl( typeParameterList: JKTypeParameterList, annotationList: JKAnnotationList, throwsList: List, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality -) : JKJavaMethod, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement +) : JKJavaMethod(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaMethod(this, data) override var returnType: JKTypeElement by child(returnType) @@ -66,6 +70,10 @@ class JKJavaMethodImpl( override var typeParameterList: JKTypeParameterList by child(typeParameterList) override var annotationList: JKAnnotationList by child(annotationList) override var throwsList: List by children(throwsList) + + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) } class JKJavaLiteralExpressionImpl( @@ -182,6 +190,15 @@ class JKJavaOperatorImpl private constructor(psiToken: IElementType) : JKOperato else -> 6 /* simple name */ } +// override val priority: Int +// get() = when (token.psiToken) { +// JavaTokenType.ASTERISK, JavaTokenType.DIV, JavaTokenType.PERC -> 12 +// JavaTokenType.PLUS, JavaTokenType.MINUS -> 11 +// JavaTokenType.GTGTGT, JavaTokenType.GTGT, JavaTokenType.LTLT -> 10 +// JavaTokenType.GT, JavaTokenType.LT, JavaTokenType.GE, JavaTokenType.LE -> 9 +// JavaTokenType.EQEQ, JavaTokenType.NE, KtTokens.EQEQEQ, KtTokens.EXCLEQEQEQ -> +// } + companion object { val tokenToOperator = (OPERATION_BIT_SET.types + arrayOf(KtTokens.EQEQEQ, KtTokens.EXCLEQEQEQ)) @@ -206,12 +223,12 @@ class JKJavaMethodCallExpressionImpl( override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList) } -class JKClassBodyImpl(declarations: List = emptyList()) : JKClassBody, JKBranchElementBase() { +class JKClassBodyImpl(declarations: List = emptyList()) : JKClassBody() { override var declarations: List by children(declarations) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClassBody(this, data) } -class JKEmptyClassBodyImpl : JKEmptyClassBody, JKBranchElementBase() { +class JKEmptyClassBodyImpl : JKEmptyClassBody() { override var declarations: List by children(emptyList()) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitEmptyClassBody(this, data) @@ -234,13 +251,15 @@ class JKJavaDefaultNewExpressionImpl( override val classSymbol: JKClassSymbol ) : JKJavaDefaultNewExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() -class JKJavaNewEmptyArrayImpl(initializer: List, type: JKTypeElement) : JKJavaNewEmptyArray, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKJavaNewEmptyArrayImpl(initializer: List, type: JKTypeElement) : JKJavaNewEmptyArray, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override val type by child(type) override var initializer by children(initializer) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewEmptyArray(this, data) } -class JKJavaNewArrayImpl(initializer: List, type: JKTypeElement) : JKJavaNewArray, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKJavaNewArrayImpl(initializer: List, type: JKTypeElement) : JKJavaNewArray, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override val type by child(type) override var initializer by children(initializer) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaNewArray(this, data) @@ -280,14 +299,15 @@ class JKJavaDisjunctionTypeImpl( class JKReturnStatementImpl( expression: JKExpression, label: JKLabel = JKLabelEmptyImpl() -) : JKBranchElementBase(), JKReturnStatement, PsiOwner by PsiOwnerImpl() { +) : JKReturnStatement(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitReturnStatement(this, data) override val expression by child(expression) override var label by child(label) } -class JKJavaAssertStatementImpl(condition: JKExpression, description: JKExpression) : JKJavaAssertStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKJavaAssertStatementImpl(condition: JKExpression, description: JKExpression) : JKJavaAssertStatement(), + PsiOwner by PsiOwnerImpl() { override val description by child(description) override val condition by child(condition) @@ -295,7 +315,7 @@ class JKJavaAssertStatementImpl(condition: JKExpression, description: JKExpressi } class JKJavaForLoopStatementImpl(initializer: JKStatement, condition: JKExpression, updaters: List, body: JKStatement) : - JKJavaForLoopStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { + JKJavaForLoopStatement(), PsiOwner by PsiOwnerImpl() { override var body by child(body) override var updaters by children(updaters) override var condition by child(condition) @@ -330,13 +350,14 @@ class JKJavaAssignmentExpressionImpl( class JKJavaSwitchStatementImpl( expression: JKExpression, cases: List -) : JKJavaSwitchStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKJavaSwitchStatement(), PsiOwner by PsiOwnerImpl() { override var expression: JKExpression by child(expression) override var cases: List by children(cases) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaSwitchStatement(this, data) } -class JKJavaDefaultSwitchCaseImpl(statements: List) : JKJavaDefaultSwitchCase, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKJavaDefaultSwitchCaseImpl(statements: List) : JKJavaDefaultSwitchCase, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override var statements: List by children(statements) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaDefaultSwitchCase(this, data) } @@ -350,7 +371,7 @@ class JKJavaLabelSwitchCaseImpl( override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaLabelSwitchCase(this, data) } -class JKJavaThrowStatementImpl(exception: JKExpression) : JKJavaThrowStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKJavaThrowStatementImpl(exception: JKExpression) : JKJavaThrowStatement(), PsiOwner by PsiOwnerImpl() { override var exception: JKExpression by child(exception) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaThrowStatement(this, data) } @@ -360,8 +381,7 @@ class JKJavaTryStatementImpl( tryBlock: JKBlock, finallyBlock: JKBlock, catchSections: List -) : JKJavaTryStatement, - JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKJavaTryStatement(), PsiOwner by PsiOwnerImpl() { override var resourceDeclarations: List by children(resourceDeclarations) override var tryBlock: JKBlock by child(tryBlock) override var finallyBlock: JKBlock by child(finallyBlock) @@ -381,7 +401,7 @@ class JKJavaTryCatchSectionImpl( class JKJavaSynchronizedStatementImpl( lockExpression: JKExpression, body: JKBlock -) : JKJavaSynchronizedStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKJavaSynchronizedStatement(), PsiOwner by PsiOwnerImpl() { override val lockExpression: JKExpression by child(lockExpression) override val body: JKBlock by child(body) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaSynchronizedStatement(this, data) @@ -391,17 +411,14 @@ class JKJavaAnnotationMethodImpl( returnType: JKTypeElement, name: JKNameIdentifier, defaultValue: JKAnnotationMemberValue -) : JKJavaAnnotationMethod, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKJavaAnnotationMethod(), PsiOwner by PsiOwnerImpl() { override var returnType: JKTypeElement by child(returnType) override var name: JKNameIdentifier by child(name) override var parameters: List by children() override var defaultValue: JKAnnotationMemberValue by child(defaultValue) - override var block: JKBlock by child(JKBodyStub) + override var block: JKBlock by child(JKBodyStubImpl) override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl()) override var annotationList: JKAnnotationList by child(JKAnnotationListImpl()) - override var extraModifiers: List = emptyList() - override var visibility: Visibility = Visibility.PUBLIC - override var modality: Modality = Modality.FINAL override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaAnnotationMethod(this, data) } @@ -414,7 +431,8 @@ class JKKtAnnotationArrayInitializerExpressionImpl(initializers: List accept(visitor: JKVisitor, data: D): R = visitor.visitKtAnnotationArrayInitializerExpression(this, data) } -class JKJavaStaticInitDeclarationImpl(block: JKBlock) : JKJavaStaticInitDeclaration, JKBranchElementBase() { + +class JKJavaStaticInitDeclarationImpl(block: JKBlock) : JKJavaStaticInitDeclaration() { override var block: JKBlock by child(block) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaStaticInitDeclaration(this, data) } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt index ec39ba6e1a0..352caecb56c 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt @@ -50,10 +50,10 @@ class JKClassImpl( typeParameterList: JKTypeParameterList, classBody: JKClassBody, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality -) : JKClass, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement +) : JKClass(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClass(this, data) override var name by child(name) @@ -61,6 +61,10 @@ class JKClassImpl( override var typeParameterList: JKTypeParameterList by child(typeParameterList) override var classBody: JKClassBody by child(classBody) override var annotationList: JKAnnotationList by child(annotationList) + + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) } class JKNameIdentifierImpl(override val value: String) : JKNameIdentifier, JKElementBase(), PsiOwner by PsiOwnerImpl() { @@ -72,7 +76,7 @@ class JKForLoopVariableImpl( name: JKNameIdentifier, initializer: JKExpression, annotationList: JKAnnotationList = JKAnnotationListImpl() -) : JKForLoopVariable, JKBranchElementBase() { +) : JKForLoopVariable() { override var initializer by child(initializer) override var name by child(name) override var type by child(type) @@ -88,16 +92,18 @@ class JKParameterImpl( override var isVarArgs: Boolean = false, initializer: JKExpression = JKStubExpressionImpl(), annotationList: JKAnnotationList = JKAnnotationListImpl() -) : JKParameter, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKParameter(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitParameter(this, data) override var initializer by child(initializer) override var name by child(name) override var type by child(type) + override var annotationList by child(annotationList) } -class JKBlockImpl(statements: List = emptyList()) : JKBlock, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKBlockImpl(statements: List = emptyList()) : JKBlock(), PsiOwner by PsiOwnerImpl() { constructor(vararg statements: JKStatement) : this(statements.toList()) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlock(this, data) override var statements by children(statements) @@ -114,21 +120,24 @@ class JKBinaryExpressionImpl( } - -class JKPrefixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPrefixExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKPrefixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPrefixExpression, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitPrefixExpression(this, data) override var expression by child(expression) } -class JKPostfixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPostfixExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKPostfixExpressionImpl(expression: JKExpression, override var operator: JKOperator) : JKPostfixExpression, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitPostfixExpression(this, data) override var expression by child(expression) } -class JKExpressionListImpl(expressions: List = emptyList()) : JKExpressionList, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKExpressionListImpl(expressions: List = emptyList()) : JKExpressionList, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { constructor(vararg expresions: JKExpression) : this(expresions.asList()) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitExpressionList(this, data) override var expressions by children(expressions) @@ -145,16 +154,19 @@ class JKQualifiedExpressionImpl( override var selector: JKExpression by child(selector) } -class JKExpressionStatementImpl(expression: JKExpression) : JKExpressionStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKExpressionStatementImpl(expression: JKExpression) : JKExpressionStatement(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitExpressionStatement(this, data) override val expression: JKExpression by child(expression) } -class JKDeclarationStatementImpl(declaredStatements: List) : JKDeclarationStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKDeclarationStatementImpl(declaredStatements: List) : JKDeclarationStatement(), + PsiOwner by PsiOwnerImpl() { override val declaredStatements by children(declaredStatements) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitDeclarationStatement(this, data) + + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) } class JKArrayAccessExpressionImpl( @@ -167,13 +179,15 @@ class JKArrayAccessExpressionImpl( override var indexExpression: JKExpression by child(indexExpression) } -class JKParenthesizedExpressionImpl(expression: JKExpression) : JKParenthesizedExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKParenthesizedExpressionImpl(expression: JKExpression) : JKParenthesizedExpression, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitParenthesizedExpression(this, data) override var expression: JKExpression by child(expression) } -class JKTypeCastExpressionImpl(override var expression: JKExpression, type: JKTypeElement) : JKTypeCastExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKTypeCastExpressionImpl(override var expression: JKExpression, type: JKTypeElement) : JKTypeCastExpression, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitTypeCastExpression(this, data) override var type by child(type) @@ -189,7 +203,7 @@ data class JKClassTypeImpl( override val nullability: Nullability = Nullability.Default ) : JKClassType -object JKNoTypeImpl: JKNoType { +object JKNoTypeImpl : JKNoType { override val nullability: Nullability = Nullability.NotNull } @@ -251,14 +265,16 @@ class JKLocalVariableImpl( type: JKTypeElement, name: JKNameIdentifier, initializer: JKExpression, - override var mutability: Mutability, + mutabilityElement: JKMutabilityModifierElement, annotationList: JKAnnotationList = JKAnnotationListImpl() -) : JKLocalVariable, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKLocalVariable(), PsiOwner by PsiOwnerImpl() { override var initializer by child(initializer) override var name by child(name) override var type by child(type) override var annotationList by child(annotationList) + override var mutabilityElement by child(mutabilityElement) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitLocalVariable(this, data) } @@ -266,19 +282,23 @@ class JKStubExpressionImpl : JKStubExpression, JKElementBase(), PsiOwner by PsiO override fun accept(visitor: JKVisitor, data: D): R = visitor.visitStubExpression(this, data) } -object JKBodyStub : JKBlock, JKTreeElement { +object JKBodyStubImpl : JKBodyStub() { + override var leftNonCodeElements: List = emptyList()//TODO fix + override var rightNonCodeElements: List = emptyList()//TODO fix + override fun copy(): JKTreeElement = this override var statements: List get() = emptyList() set(value) {} - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlock(this, data) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBodyStub(this, data) override fun acceptChildren(visitor: JKVisitor, data: D) {} - override val parent: JKElement? + override var parent: JKElement? get() = null + set (it) {} override fun detach(from: JKElement) { } @@ -287,14 +307,15 @@ object JKBodyStub : JKBlock, JKTreeElement { } } -class JKBlockStatementImpl(block: JKBlock) : JKBlockStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKBlockStatementImpl(block: JKBlock) : JKBlockStatement(), PsiOwner by PsiOwnerImpl() { override var block by child(block) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlockStatement(this, data) } -class JKBlockStatementWithoutBracketsImpl(block: JKBlock) : JKBlockStatementWithoutBrackets, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { - override var block by child(block) +class JKBlockStatementWithoutBracketsImpl(statements: List) : JKBlockStatementWithoutBrackets(), + PsiOwner by PsiOwnerImpl() { + override var statements by children(statements) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlockStatementWithoutBrackets(this, data) } @@ -304,40 +325,44 @@ class JKThisExpressionImpl(qualifierLabel: JKLabel) : JKThisExpression, JKBranch override fun accept(visitor: JKVisitor, data: D): R = visitor.visitThisExpression(this, data) } -class JKSuperExpressionImpl(qualifierLabel: JKLabel = JKLabelEmptyImpl()) : JKSuperExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKSuperExpressionImpl(qualifierLabel: JKLabel = JKLabelEmptyImpl()) : JKSuperExpression, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override var qualifierLabel: JKLabel by child(qualifierLabel) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitSuperExpression(this, data) } -class JKWhileStatementImpl(condition: JKExpression, body: JKStatement) : JKWhileStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKWhileStatementImpl(condition: JKExpression, body: JKStatement) : JKWhileStatement(), + PsiOwner by PsiOwnerImpl() { override var condition by child(condition) override var body by child(body) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitWhileStatement(this, data) } -class JKDoWhileStatementImpl(body: JKStatement, condition: JKExpression) : JKDoWhileStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKDoWhileStatementImpl(body: JKStatement, condition: JKExpression) : JKDoWhileStatement(), + PsiOwner by PsiOwnerImpl() { override var condition by child(condition) override var body by child(body) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitDoWhileStatement(this, data) } -class JKBreakStatementImpl : JKBreakStatement, JKElementBase(), PsiOwner by PsiOwnerImpl() { +class JKBreakStatementImpl : JKBreakStatement(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBreakStatement(this, data) } -class JKBreakWithLabelStatementImpl(override var label: JKNameIdentifier) : JKBreakWithLabelStatement, JKElementBase(), PsiOwner by PsiOwnerImpl() { +class JKBreakWithLabelStatementImpl(override var label: JKNameIdentifier) : JKBreakWithLabelStatement(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBreakWithLabelStatement(this, data) } -class JKIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKIfStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKIfStatement(), + PsiOwner by PsiOwnerImpl() { override var thenBranch by child(thenBranch) override var condition by child(condition) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitIfStatement(this, data) } -class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKIfElseStatement, - JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKIfElseStatement(), PsiOwner by PsiOwnerImpl() { override var elseBranch by child(elseBranch) override var thenBranch by child(thenBranch) override var condition by child(condition) @@ -354,7 +379,8 @@ class JKIfElseExpressionImpl(condition: JKExpression, thenBranch: JKExpression, override fun accept(visitor: JKVisitor, data: D): R = visitor.visitIfElseExpression(this, data) } -class JKClassAccessExpressionImpl(override var identifier: JKClassSymbol) : JKClassAccessExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() { +class JKClassAccessExpressionImpl(override var identifier: JKClassSymbol) : JKClassAccessExpression, JKElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitClassAccessExpression(this, data) } @@ -392,9 +418,11 @@ class JKDelegationConstructorCallImpl( override fun accept(visitor: JKVisitor, data: D): R = visitor.visitDelegationConstructorCall(this, data) } -class JKFieldAccessExpressionImpl(override var identifier: JKFieldSymbol) : JKFieldAccessExpression, JKElementBase(), PsiOwner by PsiOwnerImpl() { +class JKFieldAccessExpressionImpl(override var identifier: JKFieldSymbol) : JKFieldAccessExpression, JKElementBase(), + PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitFieldAccessExpression(this, data) } + val JKStatement.statements: List get() = when (this) { @@ -405,23 +433,25 @@ val JKStatement.statements: List class JKLabelEmptyImpl : JKLabelEmpty, JKElementBase(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitLabelEmpty(this, data) } + class JKLabelTextImpl(label: JKNameIdentifier) : JKLabelText, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { override val label: JKNameIdentifier by child(label) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitLabelText(this, data) } -class JKContinueStatementImpl(label: JKLabel) : JKContinueStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKContinueStatementImpl(label: JKLabel) : JKContinueStatement(), PsiOwner by PsiOwnerImpl() { override var label: JKLabel by child(label) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitContinueStatement(this, data) } -class JKLabeledStatementImpl(statement: JKStatement, labels: List) : JKLabeledStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +class JKLabeledStatementImpl(statement: JKStatement, labels: List) : JKLabeledStatement, JKBranchElementBase(), + PsiOwner by PsiOwnerImpl() { override var statement: JKStatement by child(statement) override val labels: List by children(labels) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitLabeledStatement(this, data) } -class JKEmptyStatementImpl: JKEmptyStatement, JKElementBase() , PsiOwner by PsiOwnerImpl() { +class JKEmptyStatementImpl : JKEmptyStatement(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitEmptyStatement(this, data) } @@ -430,7 +460,7 @@ class PsiOwnerImpl(override var psi: PsiElement? = null) : PsiOwner val JKElement.psi: PsiElement? get() = (this as? PsiOwner)?.psi -fun JKElement.psi(): Elem? = +fun JKElement.psi(): Elem? = (this as? PsiOwner)?.psi as? Elem class JKTypeParameterListImpl(typeParameters: List = emptyList()) : JKTypeParameterList, JKBranchElementBase() { @@ -460,7 +490,7 @@ class JKEnumConstantImpl( body: JKClassBody, type: JKTypeElement, annotationList: JKAnnotationList = JKAnnotationListImpl() -) : JKEnumConstant, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKEnumConstant(), PsiOwner by PsiOwnerImpl() { override var name: JKNameIdentifier by child(name) override val arguments: JKArgumentList by child(arguments) override val body: JKClassBody by child(body) @@ -475,7 +505,7 @@ fun JKTypeElement.present(): Boolean = type != JKNoTypeImpl class JKForInStatementImpl(declaration: JKDeclaration, iterationExpression: JKExpression, body: JKStatement) : - JKForInStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { + JKForInStatement(), PsiOwner by PsiOwnerImpl() { override var declaration: JKDeclaration by child(declaration) override var iterationExpression: JKExpression by child(iterationExpression) override var body: JKStatement by child(body) @@ -485,12 +515,12 @@ class JKForInStatementImpl(declaration: JKDeclaration, iterationExpression: JKEx fun JKStatement.isEmpty(): Boolean = when (this) { is JKEmptyStatement -> true - is JKBlockStatement -> block is JKBodyStub + is JKBlockStatement -> block is JKBodyStubImpl is JKExpressionStatement -> expression is JKStubExpression else -> false } -class JKPackageDeclarationImpl(packageName: JKNameIdentifier) : JKPackageDeclaration, JKBranchElementBase() { +class JKPackageDeclarationImpl(packageName: JKNameIdentifier) : JKPackageDeclaration() { override var packageName: JKNameIdentifier by child(packageName) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitPackageDeclaration(this, data) } @@ -506,6 +536,8 @@ class JKAnnotationImpl( ) : JKAnnotation, JKBranchElementBase() { override var arguments: List by children(arguments) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitAnnotation(this, data) + + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) } class JKTypeArgumentListImpl(typeArguments: List = emptyList()) : JKTypeArgumentList, JKBranchElementBase(), @@ -528,6 +560,8 @@ class JKImportStatementImpl(name: JKNameIdentifier) : JKImportStatement, JKBranc override val name: JKNameIdentifier by child(name) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitImportStatement(this, data) + + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) } class JKAnnotationParameterImpl(value: JKAnnotationMemberValue) : JKAnnotationParameter, JKBranchElementBase() { @@ -569,3 +603,20 @@ class JKArgumentListImpl(arguments: List = emptyList()) : JKArgument override fun accept(visitor: JKVisitor, data: D): R = visitor.visitArgumentList(this, data) } + + +class JKMutabilityModifierElementImpl(override var mutability: Mutability) : JKMutabilityModifierElement() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitMutabilityModifierElement(this, data) +} + +class JKModalityModifierElementImpl(override var modality: Modality) : JKModalityModifierElement() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitModalityModifierElement(this, data) +} + +class JKVisibilityModifierElementImpl(override var visibility: Visibility) : JKVisibilityModifierElement() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitVisibilityModifierElement(this, data) +} + +class JKExtraModifierElementImpl(override var extraModifier: ExtraModifier) : JKExtraModifierElement() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitExtraModifierElement(this, data) +} \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt index ba7e88f06f3..5e53e6a9f0b 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt @@ -30,11 +30,11 @@ class JKKtPropertyImpl( getter: JKKtGetterOrSetter, setter: JKKtGetterOrSetter, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality, - override var mutability: Mutability -) : JKBranchElementBase(), JKKtProperty, PsiOwner by PsiOwnerImpl() { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement, + mutabilityElement: JKMutabilityModifierElement +) : JKKtProperty(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtProperty(this, data) override var annotationList: JKAnnotationList by child(annotationList) @@ -43,6 +43,13 @@ class JKKtPropertyImpl( override var initializer: JKExpression by child(initializer) override var getter: JKKtGetterOrSetter by child(getter) override var setter: JKKtGetterOrSetter by child(setter) + + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) + override var mutabilityElement by child(mutabilityElement) + + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) } class JKKtFunctionImpl( @@ -52,10 +59,10 @@ class JKKtFunctionImpl( block: JKBlock, typeParameterList: JKTypeParameterList, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality -) : JKBranchElementBase(), JKKtFunction, PsiOwner by PsiOwnerImpl() { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement +) : JKKtFunction(), PsiOwner by PsiOwnerImpl() { override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtFunction(this, data) override var returnType: JKTypeElement by child(returnType) @@ -64,6 +71,11 @@ class JKKtFunctionImpl( override var block: JKBlock by child(block) override var typeParameterList: JKTypeParameterList by child(typeParameterList) override var annotationList: JKAnnotationList by child(annotationList) + + + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) } sealed class JKKtQualifierImpl : JKQualifier, JKElementBase() { @@ -147,11 +159,12 @@ class JKKtAssignmentStatementImpl( field: JKAssignableExpression, expression: JKExpression, override var operator: JKOperator -) : JKKtAssignmentStatement, JKBranchElementBase() { +) : JKKtAssignmentStatement() { override var field: JKAssignableExpression by child(field) override var expression by child(expression) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtAssignmentStatement(this, data) + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) } object JKContextType : JKType { @@ -165,10 +178,10 @@ class JKKtConstructorImpl( block: JKBlock, delegationCall: JKExpression, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality -) : JKBranchElementBase(), JKKtConstructor { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement +) : JKKtConstructor() { override var returnType: JKTypeElement by child(JKTypeElementImpl(JKNoTypeImpl)) override var name: JKNameIdentifier by child(name) @@ -178,6 +191,10 @@ class JKKtConstructorImpl( override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl()) override var annotationList: JKAnnotationList by child(annotationList) + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtConstructor(this, data) } @@ -186,26 +203,30 @@ class JKKtPrimaryConstructorImpl( parameters: List, delegationCall: JKExpression, annotationList: JKAnnotationList, - override var extraModifiers: List, - override var visibility: Visibility, - override var modality: Modality -) : JKBranchElementBase(), JKKtPrimaryConstructor { + extraModifierElements: List, + visibilityElement: JKVisibilityModifierElement, + modalityElement: JKModalityModifierElement +) : JKKtPrimaryConstructor() { override var returnType: JKTypeElement by child(JKTypeElementImpl(JKNoTypeImpl)) override var name: JKNameIdentifier by child(name) override var parameters: List by children(parameters) - override var block: JKBlock by child(JKBodyStub) + override var block: JKBlock by child(JKBodyStubImpl) override var delegationCall: JKExpression by child(delegationCall) override var typeParameterList: JKTypeParameterList by child(JKTypeParameterListImpl()) override var annotationList: JKAnnotationList by child(annotationList) + override var extraModifierElements by children(extraModifierElements) + override var visibilityElement by child(visibilityElement) + override var modalityElement by child(modalityElement) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtPrimaryConstructor(this, data) } class JKKtWhenStatementImpl( expression: JKExpression, cases: List -) : JKKtWhenStatement, JKBranchElementBase() { +) : JKKtWhenStatement() { override var expression: JKExpression by child(expression) override var cases: List by children(cases) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtWhenStatement(this, data) @@ -235,7 +256,7 @@ class JKKtIsExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKKt override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtIsExpression(this, data) } -class JKKtInitDeclarationImpl(block: JKBlock) : JKKtInitDeclaration, JKBranchElementBase() { +class JKKtInitDeclarationImpl(block: JKBlock) : JKKtInitDeclaration() { override var block: JKBlock by child(block) override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtInitDeclaration(this, data) } @@ -244,7 +265,7 @@ class JKKtInitDeclarationImpl(block: JKBlock) : JKKtInitDeclaration, JKBranchEle class JKKtConvertedFromForLoopSyntheticWhileStatementImpl( variableDeclaration: JKStatement, whileStatement: JKWhileStatement -) : JKKtConvertedFromForLoopSyntheticWhileStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() { +) : JKKtConvertedFromForLoopSyntheticWhileStatement(), PsiOwner by PsiOwnerImpl() { override var variableDeclaration: JKStatement by child(variableDeclaration) override var whileStatement: JKWhileStatement by child(whileStatement) override fun accept(visitor: JKVisitor, data: D): R = @@ -279,17 +300,21 @@ class JKKtTryCatchSectionImpl( class JKKtGetterOrSetterImpl( body: JKStatement, override val kind: JKKtGetterOrSetter.Kind, - override var visibility: Visibility + visibilityElement: JKVisibilityModifierElement ) : JKKtGetterOrSetter, JKBranchElementBase() { override var body: JKStatement by child(body) + + override var visibilityElement by child(visibilityElement) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtGetterOrSetter(this, data) } class JKKtEmptyGetterOrSetterImpl : JKKtEmptyGetterOrSetter, JKBranchElementBase() { - override var visibility: Visibility = Visibility.PUBLIC override var body: JKStatement by child(JKEmptyStatementImpl()) override val kind: JKKtGetterOrSetter.Kind get() = error("Cannot get kind of JKKtEmptyGetterOrSetter") + override var visibilityElement by child(JKVisibilityModifierElementImpl(Visibility.PUBLIC)) + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitKtEmptyGetterOrSetter(this, data) } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/tokens.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/tokens.kt new file mode 100644 index 00000000000..fdca966051e --- /dev/null +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/tokens.kt @@ -0,0 +1,21 @@ +/* + * Copyright 2010-2019 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.nj2k.tree.impl + +import org.jetbrains.kotlin.nj2k.tree.JKCommentElement +import org.jetbrains.kotlin.nj2k.tree.JKNonCodeElement +import org.jetbrains.kotlin.nj2k.tree.JKSpaceElement +import org.jetbrains.kotlin.nj2k.tree.JKTokenElement + + +class JKSpaceElementImpl(override val text: String) : JKSpaceElement + +class JKCommentElementImpl(override val text: String) : JKCommentElement + +class JKTokenElementImpl(override val text: String) : JKTokenElement { + override var leftNonCodeElements: List = emptyList() + override var rightNonCodeElements: List = emptyList() +} diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt index 284379fe9c9..adbca236b97 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt @@ -16,23 +16,28 @@ package org.jetbrains.kotlin.nj2k.tree -import org.jetbrains.kotlin.nj2k.tree.impl.JKClassSymbol +import org.jetbrains.kotlin.nj2k.tree.impl.* -interface JKField : JKVariable, JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKAnnotationListOwner +abstract class JKField : JKVariable(), JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKAnnotationListOwner -interface JKJavaField : JKField, JKBranchElement +abstract class JKJavaField : JKField() -interface JKJavaMethod : JKMethod, JKBranchElement { - var throwsList: List +abstract class JKJavaMethod : JKMethod(), JKBranchElement { + abstract var throwsList: List } interface JKJavaMethodCallExpression : JKMethodCallExpression -interface JKClassBody : JKTreeElement, JKBranchElement { - var declarations: List +abstract class JKClassBody : JKTreeElement, JKBranchElementBase() { + abstract var declarations: List + + val leftBrace = JKTokenElementImpl("{") + val rightBrace = JKTokenElementImpl("}") } -interface JKEmptyClassBody : JKClassBody +abstract class JKEmptyClassBody : JKClassBody() { + override var declarations: List = emptyList() +} interface JKJavaNewExpression : JKExpression, JKTypeArgumentListOwner, PsiOwner { val classSymbol: JKClassSymbol @@ -61,20 +66,20 @@ interface JKJavaNewArray : JKExpression { interface JKJavaLiteralExpression : JKLiteralExpression -interface JKReturnStatement : JKStatement { - val expression: JKExpression - var label: JKLabel +abstract class JKReturnStatement : JKStatement() { + abstract val expression: JKExpression + abstract var label: JKLabel } -interface JKJavaAssertStatement : JKStatement { - val condition: JKExpression - val description: JKExpression +abstract class JKJavaAssertStatement : JKStatement() { + abstract val condition: JKExpression + abstract val description: JKExpression } -interface JKJavaForLoopStatement : JKLoopStatement { - var initializer: JKStatement - var condition: JKExpression - var updaters: List +abstract class JKJavaForLoopStatement : JKLoopStatement() { + abstract var initializer: JKStatement + abstract var condition: JKExpression + abstract var updaters: List } @@ -91,15 +96,15 @@ interface JKJavaAssignmentExpression : JKExpression, JKBranchElement { var operator: JKOperator } -interface JKJavaThrowStatement : JKStatement { - var exception: JKExpression +abstract class JKJavaThrowStatement : JKStatement() { + abstract var exception: JKExpression } -interface JKJavaTryStatement : JKStatement { - var resourceDeclarations: List - var tryBlock: JKBlock - var finallyBlock: JKBlock - var catchSections: List +abstract class JKJavaTryStatement : JKStatement() { + abstract var resourceDeclarations: List + abstract var tryBlock: JKBlock + abstract var finallyBlock: JKBlock + abstract var catchSections: List } interface JKJavaTryCatchSection : JKTreeElement { @@ -108,9 +113,9 @@ interface JKJavaTryCatchSection : JKTreeElement { } -interface JKJavaSwitchStatement : JKStatement { - var expression: JKExpression - var cases: List +abstract class JKJavaSwitchStatement : JKStatement() { + abstract var expression: JKExpression + abstract var cases: List } interface JKJavaSwitchCase : JKTreeElement { @@ -127,17 +132,21 @@ interface JKJavaLabelSwitchCase : JKJavaSwitchCase { var label: JKExpression } -interface JKJavaContinueStatement: JKStatement +abstract class JKJavaContinueStatement : JKStatement() -interface JKJavaSynchronizedStatement : JKStatement, JKBranchElement { - val lockExpression: JKExpression - val body: JKBlock +abstract class JKJavaSynchronizedStatement : JKStatement(), JKBranchElement { + abstract val lockExpression: JKExpression + abstract val body: JKBlock } -interface JKJavaAnnotationMethod : JKMethod, JKBranchElement { - val defaultValue: JKAnnotationMemberValue +abstract class JKJavaAnnotationMethod : JKMethod(), JKBranchElement { + abstract val defaultValue: JKAnnotationMemberValue + + override var extraModifierElements by children() + override var visibilityElement by child(JKVisibilityModifierElementImpl(Visibility.PUBLIC)) + override var modalityElement by child(JKModalityModifierElementImpl(Modality.FINAL)) } -interface JKJavaStaticInitDeclaration : JKDeclaration, JKBranchElement { - var block: JKBlock +abstract class JKJavaStaticInitDeclaration : JKDeclaration(), JKBranchElement { + abstract var block: JKBlock } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt index 5800077aaea..f7e86aa3a85 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt @@ -17,12 +17,10 @@ package org.jetbrains.kotlin.nj2k.tree import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.nj2k.tree.impl.JKClassSymbol -import org.jetbrains.kotlin.nj2k.tree.impl.JKFieldSymbol -import org.jetbrains.kotlin.nj2k.tree.impl.JKMethodSymbol +import org.jetbrains.kotlin.nj2k.tree.impl.* import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor -interface JKTreeElement : JKElement { +interface JKTreeElement : JKElement, JKNonCodeElementsListOwner { fun accept(visitor: JKVisitor, data: D): R fun accept(visitor: JKVisitor): R = accept(visitor, null) @@ -38,7 +36,9 @@ interface PsiOwner { var psi: PsiElement? } -interface JKDeclaration : JKTreeElement +abstract class JKDeclaration : JKTreeElement, JKBranchElementBase() { + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) +} interface JKImportStatement : JKTreeElement { val name: JKNameIdentifier @@ -50,14 +50,15 @@ interface JKFile : JKTreeElement, JKBranchElement { var declarationList: List } -interface JKClass : JKDeclaration, JKVisibilityOwner, JKExtraModifiersOwner, JKModalityOwner, JKTypeParameterListOwner, JKAnnotationListOwner, +abstract class JKClass : JKDeclaration(), JKVisibilityOwner, JKExtraModifiersOwner, JKModalityOwner, JKTypeParameterListOwner, + JKAnnotationListOwner, JKBranchElement { - val name: JKNameIdentifier + abstract val name: JKNameIdentifier - val inheritance: JKInheritanceInfo + abstract val inheritance: JKInheritanceInfo - var classBody: JKClassBody - var classKind: ClassKind + abstract var classBody: JKClassBody + abstract var classKind: ClassKind enum class ClassKind { ANNOTATION, CLASS, ENUM, INTERFACE, OBJECT, COMPANION @@ -100,32 +101,71 @@ interface JKAnnotationListOwner : JKTreeElement { var annotationList: JKAnnotationList } -interface JKMethod : JKDeclaration, JKVisibilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKTypeParameterListOwner, +abstract class JKMethod : JKDeclaration(), JKVisibilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKTypeParameterListOwner, JKAnnotationListOwner { - val name: JKNameIdentifier - var parameters: List - var returnType: JKTypeElement - var block: JKBlock + abstract val name: JKNameIdentifier + abstract var parameters: List + abstract var returnType: JKTypeElement + abstract var block: JKBlock + + val leftParen = JKTokenElementImpl("(") + val rightParen = JKTokenElementImpl(")") } -interface JKVariable : JKDeclaration, JKAnnotationListOwner { - var type: JKTypeElement - var name: JKNameIdentifier - var initializer: JKExpression +abstract class JKVariable : JKDeclaration(), JKAnnotationListOwner { + abstract var type: JKTypeElement + abstract var name: JKNameIdentifier + abstract var initializer: JKExpression } -interface JKForLoopVariable : JKVariable +abstract class JKForLoopVariable : JKVariable() -interface JKLocalVariable : JKVariable, JKMutabilityOwner +abstract class JKLocalVariable : JKVariable(), JKMutabilityOwner -interface JKExtraModifiersOwner : JKModifiersListOwner { - var extraModifiers: List + +abstract class JKModifierElement : JKTreeElement, JKBranchElementBase(), JKNonCodeElementsListOwner + +val JKModifierElement.modifier: Modifier + get() = when (this) { + is JKMutabilityModifierElement -> mutability + is JKModalityModifierElement -> modality + is JKVisibilityModifierElement -> visibility + is JKExtraModifierElement -> extraModifier + else -> error("") + } + +abstract class JKMutabilityModifierElement : JKModifierElement() { + abstract var mutability: Mutability +} + +abstract class JKModalityModifierElement : JKModifierElement() { + abstract var modality: Modality +} + +abstract class JKVisibilityModifierElement : JKModifierElement() { + abstract var visibility: Visibility +} + +abstract class JKExtraModifierElement : JKModifierElement() { + abstract var extraModifier: ExtraModifier } interface Modifier { val text: String } +interface JKExtraModifiersOwner : JKModifiersListOwner { + var extraModifierElements: List +} + +fun JKExtraModifiersOwner.elementByModifier(modifier: ExtraModifier): JKExtraModifierElement? = + extraModifierElements.firstOrNull { it.extraModifier == modifier } + +fun JKExtraModifiersOwner.hasExtraModifier(modifier: ExtraModifier): Boolean = + extraModifierElements.any { it.extraModifier == modifier } + +//val JKExtraModifiersOwner.extraModifiers + enum class ExtraModifier(override val text: String) : Modifier { ACTUAL("actual"), ANNOTATION("annotation"), @@ -156,8 +196,8 @@ enum class ExtraModifier(override val text: String) : Modifier { VOLATILE("volatile") } -interface JKVisibilityOwner : JKModifiersListOwner{ - var visibility: Visibility +interface JKVisibilityOwner : JKModifiersListOwner { + val visibilityElement: JKVisibilityModifierElement } enum class Visibility(override val text: String) : Modifier { @@ -168,8 +208,14 @@ enum class Visibility(override val text: String) : Modifier { PRIVATE("private") } +var JKVisibilityOwner.visibility: Visibility + get() = visibilityElement.visibility + set(value) { + visibilityElement.visibility = value + } + interface JKModalityOwner : JKModifiersListOwner { - var modality: Modality + val modalityElement: JKModalityModifierElement } @@ -180,8 +226,14 @@ enum class Modality(override val text: String) : Modifier { OVERRIDE("override") } +var JKModalityOwner.modality: Modality + get() = modalityElement.modality + set(value) { + modalityElement.modality = value + } + interface JKMutabilityOwner : JKModifiersListOwner { - var mutability: Mutability + val mutabilityElement: JKMutabilityModifierElement } enum class Mutability(override val text: String) : Modifier { @@ -190,23 +242,38 @@ enum class Mutability(override val text: String) : Modifier { UNKNOWN("var")//TODO ??? } +var JKMutabilityOwner.mutability: Mutability + get() = mutabilityElement.mutability + set(value) { + mutabilityElement.mutability = value + } + interface JKModifiersListOwner : JKTreeElement -fun JKModifiersListOwner.modifiers(): List = - listOfNotNull((this as? JKVisibilityOwner)?.visibility) + - (this as? JKExtraModifiersOwner)?.extraModifiers.orEmpty() + - listOfNotNull((this as? JKModalityOwner)?.modality) + - listOfNotNull((this as? JKMutabilityOwner)?.mutability) +fun JKModifiersListOwner.modifierElements(): List = + listOfNotNull((this as? JKVisibilityOwner)?.visibilityElement) + + (this as? JKExtraModifiersOwner)?.extraModifierElements.orEmpty() + + listOfNotNull((this as? JKModalityOwner)?.modalityElement) + + listOfNotNull((this as? JKMutabilityOwner)?.mutabilityElement) interface JKTypeElement : JKTreeElement { val type: JKType } -interface JKStatement : JKTreeElement +abstract class JKStatement : JKTreeElement, JKBranchElementBase() { + override var rightNonCodeElements: List = listOf(JKSpaceElementImpl("\n")) +} + +abstract class JKBlock : JKTreeElement, JKBranchElementBase() { + abstract var statements: List + + val leftBrace = JKTokenElementImpl("{") + val rightBrace = JKTokenElementImpl("}") +} + +abstract class JKBodyStub : JKBlock() { -interface JKBlock : JKTreeElement { - var statements: List } interface JKIdentifier : JKTreeElement @@ -217,12 +284,12 @@ interface JKNameIdentifier : JKIdentifier { interface JKExpression : JKTreeElement, JKAnnotationMemberValue -interface JKExpressionStatement : JKStatement, JKBranchElement { - val expression: JKExpression +abstract class JKExpressionStatement : JKStatement() { + abstract val expression: JKExpression } -interface JKDeclarationStatement : JKStatement { - val declaredStatements: List +abstract class JKDeclarationStatement : JKStatement() { + abstract val declaredStatements: List } interface JKOperatorExpression : JKExpression { @@ -310,8 +377,10 @@ interface JKLiteralExpression : JKExpression { } } -interface JKParameter : JKVariable, JKModifiersListOwner { - var isVarArgs: Boolean +abstract class JKParameter : JKVariable(), JKModifiersListOwner { + abstract var isVarArgs: Boolean + + override var rightNonCodeElements: List = emptyList() } interface JKStringLiteralExpression : JKLiteralExpression { @@ -320,16 +389,16 @@ interface JKStringLiteralExpression : JKLiteralExpression { interface JKStubExpression : JKExpression -interface JKLoopStatement : JKStatement { - var body: JKStatement +abstract class JKLoopStatement : JKStatement() { + abstract var body: JKStatement } -interface JKBlockStatement : JKStatement, JKBranchElement { - var block: JKBlock +abstract class JKBlockStatement : JKStatement() { + abstract var block: JKBlock } -interface JKBlockStatementWithoutBrackets : JKStatement, JKBranchElement { - var block: JKBlock +abstract class JKBlockStatementWithoutBrackets : JKStatement() { + abstract var statements: List } interface JKThisExpression : JKExpression { @@ -340,27 +409,27 @@ interface JKSuperExpression : JKExpression { var qualifierLabel: JKLabel } -interface JKWhileStatement : JKLoopStatement { - var condition: JKExpression +abstract class JKWhileStatement : JKLoopStatement() { + abstract var condition: JKExpression } -interface JKDoWhileStatement : JKLoopStatement { - var condition: JKExpression +abstract class JKDoWhileStatement : JKLoopStatement() { + abstract var condition: JKExpression } -interface JKBreakStatement : JKStatement +abstract class JKBreakStatement : JKStatement() -interface JKBreakWithLabelStatement : JKBreakStatement { - var label: JKNameIdentifier +abstract class JKBreakWithLabelStatement : JKBreakStatement() { + abstract var label: JKNameIdentifier } -interface JKIfStatement : JKStatement { - var condition: JKExpression - var thenBranch: JKStatement +abstract class JKIfStatement : JKStatement() { + abstract var condition: JKExpression + abstract var thenBranch: JKStatement } -interface JKIfElseStatement : JKIfStatement { - var elseBranch: JKStatement +abstract class JKIfElseStatement : JKIfStatement() { + abstract var elseBranch: JKStatement } interface JKIfElseExpression : JKExpression { @@ -391,16 +460,16 @@ interface JKLabelText : JKLabel { val label: JKNameIdentifier } -interface JKContinueStatement : JKStatement { - var label: JKLabel +abstract class JKContinueStatement : JKStatement() { + abstract var label: JKLabel } -interface JKLabeledStatement : JKStatement { +interface JKLabeledStatement : JKExpression { var statement: JKStatement val labels: List } -interface JKEmptyStatement : JKStatement +abstract class JKEmptyStatement : JKStatement() interface JKTypeParameterList : JKTreeElement { var typeParameters: List @@ -415,19 +484,19 @@ interface JKTypeParameterListOwner : JKTreeElement { var typeParameterList: JKTypeParameterList } -interface JKEnumConstant : JKVariable { - val arguments: JKArgumentList - val body: JKClassBody +abstract class JKEnumConstant : JKVariable() { + abstract val arguments: JKArgumentList + abstract val body: JKClassBody } -interface JKForInStatement : JKStatement { - var declaration: JKDeclaration - var iterationExpression: JKExpression - var body: JKStatement +abstract class JKForInStatement : JKStatement() { + abstract var declaration: JKDeclaration + abstract var iterationExpression: JKExpression + abstract var body: JKStatement } -interface JKPackageDeclaration : JKDeclaration { - var packageName: JKNameIdentifier +abstract class JKPackageDeclaration : JKDeclaration() { + abstract var packageName: JKNameIdentifier } interface JKClassLiteralExpression : JKExpression { diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/k.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/k.kt index ff41e3efc26..8f8fd98f1e0 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/k.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/k.kt @@ -16,8 +16,6 @@ package org.jetbrains.kotlin.nj2k.tree -import org.jetbrains.kotlin.nj2k.tree.impl.JKMethodSymbol - interface JKKtGetterOrSetter : JKTreeElement, JKVisibilityOwner, JKBranchElement { var body: JKStatement val kind: Kind @@ -29,27 +27,24 @@ interface JKKtGetterOrSetter : JKTreeElement, JKVisibilityOwner, JKBranchElement interface JKKtEmptyGetterOrSetter : JKKtGetterOrSetter -interface JKKtProperty : JKField, PsiOwner { - var getter: JKKtGetterOrSetter - var setter: JKKtGetterOrSetter +abstract class JKKtProperty : JKField(), PsiOwner { + abstract var getter: JKKtGetterOrSetter + abstract var setter: JKKtGetterOrSetter } -interface JKKtFunction : JKMethod, PsiOwner { +abstract class JKKtFunction : JKMethod(), PsiOwner + +abstract class JKKtConstructor : JKMethod(), JKExtraModifiersOwner { + abstract var delegationCall: JKExpression } -interface JKKtConstructor : JKDeclaration, JKExtraModifiersOwner, JKMethod, JKBranchElement { - override var name: JKNameIdentifier - override var parameters: List - var delegationCall: JKExpression -} +abstract class JKKtPrimaryConstructor : JKKtConstructor() -interface JKKtPrimaryConstructor : JKKtConstructor - -interface JKKtAssignmentStatement : JKStatement { - var field: JKAssignableExpression - var expression: JKExpression - var operator: JKOperator +abstract class JKKtAssignmentStatement : JKStatement() { + abstract var field: JKAssignableExpression + abstract var expression: JKExpression + abstract var operator: JKOperator } interface JKKtCall : JKMethodCallExpression @@ -62,9 +57,9 @@ interface JKKtAlsoCallExpression : JKKtMethodCallExpression { interface JKKtLiteralExpression : JKLiteralExpression -interface JKKtWhenStatement : JKStatement { - var expression: JKExpression - var cases: List +abstract class JKKtWhenStatement : JKStatement() { + abstract var expression: JKExpression + abstract var cases: List } interface JKKtWhenCase : JKTreeElement { @@ -85,14 +80,14 @@ interface JKKtIsExpression : JKExpression, PsiOwner { var type: JKTypeElement } -interface JKKtInitDeclaration : JKDeclaration { - var block: JKBlock +abstract class JKKtInitDeclaration : JKDeclaration() { + abstract var block: JKBlock } -interface JKKtConvertedFromForLoopSyntheticWhileStatement : JKStatement { - var variableDeclaration: JKStatement - var whileStatement: JKWhileStatement +abstract class JKKtConvertedFromForLoopSyntheticWhileStatement : JKStatement() { + abstract var variableDeclaration: JKStatement + abstract var whileStatement: JKWhileStatement } diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/tokens.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/tokens.kt new file mode 100644 index 00000000000..4c57cb0de34 --- /dev/null +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/tokens.kt @@ -0,0 +1,54 @@ +/* + * Copyright 2010-2019 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.nj2k.tree + + +interface JKNonCodeElement { + val text: String +} +interface JKSpaceElement : JKNonCodeElement + +interface JKCommentElement : JKNonCodeElement + +fun JKCommentElement.isMultiline() = + text.startsWith("/*") + +fun JKCommentElement.isSingleline() = + text.startsWith("//") + + +interface JKNonCodeElementsListOwner { + var leftNonCodeElements: List + var rightNonCodeElements: List +} + +inline fun JKNonCodeElementsListOwner.takeNonCodeElementsFrom(other: JKNonCodeElementsListOwner) { + leftNonCodeElements = other.leftNonCodeElements + rightNonCodeElements = other.rightNonCodeElements +} + +fun JKTreeElement.commentsFromInside(): List { + val comments = mutableListOf() + fun recurse(element: JKTreeElement): JKTreeElement { + comments += (element.leftNonCodeElements + element.rightNonCodeElements).filterIsInstance() + return applyRecursive(element, ::recurse) + } + applyRecursive(this, ::recurse) + return comments +} + +inline fun T.withNonCodeElementsFrom(other: JKNonCodeElementsListOwner): T = + also { it.takeNonCodeElementsFrom(other) } + + +interface JKTokenElement : JKNonCodeElementsListOwner { + val text: String +} + +fun JKNonCodeElementsListOwner.containsNewLine(): Boolean = + (leftNonCodeElements + rightNonCodeElements).any { + it is JKSpaceElement && '\n' in it.text + } \ No newline at end of file diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts index e987a3b3ab1..12af8ecec0d 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/GenerateJKTreeVisitorAndTransformer.kts @@ -49,7 +49,7 @@ import java.io.File -val JK_ROOT = File("./j2k/newSrc/org/jetbrains/kotlin/j2k/tree") +val JK_ROOT = File("./nj2k/src/org/jetbrains/kotlin/nj2k/tree") val JK_OUT_ROOT = File(JK_ROOT, "visitors") @@ -58,17 +58,17 @@ val JK_JAVA_FILE = File(JK_ROOT, "j.kt") val JK_COMMON_FILE = File(JK_ROOT, "jk.kt") -val interfaceRegex = "interface (JK[a-zA-Z]+)\\s?:?\\s?(JK[a-zA-Z]+)?".toRegex() +val interfaceRegex = "(interface|abstract class)\\s+(JK[a-zA-Z]+)\\s+?:?\\s+(JK[a-zA-Z]+)?".toRegex() data class InterfaceData(val name: String, val extends: String?) fun File.interfaceNames() = - sequenceOf(this) - .map { it.readText() } - .flatMap { interfaceRegex.findAll(it) } - .map { match -> InterfaceData(match.groupValues[1], match.groupValues.getOrNull(2)) } - .toList() + sequenceOf(this) + .map { it.readText() } + .flatMap { interfaceRegex.findAll(it) } + .map { match -> InterfaceData(match.groupValues[2], match.groupValues.getOrNull(3)) } + .toList() fun String.safeVarName() = when (this) { @@ -129,6 +129,41 @@ fun genVisitors(commonData: List, uncommonData: List + val nameWithoutPrefix = name.removePrefix("JK") + val argName = nameWithoutPrefix.decapitalize().safeVarName() + val arg = "$argName: $name" + val rawVisitSuffix = "Raw" + val generifyCall = if (name != "JKTreeElement") "= visit${ext!!.removePrefix("JK")}$rawVisitSuffix($argName)" else "" + """ + | override fun visit$nameWithoutPrefix($arg) { + | printLeftNonCodeElements($argName) + | visit$nameWithoutPrefix$rawVisitSuffix($argName) + | printRightNonCodeElements($argName) + | } + | + | fun visit$nameWithoutPrefix$rawVisitSuffix($arg) $generifyCall + """.trimMargin() + } + appendln() + appendln("}") + }) + /*File(JK_OUT_ROOT, "$transformerName.kt").writeText(buildString { appendln(pkg) appendln() diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt index b35c0dccb5a..71ad9e5aad5 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt @@ -18,6 +18,11 @@ interface JKVisitor { fun visitVariable(variable: JKVariable, data: D): R = visitDeclaration(variable, data) fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: D): R = visitVariable(forLoopVariable, data) fun visitLocalVariable(localVariable: JKLocalVariable, data: D): R = visitVariable(localVariable, data) + fun visitModifierElement(modifierElement: JKModifierElement, data: D): R = visitTreeElement(modifierElement, data) + fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: D): R = visitModifierElement(mutabilityModifierElement, data) + fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: D): R = visitModifierElement(modalityModifierElement, data) + fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: D): R = visitModifierElement(visibilityModifierElement, data) + fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: D): R = visitModifierElement(extraModifierElement, data) fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: D): R = visitModifiersListOwner(extraModifiersOwner, data) fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner, data: D): R = visitModifiersListOwner(visibilityOwner, data) fun visitModalityOwner(modalityOwner: JKModalityOwner, data: D): R = visitModifiersListOwner(modalityOwner, data) @@ -26,6 +31,7 @@ interface JKVisitor { fun visitTypeElement(typeElement: JKTypeElement, data: D): R = visitTreeElement(typeElement, data) fun visitStatement(statement: JKStatement, data: D): R = visitTreeElement(statement, data) fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data) + fun visitBodyStub(bodyStub: JKBodyStub, data: D): R = visitBlock(bodyStub, data) fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitTreeElement(identifier, data) fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data) fun visitExpression(expression: JKExpression, data: D): R = visitTreeElement(expression, data) @@ -113,7 +119,7 @@ interface JKVisitor { fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter, data: D): R = visitKtGetterOrSetter(ktEmptyGetterOrSetter, data) fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, data) fun visitKtFunction(ktFunction: JKKtFunction, data: D): R = visitMethod(ktFunction, data) - fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitDeclaration(ktConstructor, data) + fun visitKtConstructor(ktConstructor: JKKtConstructor, data: D): R = visitMethod(ktConstructor, data) fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: D): R = visitKtConstructor(ktPrimaryConstructor, data) fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement, data: D): R = visitStatement(ktAssignmentStatement, data) fun visitKtCall(ktCall: JKKtCall, data: D): R = visitMethodCallExpression(ktCall, data) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt index 4756110b229..d84aa8a39da 100644 --- a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt @@ -33,6 +33,16 @@ interface JKVisitorVoid : JKVisitor { override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable, data: Nothing?) = visitForLoopVariable(forLoopVariable) fun visitLocalVariable(localVariable: JKLocalVariable) = visitVariable(localVariable, null) override fun visitLocalVariable(localVariable: JKLocalVariable, data: Nothing?) = visitLocalVariable(localVariable) + fun visitModifierElement(modifierElement: JKModifierElement) = visitTreeElement(modifierElement, null) + override fun visitModifierElement(modifierElement: JKModifierElement, data: Nothing?) = visitModifierElement(modifierElement) + fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) = visitModifierElement(mutabilityModifierElement, null) + override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement, data: Nothing?) = visitMutabilityModifierElement(mutabilityModifierElement) + fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) = visitModifierElement(modalityModifierElement, null) + override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement, data: Nothing?) = visitModalityModifierElement(modalityModifierElement) + fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElement(visibilityModifierElement, null) + override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement, data: Nothing?) = visitVisibilityModifierElement(visibilityModifierElement) + fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement) = visitModifierElement(extraModifierElement, null) + override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement, data: Nothing?) = visitExtraModifierElement(extraModifierElement) fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwner(extraModifiersOwner, null) override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner, data: Nothing?) = visitExtraModifiersOwner(extraModifiersOwner) fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwner(visibilityOwner, null) @@ -49,6 +59,8 @@ interface JKVisitorVoid : JKVisitor { override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement) fun visitBlock(block: JKBlock) = visitTreeElement(block, null) override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block) + fun visitBodyStub(bodyStub: JKBodyStub) = visitBlock(bodyStub, null) + override fun visitBodyStub(bodyStub: JKBodyStub, data: Nothing?) = visitBodyStub(bodyStub) fun visitIdentifier(identifier: JKIdentifier) = visitTreeElement(identifier, null) override fun visitIdentifier(identifier: JKIdentifier, data: Nothing?) = visitIdentifier(identifier) fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) = visitIdentifier(nameIdentifier, null) @@ -223,7 +235,7 @@ interface JKVisitorVoid : JKVisitor { override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty) fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null) override fun visitKtFunction(ktFunction: JKKtFunction, data: Nothing?) = visitKtFunction(ktFunction) - fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitDeclaration(ktConstructor, null) + fun visitKtConstructor(ktConstructor: JKKtConstructor) = visitMethod(ktConstructor, null) override fun visitKtConstructor(ktConstructor: JKKtConstructor, data: Nothing?) = visitKtConstructor(ktConstructor) fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructor(ktPrimaryConstructor, null) override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor, data: Nothing?) = visitKtPrimaryConstructor(ktPrimaryConstructor) diff --git a/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt new file mode 100644 index 00000000000..174c9ac78ee --- /dev/null +++ b/nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorWithCommentsPrinting.kt @@ -0,0 +1,1088 @@ +package org.jetbrains.kotlin.nj2k.tree.visitors + +import org.jetbrains.kotlin.nj2k.tree.* + +interface JKVisitorWithCommentsPrinting : JKVisitorVoid { + fun printLeftNonCodeElements(element: JKNonCodeElementsListOwner) + fun printRightNonCodeElements(element: JKNonCodeElementsListOwner) + + override fun visitTreeElement(treeElement: JKTreeElement) { + printLeftNonCodeElements(treeElement) + visitTreeElementRaw(treeElement) + printRightNonCodeElements(treeElement) + } + + fun visitTreeElementRaw(treeElement: JKTreeElement) + + override fun visitDeclaration(declaration: JKDeclaration) { + printLeftNonCodeElements(declaration) + visitDeclarationRaw(declaration) + printRightNonCodeElements(declaration) + } + + fun visitDeclarationRaw(declaration: JKDeclaration) = visitTreeElementRaw(declaration) + + override fun visitImportStatement(importStatement: JKImportStatement) { + printLeftNonCodeElements(importStatement) + visitImportStatementRaw(importStatement) + printRightNonCodeElements(importStatement) + } + + fun visitImportStatementRaw(importStatement: JKImportStatement) = visitTreeElementRaw(importStatement) + + override fun visitFile(file: JKFile) { + printLeftNonCodeElements(file) + visitFileRaw(file) + printRightNonCodeElements(file) + } + + fun visitFileRaw(file: JKFile) = visitTreeElementRaw(file) + + override fun visitClass(klass: JKClass) { + printLeftNonCodeElements(klass) + visitClassRaw(klass) + printRightNonCodeElements(klass) + } + + fun visitClassRaw(klass: JKClass) = visitDeclarationRaw(klass) + + override fun visitInheritanceInfo(inheritanceInfo: JKInheritanceInfo) { + printLeftNonCodeElements(inheritanceInfo) + visitInheritanceInfoRaw(inheritanceInfo) + printRightNonCodeElements(inheritanceInfo) + } + + fun visitInheritanceInfoRaw(inheritanceInfo: JKInheritanceInfo) = visitTreeElementRaw(inheritanceInfo) + + override fun visitAnnotationList(annotationList: JKAnnotationList) { + printLeftNonCodeElements(annotationList) + visitAnnotationListRaw(annotationList) + printRightNonCodeElements(annotationList) + } + + fun visitAnnotationListRaw(annotationList: JKAnnotationList) = visitTreeElementRaw(annotationList) + + override fun visitAnnotation(annotation: JKAnnotation) { + printLeftNonCodeElements(annotation) + visitAnnotationRaw(annotation) + printRightNonCodeElements(annotation) + } + + fun visitAnnotationRaw(annotation: JKAnnotation) = visitAnnotationMemberValueRaw(annotation) + + override fun visitAnnotationParameter(annotationParameter: JKAnnotationParameter) { + printLeftNonCodeElements(annotationParameter) + visitAnnotationParameterRaw(annotationParameter) + printRightNonCodeElements(annotationParameter) + } + + fun visitAnnotationParameterRaw(annotationParameter: JKAnnotationParameter) = visitTreeElementRaw(annotationParameter) + + override fun visitAnnotationNameParameter(annotationNameParameter: JKAnnotationNameParameter) { + printLeftNonCodeElements(annotationNameParameter) + visitAnnotationNameParameterRaw(annotationNameParameter) + printRightNonCodeElements(annotationNameParameter) + } + + fun visitAnnotationNameParameterRaw(annotationNameParameter: JKAnnotationNameParameter) = visitAnnotationParameterRaw(annotationNameParameter) + + override fun visitAnnotationListOwner(annotationListOwner: JKAnnotationListOwner) { + printLeftNonCodeElements(annotationListOwner) + visitAnnotationListOwnerRaw(annotationListOwner) + printRightNonCodeElements(annotationListOwner) + } + + fun visitAnnotationListOwnerRaw(annotationListOwner: JKAnnotationListOwner) = visitTreeElementRaw(annotationListOwner) + + override fun visitMethod(method: JKMethod) { + printLeftNonCodeElements(method) + visitMethodRaw(method) + printRightNonCodeElements(method) + } + + fun visitMethodRaw(method: JKMethod) = visitDeclarationRaw(method) + + override fun visitVariable(variable: JKVariable) { + printLeftNonCodeElements(variable) + visitVariableRaw(variable) + printRightNonCodeElements(variable) + } + + fun visitVariableRaw(variable: JKVariable) = visitDeclarationRaw(variable) + + override fun visitForLoopVariable(forLoopVariable: JKForLoopVariable) { + printLeftNonCodeElements(forLoopVariable) + visitForLoopVariableRaw(forLoopVariable) + printRightNonCodeElements(forLoopVariable) + } + + fun visitForLoopVariableRaw(forLoopVariable: JKForLoopVariable) = visitVariableRaw(forLoopVariable) + + override fun visitLocalVariable(localVariable: JKLocalVariable) { + printLeftNonCodeElements(localVariable) + visitLocalVariableRaw(localVariable) + printRightNonCodeElements(localVariable) + } + + fun visitLocalVariableRaw(localVariable: JKLocalVariable) = visitVariableRaw(localVariable) + + override fun visitModifierElement(modifierElement: JKModifierElement) { + printLeftNonCodeElements(modifierElement) + visitModifierElementRaw(modifierElement) + printRightNonCodeElements(modifierElement) + } + + fun visitModifierElementRaw(modifierElement: JKModifierElement) = visitTreeElementRaw(modifierElement) + + override fun visitMutabilityModifierElement(mutabilityModifierElement: JKMutabilityModifierElement) { + printLeftNonCodeElements(mutabilityModifierElement) + visitMutabilityModifierElementRaw(mutabilityModifierElement) + printRightNonCodeElements(mutabilityModifierElement) + } + + fun visitMutabilityModifierElementRaw(mutabilityModifierElement: JKMutabilityModifierElement) = visitModifierElementRaw(mutabilityModifierElement) + + override fun visitModalityModifierElement(modalityModifierElement: JKModalityModifierElement) { + printLeftNonCodeElements(modalityModifierElement) + visitModalityModifierElementRaw(modalityModifierElement) + printRightNonCodeElements(modalityModifierElement) + } + + fun visitModalityModifierElementRaw(modalityModifierElement: JKModalityModifierElement) = visitModifierElementRaw(modalityModifierElement) + + override fun visitVisibilityModifierElement(visibilityModifierElement: JKVisibilityModifierElement) { + printLeftNonCodeElements(visibilityModifierElement) + visitVisibilityModifierElementRaw(visibilityModifierElement) + printRightNonCodeElements(visibilityModifierElement) + } + + fun visitVisibilityModifierElementRaw(visibilityModifierElement: JKVisibilityModifierElement) = visitModifierElementRaw(visibilityModifierElement) + + override fun visitExtraModifierElement(extraModifierElement: JKExtraModifierElement) { + printLeftNonCodeElements(extraModifierElement) + visitExtraModifierElementRaw(extraModifierElement) + printRightNonCodeElements(extraModifierElement) + } + + fun visitExtraModifierElementRaw(extraModifierElement: JKExtraModifierElement) = visitModifierElementRaw(extraModifierElement) + + override fun visitExtraModifiersOwner(extraModifiersOwner: JKExtraModifiersOwner) { + printLeftNonCodeElements(extraModifiersOwner) + visitExtraModifiersOwnerRaw(extraModifiersOwner) + printRightNonCodeElements(extraModifiersOwner) + } + + fun visitExtraModifiersOwnerRaw(extraModifiersOwner: JKExtraModifiersOwner) = visitModifiersListOwnerRaw(extraModifiersOwner) + + override fun visitVisibilityOwner(visibilityOwner: JKVisibilityOwner) { + printLeftNonCodeElements(visibilityOwner) + visitVisibilityOwnerRaw(visibilityOwner) + printRightNonCodeElements(visibilityOwner) + } + + fun visitVisibilityOwnerRaw(visibilityOwner: JKVisibilityOwner) = visitModifiersListOwnerRaw(visibilityOwner) + + override fun visitModalityOwner(modalityOwner: JKModalityOwner) { + printLeftNonCodeElements(modalityOwner) + visitModalityOwnerRaw(modalityOwner) + printRightNonCodeElements(modalityOwner) + } + + fun visitModalityOwnerRaw(modalityOwner: JKModalityOwner) = visitModifiersListOwnerRaw(modalityOwner) + + override fun visitMutabilityOwner(mutabilityOwner: JKMutabilityOwner) { + printLeftNonCodeElements(mutabilityOwner) + visitMutabilityOwnerRaw(mutabilityOwner) + printRightNonCodeElements(mutabilityOwner) + } + + fun visitMutabilityOwnerRaw(mutabilityOwner: JKMutabilityOwner) = visitModifiersListOwnerRaw(mutabilityOwner) + + override fun visitModifiersListOwner(modifiersListOwner: JKModifiersListOwner) { + printLeftNonCodeElements(modifiersListOwner) + visitModifiersListOwnerRaw(modifiersListOwner) + printRightNonCodeElements(modifiersListOwner) + } + + fun visitModifiersListOwnerRaw(modifiersListOwner: JKModifiersListOwner) = visitTreeElementRaw(modifiersListOwner) + + override fun visitTypeElement(typeElement: JKTypeElement) { + printLeftNonCodeElements(typeElement) + visitTypeElementRaw(typeElement) + printRightNonCodeElements(typeElement) + } + + fun visitTypeElementRaw(typeElement: JKTypeElement) = visitTreeElementRaw(typeElement) + + override fun visitStatement(statement: JKStatement) { + printLeftNonCodeElements(statement) + visitStatementRaw(statement) + printRightNonCodeElements(statement) + } + + fun visitStatementRaw(statement: JKStatement) = visitTreeElementRaw(statement) + + override fun visitBlock(block: JKBlock) { + printLeftNonCodeElements(block) + visitBlockRaw(block) + printRightNonCodeElements(block) + } + + fun visitBlockRaw(block: JKBlock) = visitTreeElementRaw(block) + + override fun visitBodyStub(bodyStub: JKBodyStub) { + printLeftNonCodeElements(bodyStub) + visitBodyStubRaw(bodyStub) + printRightNonCodeElements(bodyStub) + } + + fun visitBodyStubRaw(bodyStub: JKBodyStub) = visitBlockRaw(bodyStub) + + override fun visitIdentifier(identifier: JKIdentifier) { + printLeftNonCodeElements(identifier) + visitIdentifierRaw(identifier) + printRightNonCodeElements(identifier) + } + + fun visitIdentifierRaw(identifier: JKIdentifier) = visitTreeElementRaw(identifier) + + override fun visitNameIdentifier(nameIdentifier: JKNameIdentifier) { + printLeftNonCodeElements(nameIdentifier) + visitNameIdentifierRaw(nameIdentifier) + printRightNonCodeElements(nameIdentifier) + } + + fun visitNameIdentifierRaw(nameIdentifier: JKNameIdentifier) = visitIdentifierRaw(nameIdentifier) + + override fun visitExpression(expression: JKExpression) { + printLeftNonCodeElements(expression) + visitExpressionRaw(expression) + printRightNonCodeElements(expression) + } + + fun visitExpressionRaw(expression: JKExpression) = visitTreeElementRaw(expression) + + override fun visitExpressionStatement(expressionStatement: JKExpressionStatement) { + printLeftNonCodeElements(expressionStatement) + visitExpressionStatementRaw(expressionStatement) + printRightNonCodeElements(expressionStatement) + } + + fun visitExpressionStatementRaw(expressionStatement: JKExpressionStatement) = visitStatementRaw(expressionStatement) + + override fun visitDeclarationStatement(declarationStatement: JKDeclarationStatement) { + printLeftNonCodeElements(declarationStatement) + visitDeclarationStatementRaw(declarationStatement) + printRightNonCodeElements(declarationStatement) + } + + fun visitDeclarationStatementRaw(declarationStatement: JKDeclarationStatement) = visitStatementRaw(declarationStatement) + + override fun visitOperatorExpression(operatorExpression: JKOperatorExpression) { + printLeftNonCodeElements(operatorExpression) + visitOperatorExpressionRaw(operatorExpression) + printRightNonCodeElements(operatorExpression) + } + + fun visitOperatorExpressionRaw(operatorExpression: JKOperatorExpression) = visitExpressionRaw(operatorExpression) + + override fun visitBinaryExpression(binaryExpression: JKBinaryExpression) { + printLeftNonCodeElements(binaryExpression) + visitBinaryExpressionRaw(binaryExpression) + printRightNonCodeElements(binaryExpression) + } + + fun visitBinaryExpressionRaw(binaryExpression: JKBinaryExpression) = visitOperatorExpressionRaw(binaryExpression) + + override fun visitUnaryExpression(unaryExpression: JKUnaryExpression) { + printLeftNonCodeElements(unaryExpression) + visitUnaryExpressionRaw(unaryExpression) + printRightNonCodeElements(unaryExpression) + } + + fun visitUnaryExpressionRaw(unaryExpression: JKUnaryExpression) = visitOperatorExpressionRaw(unaryExpression) + + override fun visitPrefixExpression(prefixExpression: JKPrefixExpression) { + printLeftNonCodeElements(prefixExpression) + visitPrefixExpressionRaw(prefixExpression) + printRightNonCodeElements(prefixExpression) + } + + fun visitPrefixExpressionRaw(prefixExpression: JKPrefixExpression) = visitUnaryExpressionRaw(prefixExpression) + + override fun visitPostfixExpression(postfixExpression: JKPostfixExpression) { + printLeftNonCodeElements(postfixExpression) + visitPostfixExpressionRaw(postfixExpression) + printRightNonCodeElements(postfixExpression) + } + + fun visitPostfixExpressionRaw(postfixExpression: JKPostfixExpression) = visitUnaryExpressionRaw(postfixExpression) + + override fun visitQualifiedExpression(qualifiedExpression: JKQualifiedExpression) { + printLeftNonCodeElements(qualifiedExpression) + visitQualifiedExpressionRaw(qualifiedExpression) + printRightNonCodeElements(qualifiedExpression) + } + + fun visitQualifiedExpressionRaw(qualifiedExpression: JKQualifiedExpression) = visitExpressionRaw(qualifiedExpression) + + override fun visitTypeArgumentList(typeArgumentList: JKTypeArgumentList) { + printLeftNonCodeElements(typeArgumentList) + visitTypeArgumentListRaw(typeArgumentList) + printRightNonCodeElements(typeArgumentList) + } + + fun visitTypeArgumentListRaw(typeArgumentList: JKTypeArgumentList) = visitTreeElementRaw(typeArgumentList) + + override fun visitTypeArgumentListOwner(typeArgumentListOwner: JKTypeArgumentListOwner) { + printLeftNonCodeElements(typeArgumentListOwner) + visitTypeArgumentListOwnerRaw(typeArgumentListOwner) + printRightNonCodeElements(typeArgumentListOwner) + } + + fun visitTypeArgumentListOwnerRaw(typeArgumentListOwner: JKTypeArgumentListOwner) = visitTreeElementRaw(typeArgumentListOwner) + + override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) { + printLeftNonCodeElements(methodCallExpression) + visitMethodCallExpressionRaw(methodCallExpression) + printRightNonCodeElements(methodCallExpression) + } + + fun visitMethodCallExpressionRaw(methodCallExpression: JKMethodCallExpression) = visitExpressionRaw(methodCallExpression) + + override fun visitFieldAccessExpression(fieldAccessExpression: JKFieldAccessExpression) { + printLeftNonCodeElements(fieldAccessExpression) + visitFieldAccessExpressionRaw(fieldAccessExpression) + printRightNonCodeElements(fieldAccessExpression) + } + + fun visitFieldAccessExpressionRaw(fieldAccessExpression: JKFieldAccessExpression) = visitAssignableExpressionRaw(fieldAccessExpression) + + override fun visitClassAccessExpression(classAccessExpression: JKClassAccessExpression) { + printLeftNonCodeElements(classAccessExpression) + visitClassAccessExpressionRaw(classAccessExpression) + printRightNonCodeElements(classAccessExpression) + } + + fun visitClassAccessExpressionRaw(classAccessExpression: JKClassAccessExpression) = visitExpressionRaw(classAccessExpression) + + override fun visitArrayAccessExpression(arrayAccessExpression: JKArrayAccessExpression) { + printLeftNonCodeElements(arrayAccessExpression) + visitArrayAccessExpressionRaw(arrayAccessExpression) + printRightNonCodeElements(arrayAccessExpression) + } + + fun visitArrayAccessExpressionRaw(arrayAccessExpression: JKArrayAccessExpression) = visitAssignableExpressionRaw(arrayAccessExpression) + + override fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression) { + printLeftNonCodeElements(parenthesizedExpression) + visitParenthesizedExpressionRaw(parenthesizedExpression) + printRightNonCodeElements(parenthesizedExpression) + } + + fun visitParenthesizedExpressionRaw(parenthesizedExpression: JKParenthesizedExpression) = visitExpressionRaw(parenthesizedExpression) + + override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression) { + printLeftNonCodeElements(typeCastExpression) + visitTypeCastExpressionRaw(typeCastExpression) + printRightNonCodeElements(typeCastExpression) + } + + fun visitTypeCastExpressionRaw(typeCastExpression: JKTypeCastExpression) = visitExpressionRaw(typeCastExpression) + + override fun visitExpressionList(expressionList: JKExpressionList) { + printLeftNonCodeElements(expressionList) + visitExpressionListRaw(expressionList) + printRightNonCodeElements(expressionList) + } + + fun visitExpressionListRaw(expressionList: JKExpressionList) = visitTreeElementRaw(expressionList) + + override fun visitArgument(argument: JKArgument) { + printLeftNonCodeElements(argument) + visitArgumentRaw(argument) + printRightNonCodeElements(argument) + } + + fun visitArgumentRaw(argument: JKArgument) = visitTreeElementRaw(argument) + + override fun visitNamedArgument(namedArgument: JKNamedArgument) { + printLeftNonCodeElements(namedArgument) + visitNamedArgumentRaw(namedArgument) + printRightNonCodeElements(namedArgument) + } + + fun visitNamedArgumentRaw(namedArgument: JKNamedArgument) = visitArgumentRaw(namedArgument) + + override fun visitArgumentList(argumentList: JKArgumentList) { + printLeftNonCodeElements(argumentList) + visitArgumentListRaw(argumentList) + printRightNonCodeElements(argumentList) + } + + fun visitArgumentListRaw(argumentList: JKArgumentList) = visitTreeElementRaw(argumentList) + + override fun visitLiteralExpression(literalExpression: JKLiteralExpression) { + printLeftNonCodeElements(literalExpression) + visitLiteralExpressionRaw(literalExpression) + printRightNonCodeElements(literalExpression) + } + + fun visitLiteralExpressionRaw(literalExpression: JKLiteralExpression) = visitExpressionRaw(literalExpression) + + override fun visitParameter(parameter: JKParameter) { + printLeftNonCodeElements(parameter) + visitParameterRaw(parameter) + printRightNonCodeElements(parameter) + } + + fun visitParameterRaw(parameter: JKParameter) = visitVariableRaw(parameter) + + override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression) { + printLeftNonCodeElements(stringLiteralExpression) + visitStringLiteralExpressionRaw(stringLiteralExpression) + printRightNonCodeElements(stringLiteralExpression) + } + + fun visitStringLiteralExpressionRaw(stringLiteralExpression: JKStringLiteralExpression) = visitLiteralExpressionRaw(stringLiteralExpression) + + override fun visitStubExpression(stubExpression: JKStubExpression) { + printLeftNonCodeElements(stubExpression) + visitStubExpressionRaw(stubExpression) + printRightNonCodeElements(stubExpression) + } + + fun visitStubExpressionRaw(stubExpression: JKStubExpression) = visitExpressionRaw(stubExpression) + + override fun visitLoopStatement(loopStatement: JKLoopStatement) { + printLeftNonCodeElements(loopStatement) + visitLoopStatementRaw(loopStatement) + printRightNonCodeElements(loopStatement) + } + + fun visitLoopStatementRaw(loopStatement: JKLoopStatement) = visitStatementRaw(loopStatement) + + override fun visitBlockStatement(blockStatement: JKBlockStatement) { + printLeftNonCodeElements(blockStatement) + visitBlockStatementRaw(blockStatement) + printRightNonCodeElements(blockStatement) + } + + fun visitBlockStatementRaw(blockStatement: JKBlockStatement) = visitStatementRaw(blockStatement) + + override fun visitBlockStatementWithoutBrackets(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) { + printLeftNonCodeElements(blockStatementWithoutBrackets) + visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets) + printRightNonCodeElements(blockStatementWithoutBrackets) + } + + fun visitBlockStatementWithoutBracketsRaw(blockStatementWithoutBrackets: JKBlockStatementWithoutBrackets) = visitStatementRaw(blockStatementWithoutBrackets) + + override fun visitThisExpression(thisExpression: JKThisExpression) { + printLeftNonCodeElements(thisExpression) + visitThisExpressionRaw(thisExpression) + printRightNonCodeElements(thisExpression) + } + + fun visitThisExpressionRaw(thisExpression: JKThisExpression) = visitExpressionRaw(thisExpression) + + override fun visitSuperExpression(superExpression: JKSuperExpression) { + printLeftNonCodeElements(superExpression) + visitSuperExpressionRaw(superExpression) + printRightNonCodeElements(superExpression) + } + + fun visitSuperExpressionRaw(superExpression: JKSuperExpression) = visitExpressionRaw(superExpression) + + override fun visitWhileStatement(whileStatement: JKWhileStatement) { + printLeftNonCodeElements(whileStatement) + visitWhileStatementRaw(whileStatement) + printRightNonCodeElements(whileStatement) + } + + fun visitWhileStatementRaw(whileStatement: JKWhileStatement) = visitLoopStatementRaw(whileStatement) + + override fun visitDoWhileStatement(doWhileStatement: JKDoWhileStatement) { + printLeftNonCodeElements(doWhileStatement) + visitDoWhileStatementRaw(doWhileStatement) + printRightNonCodeElements(doWhileStatement) + } + + fun visitDoWhileStatementRaw(doWhileStatement: JKDoWhileStatement) = visitLoopStatementRaw(doWhileStatement) + + override fun visitBreakStatement(breakStatement: JKBreakStatement) { + printLeftNonCodeElements(breakStatement) + visitBreakStatementRaw(breakStatement) + printRightNonCodeElements(breakStatement) + } + + fun visitBreakStatementRaw(breakStatement: JKBreakStatement) = visitStatementRaw(breakStatement) + + override fun visitBreakWithLabelStatement(breakWithLabelStatement: JKBreakWithLabelStatement) { + printLeftNonCodeElements(breakWithLabelStatement) + visitBreakWithLabelStatementRaw(breakWithLabelStatement) + printRightNonCodeElements(breakWithLabelStatement) + } + + fun visitBreakWithLabelStatementRaw(breakWithLabelStatement: JKBreakWithLabelStatement) = visitBreakStatementRaw(breakWithLabelStatement) + + override fun visitIfStatement(ifStatement: JKIfStatement) { + printLeftNonCodeElements(ifStatement) + visitIfStatementRaw(ifStatement) + printRightNonCodeElements(ifStatement) + } + + fun visitIfStatementRaw(ifStatement: JKIfStatement) = visitStatementRaw(ifStatement) + + override fun visitIfElseStatement(ifElseStatement: JKIfElseStatement) { + printLeftNonCodeElements(ifElseStatement) + visitIfElseStatementRaw(ifElseStatement) + printRightNonCodeElements(ifElseStatement) + } + + fun visitIfElseStatementRaw(ifElseStatement: JKIfElseStatement) = visitIfStatementRaw(ifElseStatement) + + override fun visitIfElseExpression(ifElseExpression: JKIfElseExpression) { + printLeftNonCodeElements(ifElseExpression) + visitIfElseExpressionRaw(ifElseExpression) + printRightNonCodeElements(ifElseExpression) + } + + fun visitIfElseExpressionRaw(ifElseExpression: JKIfElseExpression) = visitExpressionRaw(ifElseExpression) + + override fun visitAssignableExpression(assignableExpression: JKAssignableExpression) { + printLeftNonCodeElements(assignableExpression) + visitAssignableExpressionRaw(assignableExpression) + printRightNonCodeElements(assignableExpression) + } + + fun visitAssignableExpressionRaw(assignableExpression: JKAssignableExpression) = visitExpressionRaw(assignableExpression) + + override fun visitLambdaExpression(lambdaExpression: JKLambdaExpression) { + printLeftNonCodeElements(lambdaExpression) + visitLambdaExpressionRaw(lambdaExpression) + printRightNonCodeElements(lambdaExpression) + } + + fun visitLambdaExpressionRaw(lambdaExpression: JKLambdaExpression) = visitExpressionRaw(lambdaExpression) + + override fun visitDelegationConstructorCall(delegationConstructorCall: JKDelegationConstructorCall) { + printLeftNonCodeElements(delegationConstructorCall) + visitDelegationConstructorCallRaw(delegationConstructorCall) + printRightNonCodeElements(delegationConstructorCall) + } + + fun visitDelegationConstructorCallRaw(delegationConstructorCall: JKDelegationConstructorCall) = visitMethodCallExpressionRaw(delegationConstructorCall) + + override fun visitLabel(label: JKLabel) { + printLeftNonCodeElements(label) + visitLabelRaw(label) + printRightNonCodeElements(label) + } + + fun visitLabelRaw(label: JKLabel) = visitTreeElementRaw(label) + + override fun visitLabelEmpty(labelEmpty: JKLabelEmpty) { + printLeftNonCodeElements(labelEmpty) + visitLabelEmptyRaw(labelEmpty) + printRightNonCodeElements(labelEmpty) + } + + fun visitLabelEmptyRaw(labelEmpty: JKLabelEmpty) = visitLabelRaw(labelEmpty) + + override fun visitLabelText(labelText: JKLabelText) { + printLeftNonCodeElements(labelText) + visitLabelTextRaw(labelText) + printRightNonCodeElements(labelText) + } + + fun visitLabelTextRaw(labelText: JKLabelText) = visitLabelRaw(labelText) + + override fun visitContinueStatement(continueStatement: JKContinueStatement) { + printLeftNonCodeElements(continueStatement) + visitContinueStatementRaw(continueStatement) + printRightNonCodeElements(continueStatement) + } + + fun visitContinueStatementRaw(continueStatement: JKContinueStatement) = visitStatementRaw(continueStatement) + + override fun visitLabeledStatement(labeledStatement: JKLabeledStatement) { + printLeftNonCodeElements(labeledStatement) + visitLabeledStatementRaw(labeledStatement) + printRightNonCodeElements(labeledStatement) + } + + fun visitLabeledStatementRaw(labeledStatement: JKLabeledStatement) = visitExpressionRaw(labeledStatement) + + override fun visitEmptyStatement(emptyStatement: JKEmptyStatement) { + printLeftNonCodeElements(emptyStatement) + visitEmptyStatementRaw(emptyStatement) + printRightNonCodeElements(emptyStatement) + } + + fun visitEmptyStatementRaw(emptyStatement: JKEmptyStatement) = visitStatementRaw(emptyStatement) + + override fun visitTypeParameterList(typeParameterList: JKTypeParameterList) { + printLeftNonCodeElements(typeParameterList) + visitTypeParameterListRaw(typeParameterList) + printRightNonCodeElements(typeParameterList) + } + + fun visitTypeParameterListRaw(typeParameterList: JKTypeParameterList) = visitTreeElementRaw(typeParameterList) + + override fun visitTypeParameter(typeParameter: JKTypeParameter) { + printLeftNonCodeElements(typeParameter) + visitTypeParameterRaw(typeParameter) + printRightNonCodeElements(typeParameter) + } + + fun visitTypeParameterRaw(typeParameter: JKTypeParameter) = visitTreeElementRaw(typeParameter) + + override fun visitTypeParameterListOwner(typeParameterListOwner: JKTypeParameterListOwner) { + printLeftNonCodeElements(typeParameterListOwner) + visitTypeParameterListOwnerRaw(typeParameterListOwner) + printRightNonCodeElements(typeParameterListOwner) + } + + fun visitTypeParameterListOwnerRaw(typeParameterListOwner: JKTypeParameterListOwner) = visitTreeElementRaw(typeParameterListOwner) + + override fun visitEnumConstant(enumConstant: JKEnumConstant) { + printLeftNonCodeElements(enumConstant) + visitEnumConstantRaw(enumConstant) + printRightNonCodeElements(enumConstant) + } + + fun visitEnumConstantRaw(enumConstant: JKEnumConstant) = visitVariableRaw(enumConstant) + + override fun visitForInStatement(forInStatement: JKForInStatement) { + printLeftNonCodeElements(forInStatement) + visitForInStatementRaw(forInStatement) + printRightNonCodeElements(forInStatement) + } + + fun visitForInStatementRaw(forInStatement: JKForInStatement) = visitStatementRaw(forInStatement) + + override fun visitPackageDeclaration(packageDeclaration: JKPackageDeclaration) { + printLeftNonCodeElements(packageDeclaration) + visitPackageDeclarationRaw(packageDeclaration) + printRightNonCodeElements(packageDeclaration) + } + + fun visitPackageDeclarationRaw(packageDeclaration: JKPackageDeclaration) = visitDeclarationRaw(packageDeclaration) + + override fun visitClassLiteralExpression(classLiteralExpression: JKClassLiteralExpression) { + printLeftNonCodeElements(classLiteralExpression) + visitClassLiteralExpressionRaw(classLiteralExpression) + printRightNonCodeElements(classLiteralExpression) + } + + fun visitClassLiteralExpressionRaw(classLiteralExpression: JKClassLiteralExpression) = visitExpressionRaw(classLiteralExpression) + + override fun visitAnnotationMemberValue(annotationMemberValue: JKAnnotationMemberValue) { + printLeftNonCodeElements(annotationMemberValue) + visitAnnotationMemberValueRaw(annotationMemberValue) + printRightNonCodeElements(annotationMemberValue) + } + + fun visitAnnotationMemberValueRaw(annotationMemberValue: JKAnnotationMemberValue) = visitTreeElementRaw(annotationMemberValue) + + override fun visitField(field: JKField) { + printLeftNonCodeElements(field) + visitFieldRaw(field) + printRightNonCodeElements(field) + } + + fun visitFieldRaw(field: JKField) = visitVariableRaw(field) + + override fun visitJavaField(javaField: JKJavaField) { + printLeftNonCodeElements(javaField) + visitJavaFieldRaw(javaField) + printRightNonCodeElements(javaField) + } + + fun visitJavaFieldRaw(javaField: JKJavaField) = visitFieldRaw(javaField) + + override fun visitJavaMethod(javaMethod: JKJavaMethod) { + printLeftNonCodeElements(javaMethod) + visitJavaMethodRaw(javaMethod) + printRightNonCodeElements(javaMethod) + } + + fun visitJavaMethodRaw(javaMethod: JKJavaMethod) = visitMethodRaw(javaMethod) + + override fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) { + printLeftNonCodeElements(javaMethodCallExpression) + visitJavaMethodCallExpressionRaw(javaMethodCallExpression) + printRightNonCodeElements(javaMethodCallExpression) + } + + fun visitJavaMethodCallExpressionRaw(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpressionRaw(javaMethodCallExpression) + + override fun visitClassBody(classBody: JKClassBody) { + printLeftNonCodeElements(classBody) + visitClassBodyRaw(classBody) + printRightNonCodeElements(classBody) + } + + fun visitClassBodyRaw(classBody: JKClassBody) = visitTreeElementRaw(classBody) + + override fun visitEmptyClassBody(emptyClassBody: JKEmptyClassBody) { + printLeftNonCodeElements(emptyClassBody) + visitEmptyClassBodyRaw(emptyClassBody) + printRightNonCodeElements(emptyClassBody) + } + + fun visitEmptyClassBodyRaw(emptyClassBody: JKEmptyClassBody) = visitClassBodyRaw(emptyClassBody) + + override fun visitJavaNewExpression(javaNewExpression: JKJavaNewExpression) { + printLeftNonCodeElements(javaNewExpression) + visitJavaNewExpressionRaw(javaNewExpression) + printRightNonCodeElements(javaNewExpression) + } + + fun visitJavaNewExpressionRaw(javaNewExpression: JKJavaNewExpression) = visitExpressionRaw(javaNewExpression) + + override fun visitJavaDefaultNewExpression(javaDefaultNewExpression: JKJavaDefaultNewExpression) { + printLeftNonCodeElements(javaDefaultNewExpression) + visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression) + printRightNonCodeElements(javaDefaultNewExpression) + } + + fun visitJavaDefaultNewExpressionRaw(javaDefaultNewExpression: JKJavaDefaultNewExpression) = visitExpressionRaw(javaDefaultNewExpression) + + override fun visitJavaNewEmptyArray(javaNewEmptyArray: JKJavaNewEmptyArray) { + printLeftNonCodeElements(javaNewEmptyArray) + visitJavaNewEmptyArrayRaw(javaNewEmptyArray) + printRightNonCodeElements(javaNewEmptyArray) + } + + fun visitJavaNewEmptyArrayRaw(javaNewEmptyArray: JKJavaNewEmptyArray) = visitExpressionRaw(javaNewEmptyArray) + + override fun visitJavaNewArray(javaNewArray: JKJavaNewArray) { + printLeftNonCodeElements(javaNewArray) + visitJavaNewArrayRaw(javaNewArray) + printRightNonCodeElements(javaNewArray) + } + + fun visitJavaNewArrayRaw(javaNewArray: JKJavaNewArray) = visitExpressionRaw(javaNewArray) + + override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression) { + printLeftNonCodeElements(javaLiteralExpression) + visitJavaLiteralExpressionRaw(javaLiteralExpression) + printRightNonCodeElements(javaLiteralExpression) + } + + fun visitJavaLiteralExpressionRaw(javaLiteralExpression: JKJavaLiteralExpression) = visitLiteralExpressionRaw(javaLiteralExpression) + + override fun visitReturnStatement(returnStatement: JKReturnStatement) { + printLeftNonCodeElements(returnStatement) + visitReturnStatementRaw(returnStatement) + printRightNonCodeElements(returnStatement) + } + + fun visitReturnStatementRaw(returnStatement: JKReturnStatement) = visitStatementRaw(returnStatement) + + override fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement) { + printLeftNonCodeElements(javaAssertStatement) + visitJavaAssertStatementRaw(javaAssertStatement) + printRightNonCodeElements(javaAssertStatement) + } + + fun visitJavaAssertStatementRaw(javaAssertStatement: JKJavaAssertStatement) = visitStatementRaw(javaAssertStatement) + + override fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement) { + printLeftNonCodeElements(javaForLoopStatement) + visitJavaForLoopStatementRaw(javaForLoopStatement) + printRightNonCodeElements(javaForLoopStatement) + } + + fun visitJavaForLoopStatementRaw(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatementRaw(javaForLoopStatement) + + override fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression) { + printLeftNonCodeElements(javaPolyadicExpression) + visitJavaPolyadicExpressionRaw(javaPolyadicExpression) + printRightNonCodeElements(javaPolyadicExpression) + } + + fun visitJavaPolyadicExpressionRaw(javaPolyadicExpression: JKJavaPolyadicExpression) = visitExpressionRaw(javaPolyadicExpression) + + override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) { + printLeftNonCodeElements(javaAssignmentExpression) + visitJavaAssignmentExpressionRaw(javaAssignmentExpression) + printRightNonCodeElements(javaAssignmentExpression) + } + + fun visitJavaAssignmentExpressionRaw(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpressionRaw(javaAssignmentExpression) + + override fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement) { + printLeftNonCodeElements(javaThrowStatement) + visitJavaThrowStatementRaw(javaThrowStatement) + printRightNonCodeElements(javaThrowStatement) + } + + fun visitJavaThrowStatementRaw(javaThrowStatement: JKJavaThrowStatement) = visitStatementRaw(javaThrowStatement) + + override fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement) { + printLeftNonCodeElements(javaTryStatement) + visitJavaTryStatementRaw(javaTryStatement) + printRightNonCodeElements(javaTryStatement) + } + + fun visitJavaTryStatementRaw(javaTryStatement: JKJavaTryStatement) = visitStatementRaw(javaTryStatement) + + override fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection) { + printLeftNonCodeElements(javaTryCatchSection) + visitJavaTryCatchSectionRaw(javaTryCatchSection) + printRightNonCodeElements(javaTryCatchSection) + } + + fun visitJavaTryCatchSectionRaw(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElementRaw(javaTryCatchSection) + + override fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement) { + printLeftNonCodeElements(javaSwitchStatement) + visitJavaSwitchStatementRaw(javaSwitchStatement) + printRightNonCodeElements(javaSwitchStatement) + } + + fun visitJavaSwitchStatementRaw(javaSwitchStatement: JKJavaSwitchStatement) = visitStatementRaw(javaSwitchStatement) + + override fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase) { + printLeftNonCodeElements(javaSwitchCase) + visitJavaSwitchCaseRaw(javaSwitchCase) + printRightNonCodeElements(javaSwitchCase) + } + + fun visitJavaSwitchCaseRaw(javaSwitchCase: JKJavaSwitchCase) = visitTreeElementRaw(javaSwitchCase) + + override fun visitJavaDefaultSwitchCase(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) { + printLeftNonCodeElements(javaDefaultSwitchCase) + visitJavaDefaultSwitchCaseRaw(javaDefaultSwitchCase) + printRightNonCodeElements(javaDefaultSwitchCase) + } + + fun visitJavaDefaultSwitchCaseRaw(javaDefaultSwitchCase: JKJavaDefaultSwitchCase) = visitJavaSwitchCaseRaw(javaDefaultSwitchCase) + + override fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase) { + printLeftNonCodeElements(javaLabelSwitchCase) + visitJavaLabelSwitchCaseRaw(javaLabelSwitchCase) + printRightNonCodeElements(javaLabelSwitchCase) + } + + fun visitJavaLabelSwitchCaseRaw(javaLabelSwitchCase: JKJavaLabelSwitchCase) = visitJavaSwitchCaseRaw(javaLabelSwitchCase) + + override fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement) { + printLeftNonCodeElements(javaContinueStatement) + visitJavaContinueStatementRaw(javaContinueStatement) + printRightNonCodeElements(javaContinueStatement) + } + + fun visitJavaContinueStatementRaw(javaContinueStatement: JKJavaContinueStatement) = visitStatementRaw(javaContinueStatement) + + override fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement) { + printLeftNonCodeElements(javaSynchronizedStatement) + visitJavaSynchronizedStatementRaw(javaSynchronizedStatement) + printRightNonCodeElements(javaSynchronizedStatement) + } + + fun visitJavaSynchronizedStatementRaw(javaSynchronizedStatement: JKJavaSynchronizedStatement) = visitStatementRaw(javaSynchronizedStatement) + + override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) { + printLeftNonCodeElements(javaAnnotationMethod) + visitJavaAnnotationMethodRaw(javaAnnotationMethod) + printRightNonCodeElements(javaAnnotationMethod) + } + + fun visitJavaAnnotationMethodRaw(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethodRaw(javaAnnotationMethod) + + override fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) { + printLeftNonCodeElements(javaStaticInitDeclaration) + visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration) + printRightNonCodeElements(javaStaticInitDeclaration) + } + + fun visitJavaStaticInitDeclarationRaw(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclarationRaw(javaStaticInitDeclaration) + + override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) { + printLeftNonCodeElements(ktGetterOrSetter) + visitKtGetterOrSetterRaw(ktGetterOrSetter) + printRightNonCodeElements(ktGetterOrSetter) + } + + fun visitKtGetterOrSetterRaw(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElementRaw(ktGetterOrSetter) + + override fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) { + printLeftNonCodeElements(ktEmptyGetterOrSetter) + visitKtEmptyGetterOrSetterRaw(ktEmptyGetterOrSetter) + printRightNonCodeElements(ktEmptyGetterOrSetter) + } + + fun visitKtEmptyGetterOrSetterRaw(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetterRaw(ktEmptyGetterOrSetter) + + override fun visitKtProperty(ktProperty: JKKtProperty) { + printLeftNonCodeElements(ktProperty) + visitKtPropertyRaw(ktProperty) + printRightNonCodeElements(ktProperty) + } + + fun visitKtPropertyRaw(ktProperty: JKKtProperty) = visitFieldRaw(ktProperty) + + override fun visitKtFunction(ktFunction: JKKtFunction) { + printLeftNonCodeElements(ktFunction) + visitKtFunctionRaw(ktFunction) + printRightNonCodeElements(ktFunction) + } + + fun visitKtFunctionRaw(ktFunction: JKKtFunction) = visitMethodRaw(ktFunction) + + override fun visitKtConstructor(ktConstructor: JKKtConstructor) { + printLeftNonCodeElements(ktConstructor) + visitKtConstructorRaw(ktConstructor) + printRightNonCodeElements(ktConstructor) + } + + fun visitKtConstructorRaw(ktConstructor: JKKtConstructor) = visitMethodRaw(ktConstructor) + + override fun visitKtPrimaryConstructor(ktPrimaryConstructor: JKKtPrimaryConstructor) { + printLeftNonCodeElements(ktPrimaryConstructor) + visitKtPrimaryConstructorRaw(ktPrimaryConstructor) + printRightNonCodeElements(ktPrimaryConstructor) + } + + fun visitKtPrimaryConstructorRaw(ktPrimaryConstructor: JKKtPrimaryConstructor) = visitKtConstructorRaw(ktPrimaryConstructor) + + override fun visitKtAssignmentStatement(ktAssignmentStatement: JKKtAssignmentStatement) { + printLeftNonCodeElements(ktAssignmentStatement) + visitKtAssignmentStatementRaw(ktAssignmentStatement) + printRightNonCodeElements(ktAssignmentStatement) + } + + fun visitKtAssignmentStatementRaw(ktAssignmentStatement: JKKtAssignmentStatement) = visitStatementRaw(ktAssignmentStatement) + + override fun visitKtCall(ktCall: JKKtCall) { + printLeftNonCodeElements(ktCall) + visitKtCallRaw(ktCall) + printRightNonCodeElements(ktCall) + } + + fun visitKtCallRaw(ktCall: JKKtCall) = visitMethodCallExpressionRaw(ktCall) + + override fun visitKtMethodCallExpression(ktMethodCallExpression: JKKtMethodCallExpression) { + printLeftNonCodeElements(ktMethodCallExpression) + visitKtMethodCallExpressionRaw(ktMethodCallExpression) + printRightNonCodeElements(ktMethodCallExpression) + } + + fun visitKtMethodCallExpressionRaw(ktMethodCallExpression: JKKtMethodCallExpression) = visitMethodCallExpressionRaw(ktMethodCallExpression) + + override fun visitKtAlsoCallExpression(ktAlsoCallExpression: JKKtAlsoCallExpression) { + printLeftNonCodeElements(ktAlsoCallExpression) + visitKtAlsoCallExpressionRaw(ktAlsoCallExpression) + printRightNonCodeElements(ktAlsoCallExpression) + } + + fun visitKtAlsoCallExpressionRaw(ktAlsoCallExpression: JKKtAlsoCallExpression) = visitKtMethodCallExpressionRaw(ktAlsoCallExpression) + + override fun visitKtLiteralExpression(ktLiteralExpression: JKKtLiteralExpression) { + printLeftNonCodeElements(ktLiteralExpression) + visitKtLiteralExpressionRaw(ktLiteralExpression) + printRightNonCodeElements(ktLiteralExpression) + } + + fun visitKtLiteralExpressionRaw(ktLiteralExpression: JKKtLiteralExpression) = visitLiteralExpressionRaw(ktLiteralExpression) + + override fun visitKtWhenStatement(ktWhenStatement: JKKtWhenStatement) { + printLeftNonCodeElements(ktWhenStatement) + visitKtWhenStatementRaw(ktWhenStatement) + printRightNonCodeElements(ktWhenStatement) + } + + fun visitKtWhenStatementRaw(ktWhenStatement: JKKtWhenStatement) = visitStatementRaw(ktWhenStatement) + + override fun visitKtWhenCase(ktWhenCase: JKKtWhenCase) { + printLeftNonCodeElements(ktWhenCase) + visitKtWhenCaseRaw(ktWhenCase) + printRightNonCodeElements(ktWhenCase) + } + + fun visitKtWhenCaseRaw(ktWhenCase: JKKtWhenCase) = visitTreeElementRaw(ktWhenCase) + + override fun visitKtWhenLabel(ktWhenLabel: JKKtWhenLabel) { + printLeftNonCodeElements(ktWhenLabel) + visitKtWhenLabelRaw(ktWhenLabel) + printRightNonCodeElements(ktWhenLabel) + } + + fun visitKtWhenLabelRaw(ktWhenLabel: JKKtWhenLabel) = visitTreeElementRaw(ktWhenLabel) + + override fun visitKtElseWhenLabel(ktElseWhenLabel: JKKtElseWhenLabel) { + printLeftNonCodeElements(ktElseWhenLabel) + visitKtElseWhenLabelRaw(ktElseWhenLabel) + printRightNonCodeElements(ktElseWhenLabel) + } + + fun visitKtElseWhenLabelRaw(ktElseWhenLabel: JKKtElseWhenLabel) = visitKtWhenLabelRaw(ktElseWhenLabel) + + override fun visitKtValueWhenLabel(ktValueWhenLabel: JKKtValueWhenLabel) { + printLeftNonCodeElements(ktValueWhenLabel) + visitKtValueWhenLabelRaw(ktValueWhenLabel) + printRightNonCodeElements(ktValueWhenLabel) + } + + fun visitKtValueWhenLabelRaw(ktValueWhenLabel: JKKtValueWhenLabel) = visitKtWhenLabelRaw(ktValueWhenLabel) + + override fun visitKtIsExpression(ktIsExpression: JKKtIsExpression) { + printLeftNonCodeElements(ktIsExpression) + visitKtIsExpressionRaw(ktIsExpression) + printRightNonCodeElements(ktIsExpression) + } + + fun visitKtIsExpressionRaw(ktIsExpression: JKKtIsExpression) = visitExpressionRaw(ktIsExpression) + + override fun visitKtInitDeclaration(ktInitDeclaration: JKKtInitDeclaration) { + printLeftNonCodeElements(ktInitDeclaration) + visitKtInitDeclarationRaw(ktInitDeclaration) + printRightNonCodeElements(ktInitDeclaration) + } + + fun visitKtInitDeclarationRaw(ktInitDeclaration: JKKtInitDeclaration) = visitDeclarationRaw(ktInitDeclaration) + + override fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) { + printLeftNonCodeElements(ktConvertedFromForLoopSyntheticWhileStatement) + visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement) + printRightNonCodeElements(ktConvertedFromForLoopSyntheticWhileStatement) + } + + fun visitKtConvertedFromForLoopSyntheticWhileStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement) = visitStatementRaw(ktConvertedFromForLoopSyntheticWhileStatement) + + override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) { + printLeftNonCodeElements(ktThrowExpression) + visitKtThrowExpressionRaw(ktThrowExpression) + printRightNonCodeElements(ktThrowExpression) + } + + fun visitKtThrowExpressionRaw(ktThrowExpression: JKKtThrowExpression) = visitExpressionRaw(ktThrowExpression) + + override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) { + printLeftNonCodeElements(ktTryExpression) + visitKtTryExpressionRaw(ktTryExpression) + printRightNonCodeElements(ktTryExpression) + } + + fun visitKtTryExpressionRaw(ktTryExpression: JKKtTryExpression) = visitExpressionRaw(ktTryExpression) + + override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) { + printLeftNonCodeElements(ktTryCatchSection) + visitKtTryCatchSectionRaw(ktTryCatchSection) + printRightNonCodeElements(ktTryCatchSection) + } + + fun visitKtTryCatchSectionRaw(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElementRaw(ktTryCatchSection) + + override fun visitKtAnnotationArrayInitializerExpression(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) { + printLeftNonCodeElements(ktAnnotationArrayInitializerExpression) + visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression) + printRightNonCodeElements(ktAnnotationArrayInitializerExpression) + } + + fun visitKtAnnotationArrayInitializerExpressionRaw(ktAnnotationArrayInitializerExpression: JKKtAnnotationArrayInitializerExpression) = visitExpressionRaw(ktAnnotationArrayInitializerExpression) +}