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
|
// 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.caches.resolve
import com.intellij.openapi.diagnostic.ControlFlowException
import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.descriptors.*
import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
import org.jetbrains.kotlin.idea.util.actionUnderSafeAnalyzeBlock
import org.jetbrains.kotlin.idea.util.returnIfNoDescriptorForDeclarationException
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.resolve.calls.util.getResolvedCall
import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
import org.jetbrains.kotlin.resolve.lazy.NoDescriptorForDeclarationException
/**
* This function throws exception when resolveToDescriptorIfAny returns null, otherwise works equivalently.
*/
fun KtDeclaration.unsafeResolveToDescriptor(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL
): DeclarationDescriptor =
resolveToDescriptorIfAny(resolutionFacade, bodyResolveMode) ?: throw NoDescriptorForDeclarationException(this)
/**
* This function first uses declaration resolvers to resolve this declaration and/or additional declarations (e.g. its parent),
* and then takes the relevant descriptor from binding context.
* The exact set of declarations to resolve depends on bodyResolveMode
*/
fun KtDeclaration.resolveToDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): DeclarationDescriptor? {
//TODO: BodyResolveMode.PARTIAL is not quite safe!
val context = safeAnalyze(resolutionFacade, bodyResolveMode)
return if (this is KtParameter && hasValOrVar()) {
context.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, this)
// It is incorrect to have `val/var` parameters outside the primary constructor (e.g., `fun foo(val x: Int)`)
// but we still want to try to resolve in such cases.
?: context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, this)
} else {
context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, this)
}
}
fun KtAnnotationEntry.resolveToDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): AnnotationDescriptor? {
//TODO: BodyResolveMode.PARTIAL is not quite safe!
val context = safeAnalyze(resolutionFacade, bodyResolveMode)
return context.get(BindingContext.ANNOTATION, this)
}
fun KtClassOrObject.resolveToDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): ClassDescriptor? {
return (this as KtDeclaration).resolveToDescriptorIfAny(resolutionFacade, bodyResolveMode) as? ClassDescriptor
}
fun KtNamedFunction.resolveToDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): FunctionDescriptor? {
return (this as KtDeclaration).resolveToDescriptorIfAny(resolutionFacade, bodyResolveMode) as? FunctionDescriptor
}
fun KtProperty.resolveToDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): VariableDescriptor? {
return (this as KtDeclaration).resolveToDescriptorIfAny(resolutionFacade, bodyResolveMode) as? VariableDescriptor
}
fun KtParameter.resolveToParameterDescriptorIfAny(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): ValueParameterDescriptor? {
val context = safeAnalyze(resolutionFacade, bodyResolveMode)
return context.get(BindingContext.VALUE_PARAMETER, this) as? ValueParameterDescriptor
}
fun KtElement.resolveToCall(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.PARTIAL
): ResolvedCall<out CallableDescriptor>? = getResolvedCall(safeAnalyze(resolutionFacade, bodyResolveMode))
fun KtElement.safeAnalyze(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL
): BindingContext = try {
analyze(resolutionFacade, bodyResolveMode)
} catch (e: Exception) {
e.returnIfNoDescriptorForDeclarationException { BindingContext.EMPTY }
}
@JvmOverloads
fun KtElement.analyze(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL
): BindingContext = resolutionFacade.analyze(this, bodyResolveMode)
fun KtElement.analyzeAndGetResult(resolutionFacade: ResolutionFacade): AnalysisResult = try {
AnalysisResult.success(resolutionFacade.analyze(this), resolutionFacade.moduleDescriptor)
} catch (e: Exception) {
if (e is ControlFlowException) throw e
AnalysisResult.internalError(BindingContext.EMPTY, e)
}
// This function is used on declarations to make analysis not only declaration itself but also it content:
// body for declaration with body, initializer & accessors for properties
fun KtElement.analyzeWithContentAndGetResult(resolutionFacade: ResolutionFacade): AnalysisResult =
resolutionFacade.analyzeWithAllCompilerChecks(this)
// This function is used on declarations to make analysis not only declaration itself but also it content:
// body for declaration with body, initializer & accessors for properties
fun KtDeclaration.analyzeWithContent(resolutionFacade: ResolutionFacade): BindingContext =
resolutionFacade.analyzeWithAllCompilerChecks(this).bindingContext
// This function is used to make full analysis of declaration container.
// All its declarations, including their content (see above), are analyzed.
inline fun <reified T> T.analyzeWithContent(resolutionFacade: ResolutionFacade): BindingContext where T : KtDeclarationContainer, T : KtElement =
resolutionFacade.analyzeWithAllCompilerChecks(this).bindingContext
@JvmOverloads
fun KtElement.safeAnalyzeNonSourceRootCode(
bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL
): BindingContext = safeAnalyzeNonSourceRootCode(getResolutionFacade(), bodyResolveMode)
fun KtElement.safeAnalyzeNonSourceRootCode(
resolutionFacade: ResolutionFacade,
bodyResolveMode: BodyResolveMode = BodyResolveMode.FULL
): BindingContext =
actionUnderSafeAnalyzeBlock({ analyze(resolutionFacade, bodyResolveMode) }, { BindingContext.EMPTY })
@JvmOverloads
fun KtDeclaration.safeAnalyzeWithContentNonSourceRootCode(): BindingContext =
safeAnalyzeWithContentNonSourceRootCode(getResolutionFacade())
fun KtDeclaration.safeAnalyzeWithContentNonSourceRootCode(
resolutionFacade: ResolutionFacade,
): BindingContext =
actionUnderSafeAnalyzeBlock({ analyzeWithContent(resolutionFacade) }, { BindingContext.EMPTY })
|
