New J2K: Add try statement

j2k/newSrc/org/jetbrains/kotlin/j2k/ConversionsRunner.kt

@@ -26,6 +26,7 @@ object ConversionsRunner {
             +BinaryExpressionConversion(context)
             +ThrowStatementConversion()
             +ArrayInitializerConversion(context)
+            +TryStatementConversion(context)
             +ModalityConversion(context)
             +ImplicitInitializerConversion()
             +DefaultArgumentsConversion(context)

j2k/newSrc/org/jetbrains/kotlin/j2k/JavaToJKTreeBuilder.kt

@@ -382,11 +382,21 @@ class JavaToJKTreeBuilder(var symbolProvider: JKSymbolProvider) {
                 is PsiEmptyStatement -> JKEmptyStatementImpl()
                 is PsiThrowStatement ->
                     JKJavaThrowStatementImpl(with(expressionTreeMapper) { exception.toJK() })
+                is PsiTryStatement ->
+                    JKJavaTryStatementImpl(
+                        tryBlock?.toJK() ?: JKBodyStub,
+                        finallyBlock?.toJK() ?: JKBodyStub,
+                        catchSections.map { it.toJK() }
+                    )
                 else -> TODO("for ${this::class}")
             }.also {
                 if (this != null) (it as PsiOwner).psi = this
             }
         }
+
+        fun PsiCatchSection.toJK(): JKJavaTryCatchSection =
+            JKJavaTryCatchSectionImpl(parameter?.toJK()!!, catchBlock?.toJK() ?: JKBodyStub)
+                .also { it.psi = this }
     }
 
     //TODO better way than generateSequence.last??

j2k/newSrc/org/jetbrains/kotlin/j2k/NewCodeBuilder.kt

@@ -45,6 +45,28 @@ class NewCodeBuilder {
             printer.print("/* !!! Hit visitElement for element type: ${treeElement::class} !!! */")
         }
 
+        override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) {
+            printer.printlnWithNoIndent("try ")
+            if (ktTryExpression.tryBlock != JKBodyStub) {
+                printer.block { ktTryExpression.tryBlock.accept(this) }
+            }
+            ktTryExpression.catchSections.forEach { it.accept(this) }
+            if (ktTryExpression.finallyBlock != JKBodyStub) {
+                printer.printlnWithNoIndent("finally ")
+                printer.block { ktTryExpression.finallyBlock.accept(this) }
+            }
+        }
+
+        override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) {
+            printer.printWithNoIndent("catch ")
+            printer.par {
+                ktTryCatchSection.parameter.accept(this)
+            }
+            if (ktTryCatchSection.block != JKBodyStub) {
+                printer.block { ktTryCatchSection.block.accept(this) }
+            }
+        }
+
         override fun visitKtForInStatement(ktForInStatement: JKKtForInStatement) {
             printer.printWithNoIndent("for (")
             ktForInStatement.declaration.accept(this)

j2k/newSrc/org/jetbrains/kotlin/j2k/conversions/TryStatementConversion.kt

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license
+ * that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.j2k.conversions
+
+import org.jetbrains.kotlin.j2k.ConversionContext
+import org.jetbrains.kotlin.j2k.copyTreeAndDetach
+import org.jetbrains.kotlin.j2k.tree.*
+import org.jetbrains.kotlin.j2k.tree.impl.*
+
+
+class TryStatementConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
+    override fun applyToElement(element: JKTreeElement): JKTreeElement {
+        if (element !is JKJavaTryStatement) return recurse(element)
+        val tryExpression = JKKtTryExpressionImpl(
+            element::tryBlock.detached(),
+            element::finallyBlock.detached(),
+            element.catchSections.flatMap(::convertCatchSection)
+        )
+        return recurse(JKExpressionStatementImpl(tryExpression))
+    }
+
+    private fun convertCatchSection(javaCatchSection: JKJavaTryCatchSection): List<JKKtTryCatchSection> {
+        javaCatchSection.block.detach(javaCatchSection)
+        return javaCatchSection.parameter.type.type.let {
+            (it as? JKJavaDisjunctionType)?.disjunctions ?: listOf(it)
+        }.map {
+            val parameter = JKParameterImpl(
+                JKTypeElementImpl(it),
+                javaCatchSection.parameter.name.copyTreeAndDetach(),
+                JKModifierListImpl()
+            )
+            JKKtTryCatchSectionImpl(
+                parameter,
+                javaCatchSection.block.copyTreeAndDetach()
+            )
+        }
+    }
+}

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/j.kt

@@ -20,6 +20,7 @@ import com.intellij.psi.JavaTokenType
 import com.intellij.psi.impl.source.tree.ElementType.OPERATION_BIT_SET
 import com.intellij.psi.tree.IElementType
 import org.jetbrains.kotlin.j2k.ast.Nullability
+import org.jetbrains.kotlin.j2k.ast.Parameter
 import org.jetbrains.kotlin.j2k.tree.*
 import org.jetbrains.kotlin.j2k.tree.JKLiteralExpression.LiteralType.*
 import org.jetbrains.kotlin.j2k.tree.visitors.JKVisitor
@@ -232,6 +233,11 @@ object JKJavaVoidType : JKType {
 class JKJavaArrayTypeImpl(override val type: JKType, override var nullability: Nullability = Nullability.Default) : JKJavaArrayType {
 }
 
+class JKJavaDisjunctionTypeImpl(
+    override val disjunctions: List<JKType>,
+    override val nullability: Nullability = Nullability.Default
+) : JKJavaDisjunctionType
+
 class JKReturnStatementImpl(expression: JKExpression) : JKBranchElementBase(), JKReturnStatement, PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitReturnStatement(this, data)
 
@@ -310,4 +316,25 @@ class JKJavaLabelSwitchCaseImpl(
 class JKJavaThrowStatementImpl(exception: JKExpression) : JKJavaThrowStatement, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var exception: JKExpression by child(exception)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaThrowStatement(this, data)
+}
+
+class JKJavaTryStatementImpl(
+    tryBlock: JKBlock,
+    finallyBlock: JKBlock,
+    catchSections: List<JKJavaTryCatchSection>
+) : JKJavaTryStatement,
+    JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
+    override var tryBlock: JKBlock by child(tryBlock)
+    override var finallyBlock: JKBlock by child(finallyBlock)
+    override var catchSections: List<JKJavaTryCatchSection> by children(catchSections)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaTryStatement(this, data)
+}
+
+class JKJavaTryCatchSectionImpl(
+    parameter: JKParameter,
+    block: JKBlock
+) : JKJavaTryCatchSection, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
+    override var parameter: JKParameter by child(parameter)
+    override var block: JKBlock by child(block)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaTryCatchSection(this, data)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/impl/k.kt

@@ -265,4 +265,24 @@ class JKKtConvertedFromForLoopSyntheticWhileStatementImpl(
 class JKKtThrowExpressionImpl(exception: JKExpression) : JKKtThrowExpression, JKBranchElementBase() {
     override var exception: JKExpression by child(exception)
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtThrowExpression(this, data)
+}
+
+class JKKtTryExpressionImpl(
+    tryBlock: JKBlock,
+    finallyBlock: JKBlock,
+    catchSections: List<JKKtTryCatchSection>
+) : JKKtTryExpression, JKBranchElementBase(){
+    override var tryBlock: JKBlock by child(tryBlock)
+    override var finallyBlock: JKBlock by child(finallyBlock)
+    override var catchSections: List<JKKtTryCatchSection> by children(catchSections)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtTryExpression(this, data)
+}
+
+class JKKtTryCatchSectionImpl(
+    parameter: JKParameter,
+    block: JKBlock
+) : JKKtTryCatchSection, JKBranchElementBase() {
+    override var parameter: JKParameter by child(parameter)
+    override var block: JKBlock by child(block)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtTryCatchSection(this, data)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/j.kt

@@ -88,11 +88,22 @@ interface JKJavaAssignmentExpression : JKExpression, JKBranchElement {
     var operator: JKOperator
 }
 
-
 interface JKJavaThrowStatement : JKStatement {
     var exception: JKExpression
 }
 
+interface JKJavaTryStatement : JKStatement {
+    var tryBlock: JKBlock
+    var finallyBlock: JKBlock
+    var catchSections: List<JKJavaTryCatchSection>
+}
+
+interface JKJavaTryCatchSection : JKTreeElement {
+    var parameter: JKParameter
+    var block: JKBlock
+}
+
+
 interface JKJavaSwitchStatement : JKStatement {
     var expression: JKExpression
     var cases: List<JKJavaSwitchCase>

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/k.kt

@@ -98,4 +98,15 @@ interface JKKtConvertedFromForLoopSyntheticWhileStatement : JKStatement {
 
 interface JKKtThrowExpression : JKExpression {
     var exception: JKExpression
+}
+
+interface JKKtTryExpression : JKExpression {
+    var tryBlock: JKBlock
+    var finallyBlock: JKBlock
+    var catchSections: List<JKKtTryCatchSection>
+}
+
+interface JKKtTryCatchSection : JKTreeElement {
+    var parameter: JKParameter
+    var block: JKBlock
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/markers.kt

@@ -86,6 +86,10 @@ interface JKStarProjectionType : JKType {
         get() = Nullability.NotNull
 }
 
+interface JKJavaDisjunctionType : JKType {
+    val disjunctions: List<JKType>
+}
+
 inline fun <reified T> JKElement.getParentOfType(): T? {
     var p = parent
     while (true) {

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/types.kt

@@ -68,7 +68,9 @@ fun PsiType.toJK(symbolProvider: JKSymbolProvider, nullability: Nullability = Nu
         is PsiArrayType -> JKJavaArrayTypeImpl(componentType.toJK(symbolProvider, nullability), nullability)
         is PsiPrimitiveType -> JKJavaPrimitiveTypeImpl.KEYWORD_TO_INSTANCE[presentableText]
             ?: error("Invalid primitive type $presentableText")
-        else -> throw Exception("Invalid PSI")
+        is PsiDisjunctionType ->
+            JKJavaDisjunctionTypeImpl(disjunctions.map { it.toJK(symbolProvider) })
+        else -> throw Exception("Invalid PSI ${this::class.java}")
     }
 }
 

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitor.kt

@@ -76,6 +76,8 @@ interface JKVisitor<out R, in D> {
     fun visitJavaPolyadicExpression(javaPolyadicExpression: JKJavaPolyadicExpression, data: D): R = visitExpression(javaPolyadicExpression, data)
     fun visitJavaAssignmentExpression(javaAssignmentExpression: JKJavaAssignmentExpression, data: D): R = visitExpression(javaAssignmentExpression, data)
     fun visitJavaThrowStatement(javaThrowStatement: JKJavaThrowStatement, data: D): R = visitStatement(javaThrowStatement, data)
+    fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement, data: D): R = visitStatement(javaTryStatement, data)
+    fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection, data: D): R = visitTreeElement(javaTryCatchSection, data)
     fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: D): R = visitStatement(javaContinueStatement, data)
     fun visitJavaSwitchStatement(javaSwitchStatement: JKJavaSwitchStatement, data: D): R = visitStatement(javaSwitchStatement, data)
     fun visitJavaSwitchCase(javaSwitchCase: JKJavaSwitchCase, data: D): R = visitTreeElement(javaSwitchCase, data)
@@ -102,4 +104,6 @@ interface JKVisitor<out R, in D> {
     fun visitKtOperatorExpression(ktOperatorExpression: JKKtOperatorExpression, data: D): R = visitExpression(ktOperatorExpression, data)
     fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement, data: D): R = visitStatement(ktConvertedFromForLoopSyntheticWhileStatement, data)
     fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression, data: D): R = visitExpression(ktThrowExpression, data)
+    fun visitKtTryExpression(ktTryExpression: JKKtTryExpression, data: D): R = visitExpression(ktTryExpression, data)
+    fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection, data: D): R = visitTreeElement(ktTryCatchSection, data)
 }

j2k/newSrc/org/jetbrains/kotlin/j2k/tree/visitors/JKVisitorVoid.kt

@@ -159,6 +159,10 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaLabelSwitchCase(javaLabelSwitchCase: JKJavaLabelSwitchCase, data: Nothing?) = visitJavaLabelSwitchCase(javaLabelSwitchCase)
     fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement) = visitStatement(javaContinueStatement, null)
     override fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: Nothing?) = visitJavaContinueStatement(javaContinueStatement)
+    fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement) = visitStatement(javaTryStatement, null)
+    override fun visitJavaTryStatement(javaTryStatement: JKJavaTryStatement, data: Nothing?) = visitJavaTryStatement(javaTryStatement)
+    fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection) = visitTreeElement(javaTryCatchSection, null)
+    override fun visitJavaTryCatchSection(javaTryCatchSection: JKJavaTryCatchSection, data: Nothing?) = visitJavaTryCatchSection(javaTryCatchSection)
     fun visitKtProperty(ktProperty: JKKtProperty) = visitField(ktProperty, null)
     override fun visitKtProperty(ktProperty: JKKtProperty, data: Nothing?) = visitKtProperty(ktProperty)
     fun visitKtFunction(ktFunction: JKKtFunction) = visitMethod(ktFunction, null)
@@ -201,4 +205,8 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement: JKKtConvertedFromForLoopSyntheticWhileStatement, data: Nothing?) = visitKtConvertedFromForLoopSyntheticWhileStatement(ktConvertedFromForLoopSyntheticWhileStatement)
     fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression) = visitExpression(ktThrowExpression, null)
     override fun visitKtThrowExpression(ktThrowExpression: JKKtThrowExpression, data: Nothing?) = visitKtThrowExpression(ktThrowExpression)
+    fun visitKtTryExpression(ktTryExpression: JKKtTryExpression) = visitExpression(ktTryExpression, null)
+    override fun visitKtTryExpression(ktTryExpression: JKKtTryExpression, data: Nothing?) = visitKtTryExpression(ktTryExpression)
+    fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection) = visitTreeElement(ktTryCatchSection, null)
+    override fun visitKtTryCatchSection(ktTryCatchSection: JKKtTryCatchSection, data: Nothing?) = visitKtTryCatchSection(ktTryCatchSection)
 }