J2K ValueParameterDescriptor inteface in one go

compiler/backend/src/org/jetbrains/kotlin/codegen/DefaultParameterValueSubstitutor.kt

@@ -175,7 +175,7 @@ public class DefaultParameterValueSubstitutor(val state: GenerationState) {
             }
             else {
                 AsmUtil.pushDefaultValueOnStack(paramType, v)
-                val i = parameterDescriptor.getIndex()
+                val i = parameterDescriptor.index
                 if (i != 0 && i % Integer.SIZE == 0) {
                     masks.add(mask)
                     mask = 0

compiler/frontend/src/org/jetbrains/kotlin/cfg/pseudocode/pseudocodeUtils.kt

@@ -131,7 +131,7 @@ public fun getExpectedTypePredicate(
             val candidateParameter = mapping.valueParameter
             val resolvedArgument = candidateArgumentMap.get(candidateParameter)
             val expectedType = if (resolvedArgument is VarargValueArgument)
-                candidateParameter.getVarargElementType()
+                candidateParameter.varargElementType
             else
                 candidateParameter.getType()
 
@@ -190,7 +190,7 @@ public fun getExpectedTypePredicate(
                         it.arguments[value]?.let { parameter ->
                             val expectedType = when (it.resolvedCall.getValueArguments()[parameter]) {
                                 is VarargValueArgument ->
-                                    parameter.getVarargElementType()
+                                    parameter.varargElementType
                                 else ->
                                     parameter.getType()
                             }

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/Renderers.kt

@@ -183,10 +183,10 @@ public object Renderers {
             val parameterTypes = Lists.newArrayList<KotlinType>()
             for (valueParameterDescriptor in substitutedDescriptor.getValueParameters()) {
                 parameterTypes.add(valueParameterDescriptor.getType())
-                if (valueParameterDescriptor.getIndex() >= inferenceErrorData.valueArgumentsTypes.size()) continue
+                if (valueParameterDescriptor.index >= inferenceErrorData.valueArgumentsTypes.size()) continue
-                val actualType = inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.getIndex())
+                val actualType = inferenceErrorData.valueArgumentsTypes.get(valueParameterDescriptor.index)
                 if (!KotlinTypeChecker.DEFAULT.isSubtypeOf(actualType, valueParameterDescriptor.getType())) {
-                    errorPositions.add(VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex()))
+                    errorPositions.add(VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index))
                 }
             }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -201,7 +201,7 @@ class FunctionDescriptorResolver(
                 val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"),
                                                       valueParameterDescriptor.getType(), valueParameterDescriptor.declaresDefaultValue(),
                                                       valueParameterDescriptor.isCrossinline, valueParameterDescriptor.isNoinline,
-                                                      valueParameterDescriptor.getVarargElementType(), SourceElement.NO_SOURCE)
+                                                      valueParameterDescriptor.varargElementType, SourceElement.NO_SOURCE)
                 trace.record(BindingContext.AUTO_CREATED_IT, it)
                 return listOf(it)
             }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolverUtil.kt

@@ -148,13 +148,13 @@ public fun getSuperCallExpression(call: Call): KtSuperExpression? {
 
 public fun getEffectiveExpectedType(parameterDescriptor: ValueParameterDescriptor, argument: ValueArgument): KotlinType {
     if (argument.getSpreadElement() != null) {
-        if (parameterDescriptor.getVarargElementType() == null) {
+        if (parameterDescriptor.varargElementType == null) {
             // Spread argument passed to a non-vararg parameter, an error is already reported by ValueArgumentsToParametersMapper
             return DONT_CARE
         }
         return parameterDescriptor.getType()
     }
-    val varargElementType = parameterDescriptor.getVarargElementType()
+    val varargElementType = parameterDescriptor.varargElementType
     if (varargElementType != null) {
         return varargElementType
     }

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/GenericCandidateResolver.kt

@@ -75,7 +75,7 @@ class GenericCandidateResolver(
         // Value parameters
         for (entry in candidateCall.getValueArguments().entrySet()) {
             val resolvedValueArgument = entry.getValue()
-            val valueParameterDescriptor = candidate.getValueParameters().get(entry.getKey().getIndex())
+            val valueParameterDescriptor = candidate.getValueParameters().get(entry.getKey().index)
 
 
             for (valueArgument in resolvedValueArgument.getArguments()) {
@@ -131,7 +131,7 @@ class GenericCandidateResolver(
         val typeInfoForCall = argumentTypeResolver.getArgumentTypeInfo(argumentExpression, newContext, resolveFunctionArgumentBodies)
         context.candidateCall.getDataFlowInfoForArguments().updateInfo(valueArgument, typeInfoForCall.dataFlowInfo)
 
-        val constraintPosition = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
+        val constraintPosition = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index)
 
         if (addConstraintForNestedCall(argumentExpression, constraintPosition, constraintSystem, newContext, effectiveExpectedType)) return
 
@@ -240,7 +240,7 @@ class GenericCandidateResolver(
 
         //todo analyze function literal body once in 'dependent' mode, then complete it with respect to expected type
         val hasExpectedReturnType = !hasUnknownReturnType(expectedType)
-        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
+        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index)
         if (hasExpectedReturnType) {
             val temporaryToResolveFunctionLiteral = TemporaryTraceAndCache.create(
                     context, "trace to resolve function literal with expected return type", argumentExpression)
@@ -279,7 +279,7 @@ class GenericCandidateResolver(
                            ?: return
         if (!ReflectionTypes.isCallableType(expectedType)) return
         val resolvedType = getResolvedTypeForCallableReference(callableReference, context, expectedType, valueArgument)
-        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.getIndex())
+        val position = VALUE_PARAMETER_POSITION.position(valueParameterDescriptor.index)
         constraintSystem.addSubtypeConstraint(resolvedType, effectiveExpectedType, position)
     }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt

@@ -74,8 +74,8 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu
             original.getTypeParameters(),
             original.getValueParameters().drop(1).map { p ->
                 ValueParameterDescriptorImpl(
-                        result, null, p.getIndex() - 1, p.getAnnotations(), Name.identifier("p${p.getIndex() + 1}"), p.getType(),
+                        result, null, p.index - 1, p.getAnnotations(), Name.identifier("p${p.index + 1}"), p.getType(),
-                        p.declaresDefaultValue(), p.isCrossinline, p.isNoinline, p.getVarargElementType(), p.getSource()
+                        p.declaresDefaultValue(), p.isCrossinline, p.isNoinline, p.varargElementType, p.getSource()
                 )
             },
             original.getReturnType(),

compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt

@@ -83,7 +83,7 @@ public class ConstantExpressionEvaluator(
             parameterDescriptor: ValueParameterDescriptor,
             resolvedArgument: ResolvedValueArgument
     ): ConstantValue<*>? {
-        val varargElementType = parameterDescriptor.getVarargElementType()
+        val varargElementType = parameterDescriptor.varargElementType
         val argumentsAsVararg = varargElementType != null && !hasSpread(resolvedArgument)
         val constantType = if (argumentsAsVararg) varargElementType else parameterDescriptor.getType()
         val compileTimeConstants = resolveAnnotationValueArguments(resolvedArgument, constantType!!, trace)
@@ -153,7 +153,7 @@ public class ConstantExpressionEvaluator(
 
         val argumentEntry = resolvedCall.getValueArguments().entrySet().single()
 
-        val elementType = argumentEntry.getKey().getVarargElementType() ?: return null
+        val elementType = argumentEntry.getKey().varargElementType ?: return null
 
         val result = arrayListOf<KtExpression>()
         for (valueArgument in argumentEntry.getValue().getArguments()) {
@@ -588,7 +588,7 @@ private class ConstantExpressionEvaluatorVisitor(
 
         // arrayOf()
         if (CompileTimeConstantUtils.isArrayMethodCall(call)) {
-            val varargType = resultingDescriptor.getValueParameters().first().getVarargElementType()!!
+            val varargType = resultingDescriptor.getValueParameters().first().varargElementType!!
 
             val arguments = call.getValueArguments().values().flatMap { resolveArguments(it.getArguments(), varargType) }
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt

@@ -147,7 +147,7 @@ public open class LazyClassMemberScope(
 
             for (parameter in constructor.getValueParameters()) {
                 if (parameter.getType().isError()) continue
-                if (!primaryConstructorParameters.get(parameter.getIndex()).hasValOrVar()) continue
+                if (!primaryConstructorParameters.get(parameter.index).hasValOrVar()) continue
 
                 val properties = getProperties(parameter.name, location)
                 if (properties.isEmpty()) continue
@@ -219,7 +219,7 @@ public open class LazyClassMemberScope(
         for (valueParameterDescriptor in valueParameterDescriptors) {
             if (name != valueParameterDescriptor.getName()) continue
 
-            val parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex())
+            val parameter = primaryConstructorParameters.get(valueParameterDescriptor.index)
             if (parameter.hasValOrVar()) {
                 val propertyDescriptor = c.descriptorResolver.resolvePrimaryConstructorParameterToAProperty(
                         thisDescriptor, valueParameterDescriptor, thisDescriptor.getScopeForClassHeaderResolution(), parameter, trace)

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt

@@ -46,14 +46,14 @@ fun copyValueParameters(
         ValueParameterDescriptorImpl(
                 newOwner,
                 oldParameter,
-                oldParameter.getIndex(),
+                oldParameter.index,
                 oldParameter.getAnnotations(),
                 oldParameter.getName(),
                 newType,
                 oldParameter.declaresDefaultValue(),
                 oldParameter.isCrossinline,
                 oldParameter.isNoinline,
-                if (oldParameter.getVarargElementType() != null) newOwner.module.builtIns.getArrayElementType(newType) else null,
+                if (oldParameter.varargElementType != null) newOwner.module.builtIns.getArrayElementType(newType) else null,
                 oldParameter.getSource()
         )
     }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/typeEnhacement/signatureEnhancement.kt

@@ -37,7 +37,7 @@ public fun <D : CallableMemberDescriptor> D.enhanceSignature(): D {
             else null
 
     val enhancedValueParametersTypes = getValueParameters().map {
-        p -> parts(isCovariant = false) { it.getValueParameters()[p.getIndex()].getType() }.enhance()
+        p -> parts(isCovariant = false) { it.getValueParameters()[p.index].getType() }.enhance()
     }
 
     val enhancedReturnType = parts(isCovariant = true) { it.getReturnType()!! }.enhance()

core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.kt

@@ -14,53 +14,41 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.descriptors;
+package org.jetbrains.kotlin.descriptors
 
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.name.Name
-import org.jetbrains.annotations.Nullable;
+import org.jetbrains.kotlin.types.KotlinType
-import org.jetbrains.kotlin.name.Name;
-import org.jetbrains.kotlin.types.KotlinType;
 
-import java.util.Collection;
+interface ValueParameterDescriptor : VariableDescriptor, ParameterDescriptor {
-
+    override fun getContainingDeclaration(): CallableDescriptor
-public interface ValueParameterDescriptor extends VariableDescriptor, ParameterDescriptor {
-    @NotNull
-    @Override
-    CallableDescriptor getContainingDeclaration();
 
     /**
      * Returns the 0-based index of the value parameter in the parameter list of its containing function.
-     *
+
      * @return the parameter index
      */
-    int getIndex();
+    val index: Int
 
     /**
      * @return true iff this parameter belongs to a declared function (not a fake override) and declares the default value,
      * i.e. explicitly specifies it in the function signature. Also see 'hasDefaultValue' extension in DescriptorUtils.kt
      */
-    boolean declaresDefaultValue();
+    fun declaresDefaultValue(): Boolean
 
-    @Nullable
+    val varargElementType: KotlinType?
-    KotlinType getVarargElementType();
 
-    @NotNull
+    override fun getOriginal(): ValueParameterDescriptor
-    @Override
-    ValueParameterDescriptor getOriginal();
 
-    @NotNull
+    fun copy(newOwner: CallableDescriptor, newName: Name): ValueParameterDescriptor
-    ValueParameterDescriptor copy(@NotNull CallableDescriptor newOwner, @NotNull Name newName);
 
     /**
      * Parameter p1 overrides p2 iff
      * a) their respective owners (function declarations) f1 override f2
      * b) p1 and p2 have the same indices in the owners' parameter lists
      */
-    @NotNull
+    override fun getOverriddenDescriptors(): Collection<ValueParameterDescriptor>
-    @Override
-    Collection<? extends ValueParameterDescriptor> getOverriddenDescriptors();
 
-    boolean isCrossinline();
+    val isCrossinline: Boolean
 
-    boolean isNoinline();
+    val isNoinline: Boolean
 }

core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java

@@ -137,7 +137,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme
 
     @NotNull
     @Override
-    public Collection<? extends ValueParameterDescriptor> getOverriddenDescriptors() {
+    public Collection<ValueParameterDescriptor> getOverriddenDescriptors() {
         return CollectionsKt.map(
                 getContainingDeclaration().getOverriddenDescriptors(),
                 new Function1<CallableDescriptor, ValueParameterDescriptor>() {

core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt

@@ -677,7 +677,7 @@ internal class DescriptorRendererImpl(
         }
 
         if (verbose) {
-            builder.append("/*").append(valueParameter.getIndex()).append("*/ ")
+            builder.append("/*").append(valueParameter.index).append("*/ ")
         }
 
         renderAnnotations(valueParameter, builder)
@@ -704,7 +704,7 @@ internal class DescriptorRendererImpl(
     private fun renderVariable(variable: VariableDescriptor, includeName: Boolean, builder: StringBuilder, topLevel: Boolean) {
         val realType = variable.getType()
 
-        val varargElementType = (variable as? ValueParameterDescriptor)?.getVarargElementType()
+        val varargElementType = (variable as? ValueParameterDescriptor)?.varargElementType
         val typeToRender = varargElementType ?: realType
 
         if (varargElementType != null) {

idea/ide-common/src/org/jetbrains/kotlin/idea/util/ShadowedDeclarationsFilter.kt

@@ -128,11 +128,11 @@ public class ShadowedDeclarationsFilter(
 
         val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace for filtering shadowed declarations")
         for ((expression, parameter) in dummyArgumentExpressions.zip(parameters)) {
-            bindingTrace.recordType(expression, parameter.getVarargElementType() ?: parameter.getType())
+            bindingTrace.recordType(expression, parameter.varargElementType ?: parameter.getType())
             bindingTrace.record(BindingContext.PROCESSED, expression, true)
         }
 
-        val firstVarargIndex = parameters.withIndex().firstOrNull { it.value.getVarargElementType() != null }?.index
+        val firstVarargIndex = parameters.withIndex().firstOrNull { it.value.varargElementType != null }?.index
         val useNamedFromIndex = if (firstVarargIndex != null && firstVarargIndex != parameters.lastIndex) firstVarargIndex else parameters.size()
 
         class DummyArgument(val index: Int) : ValueArgument {
@@ -232,7 +232,7 @@ public class ShadowedDeclarationsFilter(
             for (i in parameters1.indices) {
                 val p1 = parameters1[i]
                 val p2 = parameters2[i]
-                if (p1.getVarargElementType() != p2.getVarargElementType()) return false // both should be vararg or or both not
+                if (p1.varargElementType != p2.varargElementType) return false // both should be vararg or or both not
                 if (p1.getType() != p2.getType()) return false
             }
             return true

idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/KotlinClsFileBase.kt

@@ -39,7 +39,7 @@ public abstract class KotlinClsFileBase(val provider: KotlinClassFileViewProvide
         if (original is ValueParameterDescriptor) {
             val callable = original.getContainingDeclaration()
             val callableDeclaration = getDeclarationForDescriptor(callable) as? KtCallableDeclaration ?: return null
-            return callableDeclaration.getValueParameters()[original.getIndex()]
+            return callableDeclaration.getValueParameters()[original.index]
         }
 
         if (original is ConstructorDescriptor && original.isPrimary()) {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/highlighter/renderersUtil.kt

@@ -53,7 +53,7 @@ fun <D : CallableDescriptor> renderResolvedCall(resolvedCall: ResolvedCall<D>):
     fun append(any: Any): StringBuilder = stringBuilder.append(any)
 
     fun renderParameter(parameter: ValueParameterDescriptor): String {
-        val varargElementType = parameter.getVarargElementType()
+        val varargElementType = parameter.varargElementType
         val parameterType = varargElementType ?: parameter.getType()
         val renderedParameter =
                 (if (varargElementType != null) "<b>vararg</b> " else "") +

idea/idea-completion/src/org/jetbrains/kotlin/idea/completion/ExpectedInfos.kt

@@ -322,7 +322,7 @@ class ExpectedInfos(
 
         fun needCommaForParameter(parameter: ValueParameterDescriptor): Boolean {
             if (parameter.hasDefaultValue()) return false // parameter is optional
-            if (parameter.getVarargElementType() != null) return false // vararg arguments list can be empty
+            if (parameter.varargElementType != null) return false // vararg arguments list can be empty
             // last parameter of functional type can be placed outside parenthesis:
             if (!isArrayAccess && parameter == parameters.last() && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(parameter.getType())) return false
             return true
@@ -342,7 +342,7 @@ class ExpectedInfos(
 
         val alreadyHasStar = argument.getSpreadElement() != null
 
-        val varargElementType = parameter!!.getVarargElementType()
+        val varargElementType = parameter!!.varargElementType
         if (varargElementType != null) {
             if (isFunctionLiteralArgument) return
 

idea/idea-core/src/org/jetbrains/kotlin/idea/core/Utils.kt

@@ -78,7 +78,7 @@ public fun Call.mapArgumentsToParameters(targetDescriptor: CallableDescriptor):
                     val parameter = parameters[positionalArgumentIndex]
                     map[argument] = parameter
 
-                    if (parameter.getVarargElementType() == null) {
+                    if (parameter.varargElementType == null) {
                         positionalArgumentIndex++
                     }
                 }

idea/src/org/jetbrains/kotlin/idea/intentions/AddNameToArgumentIntention.kt

@@ -71,7 +71,7 @@ public class AddNameToArgumentIntention
 
         if (!resolvedCall.getResultingDescriptor().hasStableParameterNames()) return null
 
-        if (argumentMatch.valueParameter.getVarargElementType() != null) {
+        if (argumentMatch.valueParameter.varargElementType != null) {
             val varargArgument = resolvedCall.getValueArguments()[argumentMatch.valueParameter] as? VarargValueArgument ?: return null
             if (varargArgument.getArguments().size() != 1) return null
         }

idea/src/org/jetbrains/kotlin/idea/intentions/RemoveArgumentNameIntention.kt

@@ -41,7 +41,7 @@ public class RemoveArgumentNameIntention
         val callExpr = argumentList.getParent() as? KtExpression ?: return null
         val resolvedCall = callExpr.getResolvedCall(callExpr.analyze(BodyResolveMode.PARTIAL)) ?: return null
         val argumentMatch = resolvedCall.getArgumentMapping(element) as? ArgumentMatch ?: return null
-        if (argumentMatch.valueParameter.getIndex() != arguments.indexOf(element)) return null
+        if (argumentMatch.valueParameter.index != arguments.indexOf(element)) return null
 
         val expression = element.getArgumentExpression() ?: return null
         return TextRange(element.startOffset, expression.startOffset)

idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceCallWithBinaryOperatorIntention.kt

@@ -37,7 +37,7 @@ public class ReplaceCallWithBinaryOperatorIntention : JetSelfTargetingRangeInten
         if (!resolvedCall.isReallySuccess()) return null
         if (resolvedCall.getCall().getTypeArgumentList() != null) return null
         val argument = resolvedCall.getCall().getValueArguments().singleOrNull() ?: return null
-        if ((resolvedCall.getArgumentMapping(argument) as ArgumentMatch).valueParameter.getIndex() != 0) return null
+        if ((resolvedCall.getArgumentMapping(argument) as ArgumentMatch).valueParameter.index != 0) return null
 
         if (!element.isReceiverExpressionWithValue()) return null
 

idea/src/org/jetbrains/kotlin/idea/intentions/conventionNameCalls/ReplaceContainsIntention.kt

@@ -35,7 +35,7 @@ public class ReplaceContainsIntention : JetSelfTargetingRangeIntention<KtDotQual
         val resolvedCall = element.toResolvedCall(BodyResolveMode.PARTIAL) ?: return null
         if (!resolvedCall.isReallySuccess()) return null
         val argument = resolvedCall.getCall().getValueArguments().singleOrNull() ?: return null
-        if ((resolvedCall.getArgumentMapping(argument) as ArgumentMatch).valueParameter.getIndex() != 0) return null
+        if ((resolvedCall.getArgumentMapping(argument) as ArgumentMatch).valueParameter.index != 0) return null
 
         val target = resolvedCall.getResultingDescriptor()
         val returnType = target.getReturnType() ?: return null

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureData.kt

@@ -62,10 +62,10 @@ public class JetChangeSignatureData(
         }
         parameters = baseDescriptor.getValueParameters()
                 .mapTo(receiver?.let{ arrayListOf(it) } ?: arrayListOf()) { parameterDescriptor ->
-                    val jetParameter = valueParameters?.get(parameterDescriptor.getIndex())
+                    val jetParameter = valueParameters?.get(parameterDescriptor.index)
                     JetParameterInfo(
                             callableDescriptor = baseDescriptor,
-                            originalIndex = parameterDescriptor.getIndex(),
+                            originalIndex = parameterDescriptor.index,
                             name = parameterDescriptor.getName().asString(),
                             type = parameterDescriptor.getType(),
                             defaultValueForParameter = jetParameter?.getDefaultValue(),

idea/src/org/jetbrains/kotlin/idea/refactoring/changeSignature/JetChangeSignatureHandler.kt

@@ -167,7 +167,7 @@ public class JetChangeSignatureHandler : ChangeSignatureHandler {
 
             return when (descriptor) {
                 is FunctionDescriptor -> {
-                    if (descriptor.getValueParameters().any { it.getVarargElementType() != null }) {
+                    if (descriptor.getValueParameters().any { it.varargElementType != null }) {
                         val message = JetRefactoringBundle.message("error.cant.refactor.vararg.functions")
                         CommonRefactoringUtil.showErrorHint(project, editor, message, ChangeSignatureHandler.REFACTORING_NAME, HelpID.CHANGE_SIGNATURE)
                         return null

js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/CallArgumentTranslator.kt

@@ -93,7 +93,7 @@ public class CallArgumentTranslator private constructor(
         var concatArguments: MutableList<JsExpression>? = null
 
         for (parameterDescriptor in valueParameters) {
-            val actualArgument = valueArgumentsByIndex.get(parameterDescriptor.getIndex())
+            val actualArgument = valueArgumentsByIndex.get(parameterDescriptor.index)
 
             val argContext = context().innerBlock()