1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
// Copyright 2000-2021 JetBrains s.r.o. and contributors. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file.
package org.jetbrains.kotlin.idea.core
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.idea.FrontendInternals
import org.jetbrains.kotlin.idea.analysis.computeTypeInContext
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
import org.jetbrains.kotlin.idea.caches.resolve.safeAnalyzeNonSourceRootCode
import org.jetbrains.kotlin.idea.caches.resolve.unsafeResolveToDescriptor
import org.jetbrains.kotlin.idea.references.mainReference
import org.jetbrains.kotlin.idea.references.resolveToDescriptors
import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.resolve.frontendService
import org.jetbrains.kotlin.idea.resolve.getDataFlowValueFactory
import org.jetbrains.kotlin.idea.resolve.getLanguageVersionSettings
import org.jetbrains.kotlin.idea.util.getImplicitReceiversWithInstanceToExpression
import org.jetbrains.kotlin.idea.util.getResolutionScope
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.parentOrNull
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DelegatingBindingTrace
import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver
import org.jetbrains.kotlin.resolve.bindingContextUtil.getDataFlowInfoBefore
import org.jetbrains.kotlin.resolve.calls.CallResolver
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.calls.components.isVararg
import org.jetbrains.kotlin.resolve.calls.context.BasicCallResolutionContext
import org.jetbrains.kotlin.resolve.calls.context.CheckArgumentTypesMode
import org.jetbrains.kotlin.resolve.calls.context.ContextDependency
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.results.ResolutionStatus
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.calls.util.getDispatchReceiverWithSmartCast
import org.jetbrains.kotlin.resolve.scopes.LexicalScope
import org.jetbrains.kotlin.resolve.scopes.receivers.ImplicitReceiver
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.types.KotlinType
import org.jetbrains.kotlin.types.TypeUtils
import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
import org.jetbrains.kotlin.types.typeUtil.isSubtypeOf
import java.util.*
/**
* See `ArgumentsToParametersMapper` class in the compiler.
*/
fun Call.mapArgumentsToParameters(targetDescriptor: CallableDescriptor): Map<ValueArgument, ValueParameterDescriptor> {
val parameters = targetDescriptor.valueParameters
if (parameters.isEmpty()) return emptyMap()
val map = HashMap<ValueArgument, ValueParameterDescriptor>()
val parametersByName = if (targetDescriptor.hasStableParameterNames()) parameters.associateBy { it.name } else emptyMap()
var positionalArgumentIndex: Int? = 0
for (argument in valueArguments) {
if (argument is LambdaArgument) {
map[argument] = parameters.last()
} else {
val argumentName = argument.getArgumentName()?.asName
if (argumentName != null) {
val parameter = parametersByName[argumentName]
if (parameter != null) {
map[argument] = parameter
if (parameter.index == positionalArgumentIndex) {
positionalArgumentIndex++
continue
}
}
positionalArgumentIndex = null
} else {
if (positionalArgumentIndex != null && positionalArgumentIndex < parameters.size) {
val parameter = parameters[positionalArgumentIndex]
map[argument] = parameter
if (!parameter.isVararg) {
positionalArgumentIndex++
}
}
}
}
}
return map
}
fun ImplicitReceiver.asExpression(resolutionScope: LexicalScope, psiFactory: KtPsiFactory): KtExpression? {
val expressionFactory = resolutionScope.getImplicitReceiversWithInstanceToExpression()
.entries
.firstOrNull { it.key.containingDeclaration == this.declarationDescriptor }
?.value ?: return null
return expressionFactory.createExpression(psiFactory)
}
fun KtImportDirective.targetDescriptors(resolutionFacade: ResolutionFacade = this.getResolutionFacade()): Collection<DeclarationDescriptor> {
// For codeFragments imports are created in dummy file
if (this.containingKtFile.doNotAnalyze != null) return emptyList()
val nameExpression = importedReference?.getQualifiedElementSelector() as? KtSimpleNameExpression ?: return emptyList()
return nameExpression.mainReference.resolveToDescriptors(resolutionFacade.analyze(nameExpression))
}
fun Call.resolveCandidates(
bindingContext: BindingContext,
resolutionFacade: ResolutionFacade,
expectedType: KotlinType = expectedType(this, bindingContext),
filterOutWrongReceiver: Boolean = true,
filterOutByVisibility: Boolean = true
): Collection<ResolvedCall<FunctionDescriptor>> {
val resolutionScope = callElement.getResolutionScope(bindingContext, resolutionFacade)
val inDescriptor = resolutionScope.ownerDescriptor
val dataFlowInfo = bindingContext.getDataFlowInfoBefore(callElement)
val bindingTrace = DelegatingBindingTrace(bindingContext, "Temporary trace")
val callResolutionContext = BasicCallResolutionContext.create(
bindingTrace, resolutionScope, this, expectedType, dataFlowInfo,
ContextDependency.INDEPENDENT, CheckArgumentTypesMode.CHECK_VALUE_ARGUMENTS,
false, resolutionFacade.getLanguageVersionSettings(),
resolutionFacade.getDataFlowValueFactory()
).replaceCollectAllCandidates(true)
@OptIn(FrontendInternals::class)
val callResolver = resolutionFacade.frontendService<CallResolver>()
val results = callResolver.resolveFunctionCall(callResolutionContext)
var candidates = results.allCandidates!!
if (callElement is KtConstructorDelegationCall) { // for "this(...)" delegation call exclude caller from candidates
inDescriptor as ConstructorDescriptor
candidates = candidates.filter { it.resultingDescriptor.original != inDescriptor.original }
}
if (filterOutWrongReceiver) {
candidates = candidates.filter {
it.status != ResolutionStatus.RECEIVER_TYPE_ERROR && it.status != ResolutionStatus.RECEIVER_PRESENCE_ERROR
}
}
if (filterOutByVisibility) {
candidates = candidates.filter {
DescriptorVisibilityUtils.isVisible(
it.getDispatchReceiverWithSmartCast(),
it.resultingDescriptor,
inDescriptor,
resolutionFacade.getLanguageVersionSettings()
)
}
}
return candidates
}
private fun expectedType(call: Call, bindingContext: BindingContext): KotlinType {
return (call.callElement as? KtExpression)?.let {
bindingContext[BindingContext.EXPECTED_EXPRESSION_TYPE, it.getQualifiedExpressionForSelectorOrThis()]
} ?: TypeUtils.NO_EXPECTED_TYPE
}
fun KtCallableDeclaration.canOmitDeclaredType(initializerOrBodyExpression: KtExpression, canChangeTypeToSubtype: Boolean): Boolean {
val declaredType = (unsafeResolveToDescriptor() as? CallableDescriptor)?.returnType ?: return false
val bindingContext = initializerOrBodyExpression.analyze()
val scope = initializerOrBodyExpression.getResolutionScope(bindingContext, initializerOrBodyExpression.getResolutionFacade())
val expressionType = initializerOrBodyExpression.computeTypeInContext(scope) ?: return false
if (KotlinTypeChecker.DEFAULT.equalTypes(expressionType, declaredType)) return true
return canChangeTypeToSubtype && expressionType.isSubtypeOf(declaredType)
}
fun FqName.quoteSegmentsIfNeeded(): String {
return pathSegments().joinToString(".") { it.asString().quoteIfNeeded() }
}
fun FqName.quoteIfNeeded() = FqName(quoteSegmentsIfNeeded())
fun CallableId.asFqNameWithRootPrefixIfNeeded() =
asSingleFqName().withRootPrefixIfNeeded()
fun FqName.withRootPrefixIfNeeded(targetElement: KtElement? = null) =
if (canAddRootPrefix() && targetElement?.canAddRootPrefix() != false)
FqName(QualifiedExpressionResolver.ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE_WITH_DOT + asString())
else
this
fun FqName.canAddRootPrefix(): Boolean =
!asString().startsWith(QualifiedExpressionResolver.ROOT_PREFIX_FOR_IDE_RESOLUTION_MODE_WITH_DOT) && !thisOrParentIsRoot()
fun FqName.thisOrParentIsRoot(): Boolean = parentOrNull()?.isRoot != false
fun KtElement.canAddRootPrefix(): Boolean = getParentOfTypes2<KtImportDirective, KtPackageDirective>() == null
fun isEnumCompanionPropertyWithEntryConflict(element: PsiElement, expectedName: String): Boolean {
if (element !is KtProperty) return false
val propertyClass = element.containingClassOrObject as? KtObjectDeclaration ?: return false
if (!propertyClass.isCompanion()) return false
val outerClass = propertyClass.containingClassOrObject as? KtClass ?: return false
if (!outerClass.isEnum()) return false
return outerClass.declarations.any { it is KtEnumEntry && it.name == expectedName }
}
fun KtCallExpression.receiverValue(): ReceiverValue? {
val resolvedCall = getResolvedCall(safeAnalyzeNonSourceRootCode(BodyResolveMode.PARTIAL)) ?: return null
return resolvedCall.dispatchReceiver ?: resolvedCall.extensionReceiver
}
fun KtCallExpression.receiverType(): KotlinType? = receiverValue()?.type
fun KtExpression.resolveType(): KotlinType? = this.analyze(BodyResolveMode.PARTIAL).getType(this)
fun KtModifierKeywordToken.toVisibility(): DescriptorVisibility {
return when (this) {
KtTokens.PUBLIC_KEYWORD -> DescriptorVisibilities.PUBLIC
KtTokens.PRIVATE_KEYWORD -> DescriptorVisibilities.PRIVATE
KtTokens.PROTECTED_KEYWORD -> DescriptorVisibilities.PROTECTED
KtTokens.INTERNAL_KEYWORD -> DescriptorVisibilities.INTERNAL
else -> throw IllegalArgumentException("Unknown visibility modifier:$this")
}
}
|
