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

[FIR] Enhance diagnostic DSL to be able to use concrete factories

Browse Source 
Before this commit, things like DiagnosticFactory0<KtDeclaration>
were effectively unusable.
This commit is contained in:
Mikhail Glukhikh
2020-03-25 14:43:44 +03:00
parent a1d81aa15f
commit 2f63c8a46a
10 changed files with 142 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt
+1 -1
View File
@@ -65,7 +65,7 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
reporter.report(coneDiagnostic) reporter.report(coneDiagnostic)
} }
private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceElement> { private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceElement, *> {
@Suppress("UNCHECKED_CAST") @Suppress("UNCHECKED_CAST")
return when (kind) { return when (kind) {
DiagnosticKind.Syntax -> FirErrors.SYNTAX_ERROR DiagnosticKind.Syntax -> FirErrors.SYNTAX_ERROR
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt
+41 -40
View File
@@ -5,6 +5,7 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.Diagnostic import org.jetbrains.kotlin.diagnostics.Diagnostic
import org.jetbrains.kotlin.diagnostics.Severity import org.jetbrains.kotlin.diagnostics.Severity
import org.jetbrains.kotlin.fir.FirLightSourceElement import org.jetbrains.kotlin.fir.FirLightSourceElement
@@ -20,75 +21,75 @@ sealed class FirDiagnostic<out E : FirSourceElement> {
} }
sealed class FirSimpleDiagnostic<out E : FirSourceElement> : FirDiagnostic<E>() { sealed class FirSimpleDiagnostic<out E : FirSourceElement> : FirDiagnostic<E>() {
abstract override val factory: FirDiagnosticFactory0<*> abstract override val factory: FirDiagnosticFactory0<*, *>
} }
sealed class FirDiagnosticWithParameters1<out E : FirSourceElement, A> : FirDiagnostic<E>() { sealed class FirDiagnosticWithParameters1<out E : FirSourceElement, A> : FirDiagnostic<E>() {
abstract val a: A abstract val a: A
abstract override val factory: FirDiagnosticFactory1<*, A> abstract override val factory: FirDiagnosticFactory1<*, *, A>
} }
sealed class FirDiagnosticWithParameters2<out E : FirSourceElement, A, B> : FirDiagnostic<E>() { sealed class FirDiagnosticWithParameters2<out E : FirSourceElement, A, B> : FirDiagnostic<E>() {
abstract val a: A abstract val a: A
abstract val b: B abstract val b: B
abstract override val factory: FirDiagnosticFactory2<*, A, B> abstract override val factory: FirDiagnosticFactory2<*, *, A, B>
} }
sealed class FirDiagnosticWithParameters3<out E : FirSourceElement, A, B, C> : FirDiagnostic<E>() { sealed class FirDiagnosticWithParameters3<out E : FirSourceElement, A, B, C> : FirDiagnostic<E>() {
abstract val a: A abstract val a: A
abstract val b: B abstract val b: B
abstract val c: C abstract val c: C
abstract override val factory: FirDiagnosticFactory3<*, A, B, C> abstract override val factory: FirDiagnosticFactory3<*, *, A, B, C>
} }
// ------------------------------ psi diagnostics ------------------------------ // ------------------------------ psi diagnostics ------------------------------
interface FirPsiDiagnostic<out E : FirPsiSourceElement> { interface FirPsiDiagnostic<P : PsiElement> {
fun asPsiBasedDiagnostic(): Diagnostic fun asPsiBasedDiagnostic(): Diagnostic
val element: E val element: FirPsiSourceElement<P>
} }
data class FirPsiSimpleDiagnostic<out E : FirPsiSourceElement>( data class FirPsiSimpleDiagnostic<P : PsiElement>(
override val element: E, override val element: FirPsiSourceElement<P>,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory0<*> override val factory: FirDiagnosticFactory0<FirPsiSourceElement<P>, P>
) : FirSimpleDiagnostic<E>(), FirPsiDiagnostic<E> { ) : FirSimpleDiagnostic<FirPsiSourceElement<P>>(), FirPsiDiagnostic<P> {
override fun asPsiBasedDiagnostic(): Diagnostic { override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi) return factory.psiDiagnosticFactory.on(element.psi)
} }
} }
data class FirPsiDiagnosticWithParameters1<out E : FirPsiSourceElement, A>( data class FirPsiDiagnosticWithParameters1<P : PsiElement, A>(
override val element: E, override val element: FirPsiSourceElement<P>,
override val a: A, override val a: A,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory1<*, A> override val factory: FirDiagnosticFactory1<FirPsiSourceElement<P>, P, A>
) : FirDiagnosticWithParameters1<E, A>(), FirPsiDiagnostic<E> { ) : FirDiagnosticWithParameters1<FirPsiSourceElement<P>, A>(), FirPsiDiagnostic<P> {
override fun asPsiBasedDiagnostic(): Diagnostic { override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a) return factory.psiDiagnosticFactory.on(element.psi, a)
} }
} }
data class FirPsiDiagnosticWithParameters2<out E : FirPsiSourceElement, A, B>( data class FirPsiDiagnosticWithParameters2<P : PsiElement, A, B>(
override val element: E, override val element: FirPsiSourceElement<P>,
override val a: A, override val a: A,
override val b: B, override val b: B,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory2<*, A, B> override val factory: FirDiagnosticFactory2<FirPsiSourceElement<P>, P, A, B>
) : FirDiagnosticWithParameters2<E, A, B>(), FirPsiDiagnostic<E> { ) : FirDiagnosticWithParameters2<FirPsiSourceElement<P>, A, B>(), FirPsiDiagnostic<P> {
override fun asPsiBasedDiagnostic(): Diagnostic { override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a, b) return factory.psiDiagnosticFactory.on(element.psi, a, b)
} }
} }
data class FirPsiDiagnosticWithParameters3<out E : FirPsiSourceElement, A, B, C>( data class FirPsiDiagnosticWithParameters3<P : PsiElement, A, B, C>(
override val element: E, override val element: FirPsiSourceElement<P>,
override val a: A, override val a: A,
override val b: B, override val b: B,
override val c: C, override val c: C,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory3<*, A, B, C> override val factory: FirDiagnosticFactory3<FirPsiSourceElement<P>, P, A, B, C>
) : FirDiagnosticWithParameters3<E, A, B, C>(), FirPsiDiagnostic<E> { ) : FirDiagnosticWithParameters3<FirPsiSourceElement<P>, A, B, C>(), FirPsiDiagnostic<P> {
override fun asPsiBasedDiagnostic(): Diagnostic { override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a, b, c) return factory.psiDiagnosticFactory.on(element.psi, a, b, c)
} }
@@ -96,36 +97,36 @@ data class FirPsiDiagnosticWithParameters3<out E : FirPsiSourceElement, A, B, C>
// ------------------------------ light tree diagnostics ------------------------------ // ------------------------------ light tree diagnostics ------------------------------
interface FirLightDiagnostic<out E: FirLightSourceElement> { interface FirLightDiagnostic {
val element: E val element: FirLightSourceElement
} }
data class FirLightSimpleDiagnostic<out E : FirLightSourceElement>( data class FirLightSimpleDiagnostic(
override val element: E, override val element: FirLightSourceElement,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory0<*> override val factory: FirDiagnosticFactory0<*, *>
) : FirSimpleDiagnostic<E>(), FirLightDiagnostic<E> ) : FirSimpleDiagnostic<FirLightSourceElement>(), FirLightDiagnostic
data class FirLightDiagnosticWithParameters1<out E : FirLightSourceElement, A>( data class FirLightDiagnosticWithParameters1<A>(
override val element: E, override val element: FirLightSourceElement,
override val a: A, override val a: A,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory1<*, A> override val factory: FirDiagnosticFactory1<*, *, A>
) : FirDiagnosticWithParameters1<E, A>(), FirLightDiagnostic<E> ) : FirDiagnosticWithParameters1<FirLightSourceElement, A>(), FirLightDiagnostic
data class FirLightDiagnosticWithParameters2<out E : FirLightSourceElement, A, B>( data class FirLightDiagnosticWithParameters2<A, B>(
override val element: E, override val element: FirLightSourceElement,
override val a: A, override val a: A,
override val b: B, override val b: B,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory2<*, A, B> override val factory: FirDiagnosticFactory2<*, *, A, B>
) : FirDiagnosticWithParameters2<E, A, B>(), FirLightDiagnostic<E> ) : FirDiagnosticWithParameters2<FirLightSourceElement, A, B>(), FirLightDiagnostic
data class FirLightDiagnosticWithParameters3<out E : FirLightSourceElement, A, B, C>( data class FirLightDiagnosticWithParameters3<A, B, C>(
override val element: E, override val element: FirLightSourceElement,
override val a: A, override val a: A,
override val b: B, override val b: B,
override val c: C, override val c: C,
override val severity: Severity, override val severity: Severity,
override val factory: FirDiagnosticFactory3<*, A, B, C> override val factory: FirDiagnosticFactory3<*, *, A, B, C>
) : FirDiagnosticWithParameters3<E, A, B, C>(), FirLightDiagnostic<E> ) : FirDiagnosticWithParameters3<FirLightSourceElement, A, B, C>(), FirLightDiagnostic
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactory.kt
+25 -17
View File
@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.FirLightSourceElement
import org.jetbrains.kotlin.fir.FirPsiSourceElement import org.jetbrains.kotlin.fir.FirPsiSourceElement
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
sealed class AbstractFirDiagnosticFactory<E : FirSourceElement, D : FirDiagnostic<E>>( sealed class AbstractFirDiagnosticFactory<out E : FirSourceElement, D : FirDiagnostic<E>>(
val name: String, val name: String,
val severity: Severity, val severity: Severity,
) { ) {
@@ -22,51 +22,59 @@ sealed class AbstractFirDiagnosticFactory<E : FirSourceElement, D : FirDiagnosti
} }
} }
class FirDiagnosticFactory0<E : FirSourceElement>( class FirDiagnosticFactory0<E : FirSourceElement, P : PsiElement>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory0<PsiElement> name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory0<P>
) : AbstractFirDiagnosticFactory<E, FirSimpleDiagnostic<E>>(name, severity) { ) : AbstractFirDiagnosticFactory<E, FirSimpleDiagnostic<E>>(name, severity) {
fun on(element: E): FirSimpleDiagnostic<E> { fun on(element: E): FirSimpleDiagnostic<E> {
return when (element) { return when (element) {
is FirPsiSourceElement -> FirPsiSimpleDiagnostic(element, severity, this) is FirPsiSourceElement<*> -> FirPsiSimpleDiagnostic(
element as FirPsiSourceElement<P>, severity, this as FirDiagnosticFactory0<FirPsiSourceElement<P>, P>
)
is FirLightSourceElement -> FirLightSimpleDiagnostic(element, severity, this) is FirLightSourceElement -> FirLightSimpleDiagnostic(element, severity, this)
else -> incorrectElement(element) else -> incorrectElement(element)
} } as FirSimpleDiagnostic<E>
} }
} }
class FirDiagnosticFactory1<E : FirSourceElement, A>( class FirDiagnosticFactory1<E : FirSourceElement, P : PsiElement, A>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A> name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory1<P, A>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters1<E, A>>(name, severity) { ) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters1<E, A>>(name, severity) {
fun on(element: E, a: A): FirDiagnosticWithParameters1<E, A> { fun on(element: E, a: A): FirDiagnosticWithParameters1<E, A> {
return when (element) { return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters1(element, a, severity, this) is FirPsiSourceElement<*> -> FirPsiDiagnosticWithParameters1(
element as FirPsiSourceElement<P>, a, severity, this as FirDiagnosticFactory1<FirPsiSourceElement<P>, P, A>
)
is FirLightSourceElement -> FirLightDiagnosticWithParameters1(element, a, severity, this) is FirLightSourceElement -> FirLightDiagnosticWithParameters1(element, a, severity, this)
else -> incorrectElement(element) else -> incorrectElement(element)
} } as FirDiagnosticWithParameters1<E, A>
} }
} }
class FirDiagnosticFactory2<E : FirSourceElement, A, B>( class FirDiagnosticFactory2<E : FirSourceElement, P : PsiElement, A, B>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B> name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory2<P, A, B>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters2<E, A, B>>(name, severity) { ) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters2<E, A, B>>(name, severity) {
fun on(element: E, a: A, b: B): FirDiagnosticWithParameters2<E, A, B> { fun on(element: E, a: A, b: B): FirDiagnosticWithParameters2<E, A, B> {
return when (element) { return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters2(element, a, b, severity, this) is FirPsiSourceElement<*> -> FirPsiDiagnosticWithParameters2(
element as FirPsiSourceElement<P>, a, b, severity, this as FirDiagnosticFactory2<FirPsiSourceElement<P>, P, A, B>
)
is FirLightSourceElement -> FirLightDiagnosticWithParameters2(element, a, b, severity, this) is FirLightSourceElement -> FirLightDiagnosticWithParameters2(element, a, b, severity, this)
else -> incorrectElement(element) else -> incorrectElement(element)
} } as FirDiagnosticWithParameters2<E, A, B>
} }
} }
class FirDiagnosticFactory3<E : FirSourceElement, A, B, C>( class FirDiagnosticFactory3<E : FirSourceElement, P : PsiElement, A, B, C>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C> name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory3<P, A, B, C>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters3<E, A, B, C>>(name, severity) { ) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters3<E, A, B, C>>(name, severity) {
fun on(element: E, a: A, b: B, c: C): FirDiagnosticWithParameters3<E, A, B, C> { fun on(element: E, a: A, b: B, c: C): FirDiagnosticWithParameters3<E, A, B, C> {
return when (element) { return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters3(element, a, b, c, severity, this) is FirPsiSourceElement<*> -> FirPsiDiagnosticWithParameters3(
element as FirPsiSourceElement<P>, a, b, c, severity, this as FirDiagnosticFactory3<FirPsiSourceElement<P>, P, A, B, C>
)
is FirLightSourceElement -> FirLightDiagnosticWithParameters3(element, a, b, c, severity, this) is FirLightSourceElement -> FirLightDiagnosticWithParameters3(element, a, b, c, severity, this)
else -> incorrectElement(element) else -> incorrectElement(element)
} } as FirDiagnosticWithParameters3<E, A, B, C>
} }
} }
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactoryDsl.kt
+36 -28
View File
@@ -11,35 +11,35 @@ import org.jetbrains.kotlin.fir.FirSourceElement
import kotlin.properties.ReadOnlyProperty import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty import kotlin.reflect.KProperty
fun <E : FirSourceElement> warning0(): DiagnosticFactory0DelegateProvider<E> { fun <E : FirSourceElement, P : PsiElement> warning0(): DiagnosticFactory0DelegateProvider<E, P> {
return DiagnosticFactory0DelegateProvider(Severity.WARNING, null) return DiagnosticFactory0DelegateProvider(Severity.WARNING, null)
} }
fun <E : FirSourceElement, A> warning1(): DiagnosticFactory1DelegateProvider<E, A> { fun <E : FirSourceElement, P : PsiElement, A> warning1(): DiagnosticFactory1DelegateProvider<E, P, A> {
return DiagnosticFactory1DelegateProvider(Severity.WARNING, null) return DiagnosticFactory1DelegateProvider(Severity.WARNING, null)
} }
fun <E : FirSourceElement, A, B> warning2(): DiagnosticFactory2DelegateProvider<E, A, B> { fun <E : FirSourceElement, P : PsiElement, A, B> warning2(): DiagnosticFactory2DelegateProvider<E, P, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.WARNING, null) return DiagnosticFactory2DelegateProvider(Severity.WARNING, null)
} }
fun <E : FirSourceElement, A, B, C> warning3(): DiagnosticFactory3DelegateProvider<E, A, B, C> { fun <E : FirSourceElement, P : PsiElement, A, B, C> warning3(): DiagnosticFactory3DelegateProvider<E, P, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.WARNING, null) return DiagnosticFactory3DelegateProvider(Severity.WARNING, null)
} }
fun <E : FirSourceElement> error0(): DiagnosticFactory0DelegateProvider<E> { fun <E : FirSourceElement, P : PsiElement> error0(): DiagnosticFactory0DelegateProvider<E, P> {
return DiagnosticFactory0DelegateProvider(Severity.ERROR, null) return DiagnosticFactory0DelegateProvider(Severity.ERROR, null)
} }
fun <E : FirSourceElement, A> error1(): DiagnosticFactory1DelegateProvider<E, A> { fun <E : FirSourceElement, P : PsiElement, A> error1(): DiagnosticFactory1DelegateProvider<E, P, A> {
return DiagnosticFactory1DelegateProvider(Severity.ERROR, null) return DiagnosticFactory1DelegateProvider(Severity.ERROR, null)
} }
fun <E : FirSourceElement, A, B> error2(): DiagnosticFactory2DelegateProvider<E, A, B> { fun <E : FirSourceElement, P : PsiElement, A, B> error2(): DiagnosticFactory2DelegateProvider<E, P, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.ERROR, null) return DiagnosticFactory2DelegateProvider(Severity.ERROR, null)
} }
fun <E : FirSourceElement, A, B, C> error3(): DiagnosticFactory3DelegateProvider<E, A, B, C> { fun <E : FirSourceElement, P : PsiElement, A, B, C> error3(): DiagnosticFactory3DelegateProvider<E, P, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.ERROR, null) return DiagnosticFactory3DelegateProvider(Severity.ERROR, null)
} }
@@ -47,66 +47,74 @@ fun <E : FirSourceElement, A, B, C> error3(): DiagnosticFactory3DelegateProvider
* Note that those functions can be applicable only for factories * Note that those functions can be applicable only for factories
* that takes `PsiElement` as first type parameter * that takes `PsiElement` as first type parameter
*/ */
fun <E : FirSourceElement> existing(psiDiagnosticFactory: DiagnosticFactory0<PsiElement>): DiagnosticFactory0DelegateProvider<E> { fun <E : FirSourceElement, P : PsiElement> existing(
psiDiagnosticFactory: DiagnosticFactory0<P>
): DiagnosticFactory0DelegateProvider<E, P> {
return DiagnosticFactory0DelegateProvider(Severity.ERROR, psiDiagnosticFactory) return DiagnosticFactory0DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
} }
fun <E : FirSourceElement, A> existing(psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A>): DiagnosticFactory1DelegateProvider<E, A> { fun <E : FirSourceElement, P : PsiElement, A> existing(
psiDiagnosticFactory: DiagnosticFactory1<P, A>
): DiagnosticFactory1DelegateProvider<E, P, A> {
return DiagnosticFactory1DelegateProvider(Severity.ERROR, psiDiagnosticFactory) return DiagnosticFactory1DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
} }
fun <E : FirSourceElement, A, B> existing(psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B>): DiagnosticFactory2DelegateProvider<E, A, B> { fun <E : FirSourceElement, P : PsiElement, A, B> existing(
psiDiagnosticFactory: DiagnosticFactory2<P, A, B>
): DiagnosticFactory2DelegateProvider<E, P, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.ERROR, psiDiagnosticFactory) return DiagnosticFactory2DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
} }
fun <E : FirSourceElement, A, B, C> existing(psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C>): DiagnosticFactory3DelegateProvider<E, A, B, C> { fun <E : FirSourceElement, P : PsiElement, A, B, C> existing(
psiDiagnosticFactory: DiagnosticFactory3<P, A, B, C>
): DiagnosticFactory3DelegateProvider<E, P, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.ERROR, psiDiagnosticFactory) return DiagnosticFactory3DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
} }
// ------------------------------ Providers ------------------------------ // ------------------------------ Providers ------------------------------
class DiagnosticFactory0DelegateProvider<E : FirSourceElement>( class DiagnosticFactory0DelegateProvider<E : FirSourceElement, P : PsiElement>(
private val severity: Severity, private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory0<PsiElement>? private val psiDiagnosticFactory: DiagnosticFactory0<P>?
) { ) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory0<E>> { operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory0<E, P>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory0.create<PsiElement>(severity).apply { val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory0.create<P>(severity).apply {
initializeName(prop.name) initializeName(prop.name)
} }
return DummyDelegate(FirDiagnosticFactory0(prop.name, severity, psiFactory)) return DummyDelegate(FirDiagnosticFactory0(prop.name, severity, psiFactory))
} }
} }
class DiagnosticFactory1DelegateProvider<E : FirSourceElement, A>( class DiagnosticFactory1DelegateProvider<E : FirSourceElement, P : PsiElement, A>(
private val severity: Severity, private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A>? private val psiDiagnosticFactory: DiagnosticFactory1<P, A>?
) { ) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory1<E, A>> { operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory1<E, P, A>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory1.create<PsiElement, A>(severity).apply { val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory1.create<P, A>(severity).apply {
initializeName(prop.name) initializeName(prop.name)
} }
return DummyDelegate(FirDiagnosticFactory1(prop.name, severity, psiFactory)) return DummyDelegate(FirDiagnosticFactory1(prop.name, severity, psiFactory))
} }
} }
class DiagnosticFactory2DelegateProvider<E : FirSourceElement, A, B>( class DiagnosticFactory2DelegateProvider<E : FirSourceElement, P : PsiElement, A, B>(
private val severity: Severity, private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B>? private val psiDiagnosticFactory: DiagnosticFactory2<P, A, B>?
) { ) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory2<E, A, B>> { operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory2<E, P, A, B>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory2.create<PsiElement, A, B>(severity).apply { val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory2.create<P, A, B>(severity).apply {
initializeName(prop.name) initializeName(prop.name)
} }
return DummyDelegate(FirDiagnosticFactory2(prop.name, severity, psiFactory)) return DummyDelegate(FirDiagnosticFactory2(prop.name, severity, psiFactory))
} }
} }
class DiagnosticFactory3DelegateProvider<E : FirSourceElement, A, B, C>( class DiagnosticFactory3DelegateProvider<E : FirSourceElement, P : PsiElement, A, B, C>(
private val severity: Severity, private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C>? private val psiDiagnosticFactory: DiagnosticFactory3<P, A, B, C>?
) { ) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory3<E, A, B, C>> { operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory3<E, P, A, B, C>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory3.create<PsiElement, A, B, C>(severity).apply { val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory3.create<P, A, B, C>(severity).apply {
initializeName(prop.name) initializeName(prop.name)
} }
return DummyDelegate(FirDiagnosticFactory3(prop.name, severity, psiFactory)) return DummyDelegate(FirDiagnosticFactory3(prop.name, severity, psiFactory))
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactoryToRendererMap.kt
+4 -4
View File
@@ -16,13 +16,13 @@ class FirDiagnosticFactoryToRendererMap(val name: String) {
operator fun get(factory: AbstractFirDiagnosticFactory<*, *>): DiagnosticRenderer<*>? = diagnosticsMap[factory] operator fun get(factory: AbstractFirDiagnosticFactory<*, *>): DiagnosticRenderer<*>? = diagnosticsMap[factory]
fun put(factory: FirDiagnosticFactory0<*>, message: String) { fun put(factory: FirDiagnosticFactory0<*, *>, message: String) {
psiDiagnosticMap.put(factory.psiDiagnosticFactory, message) psiDiagnosticMap.put(factory.psiDiagnosticFactory, message)
putToFirMap(factory) putToFirMap(factory)
} }
fun <A> put( fun <A> put(
factory: FirDiagnosticFactory1<*, A>, factory: FirDiagnosticFactory1<*, *, A>,
message: String, message: String,
rendererA: DiagnosticParameterRenderer<A>? rendererA: DiagnosticParameterRenderer<A>?
) { ) {
@@ -31,7 +31,7 @@ class FirDiagnosticFactoryToRendererMap(val name: String) {
} }
fun <A, B> put( fun <A, B> put(
factory: FirDiagnosticFactory2<*, A, B>, factory: FirDiagnosticFactory2<*, *, A, B>,
message: String, message: String,
rendererA: DiagnosticParameterRenderer<A>?, rendererA: DiagnosticParameterRenderer<A>?,
rendererB: DiagnosticParameterRenderer<B>? rendererB: DiagnosticParameterRenderer<B>?
@@ -41,7 +41,7 @@ class FirDiagnosticFactoryToRendererMap(val name: String) {
} }
fun <A, B, C> put( fun <A, B, C> put(
factory: FirDiagnosticFactory3<*, A, B, C>, factory: FirDiagnosticFactory3<*, *, A, B, C>,
message: String, message: String,
rendererA: DiagnosticParameterRenderer<A>?, rendererA: DiagnosticParameterRenderer<A>?,
rendererB: DiagnosticParameterRenderer<B>?, rendererB: DiagnosticParameterRenderer<B>?,
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+24 -22
View File
@@ -5,36 +5,38 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.psi.KtDeclaration
import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
object FirErrors { object FirErrors {
val UNRESOLVED_REFERENCE by error1<FirSourceElement, String?>() val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String?>()
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>() val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
val AMBIGUITY by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>() val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>() val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>()
val SYNTAX_ERROR by error0<FirSourceElement>() val SYNTAX_ERROR by error0<FirSourceElement, PsiElement>()
val UNRESOLVED_LABEL by error0<FirSourceElement>() val UNRESOLVED_LABEL by error0<FirSourceElement, PsiElement>()
val ILLEGAL_CONST_EXPRESSION by error0<FirSourceElement>() val ILLEGAL_CONST_EXPRESSION by error0<FirSourceElement, PsiElement>()
val DESERIALIZATION_ERROR by error0<FirSourceElement>() val DESERIALIZATION_ERROR by error0<FirSourceElement, PsiElement>()
val INFERENCE_ERROR by error0<FirSourceElement>() val INFERENCE_ERROR by error0<FirSourceElement, PsiElement>()
val NO_SUPERTYPE by error0<FirSourceElement>() val NO_SUPERTYPE by error0<FirSourceElement, PsiElement>()
val TYPE_PARAMETER_AS_SUPERTYPE by error0<FirSourceElement>() val TYPE_PARAMETER_AS_SUPERTYPE by error0<FirSourceElement, PsiElement>()
val ENUM_AS_SUPERTYPE by error0<FirSourceElement>() val ENUM_AS_SUPERTYPE by error0<FirSourceElement, PsiElement>()
val RECURSION_IN_SUPERTYPES by error0<FirSourceElement>() val RECURSION_IN_SUPERTYPES by error0<FirSourceElement, PsiElement>()
val RECURSION_IN_IMPLICIT_TYPES by error0<FirSourceElement>() val RECURSION_IN_IMPLICIT_TYPES by error0<FirSourceElement, PsiElement>()
val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement>() val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement, PsiElement>()
val OTHER_ERROR by error0<FirSourceElement>() val OTHER_ERROR by error0<FirSourceElement, PsiElement>()
val TYPE_MISMATCH by error2<FirSourceElement, ConeKotlinType, ConeKotlinType>() val TYPE_MISMATCH by error2<FirSourceElement, PsiElement, ConeKotlinType, ConeKotlinType>()
val VARIABLE_EXPECTED by error0<FirSourceElement>() val VARIABLE_EXPECTED by error0<FirSourceElement, PsiElement>()
val RETURN_NOT_ALLOWED by error0<FirSourceElement>() val RETURN_NOT_ALLOWED by error0<FirSourceElement, PsiElement>()
val CONSTRUCTOR_IN_OBJECT by error0<FirSourceElement>() val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement, PsiElement>()
val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement>()
val INAPPLICABLE_INFIX_MODIFIER by existing<FirSourceElement, String>(Errors.INAPPLICABLE_INFIX_MODIFIER) val INAPPLICABLE_INFIX_MODIFIER by existing<FirSourceElement, PsiElement, String>(Errors.INAPPLICABLE_INFIX_MODIFIER)
val CONSTRUCTOR_IN_OBJECT by existing<FirSourceElement, KtDeclaration>(Errors.CONSTRUCTOR_IN_OBJECT)
val REPEATED_MODIFIER by error1<FirSourceElement, KtModifierKeywordToken>() val REPEATED_MODIFIER by error1<FirSourceElement, KtModifierKeywordToken>()
val REDUNDANT_MODIFIER by error2<FirSourceElement, KtModifierKeywordToken, KtModifierKeywordToken>() val REDUNDANT_MODIFIER by error2<FirSourceElement, KtModifierKeywordToken, KtModifierKeywordToken>()
compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+3 -3
View File
@@ -53,7 +53,7 @@ class RawFirBuilder(
return file.accept(Visitor(), Unit) as FirFile return file.accept(Visitor(), Unit) as FirFile
} }
override fun PsiElement.toFirSourceElement(): FirPsiSourceElement { override fun PsiElement.toFirSourceElement(): FirPsiSourceElement<*> {
return FirPsiSourceElement(this) return FirPsiSourceElement(this)
} }
@@ -1475,7 +1475,7 @@ class RawFirBuilder(
private fun splitToCalleeAndReceiver( private fun splitToCalleeAndReceiver(
calleeExpression: KtExpression?, calleeExpression: KtExpression?,
defaultSource: FirPsiSourceElement, defaultSource: FirPsiSourceElement<*>,
): Pair<FirNamedReference, FirExpression?> { ): Pair<FirNamedReference, FirExpression?> {
return when (calleeExpression) { return when (calleeExpression) {
is KtSimpleNameExpression -> buildSimpleNamedReference { is KtSimpleNameExpression -> buildSimpleNamedReference {
@@ -1535,7 +1535,7 @@ class RawFirBuilder(
override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement { override fun visitArrayAccessExpression(expression: KtArrayAccessExpression, data: Unit): FirElement {
val arrayExpression = expression.arrayExpression val arrayExpression = expression.arrayExpression
return buildFunctionCall { return buildFunctionCall {
val source: FirPsiSourceElement val source: FirPsiSourceElement<*>
val getArgument = context.arraySetArgument.remove(expression) val getArgument = context.arraySetArgument.remove(expression)
if (getArgument != null) { if (getArgument != null) {
calleeReference = buildSimpleNamedReference { calleeReference = buildSimpleNamedReference {
compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirSourceElement.kt
+5 -5
View File
@@ -21,7 +21,7 @@ sealed class FirSourceElement {
abstract val endOffset: Int abstract val endOffset: Int
} }
class FirPsiSourceElement(val psi: PsiElement) : FirSourceElement() { class FirPsiSourceElement<P : PsiElement>(val psi: P) : FirSourceElement() {
override val elementType: IElementType override val elementType: IElementType
get() = psi.node.elementType get() = psi.node.elementType
@@ -42,19 +42,19 @@ class FirLightSourceElement(
get() = element.tokenType get() = element.tokenType
} }
val FirSourceElement?.psi: PsiElement? get() = (this as? FirPsiSourceElement)?.psi val FirSourceElement?.psi: PsiElement? get() = (this as? FirPsiSourceElement<*>)?.psi
val FirElement.psi: PsiElement? get() = (source as? FirPsiSourceElement)?.psi val FirElement.psi: PsiElement? get() = (source as? FirPsiSourceElement<*>)?.psi
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
inline fun PsiElement.toFirSourceElement(): FirPsiSourceElement = FirPsiSourceElement(this) inline fun PsiElement.toFirSourceElement(): FirPsiSourceElement<*> = FirPsiSourceElement(this)
val FirSourceElement?.lightNode: LighterASTNode? get() = (this as? FirLightSourceElement)?.element val FirSourceElement?.lightNode: LighterASTNode? get() = (this as? FirLightSourceElement)?.element
fun FirSourceElement?.getModifierList(): FirModifierList? { fun FirSourceElement?.getModifierList(): FirModifierList? {
return when (this) { return when (this) {
null -> null null -> null
is FirPsiSourceElement -> (psi as? KtModifierListOwner)?.modifierList?.let { FirPsiModifierList(it) } is FirPsiSourceElement<*> -> (psi as? KtModifierListOwner)?.modifierList?.let { FirPsiModifierList(it) }
is FirLightSourceElement -> { is FirLightSourceElement -> {
val kidsRef = Ref<Array<LighterASTNode?>>() val kidsRef = Ref<Array<LighterASTNode?>>()
tree.getChildren(element, kidsRef) tree.getChildren(element, kidsRef)
compiler/testData/diagnostics/tests/ObjectWithConstructor.fir.kt
Vendored
+2 -2
View File
@@ -11,10 +11,10 @@ object A2 public constructor(private val prop: Int) {
} }
val x = object (val prop: Int) { val x = object (val prop: Int) {
<!CONSTRUCTOR_IN_OBJECT, CONSTRUCTOR_IN_OBJECT!>constructor() : <!UNRESOLVED_REFERENCE!>this<!>(1) { <!CONSTRUCTOR_IN_OBJECT, CONSTRUCTOR_IN_OBJECT!>constructor()<!> : <!UNRESOLVED_REFERENCE!>this<!>(1) {
val x = 1 val x = 1
x * x x * x
}<!> }
} }
class A3 { class A3 {
compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticsWithLightTreeTest.kt
+1 -1
View File
@@ -36,7 +36,7 @@ abstract class AbstractFirDiagnosticsWithLightTreeTest : AbstractFirDiagnosticsT
val diagnostics = fileToDiagnostics[firFile] ?: emptyList() val diagnostics = fileToDiagnostics[firFile] ?: emptyList()
val actualDiagnostics = diagnostics.groupBy { val actualDiagnostics = diagnostics.groupBy {
require(it is FirLightDiagnostic<*>) require(it is FirLightDiagnostic)
it.element.startOffset it.element.startOffset
}.mapValues { (_, diagnostics) -> diagnostics.map { it.factory.name }.countEntries() } }.mapValues { (_, diagnostics) -> diagnostics.map { it.factory.name }.countEntries() }