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
|
// 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.inspections
import com.intellij.codeInspection.*
import com.intellij.codeInspection.ui.SingleCheckboxOptionsPanel
import com.intellij.openapi.progress.ProgressManager
import com.intellij.openapi.project.Project
import com.intellij.openapi.util.TextRange
import com.intellij.psi.PsiElementVisitor
import org.jetbrains.kotlin.descriptors.ClassConstructorDescriptor
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.idea.KotlinBundle
import org.jetbrains.kotlin.idea.analysis.analyzeAsReplacement
import org.jetbrains.kotlin.idea.caches.resolve.analyze
import org.jetbrains.kotlin.idea.core.ShortenReferences
import org.jetbrains.kotlin.idea.core.compareDescriptors
import org.jetbrains.kotlin.idea.core.unwrapIfFakeOverride
import org.jetbrains.kotlin.idea.imports.importableFqName
import org.jetbrains.kotlin.idea.intentions.isReferenceToBuiltInEnumFunction
import org.jetbrains.kotlin.idea.references.mainReference
import org.jetbrains.kotlin.idea.references.resolveToDescriptors
import org.jetbrains.kotlin.idea.caches.resolve.safeAnalyzeNonSourceRootCode
import org.jetbrains.kotlin.idea.util.getResolutionScope
import org.jetbrains.kotlin.idea.util.hasNotReceiver
import org.jetbrains.kotlin.incremental.components.NoLookupLocation
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.psi.psiUtil.*
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.ImportedFromObjectCallableDescriptor
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.resolve.descriptorUtil.isCompanionObject
import org.jetbrains.kotlin.resolve.scopes.utils.findFirstClassifierWithDeprecationStatus
import org.jetbrains.kotlin.utils.addToStdlib.safeAs
import javax.swing.JComponent
class RemoveRedundantQualifierNameInspection : AbstractKotlinInspection(), CleanupLocalInspectionTool {
/**
* In order to detect that `foo()` and `GrandBase.foo()` point to the same method,
* we need to unwrap fake overrides from descriptors. If we don't do that, they will
* have different `fqName`s, and the inspection will not detect `GrandBase` as a
* redundant qualifier.
*/
var unwrapFakeOverrides: Boolean = false
override fun createOptionsPanel(): JComponent =
SingleCheckboxOptionsPanel(
KotlinBundle.message("redundant.qualifier.unnecessary.non.direct.parent.class.qualifier"),
this,
::unwrapFakeOverrides.name
)
override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor =
object : KtVisitorVoid() {
override fun visitDotQualifiedExpression(expression: KtDotQualifiedExpression) {
val expressionParent = expression.parent
if (expressionParent is KtDotQualifiedExpression || expressionParent is KtPackageDirective || expressionParent is KtImportDirective) return
val expressionForAnalyze = expression.firstExpressionWithoutReceiver() ?: return
if (expressionForAnalyze.selectorExpression?.text == expressionParent.getNonStrictParentOfType<KtProperty>()?.name) return
val originalExpression: KtExpression = expressionForAnalyze.parent as? KtClassLiteralExpression ?: expressionForAnalyze
val receiverReference = expressionForAnalyze.receiverExpression.let {
it.safeAs<KtQualifiedExpression>()?.receiverExpression ?: it
}.mainReference?.resolve()
val parentEnumEntry = expressionForAnalyze.getStrictParentOfType<KtEnumEntry>()
if (parentEnumEntry != null) {
val companionObject = (receiverReference as? KtObjectDeclaration)?.takeIf { it.isCompanion() }
if (companionObject?.containingClass() == parentEnumEntry.getStrictParentOfType<KtClass>()) return
}
if (receiverReference?.safeAs<KtClass>()?.isEnum() == true
&& expressionForAnalyze.getParentOfTypesAndPredicate(true, KtClass::class.java) { it.isEnum() } != receiverReference
&& (expressionForAnalyze.isReferenceToBuiltInEnumFunction() || expressionForAnalyze.isCompanionObjectReference())
) return
val context = originalExpression.analyze()
val originalDescriptor = expressionForAnalyze.getQualifiedElementSelector()
?.mainReference?.resolveToDescriptors(context)
?.firstOrNull() ?: return
val applicableExpression = expressionForAnalyze.firstApplicableExpression(
validator = { applicableExpression(originalExpression, context, originalDescriptor, unwrapFakeOverrides) },
generator = { firstChild as? KtDotQualifiedExpression }
) ?: return
reportProblem(holder, applicableExpression)
}
override fun visitUserType(type: KtUserType) {
if (type.parent is KtUserType) return
val context = type.safeAnalyzeNonSourceRootCode()
val applicableExpression = type.firstApplicableExpression(
validator = { applicableExpression(context) },
generator = { firstChild as? KtUserType }
) ?: return
reportProblem(holder, applicableExpression)
}
}
private fun KtDotQualifiedExpression.isCompanionObjectReference(): Boolean {
val selector = receiverExpression.safeAs<KtDotQualifiedExpression>()?.selectorExpression ?: selectorExpression
return selector?.referenceExpression()?.mainReference?.resolve()?.safeAs<KtObjectDeclaration>()?.isCompanion() == true
}
}
private tailrec fun KtDotQualifiedExpression.firstExpressionWithoutReceiver(): KtDotQualifiedExpression? = if (hasNotReceiver())
this
else
(receiverExpression as? KtDotQualifiedExpression)?.firstExpressionWithoutReceiver()
private tailrec fun <T : KtElement> T.firstApplicableExpression(validator: T.() -> T?, generator: T.() -> T?): T? {
ProgressManager.checkCanceled()
return validator() ?: generator()?.firstApplicableExpression(validator, generator)
}
private fun KtDotQualifiedExpression.applicableExpression(
originalExpression: KtExpression,
oldContext: BindingContext,
originalDescriptor: DeclarationDescriptor,
unwrapFakeOverrides: Boolean
): KtDotQualifiedExpression? {
if (!receiverExpression.isApplicableReceiver(oldContext) || !ShortenReferences.canBePossibleToDropReceiver(this, oldContext)) {
return null
}
val expressionText = originalExpression.text.substring(lastChild.startOffset - originalExpression.startOffset)
val newExpression = KtPsiFactory(originalExpression).createExpressionIfPossible(expressionText) ?: return null
val newContext = newExpression.analyzeAsReplacement(originalExpression, oldContext)
val newDescriptor = newExpression.selector()
?.mainReference?.resolveToDescriptors(newContext)
?.firstOrNull() ?: return null
fun DeclarationDescriptor.unwrapFakeOverrideIfNecessary(): DeclarationDescriptor {
return if (unwrapFakeOverrides) this.unwrapIfFakeOverride() else this
}
val originalDescriptorFqName = originalDescriptor.unwrapFakeOverrideIfNecessary().fqNameSafe
val newDescriptorFqName = newDescriptor.unwrapFakeOverrideIfNecessary().fqNameSafe
if (originalDescriptorFqName != newDescriptorFqName) return null
return this.takeIf {
if (newDescriptor is ImportedFromObjectCallableDescriptor<*>)
compareDescriptors(project, newDescriptor.callableFromObject, originalDescriptor)
else
compareDescriptors(project, newDescriptor, originalDescriptor)
}
}
private fun KtExpression.selector(): KtElement? = if (this is KtClassLiteralExpression) receiverExpression?.getQualifiedElementSelector()
else getQualifiedElementSelector()
private fun KtExpression.isApplicableReceiver(context: BindingContext): Boolean {
if (this is KtInstanceExpressionWithLabel) return false
val reference = getQualifiedElementSelector()
val descriptor = reference?.mainReference?.resolveToDescriptors(context)?.firstOrNull() ?: return false
return if (!descriptor.isCompanionObject()) true
else descriptor.name.asString() != reference.text
}
private fun KtUserType.applicableExpression(context: BindingContext): KtUserType? {
if (firstChild !is KtUserType) return null
val referenceExpression = referenceExpression as? KtNameReferenceExpression ?: return null
val originalDescriptor = referenceExpression.mainReference.resolveToDescriptors(context).firstOrNull()?.let {
it.safeAs<ClassConstructorDescriptor>()?.containingDeclaration ?: it
} ?: return null
if (originalDescriptor is ClassDescriptor
&& originalDescriptor.isInner
&& (originalDescriptor.containingDeclaration as? ClassDescriptor)?.typeConstructor != null
) return null
val shortName = originalDescriptor.importableFqName?.shortName() ?: return null
val scope = referenceExpression.getResolutionScope(context) ?: return null
val descriptor = scope.findFirstClassifierWithDeprecationStatus(shortName, NoLookupLocation.FROM_IDE)?.descriptor ?: return null
return if (descriptor == originalDescriptor) this else null
}
private fun reportProblem(holder: ProblemsHolder, element: KtElement) {
val firstChild = element.firstChild
holder.registerProblem(
element,
KotlinBundle.message("redundant.qualifier.name"),
ProblemHighlightType.LIKE_UNUSED_SYMBOL,
TextRange.from(firstChild.startOffsetInParent, firstChild.textLength + 1),
RemoveRedundantQualifierNameQuickFix()
)
}
class RemoveRedundantQualifierNameQuickFix : LocalQuickFix {
override fun getName() = KotlinBundle.message("remove.redundant.qualifier.name.quick.fix.text")
override fun getFamilyName() = name
override fun applyFix(project: Project, descriptor: ProblemDescriptor) {
val file = descriptor.psiElement.containingFile as KtFile
val range = when (val element = descriptor.psiElement) {
is KtUserType -> IntRange(element.startOffset, element.endOffset)
is KtDotQualifiedExpression -> IntRange(
element.startOffset,
element.getLastParentOfTypeInRowWithSelf<KtDotQualifiedExpression>()?.getQualifiedElementSelector()?.endOffset ?: return
)
else -> IntRange.EMPTY
}
val substring = file.text.substring(range.first, range.last)
Regex.fromLiteral(substring).findAll(file.text, file.importList?.endOffset ?: 0).toList().asReversed().forEach {
ShortenReferences.DEFAULT.process(file, it.range.first, it.range.last + 1)
}
}
}
|
