Use of Block.of()

j2k/src/org/jetbrains/kotlin/j2k/Converter.kt

@@ -354,7 +354,7 @@ class Converter private constructor(
                     val superExpression = SuperExpression(Identifier.Empty).assignNoPrototype()
                     val superAccess = QualifiedExpression(superExpression, propertyInfo.identifier).assignNoPrototype()
                     val returnStatement = ReturnStatement(superAccess).assignNoPrototype()
-                    val body = Block(listOf(returnStatement), LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
+                    val body = Block.of(returnStatement).assignNoPrototype()
                     val parameterList = ParameterList(emptyList()).assignNoPrototype()
                     getter = PropertyAccessor(AccessorKind.GETTER, Annotations.Empty, Modifiers.Empty, parameterList, deferredElement { body })
                     getter.assignNoPrototype()
@@ -388,7 +388,7 @@ class Converter private constructor(
                     val superAccess = QualifiedExpression(superExpression, propertyInfo.identifier).assignNoPrototype()
                     val valueIdentifier = Identifier("value", false).assignNoPrototype()
                     val assignment = AssignmentExpression(superAccess, valueIdentifier, Operator.EQ).assignNoPrototype()
-                    val body = Block(listOf(assignment), LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
+                    val body = Block.of(assignment).assignNoPrototype()
                     val parameter = FunctionParameter(valueIdentifier, propertyType, FunctionParameter.VarValModifier.None, Annotations.Empty, Modifiers.Empty).assignNoPrototype()
                     val parameterList = ParameterList(listOf(parameter)).assignNoPrototype()
                     setter = PropertyAccessor(AccessorKind.SETTER, Annotations.Empty, accessorModifiers, parameterList, deferredElement { body })

j2k/src/org/jetbrains/kotlin/j2k/ExpressionConverter.kt

@@ -698,7 +698,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
         when (body) {
             is PsiExpression -> {
                 val convertedBody = codeConverter.convertExpression(body).assignPrototype(body)
-                result = LambdaExpression(convertedParameters, Block(listOf(convertedBody), LBrace().assignNoPrototype(), RBrace().assignNoPrototype()))
+                result = LambdaExpression(convertedParameters, Block.of(convertedBody).assignNoPrototype())
             }
             is PsiCodeBlock -> {
                 val convertedBlock = codeConverter.withSpecialStatementConverter(object: SpecialStatementConverter {
@@ -812,12 +812,7 @@ class DefaultExpressionConverter : JavaElementVisitor(), ExpressionConverter {
                     parameters.map { LambdaParameter(it.first, it.second).assignNoPrototype() }
                 }).assignNoPrototype()
 
-        val lambdaExpression = LambdaExpression(
+        val lambdaExpression = LambdaExpression(lambdaParameterList, Block.of(statement).assignNoPrototype()).assignNoPrototype()
-                lambdaParameterList,
-                Block(listOf(statement),
-                      LBrace().assignNoPrototype(),
-                      RBrace().assignNoPrototype()).assignNoPrototype()
-        ).assignNoPrototype()
 
         if (isKotlinFunctionType) {
             result = lambdaExpression

j2k/src/org/jetbrains/kotlin/j2k/ForConverter.kt

@@ -69,7 +69,7 @@ class ForConverter(
                         }
                     }
                     else {
-                        return Block(statements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype())
+                        return Block.of(statements)
                     }
                 }
             })
@@ -85,7 +85,7 @@ class ForConverter(
 
                 if (nameConflict) {
                     val statements = listOf(codeConverterToUse.convertStatement(body), updateConverted)
-                    Block(statements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype(), true).assignNoPrototype()
+                    Block.of(statements).assignNoPrototype()
                 }
                 else {
                     val block = codeConverterToUse.convertBlock(body.codeBlock, true)
@@ -94,7 +94,7 @@ class ForConverter(
             }
             else {
                 val statements = listOf(codeConverterToUse.convertStatement(body), updateConverted)
-                Block(statements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype(), true).assignNoPrototype()
+                Block.of(statements).assignNoPrototype()
             }
         }
 
@@ -133,7 +133,7 @@ class ForConverter(
                 builder.append(statements, "\n")
             }
             else {
-                val block = Block(statements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
+                val block = Block.of(statements).assignNoPrototype()
                 if (kind == Kind.WITH_BLOCK) {
                     block.generateCode(builder)
                 }

j2k/src/org/jetbrains/kotlin/j2k/StatementConverter.kt

@@ -58,8 +58,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
         }
         else {
             val description = codeConverter.convertExpression(descriptionExpr)
-            val block = Block(listOf(description), LBrace().assignNoPrototype(), RBrace().assignNoPrototype())
+            val lambda = LambdaExpression(null, Block.of(description).assignNoPrototype())
-            val lambda = LambdaExpression(null, block.assignNoPrototype())
             result = MethodCallExpression.build(null, "assert", listOf(condition, lambda), listOf(), false)
         }
     }
@@ -210,8 +209,8 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
     }
 
     private fun convertTryWithResources(tryBlock: PsiCodeBlock?, resourceVariables: List<PsiResourceVariable>, catchesConverted: List<CatchStatement>, finallyConverted: Block): Statement {
-        var wrapResultStatement: (Expression) -> Statement = { it }
+        val wrapResultStatement: (Expression) -> Statement = { it }
-        var converterForBody = codeConverter
+        val converterForBody = codeConverter
 
         var block = converterForBody.convertBlock(tryBlock)
         var expression: Expression = Expression.Empty
@@ -221,7 +220,7 @@ class DefaultStatementConverter : JavaElementVisitor(), StatementConverter {
             val lambda = LambdaExpression(parameterList, block)
             expression = MethodCallExpression.build(codeConverter.convertExpression(variable.initializer), "use", listOf(lambda), listOf(), false)
             expression.assignNoPrototype()
-            block = Block(listOf(expression), LBrace().assignNoPrototype(), RBrace().assignNoPrototype()).assignNoPrototype()
+            block = Block.of(expression).assignNoPrototype()
         }
 
         if (catchesConverted.isEmpty() && finallyConverted.isEmpty) {

j2k/src/org/jetbrains/kotlin/j2k/SwitchConverter.kt

@@ -108,7 +108,7 @@ class SwitchConverter(private val codeConverter: CodeConverter) {
         return if (statements.size == 1)
             statements.single()
         else
-            Block(statements, LBrace().assignNoPrototype(), RBrace().assignNoPrototype(), true).assignNoPrototype()
+            Block.of(statements).assignNoPrototype()
     }
 
     private fun isSwitchBreak(statement: PsiStatement) = statement is PsiBreakStatement && statement.labelIdentifier == null

j2k/src/org/jetbrains/kotlin/j2k/ast/Block.kt

@@ -40,13 +40,14 @@ class Block(val statements: List<Statement>, val lBrace: LBrace, val rBrace: RBr
 }
 
 // we use LBrace and RBrace elements to better handle comments around them
-class LBrace() : Element() {
+class LBrace : Element() {
     override fun generateCode(builder: CodeBuilder) {
         builder.append("{")
     }
 }
 
-class RBrace() : Element() {
+
+class RBrace : Element() {
     override fun generateCode(builder: CodeBuilder) {
         builder.append("}")
     }