azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

FIR: Fix positioning of ENUM_ENTRY_AS_TYPE

Browse Source 
The current SELECTOR_BY_QUALIFIED positioning strategy is closely
related what should be done here. But it only works on qualified access
expressions. This change also makes it work for type references.
This commit is contained in:
Tianyu Geng
2021-06-15 11:20:54 -07:00
committed by Mikhail Glukhikh
parent c648356887
commit a8e379a025
7 changed files with 59 additions and 33 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+1 -1
View File
@@ -967,7 +967,7 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
parameter<Boolean>("compileTimeCheckResult")
}
val IS_ENUM_ENTRY by error<KtTypeReference>()
val ENUM_ENTRY_AS_TYPE by error<KtTypeReference>()
val ENUM_ENTRY_AS_TYPE by error<KtTypeReference>(PositioningStrategy.SELECTOR_BY_QUALIFIED)
}
val WHEN_EXPRESSIONS by object : DiagnosticGroup("When expressions") {
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+1 -1
View File
@@ -510,7 +510,7 @@ object FirErrors {
val USELESS_CAST by warning0<KtBinaryExpressionWithTypeRHS>(SourceElementPositioningStrategies.AS_TYPE)
val USELESS_IS_CHECK by warning1<KtElement, Boolean>()
val IS_ENUM_ENTRY by error0<KtTypeReference>()
val ENUM_ENTRY_AS_TYPE by error0<KtTypeReference>()
val ENUM_ENTRY_AS_TYPE by error0<KtTypeReference>(SourceElementPositioningStrategies.SELECTOR_BY_QUALIFIED)
// When expressions
val EXPECTED_CONDITION by error0<KtWhenCondition>()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+24 -6
View File
@@ -20,8 +20,7 @@ import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
import org.jetbrains.kotlin.psi.stubs.elements.KtConstantExpressionElementType
import org.jetbrains.kotlin.psi.stubs.elements.KtStringTemplateExpressionElementType
import org.jetbrains.kotlin.psi.stubs.elements.KtValueArgumentElementType
import org.jetbrains.kotlin.psi.stubs.elements.KtValueArgumentListElementType
import org.jetbrains.kotlin.psi.stubs.elements.KtStubElementTypes
object LightTreePositioningStrategies {
val DEFAULT = object : LightTreePositioningStrategy() {
@@ -462,17 +461,36 @@ object LightTreePositioningStrategies {
return markElement(it, startOffset, endOffset, tree, node)
}
}
if (node.tokenType !in KtTokens.QUALIFIED_ACCESS) {
if (node.tokenType in KtTokens.QUALIFIED_ACCESS) {
val selector = tree.selector(node)
if (selector != null) {
return markElement(selector, startOffset, endOffset, tree, node)
}
return super.mark(node, startOffset, endOffset, tree)
}
val selector = tree.selector(node)
if (selector != null) {
return markElement(selector, startOffset, endOffset, tree, node)
if (node.tokenType == KtNodeTypes.TYPE_REFERENCE) {
val typeElement = tree.findChildByType(node, KtStubElementTypes.TYPE_ELEMENT_TYPES)
if (typeElement != null) {
val referencedTypeExpression = tree.referencedTypeExpression(typeElement)
if (referencedTypeExpression != null) {
return markElement(referencedTypeExpression, startOffset, endOffset, tree, node)
}
}
}
return super.mark(node, startOffset, endOffset, tree)
}
}
private fun FlyweightCapableTreeStructure<LighterASTNode>.referencedTypeExpression(node: LighterASTNode): LighterASTNode? {
return when (node.tokenType) {
KtNodeTypes.USER_TYPE -> findChildByType(node, KtNodeTypes.REFERENCE_EXPRESSION)
?: findChildByType(node, KtNodeTypes.ENUM_ENTRY_SUPERCLASS_REFERENCE_EXPRESSION)
KtNodeTypes.NULLABLE_TYPE, KtNodeTypes.DEFINITELY_NOT_NULL_TYPE -> findChildByType(node, KtStubElementTypes.TYPE_ELEMENT_TYPES)
?.let { referencedTypeExpression(it) }
else -> null
}
}
val FUN_INTERFACE: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+12
View File
@@ -821,10 +821,22 @@ object PositioningStrategies {
is KtElement -> return mark(selectorExpression)
}
}
if (element is KtTypeReference) {
element.typeElement?.getReferencedTypeExpression()?.let { return mark(it) }
}
return super.mark(element)
}
}
private fun KtTypeElement.getReferencedTypeExpression(): KtElement? {
return when (this) {
is KtUserType -> referenceExpression
is KtNullableType -> innerType?.getReferencedTypeExpression()
is KtDefinitelyNotNullType -> innerType?.getReferencedTypeExpression()
else -> null
}
}
val RESERVED_UNDERSCORE: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
override fun mark(element: PsiElement): List<TextRange> {
if (element is PsiNameIdentifierOwner) {
compiler/testData/diagnostics/tests/EnumEntryAsType.fir.kt
Vendored
+20 -20
View File
@@ -6,22 +6,22 @@ enum class Color {
}
}
class MyColor(val x: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>, y: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>) : <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> {
class MyColor(val x: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>, y: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
var z: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> = Color.RED
set(arg: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>) { z = arg }
var z: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = Color.RED
set(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>) { z = arg }
fun foo(arg: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>): <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> = arg
fun foo(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
fun bar(): <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> {
class Local : <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>
fun local(arg: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>): <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> = arg
val temp: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> = Color.RED
temp as? <!ENUM_ENTRY_AS_TYPE, ENUM_ENTRY_AS_TYPE!>Color.RED<!>
fun bar(): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {
class Local : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
fun local(arg: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>): Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = arg
val temp: Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> = Color.RED
temp as? Color.<!ENUM_ENTRY_AS_TYPE, ENUM_ENTRY_AS_TYPE!>RED<!>
if (temp is <!IS_ENUM_ENTRY!>Color.RED<!>) {
return temp as <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>
return temp as Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
}
val obj = object : <!ENUM_ENTRY_AS_TYPE!>Color.RED<!> {}
val obj = object : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!> {}
if (obj is <!IS_ENUM_ENTRY!>Color.RED<!>) {
return obj
}
@@ -29,26 +29,26 @@ class MyColor(val x: <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>, y: <!ENUM_ENTRY_AS_TYPE
}
}
fun create(): Array<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>? = null
fun create(): Array<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>? = null
interface Your<T : <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>
interface Your<T : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>
class His : Your<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>
class His : Your<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>
fun <T : <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>> otherCreate(): Array<T>? = null
fun <T : Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>> otherCreate(): Array<T>? = null
typealias RedAlias = <!ENUM_ENTRY_AS_TYPE!>Color.RED<!>
typealias RedAlias = Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>
typealias ArrayOfEnumEntry = Array<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>
typealias ArrayOfEnumEntry = Array<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>
typealias ArrayOfEnumEntryAlias = Array<RedAlias>
fun <T> bar(a: Any): T = a as T
fun <T> foo() {
foo<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>()
foo<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>()
foo<<!CANNOT_INFER_PARAMETER_TYPE!>RedAlias<!>>()
bar<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>(<!ARGUMENT_TYPE_MISMATCH!>Color.RED<!>)
bar<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>(<!ARGUMENT_TYPE_MISMATCH!>Color.RED<!>)
}
fun Array<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>.foo(entries: Array<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>>): Array<<!ENUM_ENTRY_AS_TYPE!>Color.RED<!>> = null!!
fun Array<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>.foo(entries: Array<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>>): Array<Color.<!ENUM_ENTRY_AS_TYPE!>RED<!>> = null!!
compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.fir.kt
Vendored
-5
View File
@@ -1,5 +0,0 @@
enum class E {
ENTRY
}
class A : <!ENUM_ENTRY_AS_TYPE!>E.ENTRY<!>
compiler/testData/diagnostics/tests/enum/inheritFromEnumEntry.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
enum class E {
ENTRY
}