From e175e87225ec4bc551ade854fc42b24b0539a370 Mon Sep 17 00:00:00 2001 From: Mark Punzalan Date: Wed, 30 Sep 2020 22:46:08 +0000 Subject: [PATCH] [FIR] Change type of argumentMapping properties and parameters from Map to LinkedHashMap, to signify that the order is important and we don't assume that mutableMapOf() will always return a LinkedHashMap. --- .../backend/generators/CallAndReferenceGenerator.kt | 2 +- .../jetbrains/kotlin/fir/resolve/calls/Candidate.kt | 2 +- .../resolve/calls/FirArgumentsToParametersMapper.kt | 13 ++++++------- .../FirCallCompletionResultsWriterTransformer.kt | 8 ++++++-- .../transformers/body/resolve/BodyResolveUtils.kt | 6 +++--- .../kotlin/fir/expressions/FirArgumentUtil.kt | 2 +- .../kotlin/fir/expressions/FirExpressionUtil.kt | 2 +- .../fir/expressions/impl/FirResolvedArgumentList.kt | 2 +- 8 files changed, 20 insertions(+), 17 deletions(-) diff --git a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt index e1d1ff4be93..a802be503ee 100644 --- a/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt +++ b/compiler/fir/fir2ir/src/org/jetbrains/kotlin/fir/backend/generators/CallAndReferenceGenerator.kt @@ -456,7 +456,7 @@ class CallAndReferenceGenerator( } private fun IrMemberAccessExpression<*>.applyArgumentsWithReorderingIfNeeded( - argumentMapping: Map, + argumentMapping: LinkedHashMap, valueParameters: List, annotationMode: Boolean ): IrExpression { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt index 3b28df7f6e4..c0a8e5ad41f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/Candidate.kt @@ -102,7 +102,7 @@ class Candidate( var usesSAM: Boolean = false var usesSuspendConversion: Boolean = false - var argumentMapping: Map? = null + var argumentMapping: LinkedHashMap? = null var numDefaults: Int = 0 lateinit var typeArgumentMapping: TypeArgumentMapping val postponedAtoms = mutableListOf() diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt index 1a9320cd304..c709fdfb012 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/FirArgumentsToParametersMapper.kt @@ -20,6 +20,7 @@ import org.jetbrains.kotlin.fir.scopes.FirScope import org.jetbrains.kotlin.name.Name import java.util.* import kotlin.collections.ArrayList +import kotlin.collections.LinkedHashMap import kotlin.collections.component1 import kotlin.collections.component2 import kotlin.collections.set @@ -29,13 +30,11 @@ data class ArgumentMapping( // fun foo(a: Int, b: Int) {} // foo(b = bar(), a = qux()) // parameterToCallArgumentMap.values() should be [ 'bar()', 'foo()' ] - // TODO: Consider changing this (and other similar declarations like Candidate.argumentMapping) to LinkedHashMap to signify that - // order is important. Right now we're assuming that mutableMapOf() will always return a LinkedHashMap. - val parameterToCallArgumentMap: Map, + val parameterToCallArgumentMap: LinkedHashMap, val diagnostics: List ) { - fun toArgumentToParameterMapping(): Map { - val argumentToParameterMapping = mutableMapOf() + fun toArgumentToParameterMapping(): LinkedHashMap { + val argumentToParameterMapping = linkedMapOf() parameterToCallArgumentMap.forEach { (valueParameter, resolvedArgument) -> when (resolvedArgument) { is ResolvedCallArgument.SimpleArgument -> argumentToParameterMapping[resolvedArgument.callArgument] = valueParameter @@ -52,7 +51,7 @@ data class ArgumentMapping( } } -private val EmptyArgumentMapping = ArgumentMapping(emptyMap(), emptyList()) +private val EmptyArgumentMapping = ArgumentMapping(linkedMapOf(), emptyList()) fun BodyResolveComponents.mapArguments( arguments: List, @@ -108,7 +107,7 @@ private class FirCallArgumentsProcessor( private var nameToParameter: Map? = null var diagnostics: MutableList? = null private set - val result: MutableMap = LinkedHashMap() + val result: LinkedHashMap = LinkedHashMap(function.valueParameters.size) private enum class State { POSITION_ARGUMENTS, diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index d8a5ae6ee4b..c0e1d2c4d8c 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -207,8 +207,12 @@ class FirCallCompletionResultsWriterTransformer( withFirArrayOfCallTransformer { annotationCall.argumentList.transformArguments(this, expectedArgumentsTypeMapping) var index = 0 - subCandidate.argumentMapping = subCandidate.argumentMapping?.mapKeys { (_, _) -> - annotationCall.argumentList.arguments[index++] + subCandidate.argumentMapping = subCandidate.argumentMapping?.let { + LinkedHashMap(it.size).let { newMapping -> + subCandidate.argumentMapping?.mapKeysTo(newMapping) { (_, _) -> + annotationCall.argumentList.arguments[index++] + } + } } } if (!calleeReference.isError) { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt index 8beb7ec520a..2e4e1115ace 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/BodyResolveUtils.kt @@ -37,8 +37,8 @@ internal inline var FirExpression.resultType: FirTypeRef internal fun remapArgumentsWithVararg( varargParameter: FirValueParameter, varargArrayType: ConeKotlinType, - argumentMapping: Map -): Map { + argumentMapping: LinkedHashMap +): LinkedHashMap { // Create a FirVarargArgumentExpression for the vararg arguments. // The order of arguments in the mapping must be preserved for FIR2IR, hence we have to find where the vararg arguments end. // FIR2IR uses the mapping order to determine if arguments need to be reordered. @@ -46,7 +46,7 @@ internal fun remapArgumentsWithVararg( val varargElementType = varargArrayType.arrayElementType() val argumentList = argumentMapping.keys.toList() var indexAfterVarargs = argumentList.size - val newArgumentMapping = mutableMapOf() + val newArgumentMapping = linkedMapOf() val varargArgument = buildVarargArgumentsExpression { this.varargElementType = varargParameterTypeRef.withReplacedConeType(varargElementType) this.typeRef = varargParameterTypeRef.withReplacedConeType(varargArrayType) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArgumentUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArgumentUtil.kt index 3792ed4d91a..5cb3d7fcf1f 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArgumentUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirArgumentUtil.kt @@ -22,7 +22,7 @@ fun buildBinaryArgumentList(left: FirExpression, right: FirExpression): FirArgum fun buildArraySetArgumentList(rValue: FirExpression, indexes: List): FirArgumentList = FirArraySetArgumentList(rValue, indexes) -fun buildResolvedArgumentList(mapping: Map): FirArgumentList = +fun buildResolvedArgumentList(mapping: LinkedHashMap): FirArgumentList = FirResolvedArgumentList(mapping) object FirEmptyArgumentList : FirAbstractArgumentList() { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt index c2a4577a80f..06956fb6e64 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt @@ -40,7 +40,7 @@ inline val FirCall.arguments: List get() = argumentList.arguments inline val FirCall.argument: FirExpression get() = argumentList.arguments.first() -inline val FirCall.argumentMapping: Map? +inline val FirCall.argumentMapping: LinkedHashMap? get() = (argumentList as? FirResolvedArgumentList)?.mapping fun FirExpression.toResolvedCallableReference(): FirResolvedNamedReference? { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedArgumentList.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedArgumentList.kt index 0d21296ce82..f3d8cefb5ba 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedArgumentList.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/impl/FirResolvedArgumentList.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.visitors.FirVisitor class FirResolvedArgumentList internal constructor( - val mapping: Map + val mapping: LinkedHashMap ) : FirAbstractArgumentList() { override val arguments: List get() = mapping.keys.toList()