New J2K: Add support of named parameters

nj2k/src/org/jetbrains/kotlin/nj2k/JavaToJKTreeBuilder.kt

@@ -236,13 +236,13 @@ class JavaToJKTreeBuilder(
                                 val receiver = arguments.expressions.firstOrNull()?.toJK()?.parenthesizeIfBinaryExpression()
                                 JKJavaMethodCallExpressionImpl(
                                     symbolProvider.provideDirectSymbol(origin) as JKMethodSymbol,
-                                    arguments.expressions.drop(1).map { it.toJK() }.toExpressionList(),
+                                    arguments.expressions.drop(1).map { it.toJK() }.toArgumentList(),
                                     typeArguments
                                 ).qualified(receiver)
                             } else {
                                 JKJavaMethodCallExpressionImpl(
                                     symbolProvider.provideDirectSymbol(origin) as JKMethodSymbol,
-                                    arguments.expressions.map { it.toJK() }.toExpressionList(),
+                                    arguments.toJK(),
                                     typeArguments
                                 ).qualified(qualifier)
                             }
@@ -359,7 +359,7 @@ class JavaToJKTreeBuilder(
                                 } ?: JKTypeArgumentListImpl()
                     JKJavaNewExpressionImpl(
                         classSymbol,
-                        argumentList.toJK(),
+                        argumentList?.toJK() ?: JKArgumentListImpl(),
                         typeArgumentList,
                         with(declarationMapper) { anonymousClass?.createClassBody() } ?: JKEmptyClassBodyImpl()
                     )
@@ -447,7 +447,7 @@ class JavaToJKTreeBuilder(
         fun PsiEnumConstant.toJK(): JKEnumConstant =
             JKEnumConstantImpl(
                 JKNameIdentifierImpl(name),
-                with(expressionTreeMapper) { argumentList.toJK() },
+                with(expressionTreeMapper) { argumentList?.toJK() ?: JKArgumentListImpl() },
                 initializingClass?.createClassBody() ?: JKEmptyClassBodyImpl(),
                 JKTypeElementImpl(JKClassTypeImpl(symbolProvider.provideDirectSymbol(containingClass!!) as JKClassSymbol, emptyList()))
             ).also {

nj2k/src/org/jetbrains/kotlin/nj2k/NewCodeBuilder.kt

@@ -273,7 +273,7 @@ class NewCodeBuilder {
 
         override fun visitEnumConstant(enumConstant: JKEnumConstant) {
             enumConstant.name.accept(this)
-            if (enumConstant.arguments.expressions.isNotEmpty()) {
+            if (enumConstant.arguments.arguments.isNotEmpty()) {
                 printer.par {
                     enumConstant.arguments.accept(this)
                 }
@@ -513,6 +513,21 @@ class NewCodeBuilder {
             renderList(expressionList.expressions) { it.accept(this) }
         }
 
+
+        override fun visitArgumentList(argumentList: JKArgumentList) {
+            renderList(argumentList.arguments) { it.accept(this) }
+        }
+
+        override fun visitArgument(argument: JKArgument) {
+            argument.value.accept(this)
+        }
+
+        override fun visitNamedArgument(namedArgument: JKNamedArgument) {
+            namedArgument.name.accept(this)
+            printer.printWithNoIndent(" = ")
+            namedArgument.value.accept(this)
+        }
+
         override fun visitMethodCallExpression(methodCallExpression: JKMethodCallExpression) {
             printer.printWithNoIndent(FqName(methodCallExpression.identifier.fqName).shortName().asString().escaped())
             methodCallExpression.typeArgumentList.accept(this)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ArrayInitializerConversion.kt

@@ -7,8 +7,9 @@ package org.jetbrains.kotlin.nj2k.conversions
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.builtins.PrimitiveType
-import org.jetbrains.kotlin.nj2k.ConversionContext
 import org.jetbrains.kotlin.j2k.ast.Nullability
+import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.toArgumentList
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.resolve.CollectionLiteralResolver
@@ -26,7 +27,7 @@ class ArrayInitializerConversion(private val context: ConversionContext) : Recur
                     CollectionLiteralResolver.ARRAY_OF_FUNCTION.asString()
             newElement = JKJavaMethodCallExpressionImpl(
                 context.symbolProvider.provideByFqName("kotlin.$arrayConstructorName"),
-                JKExpressionListImpl(element.initializer.also { element.initializer = emptyList() })
+                element.initializer.also { element.initializer = emptyList() }.toArgumentList()
             )
         } else if (element is JKJavaNewEmptyArray) {
             newElement = buildArrayInitializer(
@@ -42,13 +43,13 @@ class ArrayInitializerConversion(private val context: ConversionContext) : Recur
             return if (type !is JKJavaPrimitiveType) {
                 JKJavaMethodCallExpressionImpl(
                     context.symbolProvider.provideByFqName("kotlin/arrayOfNulls"),
-                    JKExpressionListImpl(dimensions[0]),
+                    JKArgumentListImpl(dimensions[0]),
                     JKTypeArgumentListImpl(listOf(JKTypeElementImpl(type.updateNullability(Nullability.NotNull))))
                 )
             } else {
                 JKJavaNewExpressionImpl(
                     context.symbolProvider.provideByFqName(type.arrayFqName()),
-                    JKExpressionListImpl(dimensions[0]),
+                    JKArgumentListImpl(dimensions[0]),
                     JKTypeArgumentListImpl(emptyList())
                 )
             }
@@ -56,7 +57,7 @@ class ArrayInitializerConversion(private val context: ConversionContext) : Recur
         if (dimensions[1] !is JKStubExpression) {
             return JKJavaMethodCallExpressionImpl(
                 context.symbolProvider.provideByFqName("kotlin.Array"),
-                JKExpressionListImpl(
+                JKArgumentListImpl(
                     dimensions[0],
                     JKLambdaExpressionImpl(
                         JKExpressionStatementImpl(buildArrayInitializer(dimensions.subList(1, dimensions.size), type)),
@@ -79,7 +80,7 @@ class ArrayInitializerConversion(private val context: ConversionContext) : Recur
         }
         return JKJavaMethodCallExpressionImpl(
             context.symbolProvider.provideByFqName("kotlin/arrayOfNulls"),
-            JKExpressionListImpl(dimensions[0]),
+            JKArgumentListImpl(dimensions[0]),
             JKTypeArgumentListImpl(listOf(JKTypeElementImpl(resultType)))
         )
     }

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BlockToRunConversion.kt

@@ -5,14 +5,12 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 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.impl.*
-import org.jetbrains.kotlin.name.ClassId
 
 class BlockToRunConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -29,7 +27,7 @@ class BlockToRunConversion(private val context: ConversionContext) : RecursiveAp
             JKBlockStatementImpl(element.block),
             emptyList()
         )
-        val call = JKKtCallExpressionImpl(context.symbolProvider.provideByFqName("kotlin.run", true), JKExpressionListImpl(listOf(lambda)))
+        val call = JKKtCallExpressionImpl(context.symbolProvider.provideByFqName("kotlin.run", true), JKArgumentListImpl(lambda))
         return recurse(JKExpressionStatementImpl(call))
     }
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BoxedTypeOperationsConversion.kt

@@ -7,9 +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.JKExpressionListImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKArgumentListImpl
 import org.jetbrains.kotlin.nj2k.tree.impl.JKKtCallExpressionImpl
-import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
 class BoxedTypeOperationsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -26,8 +25,8 @@ class BoxedTypeOperationsConversion(private val context: ConversionContext) : Re
 
     private fun convertCreationOfBoxedType(newExpression: JKJavaNewExpression): JKExpression? {
         if (newExpression.classSymbol.fqName !in boxedTypeFqNames) return null
-        val singleArgument = newExpression.arguments.expressions.singleOrNull() ?: return null
+        val singleArgument = newExpression.arguments.arguments.singleOrNull() ?: return null
-        return singleArgument.detached(newExpression.arguments)
+        return singleArgument::value.detached()
     }
 
     private fun convertBoxedTypeUnwrapping(methodCallExpression: JKMethodCallExpression): JKExpression? {
@@ -43,7 +42,7 @@ class BoxedTypeOperationsConversion(private val context: ConversionContext) : Re
             context.symbolProvider.provideByFqName(
                 "kotlin.${primitiveTypeName.capitalize()}.to${operationType.capitalize()}"
             ),
-            JKExpressionListImpl()
+            JKArgumentListImpl()
         )
     }
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/BuiltinMembersConversion.kt

@@ -33,13 +33,15 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi
                 } else newSelector
             }
             ReplaceType.FULL_REPLACE -> newSelector
+        }.let { expression ->
+            conversion.actionAfter?.invoke(expression.copyTreeAndDetach()) ?: expression
         }
     }
 
     private fun JKExpression.getConversion(): Conversion? = when (this) {
         is JKMethodCallExpression ->
-            conversions[identifier.deepestFqName()]?.firstOrNull() { conversion ->
+            conversions[identifier.deepestFqName()]?.firstOrNull { conversion ->
-                conversion.from is Method && conversion.byArgumentsFilter?.invoke(arguments.expressions) ?: true
+                conversion.from is Method && conversion.byArgumentsFilter?.invoke(arguments.arguments.map { it.value }) ?: true
             }
         is JKFieldAccessExpression ->
             conversions[identifier.deepestFqName()]?.firstOrNull { conversion -> conversion.from is Field }
@@ -53,7 +55,7 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi
 
     private inner class MethodBuilder(
         private val fqName: String,
-        private val argumentsProvider: (JKExpressionList) -> JKExpressionList
+        private val argumentsProvider: (JKArgumentList) -> JKArgumentList
     ) : ResultBuilder {
         override fun build(from: JKExpression): JKExpression =
             when (from) {
@@ -66,7 +68,7 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi
                 is JKFieldAccessExpression ->
                     JKKtCallExpressionImpl(
                         context.symbolProvider.provideByFqNameMulti(fqName),
-                        JKExpressionListImpl(),
+                        JKArgumentListImpl(),
                         JKTypeArgumentListImpl()
                     )
                 else -> error("Bad conversion")
@@ -96,13 +98,13 @@ class BuiltinMembersConversion(private val context: ConversionContext) : Recursi
         override fun build(from: JKExpression): JKExpression =
             when (from) {
                 is JKMethodCallExpression -> {
-                    val arguments = from.arguments::expressions.detached()
+                    val arguments = from.arguments::arguments.detached()
                     JKQualifiedExpressionImpl(
-                        arguments.first().parenthesizeIfBinaryExpression(),
+                        arguments.first()::value.detached().parenthesizeIfBinaryExpression(),
                         JKKtQualifierImpl.DOT,
                         JKKtCallExpressionImpl(
                             context.symbolProvider.provideByFqNameMulti(fqName),
-                            JKExpressionListImpl(arguments.drop(1)),
+                            JKArgumentListImpl(arguments.drop(1)),
                             from::typeArgumentList.detached()
                         )
                     )

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/DefaultArgumentsConversion.kt

@@ -52,7 +52,7 @@ class DefaultArgumentsConversion(private val context: ConversionContext) : Recur
             for (i in method.parameters.indices) {
                 val parameter = method.parameters[i]
                 val targetParameter = calledMethod.parameters[i]
-                val argument = call.arguments.expressions[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
@@ -60,7 +60,8 @@ class DefaultArgumentsConversion(private val context: ConversionContext) : Recur
 
 
             call.arguments.invalidate()
-            val defaults = call.arguments.expressions
+            val defaults = call.arguments.arguments
+                .map { it::value.detached() }
                 .zip(calledMethod.parameters)
                 .drop(method.parameters.size)
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/EqualsOperatorConversion.kt

@@ -5,27 +5,24 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.idea.refactoring.fqName.getKotlinFqName
 import org.jetbrains.kotlin.nj2k.ConversionContext
-import org.jetbrains.kotlin.j2k.ast.Nullability
 import org.jetbrains.kotlin.nj2k.equalsExpression
 import org.jetbrains.kotlin.nj2k.tree.*
-import org.jetbrains.kotlin.nj2k.tree.impl.*
+import org.jetbrains.kotlin.nj2k.tree.impl.JKParenthesizedExpressionImpl
-import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.nj2k.tree.impl.deepestFqName
 
 class EqualsOperatorConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
         if (element !is JKQualifiedExpression) return recurse(element)
         if (element.receiver is JKSuperExpression) return recurse(element)
         val selector = element.selector as? JKMethodCallExpression ?: return (element)
-        val argument = selector.arguments.expressions.singleOrNull() ?: return recurse(element)
+        val argument = selector.arguments.arguments.singleOrNull() ?: return recurse(element)
         if (selector.identifier.deepestFqName() == "java.lang.Object.equals") {
             return recurse(
                 JKParenthesizedExpressionImpl(
                     equalsExpression(
                         element::receiver.detached(),
-                        argument.detached(selector.arguments),
+                        argument::value.detached(),
                         context.symbolProvider
                     )
                 )

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ForConversion.kt

@@ -9,11 +9,11 @@ import com.intellij.psi.*
 import com.intellij.util.IncorrectOperationException
 import org.jetbrains.kotlin.j2k.ReferenceSearcher
 import org.jetbrains.kotlin.j2k.hasWriteAccesses
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.nj2k.*
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-import org.jetbrains.kotlin.lexer.KtTokens
-import org.jetbrains.kotlin.name.ClassId
 
 
 class ForConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
@@ -242,7 +242,7 @@ class ForConversion(private val context: ConversionContext) : RecursiveApplicabl
             JKQualifiedExpressionImpl(
                 indices,
                 JKKtQualifierImpl.DOT,
-                JKJavaMethodCallExpressionImpl(reversedSymbol, JKExpressionListImpl())
+                JKJavaMethodCallExpressionImpl(reversedSymbol, JKArgumentListImpl())
             )
         } else indices
     }
@@ -251,7 +251,7 @@ class ForConversion(private val context: ConversionContext) : RecursiveApplicabl
     private fun indicesByCollectionSize(javaSizeCall: JKQualifiedExpression): JKQualifiedExpression? {
         val methodCall = javaSizeCall.selector as? JKMethodCallExpression ?: return null
         return if (methodCall.identifier.deepestFqName() == "java.util.Collection.size"
-            && methodCall.arguments.expressions.isEmpty()
+            && methodCall.arguments.arguments.isEmpty()
         ) toIndicesCall(javaSizeCall) else null
     }
 

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/ImplicitCastsConversion.kt

@@ -5,11 +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.*
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
 class ImplicitCastsConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
     override fun applyToElement(element: JKTreeElement): JKTreeElement {
@@ -108,18 +109,17 @@ class ImplicitCastsConversion(private val context: ConversionContext) : Recursiv
         if (expression.identifier.isUnresolved()) return
         val parameterTypes = expression.identifier.parameterTypesWithUnfoldedVarargs() ?: return
         val newArguments =
-            (expression.arguments.expressions.asSequence() zip parameterTypes)
+            (expression.arguments.arguments.asSequence() zip parameterTypes)
                 .map { (expression, toType) ->
-                    expression.castTo(toType)
+                    expression.value.castTo(toType)
                 }.toList()
         val needUpdate = newArguments.any { it != null }
         if (needUpdate) {
-            expression.arguments = JKExpressionListImpl(
+            for ((newArgument, oldArgument) in newArguments zip expression.arguments.arguments) {
-                (newArguments zip expression.arguments.expressions)
+                if (newArgument != null) {
-                    .map { (newArgument, oldArgument) ->
+                    oldArgument.value = newArgument.copyTreeAndDetach()
-                        (newArgument ?: oldArgument).copyTreeAndDetach()
+                }
-                    }
+            }
-            )
         }
     }
 
@@ -171,7 +171,7 @@ class ImplicitCastsConversion(private val context: ConversionContext) : Recursiv
             JKKtQualifierImpl.DOT,
             JKJavaMethodCallExpressionImpl(
                 context.symbolProvider.provideByFqName("kotlin.$initialTypeName.$conversionFunctionName"),
-                JKExpressionListImpl()
+                JKArgumentListImpl()
             )
         )
     }

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/InsertDefaultPrimaryConstructorConversion.kt

@@ -39,7 +39,7 @@ class InsertDefaultPrimaryConstructorConversion(private val context: ConversionC
                     element
                 )
             )
-            constructor.delegationCall = JKDelegationConstructorCallImpl(superConstructor, JKSuperExpressionImpl(), JKExpressionListImpl())
+            constructor.delegationCall = JKDelegationConstructorCallImpl(superConstructor, JKSuperExpressionImpl(), JKArgumentListImpl())
         }
 
         return recurse(element)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/LabeledStatementConversion.kt

@@ -5,9 +5,14 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.blockStatement
+import org.jetbrains.kotlin.nj2k.asStatement
-import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.tree.JKLabeledStatement
-import org.jetbrains.kotlin.nj2k.tree.impl.*
+import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
+import org.jetbrains.kotlin.nj2k.tree.detached
+import org.jetbrains.kotlin.nj2k.tree.impl.JKBlockImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKBlockStatementWithoutBracketsImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKKtConvertedFromForLoopSyntheticWhileStatementImpl
+import org.jetbrains.kotlin.nj2k.tree.impl.JKLabeledStatementImpl
 
 
 class LabeledStatementConversion : RecursiveApplicableConversionBase() {
@@ -19,7 +24,7 @@ class LabeledStatementConversion : RecursiveApplicableConversionBase() {
             JKBlockStatementWithoutBracketsImpl(
                 JKBlockImpl(
                     statement::variableDeclaration.detached(),
-                    JKLabeledStatementImpl(statement::whileStatement.detached(), element::labels.detached())
+                    JKLabeledStatementImpl(statement::whileStatement.detached(), element::labels.detached()).asStatement()
                 )
             )
         )

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/OperatorExpressionConversion.kt

@@ -6,10 +6,13 @@
 package org.jetbrains.kotlin.nj2k.conversions
 
 import com.intellij.psi.JavaTokenType
-import org.jetbrains.kotlin.nj2k.*
+import org.jetbrains.kotlin.lexer.KtTokens
+import org.jetbrains.kotlin.nj2k.ConversionContext
+import org.jetbrains.kotlin.nj2k.kotlinBinaryExpression
+import org.jetbrains.kotlin.nj2k.kotlinPostfixExpression
+import org.jetbrains.kotlin.nj2k.kotlinPrefixExpression
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.impl.*
-import org.jetbrains.kotlin.lexer.KtTokens
 
 
 class OperatorExpressionConversion(private val context: ConversionContext) : RecursiveApplicableConversionBase() {
@@ -47,7 +50,7 @@ class OperatorExpressionConversion(private val context: ConversionContext) : Rec
             val invCall =
                 JKKtCallExpressionImpl(
                     context.symbolProvider.provideByFqName("kotlin.Int.inv"),//TODO check if Long
-                    JKExpressionListImpl()
+                    JKArgumentListImpl()
                 )
             JKQualifiedExpressionImpl(
                 JKParenthesizedExpressionImpl(operand),
@@ -70,7 +73,7 @@ class OperatorExpressionConversion(private val context: ConversionContext) : Rec
             val toStringCall =
                 JKKtCallExpressionImpl(
                     context.symbolProvider.provideByFqName("kotlin.Any.toString"),
-                    JKExpressionListImpl()
+                    JKArgumentListImpl()
                 )
             val qualifiedCall = JKQualifiedExpressionImpl(left, JKKtQualifierImpl.DOT, toStringCall)
             kotlinBinaryExpression(qualifiedCall, right, KtTokens.PLUS, context.symbolProvider)

nj2k/src/org/jetbrains/kotlin/nj2k/conversions/SynchronizedStatementConversion.kt

@@ -5,8 +5,9 @@
 
 package org.jetbrains.kotlin.nj2k.conversions
 
-import org.jetbrains.kotlin.nj2k.*
+import org.jetbrains.kotlin.nj2k.ConversionContext
-import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.tree.JKJavaSynchronizedStatement
+import org.jetbrains.kotlin.nj2k.tree.JKTreeElement
 import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 
@@ -21,7 +22,7 @@ class SynchronizedStatementConversion(private val context: ConversionContext) :
         val synchronizedCall =
             JKKtCallExpressionImpl(
                 context.symbolProvider.provideByFqNameMulti("kotlin.synchronized"),
-                JKExpressionListImpl(
+                JKArgumentListImpl(
                     element.lockExpression,
                     lambdaBody
                 )

nj2k/src/org/jetbrains/kotlin/nj2k/expressions.kt

@@ -10,16 +10,17 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.tree.TokenSet
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.conversions.RecursiveApplicableConversionBase
-import org.jetbrains.kotlin.nj2k.conversions.multiResolveFqName
-import org.jetbrains.kotlin.nj2k.conversions.resolveFqName
-import org.jetbrains.kotlin.nj2k.tree.*
-import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.nj2k.conversions.RecursiveApplicableConversionBase
+import org.jetbrains.kotlin.nj2k.conversions.multiResolveFqName
+import org.jetbrains.kotlin.nj2k.tree.*
+import org.jetbrains.kotlin.nj2k.tree.impl.*
 import org.jetbrains.kotlin.psi.KtNamedFunction
+import org.jetbrains.kotlin.utils.addToStdlib.cast
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
+import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 import java.math.BigInteger
 
 fun kotlinTypeByName(name: String, symbolProvider: JKSymbolProvider, nullability: Nullability = Nullability.Nullable): JKClassType =
@@ -289,7 +290,7 @@ fun useExpression(
     val methodCall =
         JKJavaMethodCallExpressionImpl(
             useSymbol,
-            JKExpressionListImpl(listOf(lambda))
+            listOf(lambda).toArgumentList()
         )
     return JKQualifiedExpressionImpl(receiver, JKKtQualifierImpl.DOT, methodCall)
 }
@@ -300,7 +301,7 @@ fun kotlinAssert(assertion: JKExpression, message: JKExpression?, symbolProvider
             "assert",
             kotlinTypeByName(KotlinBuiltIns.FQ_NAMES.unit.asString(), symbolProvider)
         ),
-        JKExpressionListImpl(listOfNotNull(assertion, message))
+        (listOfNotNull(assertion, message)).toArgumentList()
     )
 
 fun jvmAnnotation(name: String, symbolProvider: JKSymbolProvider) =
@@ -502,7 +503,7 @@ fun runExpression(body: JKStatement, symbolProvider: JKSymbolProvider): JKExpres
     )
     return JKKtCallExpressionImpl(
         symbolProvider.provideByFqNameMulti("kotlin.run"),
-        JKExpressionListImpl(listOf(lambda))
+        (listOf(lambda)).toArgumentList()
     )
 }
 
@@ -525,7 +526,17 @@ fun JKAnnotationMemberValue.toExpression(symbolProvider: JKSymbolProvider): JKEx
             this is JKAnnotation ->
                 JKJavaNewExpressionImpl(
                     classSymbol,
-                    JKExpressionListImpl(arguments.map { it.value.detached(this).toExpression(symbolProvider) }),
+                    JKArgumentListImpl(
+                        arguments.map { argument ->
+                            val value = argument.value.copyTreeAndDetach().toExpression(symbolProvider)
+                            when (argument) {
+                                is JKAnnotationNameParameter ->
+                                    JKNamedArgumentImpl(value, JKNameIdentifierImpl(argument.name.value))
+                                else -> JKArgumentImpl(value)
+                            }
+
+                        }
+                    ),
                     JKTypeArgumentListImpl()
                 )
             this is JKKtAnnotationArrayInitializerExpression ->
@@ -539,6 +550,9 @@ fun JKAnnotationMemberValue.toExpression(symbolProvider: JKSymbolProvider): JKEx
 inline fun JKClass.primaryConstructor(): JKKtPrimaryConstructor? =
     classBody.declarations.firstIsInstanceOrNull()
 
+fun List<JKExpression>.toArgumentList(): JKArgumentList =
+    JKArgumentListImpl(map { JKArgumentImpl(it) })
+
 fun JKAnnotation.isVarargsArgument(index: Int): Boolean {
     val target = classSymbol.target
     return when (target) {

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/j.kt

@@ -20,10 +20,10 @@ 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.lexer.KtTokens
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.JKLiteralExpression.LiteralType.*
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor
-import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.resolve.jvm.JvmPrimitiveType
 
 class JKJavaFieldImpl(
@@ -197,12 +197,12 @@ sealed class JKJavaQualifierImpl : JKQualifier {
 
 class JKJavaMethodCallExpressionImpl(
     override var identifier: JKMethodSymbol,
-    arguments: JKExpressionList,
+    arguments: JKArgumentList,
     typeArgumentList: JKTypeArgumentList = JKTypeArgumentListImpl()
 ) : JKJavaMethodCallExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitJavaMethodCallExpression(this, data)
 
-    override var arguments: JKExpressionList by child(arguments)
+    override var arguments: JKArgumentList by child(arguments)
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
 }
 
@@ -219,11 +219,11 @@ class JKEmptyClassBodyImpl : JKEmptyClassBody, JKBranchElementBase() {
 
 class JKJavaNewExpressionImpl(
     override var classSymbol: JKClassSymbol,
-    arguments: JKExpressionList,
+    arguments: JKArgumentList,
     typeArgumentList: JKTypeArgumentList,
     classBody: JKClassBody = JKEmptyClassBodyImpl()
 ) : JKJavaNewExpression, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
-    override var arguments: JKExpressionList by child(arguments)
+    override var arguments: JKArgumentList by child(arguments)
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
     override var classBody: JKClassBody by child(classBody)
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/jk.kt

@@ -19,17 +19,15 @@ package org.jetbrains.kotlin.nj2k.tree.impl
 import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.nj2k.JKSymbolProvider
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import org.jetbrains.kotlin.nj2k.conversions.resolveFqName
+import org.jetbrains.kotlin.name.ClassId
+import org.jetbrains.kotlin.nj2k.JKSymbolProvider
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.JKLiteralExpression.LiteralType
 import org.jetbrains.kotlin.nj2k.tree.JKLiteralExpression.LiteralType.BOOLEAN
 import org.jetbrains.kotlin.nj2k.tree.JKLiteralExpression.LiteralType.NULL
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor
-import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.psi.KtClass
-import org.jetbrains.kotlin.psi.KtNamedFunction
 
 
 class JKFileImpl(
@@ -380,11 +378,11 @@ class JKInheritanceInfoImpl(
 class JKDelegationConstructorCallImpl(
     override val identifier: JKMethodSymbol,
     expression: JKExpression,
-    arguments: JKExpressionList
+    arguments: JKArgumentList
 ) : JKBranchElementBase(), JKDelegationConstructorCall, PsiOwner by PsiOwnerImpl() {
     override var typeArgumentList: JKTypeArgumentList by child(JKTypeArgumentListImpl())
     override val expression: JKExpression by child(expression)
-    override var arguments: JKExpressionList by child(arguments)
+    override var arguments: JKArgumentList by child(arguments)
 
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitDelegationConstructorCall(this, data)
 }
@@ -453,12 +451,12 @@ class JKTypeParameterTypeImpl(
 
 class JKEnumConstantImpl(
     name: JKNameIdentifier,
-    arguments: JKExpressionList,
+    arguments: JKArgumentList,
     body: JKClassBody,
     type: JKTypeElement
 ) : JKEnumConstant, JKBranchElementBase(), PsiOwner by PsiOwnerImpl() {
     override var name: JKNameIdentifier by child(name)
-    override val arguments: JKExpressionList by child(arguments)
+    override val arguments: JKArgumentList by child(arguments)
     override val body: JKClassBody by child(body)
     override var type: JKTypeElement by child(type)
     override var initializer: JKExpression by child(JKStubExpressionImpl())
@@ -540,3 +538,27 @@ class JKAnnotationNameParameterImpl(
 
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitAnnotationNameParameter(this, data)
 }
+
+class JKNamedArgumentImpl(
+    value: JKExpression,
+    name: JKNameIdentifier
+) : JKNamedArgument, JKBranchElementBase() {
+    override var value by child(value)
+    override val name by child(name)
+
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitNamedArgument(this, data)
+}
+
+class JKArgumentImpl(value: JKExpression) : JKArgument, JKBranchElementBase() {
+    override var value by child(value)
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArgument(this, data)
+}
+
+class JKArgumentListImpl(arguments: List<JKArgument> = emptyList()) : JKArgumentList, JKBranchElementBase() {
+    constructor(vararg arguments: JKArgument) : this(arguments.toList())
+    constructor(vararg values: JKExpression) : this(values.map { JKArgumentImpl(it) })
+
+    override var arguments by children(arguments)
+
+    override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitArgumentList(this, data)
+}

nj2k/src/org/jetbrains/kotlin/nj2k/tree/impl/k.kt

@@ -16,12 +16,10 @@
 
 package org.jetbrains.kotlin.nj2k.tree.impl
 
-import com.intellij.psi.JavaTokenType
 import org.jetbrains.kotlin.j2k.ast.Nullability
-import com.intellij.psi.tree.IElementType
+import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.nj2k.tree.*
 import org.jetbrains.kotlin.nj2k.tree.visitors.JKVisitor
-import org.jetbrains.kotlin.lexer.KtSingleValueToken
 import org.jetbrains.kotlin.types.expressions.OperatorConventions
 import org.jetbrains.kotlin.utils.addToStdlib.cast
 
@@ -75,12 +73,12 @@ sealed class JKKtQualifierImpl : JKQualifier, JKElementBase() {
 
 class JKKtCallExpressionImpl(
     override val identifier: JKMethodSymbol,
-    arguments: JKExpressionList,
+    arguments: JKArgumentList,
     typeArgumentList: JKTypeArgumentList = JKTypeArgumentListImpl()
 ) : JKKtMethodCallExpression, JKBranchElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtMethodCallExpression(this, data)
 
-    override var arguments: JKExpressionList by child(arguments)
+    override var arguments: JKArgumentList by child(arguments)
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)
 }
 
@@ -122,15 +120,13 @@ class JKKtAlsoCallExpressionImpl(
 ) : JKKtAlsoCallExpression, JKBranchElementBase() {
     override fun <R, D> accept(visitor: JKVisitor<R, D>, data: D): R = visitor.visitKtAlsoCallExpression(this, data)
     override var statement
-        get() = arguments.expressions.first().cast<JKLambdaExpressionImpl>().statement
+        get() = arguments.arguments.first().value.cast<JKLambdaExpressionImpl>().statement
         set(it) {
-            arguments.expressions.first().cast<JKLambdaExpressionImpl>().statement = it
+            arguments.arguments.first().value.cast<JKLambdaExpressionImpl>().statement = it
         }
-    override var arguments: JKExpressionList by child(
+    override var arguments: JKArgumentList by child(
-        JKExpressionListImpl(
+        JKArgumentListImpl(
-            listOf(
+            JKLambdaExpressionImpl(statement, emptyList())
-                JKLambdaExpressionImpl(statement, emptyList())
-            )
         )
     )
     override var typeArgumentList: JKTypeArgumentList by child(typeArgumentList)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/j.kt

@@ -16,8 +16,7 @@
 
 package org.jetbrains.kotlin.nj2k.tree
 
-import org.jetbrains.kotlin.idea.search.usagesSearch.constructor
+import org.jetbrains.kotlin.nj2k.tree.impl.JKClassSymbol
-import org.jetbrains.kotlin.nj2k.tree.impl.*
 
 interface JKField : JKVariable, JKVisibilityOwner, JKMutabilityOwner, JKModalityOwner, JKExtraModifiersOwner, JKAnnotationListOwner
 
@@ -37,7 +36,7 @@ interface JKEmptyClassBody : JKClassBody
 
 interface JKJavaNewExpression : JKExpression, JKTypeArgumentListOwner, PsiOwner {
     val classSymbol: JKClassSymbol
-    var arguments: JKExpressionList
+    var arguments: JKArgumentList
     var classBody: JKClassBody
 }
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/jk.kt

@@ -259,7 +259,7 @@ interface JKTypeArgumentListOwner : JKTreeElement {
 
 interface JKMethodCallExpression : JKExpression, JKTypeArgumentListOwner, JKBranchElement {
     val identifier: JKMethodSymbol
-    var arguments: JKExpressionList
+    var arguments: JKArgumentList
 }
 
 interface JKFieldAccessExpression : JKAssignableExpression {
@@ -288,6 +288,19 @@ interface JKExpressionList : JKTreeElement, JKBranchElement {
     var expressions: List<JKExpression>
 }
 
+interface JKArgument : JKTreeElement, JKBranchElement {
+    var value: JKExpression
+}
+
+interface JKNamedArgument : JKArgument {
+    val name: JKNameIdentifier
+}
+
+interface JKArgumentList : JKTreeElement, JKBranchElement {
+    var arguments: List<JKArgument>
+}
+
+
 interface JKLiteralExpression : JKExpression {
     val literal: String
     val type: LiteralType
@@ -367,7 +380,7 @@ interface JKLambdaExpression : JKExpression {
 interface JKDelegationConstructorCall : JKMethodCallExpression {
     override val identifier: JKMethodSymbol
     val expression: JKExpression
-    override var arguments: JKExpressionList
+    override var arguments: JKArgumentList
 }
 
 interface JKLabel : JKTreeElement
@@ -403,7 +416,7 @@ interface JKTypeParameterListOwner : JKTreeElement {
 }
 
 interface JKEnumConstant : JKVariable {
-    val arguments: JKExpressionList
+    val arguments: JKArgumentList
     val body: JKClassBody
 }
 

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitor.kt

@@ -46,6 +46,9 @@ interface JKVisitor<out R, in D> {
     fun visitParenthesizedExpression(parenthesizedExpression: JKParenthesizedExpression, data: D): R = visitExpression(parenthesizedExpression, data)
     fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: D): R = visitExpression(typeCastExpression, data)
     fun visitExpressionList(expressionList: JKExpressionList, data: D): R = visitTreeElement(expressionList, data)
+    fun visitArgument(argument: JKArgument, data: D): R = visitTreeElement(argument, data)
+    fun visitNamedArgument(namedArgument: JKNamedArgument, data: D): R = visitArgument(namedArgument, data)
+    fun visitArgumentList(argumentList: JKArgumentList, data: D): R = visitTreeElement(argumentList, data)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: D): R = visitExpression(literalExpression, data)
     fun visitParameter(parameter: JKParameter, data: D): R = visitVariable(parameter, data)
     fun visitStringLiteralExpression(stringLiteralExpression: JKStringLiteralExpression, data: D): R = visitLiteralExpression(stringLiteralExpression, data)
@@ -69,7 +72,7 @@ interface JKVisitor<out R, in D> {
     fun visitLabelEmpty(labelEmpty: JKLabelEmpty, data: D): R = visitLabel(labelEmpty, data)
     fun visitLabelText(labelText: JKLabelText, data: D): R = visitLabel(labelText, data)
     fun visitContinueStatement(continueStatement: JKContinueStatement, data: D): R = visitStatement(continueStatement, data)
-    fun visitLabeledStatement(labeledStatement: JKLabeledStatement, data: D): R = visitStatement(labeledStatement, data)
+    fun visitLabeledStatement(labeledStatement: JKLabeledStatement, data: D): R = visitExpression(labeledStatement, data)
     fun visitEmptyStatement(emptyStatement: JKEmptyStatement, data: D): R = visitStatement(emptyStatement, data)
     fun visitTypeParameterList(typeParameterList: JKTypeParameterList, data: D): R = visitTreeElement(typeParameterList, data)
     fun visitTypeParameter(typeParameter: JKTypeParameter, data: D): R = visitTreeElement(typeParameter, data)
@@ -105,6 +108,7 @@ interface JKVisitor<out R, in D> {
     fun visitJavaContinueStatement(javaContinueStatement: JKJavaContinueStatement, data: D): R = visitStatement(javaContinueStatement, data)
     fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement, data: D): R = visitStatement(javaSynchronizedStatement, data)
     fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod, data: D): R = visitMethod(javaAnnotationMethod, data)
+    fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration, data: D): R = visitDeclaration(javaStaticInitDeclaration, data)
     fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter, data: D): R = visitTreeElement(ktGetterOrSetter, data)
     fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter, data: D): R = visitKtGetterOrSetter(ktEmptyGetterOrSetter, data)
     fun visitKtProperty(ktProperty: JKKtProperty, data: D): R = visitField(ktProperty, data)

nj2k/src/org/jetbrains/kotlin/nj2k/tree/visitors/JKVisitorVoid.kt

@@ -89,6 +89,12 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitTypeCastExpression(typeCastExpression: JKTypeCastExpression, data: Nothing?) = visitTypeCastExpression(typeCastExpression)
     fun visitExpressionList(expressionList: JKExpressionList) = visitTreeElement(expressionList, null)
     override fun visitExpressionList(expressionList: JKExpressionList, data: Nothing?) = visitExpressionList(expressionList)
+    fun visitArgument(argument: JKArgument) = visitTreeElement(argument, null)
+    override fun visitArgument(argument: JKArgument, data: Nothing?) = visitArgument(argument)
+    fun visitNamedArgument(namedArgument: JKNamedArgument) = visitArgument(namedArgument, null)
+    override fun visitNamedArgument(namedArgument: JKNamedArgument, data: Nothing?) = visitNamedArgument(namedArgument)
+    fun visitArgumentList(argumentList: JKArgumentList) = visitTreeElement(argumentList, null)
+    override fun visitArgumentList(argumentList: JKArgumentList, data: Nothing?) = visitArgumentList(argumentList)
     fun visitLiteralExpression(literalExpression: JKLiteralExpression) = visitExpression(literalExpression, null)
     override fun visitLiteralExpression(literalExpression: JKLiteralExpression, data: Nothing?) = visitLiteralExpression(literalExpression)
     fun visitParameter(parameter: JKParameter) = visitVariable(parameter, null)
@@ -135,7 +141,7 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitLabelText(labelText: JKLabelText, data: Nothing?) = visitLabelText(labelText)
     fun visitContinueStatement(continueStatement: JKContinueStatement) = visitStatement(continueStatement, null)
     override fun visitContinueStatement(continueStatement: JKContinueStatement, data: Nothing?) = visitContinueStatement(continueStatement)
-    fun visitLabeledStatement(labeledStatement: JKLabeledStatement) = visitStatement(labeledStatement, null)
+    fun visitLabeledStatement(labeledStatement: JKLabeledStatement) = visitExpression(labeledStatement, null)
     override fun visitLabeledStatement(labeledStatement: JKLabeledStatement, data: Nothing?) = visitLabeledStatement(labeledStatement)
     fun visitEmptyStatement(emptyStatement: JKEmptyStatement) = visitStatement(emptyStatement, null)
     override fun visitEmptyStatement(emptyStatement: JKEmptyStatement, data: Nothing?) = visitEmptyStatement(emptyStatement)
@@ -207,6 +213,8 @@ interface JKVisitorVoid : JKVisitor<Unit, Nothing?> {
     override fun visitJavaSynchronizedStatement(javaSynchronizedStatement: JKJavaSynchronizedStatement, data: Nothing?) = visitJavaSynchronizedStatement(javaSynchronizedStatement)
     fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod) = visitMethod(javaAnnotationMethod, null)
     override fun visitJavaAnnotationMethod(javaAnnotationMethod: JKJavaAnnotationMethod, data: Nothing?) = visitJavaAnnotationMethod(javaAnnotationMethod)
+    fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration) = visitDeclaration(javaStaticInitDeclaration, null)
+    override fun visitJavaStaticInitDeclaration(javaStaticInitDeclaration: JKJavaStaticInitDeclaration, data: Nothing?) = visitJavaStaticInitDeclaration(javaStaticInitDeclaration)
     fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter) = visitTreeElement(ktGetterOrSetter, null)
     override fun visitKtGetterOrSetter(ktGetterOrSetter: JKKtGetterOrSetter, data: Nothing?) = visitKtGetterOrSetter(ktGetterOrSetter)
     fun visitKtEmptyGetterOrSetter(ktEmptyGetterOrSetter: JKKtEmptyGetterOrSetter) = visitKtGetterOrSetter(ktEmptyGetterOrSetter, null)