diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt index 13b5d838702..c62c6172f76 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt @@ -38,53 +38,37 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { val backAnnotation = mutableMapOf() private inner class ExpressionTreeMapper { - fun PsiExpression.toJK(): JKExpression { - when (this) { - is PsiBinaryExpression -> { - return toJK() - } - is PsiPrefixExpression -> { - return toJK() - } - is PsiPostfixExpression -> { - return toJK() - } - is PsiLiteralExpression -> { - return toJK() - } - is PsiMethodCallExpression -> { - return toJK() - } - is PsiReferenceExpression -> { - return toJK() - } - is PsiNewExpression -> { - return toJK() - } - is PsiArrayAccessExpression -> { - return toJK() - } - is PsiTypeCastExpression -> { - return toJK() - } - is PsiParenthesizedExpression -> { - return toJK() - } - is PsiAssignmentExpression -> { - return toJK() - } + fun PsiExpression?.toJK(): JKExpression { + return when (this) { + null -> JKStubExpressionImpl() + is PsiBinaryExpression -> toJK() + is PsiPrefixExpression -> toJK() + is PsiPostfixExpression -> toJK() + is PsiLiteralExpression -> toJK() + is PsiMethodCallExpression -> toJK() + is PsiReferenceExpression -> toJK() + is PsiNewExpression -> toJK() + is PsiArrayAccessExpression -> toJK() + is PsiTypeCastExpression -> toJK() + is PsiParenthesizedExpression -> toJK() + is PsiAssignmentExpression -> toJK() + is PsiInstanceOfExpression -> toJK() else -> { throw RuntimeException("Not supported: ${this::class}") } } } + fun PsiInstanceOfExpression.toJK(): JKJavaInstanceOfExpression { + return JKJavaInstanceOfExpressionImpl(operand.toJK(), checkType?.toJK() ?: TODO()) + } + fun PsiAssignmentExpression.toJK(): JKJavaAssignmentExpression { - return JKJavaAssignmentExpressionImpl(lExpression.toJK(), rExpression?.toJK() ?: TODO()) + return JKJavaAssignmentExpressionImpl(lExpression.toJK(), rExpression.toJK()) } fun PsiBinaryExpression.toJK(): JKExpression { - return JKBinaryExpressionImpl(lOperand.toJK(), rOperand?.toJK() ?: TODO(), operationSign.toJK()) + return JKBinaryExpressionImpl(lOperand.toJK(), rOperand.toJK(), operationSign.toJK()) } fun PsiLiteralExpression.toJK(): JKLiteralExpression { @@ -117,7 +101,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { } fun PsiPrefixExpression.toJK(): JKExpression { - return JKPrefixExpressionImpl(operand?.toJK() ?: TODO(), operationSign.toJK()) + return JKPrefixExpressionImpl(operand.toJK(), operationSign.toJK()) } fun PsiPostfixExpression.toJK(): JKExpression { @@ -156,7 +140,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { if ((this as PsiNewExpressionImpl).findChildByRole(ChildRole.LBRACKET) != null) { val arrayInitializer = arrayInitializer if (arrayInitializer != null) { - return JKJavaNewArrayImpl(arrayInitializer.initializers.map { toJK() }) + return JKJavaNewArrayImpl(arrayInitializer.initializers.map { it.toJK() }) } else { val dimensions = mutableListOf() var child = firstChild @@ -239,7 +223,7 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { with(modifierMapper) { modifierList.toJK() }, with(expressionTreeMapper) { typeElement?.toJK() } ?: TODO(), JKNameIdentifierImpl(name), - with(expressionTreeMapper) { initializer?.toJK() } ?: JKStubExpressionImpl() + with(expressionTreeMapper) { initializer.toJK() } ).also { (symbolProvider.provideSymbol(this) as? JKUniverseFieldSymbol)?.run { target = it } } @@ -282,20 +266,29 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) { with(modifierMapper) { it.modifierList.toJK() }, with(expressionTreeMapper) { it.typeElement.toJK() }, JKNameIdentifierImpl(it.name ?: TODO()), - with(expressionTreeMapper) { it.initializer?.toJK() } ?: JKStubExpressionImpl() + with(expressionTreeMapper) { it.initializer.toJK() } ).also { i -> symbolProvider.symbols[it] = JKUniverseFieldSymbol(i) } } else TODO() } } - fun PsiStatement.toJK(): JKStatement { + fun PsiStatement?.toJK(): JKStatement { return when (this) { + null -> JKExpressionStatementImpl(JKStubExpressionImpl()) is PsiExpressionStatement -> JKExpressionStatementImpl(with(expressionTreeMapper) { expression.toJK() }) - is PsiReturnStatement -> JKReturnStatementImpl(with(expressionTreeMapper) { returnValue?.toJK() ?: JKStubExpressionImpl() }) + is PsiReturnStatement -> JKReturnStatementImpl(with(expressionTreeMapper) { returnValue.toJK() }) is PsiDeclarationStatement -> JKDeclarationStatementImpl(declaredElements.toJK()) - is PsiAssertStatement -> JKAssertStatementImpl( - with(expressionTreeMapper) { assertCondition?.toJK() } ?: JKStubExpressionImpl(), - with(expressionTreeMapper) { assertDescription?.toJK() } ?: JKStubExpressionImpl()) + is PsiAssertStatement -> JKJavaAssertStatementImpl( + with(expressionTreeMapper) { assertCondition.toJK() }, + with(expressionTreeMapper) { assertDescription.toJK() }) + is PsiIfStatement -> if (elseElement == null) + JKJavaIfStatementImpl(with(expressionTreeMapper) { condition.toJK() }, thenBranch.toJK()) + else + JKJavaIfElseStatementImpl(with(expressionTreeMapper) { condition.toJK() }, thenBranch.toJK(), elseBranch.toJK()) + is PsiForStatement -> JKJavaForLoopStatementImpl( + initialization.toJK(), with(expressionTreeMapper) { condition.toJK() }, update.toJK(), body.toJK() + ) + is PsiBlockStatement -> JKBlockStatementImpl(codeBlock.toJK()) else -> TODO("for ${this::class}") } } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt index 4ad2ffe327d..dd4fca01dc0 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt @@ -144,4 +144,44 @@ class JKJavaAssignmentExpressionImpl( override var lExpression: JKExpression by child(lExpression) override var rExpression: JKExpression by child(rExpression) +} + +class JKJavaAssertStatementImpl(condition: JKExpression, description: JKExpression) : JKJavaAssertStatement, JKBranchElementBase() { + override val description by child(description) + override val condition by child(condition) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaAssertStatement(this, data) +} + +class JKJavaIfStatementImpl(condition: JKExpression, thenBranch: JKStatement) : JKJavaIfStatement, JKBranchElementBase() { + override var thenBranch by child(thenBranch) + override var condition by child(condition) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaIfStatement(this, data) +} + +class JKJavaIfElseStatementImpl(condition: JKExpression, thenBranch: JKStatement, elseBranch: JKStatement) : JKJavaIfElseStatement, + JKBranchElementBase() { + override var elseBranch by child(elseBranch) + override var thenBranch by child(thenBranch) + override var condition by child(condition) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaIfElseStatement(this, data) +} + +class JKJavaForLoopStatementImpl(initializer: JKStatement, condition: JKExpression, updater: JKStatement, body: JKStatement) : + JKJavaForLoopStatement, JKBranchElementBase() { + override var body by child(body) + override var updater by child(updater) + override var condition by child(condition) + override var initializer by child(initializer) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaForLoopStatement(this, data) +} + +class JKJavaInstanceOfExpressionImpl(expression: JKExpression, type: JKTypeElement) : JKJavaInstanceOfExpression, JKBranchElementBase() { + override var type by child(type) + override var expression by child(expression) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitJavaInstanceOfExpression(this, data) } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt index f3005f48340..2feb9326bce 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/jk.kt @@ -166,13 +166,8 @@ class JKLocalVariableImpl(modifierList: JKModifierList, type: JKTypeElement, nam override fun accept(visitor: JKVisitor, data: D): R = visitor.visitLocalVariable(this, data) } -class JKStubExpressionImpl : JKStubExpression, JKElementBase() - -class JKAssertStatementImpl(condition: JKExpression, description: JKExpression) : JKAssertStatement, JKBranchElementBase() { - override val description by child(description) - override val condition by child(condition) - - override fun accept(visitor: JKVisitor, data: D): R = visitor.visitAssertStatement(this, data) +class JKStubExpressionImpl : JKStubExpression, JKElementBase() { + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitStubExpression(this, data) } object JKBodyStub : JKBlock, JKTreeElement { @@ -192,4 +187,10 @@ object JKBodyStub : JKBlock, JKTreeElement { override fun attach(to: JKElement) { } +} + +class JKBlockStatementImpl(block: JKBlock) : JKBlockStatement, JKBranchElementBase() { + override var block by child(block) + + override fun accept(visitor: JKVisitor, data: D): R = visitor.visitBlockStatement(this, data) } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt index 310c45969d9..782d66a67e2 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt @@ -24,8 +24,6 @@ interface JKJavaMethod : JKMethod, JKBranchElement { val block: JKBlock } -interface JKJavaForLoop : JKLoop - interface JKJavaAssignmentExpression : JKExpression, JKBranchElement { var lExpression: JKExpression var rExpression: JKExpression @@ -68,4 +66,29 @@ interface JKJavaLiteralExpression : JKLiteralExpression interface JKReturnStatement : JKStatement { val expression: JKExpression +} + +interface JKJavaAssertStatement : JKStatement { + val condition: JKExpression + val description: JKExpression +} + +interface JKJavaIfStatement : JKStatement { + var condition: JKExpression + var thenBranch: JKStatement +} + +interface JKJavaIfElseStatement : JKJavaIfStatement { + var elseBranch: JKStatement +} + +interface JKJavaForLoopStatement : JKLoopStatement { + var initializer: JKStatement + var condition: JKExpression + var updater: JKStatement +} + +interface JKJavaInstanceOfExpression : JKExpression { + var expression: JKExpression + var type: JKTypeElement } \ No newline at end of file diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt index 20369a7d014..9a7b6c9b31c 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/jk.kt @@ -68,8 +68,6 @@ interface JKTypeElement : JKTreeElement { interface JKStatement : JKTreeElement -interface JKLoop : JKStatement - interface JKBlock : JKTreeElement { var statements: List } @@ -158,7 +156,10 @@ interface JKStringLiteralExpression : JKLiteralExpression { interface JKStubExpression : JKExpression -interface JKAssertStatement : JKStatement { - val condition: JKExpression - val description: JKExpression +interface JKLoopStatement : JKStatement { + var body: JKStatement +} + +interface JKBlockStatement : JKStatement { + var block: JKBlock } diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt index db09c9a87e8..7ba2655c7e9 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt @@ -15,7 +15,6 @@ interface JKVisitor { fun visitModalityModifier(modalityModifier: JKModalityModifier, data: D): R = visitModifier(modalityModifier, data) fun visitTypeElement(typeElement: JKTypeElement, data: D): R = visitTreeElement(typeElement, data) fun visitStatement(statement: JKStatement, data: D): R = visitTreeElement(statement, data) - fun visitLoop(loop: JKLoop, data: D): R = visitStatement(loop, data) fun visitBlock(block: JKBlock, data: D): R = visitTreeElement(block, data) fun visitIdentifier(identifier: JKIdentifier, data: D): R = visitTreeElement(identifier, data) fun visitNameIdentifier(nameIdentifier: JKNameIdentifier, data: D): R = visitIdentifier(nameIdentifier, data) @@ -37,10 +36,10 @@ interface JKVisitor { fun visitValueArgument(valueArgument: JKValueArgument, data: D): R = visitTreeElement(valueArgument, data) fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data) fun visitStubExpression(stubExpression: JKStubExpression, data: D): R = visitExpression(stubExpression, data) - fun visitAssertStatement(assertStatement: JKAssertStatement, data: D): R = visitStatement(assertStatement, data) + fun visitLoopStatement(loopStatement: JKLoopStatement, data: D): R = visitStatement(loopStatement, data) + fun visitBlockStatement(blockStatement: JKBlockStatement, data: D): R = visitStatement(blockStatement, data) fun visitJavaField(javaField: JKJavaField, data: D): R = visitField(javaField, data) fun visitJavaMethod(javaMethod: JKJavaMethod, data: D): R = visitMethod(javaMethod, data) - fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: D): R = visitLoop(javaForLoop, data) fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data) fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression, data: D): R = visitMethodCallExpression(javaMethodCallExpression, data) fun visitJavaFieldAccessExpression(javaFieldAccessExpression: JKJavaFieldAccessExpression, data: D): R = visitFieldAccessExpression(javaFieldAccessExpression, data) @@ -51,6 +50,11 @@ interface JKVisitor { fun visitJavaNewArray(javaNewArray: JKJavaNewArray, data: D): R = visitExpression(javaNewArray, data) fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: D): R = visitLiteralExpression(javaLiteralExpression, data) fun visitReturnStatement(returnStatement: JKReturnStatement, data: D): R = visitStatement(returnStatement, data) + fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement, data: D): R = visitStatement(javaAssertStatement, data) + fun visitJavaIfStatement(javaIfStatement: JKJavaIfStatement, data: D): R = visitStatement(javaIfStatement, data) + fun visitJavaIfElseStatement(javaIfElseStatement: JKJavaIfElseStatement, data: D): R = visitJavaIfStatement(javaIfElseStatement, data) + fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement, data: D): R = visitLoopStatement(javaForLoopStatement, data) + fun visitJavaInstanceOfExpression(javaInstanceOfExpression: JKJavaInstanceOfExpression, data: D): R = visitExpression(javaInstanceOfExpression, 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) diff --git a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt index dbe56fc5b9b..c5bf523086b 100644 --- a/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt +++ b/j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt @@ -27,8 +27,6 @@ interface JKVisitorVoid : JKVisitor { override fun visitTypeElement(typeElement: JKTypeElement, data: Nothing?) = visitTypeElement(typeElement) fun visitStatement(statement: JKStatement) = visitTreeElement(statement, null) override fun visitStatement(statement: JKStatement, data: Nothing?) = visitStatement(statement) - fun visitLoop(loop: JKLoop) = visitStatement(loop, null) - override fun visitLoop(loop: JKLoop, data: Nothing?) = visitLoop(loop) fun visitBlock(block: JKBlock) = visitTreeElement(block, null) override fun visitBlock(block: JKBlock, data: Nothing?) = visitBlock(block) fun visitIdentifier(identifier: JKIdentifier) = visitTreeElement(identifier, null) @@ -71,14 +69,14 @@ interface JKVisitorVoid : JKVisitor { override fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: Nothing?) = visitStringLiteralExpression(stringLiteralExpression) fun visitStubExpression(stubExpression: JKStubExpression) = visitExpression(stubExpression, null) override fun visitStubExpression(stubExpression: JKStubExpression, data: Nothing?) = visitStubExpression(stubExpression) - fun visitAssertStatement(assertStatement: JKAssertStatement) = visitStatement(assertStatement, null) - override fun visitAssertStatement(assertStatement: JKAssertStatement, data: Nothing?) = visitAssertStatement(assertStatement) + fun visitLoopStatement(loopStatement: JKLoopStatement) = visitStatement(loopStatement, null) + override fun visitLoopStatement(loopStatement: JKLoopStatement, data: Nothing?) = visitLoopStatement(loopStatement) + fun visitBlockStatement(blockStatement: JKBlockStatement) = visitStatement(blockStatement, null) + override fun visitBlockStatement(blockStatement: JKBlockStatement, data: Nothing?) = visitBlockStatement(blockStatement) fun visitJavaField(javaField: JKJavaField) = visitField(javaField, null) override fun visitJavaField(javaField: JKJavaField, data: Nothing?) = visitJavaField(javaField) fun visitJavaMethod(javaMethod: JKJavaMethod) = visitMethod(javaMethod, null) override fun visitJavaMethod(javaMethod: JKJavaMethod, data: Nothing?) = visitJavaMethod(javaMethod) - fun visitJavaForLoop(javaForLoop: JKJavaForLoop) = visitLoop(javaForLoop, null) - override fun visitJavaForLoop(javaForLoop: JKJavaForLoop, data: Nothing?) = visitJavaForLoop(javaForLoop) fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression) = visitExpression(javaAssignmentExpression, null) override fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: Nothing?) = visitJavaAssignmentExpression(javaAssignmentExpression) fun visitJavaMethodCallExpression(javaMethodCallExpression: JKJavaMethodCallExpression) = visitMethodCallExpression(javaMethodCallExpression, null) @@ -99,6 +97,16 @@ interface JKVisitorVoid : JKVisitor { override fun visitJavaLiteralExpression(javaLiteralExpression: JKJavaLiteralExpression, data: Nothing?) = visitJavaLiteralExpression(javaLiteralExpression) fun visitReturnStatement(returnStatement: JKReturnStatement) = visitStatement(returnStatement, null) override fun visitReturnStatement(returnStatement: JKReturnStatement, data: Nothing?) = visitReturnStatement(returnStatement) + fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement) = visitStatement(javaAssertStatement, null) + override fun visitJavaAssertStatement(javaAssertStatement: JKJavaAssertStatement, data: Nothing?) = visitJavaAssertStatement(javaAssertStatement) + fun visitJavaIfStatement(javaIfStatement: JKJavaIfStatement) = visitStatement(javaIfStatement, null) + override fun visitJavaIfStatement(javaIfStatement: JKJavaIfStatement, data: Nothing?) = visitJavaIfStatement(javaIfStatement) + fun visitJavaIfElseStatement(javaIfElseStatement: JKJavaIfElseStatement) = visitJavaIfStatement(javaIfElseStatement, null) + override fun visitJavaIfElseStatement(javaIfElseStatement: JKJavaIfElseStatement, data: Nothing?) = visitJavaIfElseStatement(javaIfElseStatement) + fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement) = visitLoopStatement(javaForLoopStatement, null) + override fun visitJavaForLoopStatement(javaForLoopStatement: JKJavaForLoopStatement, data: Nothing?) = visitJavaForLoopStatement(javaForLoopStatement) + fun visitJavaInstanceOfExpression(javaInstanceOfExpression: JKJavaInstanceOfExpression) = visitExpression(javaInstanceOfExpression, null) + override fun visitJavaInstanceOfExpression(javaInstanceOfExpression: JKJavaInstanceOfExpression, data: Nothing?) = visitJavaInstanceOfExpression(javaInstanceOfExpression) fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null) override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty) fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)