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

[FIR] Add unified diagnostics for psi and light tree

Browse Source
This commit is contained in:
Dmitriy Novozhilov
2020-03-23 12:24:29 +03:00
parent 1a3fef5fa1
commit 2c37627b15
28 changed files with 499 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirInfixFunctionDeclarationChecker.kt
+2 -3
View File
@@ -5,11 +5,10 @@
package org.jetbrains.kotlin.fir.analysis.checkers.declaration
import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.isInfix
@@ -28,6 +27,6 @@ object FirInfixFunctionDeclarationChecker : FirDeclarationChecker<FirMemberDecla
}
private fun DiagnosticReporter.report(source: FirSourceElement?) {
source?.let { report(Errors.INAPPLICABLE_INFIX_MODIFIER.onSource(it, "Inapplicable infix modifier")) }
source?.let { report(FirErrors.INAPPLICABLE_INFIX_MODIFIER.on(it, "Inapplicable infix modifier")) }
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt
+3 -3
View File
@@ -9,8 +9,8 @@ import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
import org.jetbrains.kotlin.fir.analysis.collectors.components.*
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.declarations.*
import org.jetbrains.kotlin.fir.resolve.ScopeSession
import org.jetbrains.kotlin.fir.resolve.SessionHolder
@@ -27,7 +27,7 @@ abstract class AbstractDiagnosticCollector(
override val session: FirSession,
override val scopeSession: ScopeSession = ScopeSession()
) : SessionHolder {
fun collectDiagnostics(firFile: FirFile): Iterable<FirDiagnostic> {
fun collectDiagnostics(firFile: FirFile): Iterable<FirDiagnostic<*>> {
if (!componentsInitialized) {
throw IllegalStateException("Components are not initialized")
}
@@ -37,7 +37,7 @@ abstract class AbstractDiagnosticCollector(
}
protected abstract fun initializeCollector()
protected abstract fun getCollectedDiagnostics(): Iterable<FirDiagnostic>
protected abstract fun getCollectedDiagnostics(): Iterable<FirDiagnostic<*>>
abstract fun runCheck(block: (DiagnosticReporter) -> Unit)
private val components: MutableList<AbstractDiagnosticCollectorComponent> = mutableListOf()
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt
+4 -4
View File
@@ -6,8 +6,8 @@
package org.jetbrains.kotlin.fir.analysis.collectors
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter
import java.util.*
import java.util.concurrent.Executors
@@ -42,10 +42,10 @@ class ParallelDiagnosticsCollector(session: FirSession, private val numberOfThre
futures.clear()
}
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic<*>> {
futures.forEach { it.get() }
return Iterable {
object : Iterator<FirDiagnostic> {
object : Iterator<FirDiagnostic<*>> {
private val globalIterator = reporters.iterator()
private var localIterator = globalIterator.next().diagnostics.iterator()
@@ -60,7 +60,7 @@ class ParallelDiagnosticsCollector(session: FirSession, private val numberOfThre
return localIterator.hasNext()
}
override fun next(): FirDiagnostic {
override fun next(): FirDiagnostic<*> {
update()
return localIterator.next()
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt
+2 -2
View File
@@ -6,8 +6,8 @@
package org.jetbrains.kotlin.fir.analysis.collectors
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter
class SimpleDiagnosticsCollector(session: FirSession) : AbstractDiagnosticCollector(session) {
@@ -17,7 +17,7 @@ class SimpleDiagnosticsCollector(session: FirSession) : AbstractDiagnosticCollec
reporter = SimpleDiagnosticReporter()
}
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic<*>> {
return reporter.diagnostics
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt
+21 -28
View File
@@ -5,16 +5,17 @@
package org.jetbrains.kotlin.fir.analysis.collectors.components
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0
import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1
import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
import org.jetbrains.kotlin.fir.analysis.diagnostics.*
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory0
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
import org.jetbrains.kotlin.fir.diagnostics.*
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
@@ -49,30 +50,29 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
private fun reportFirDiagnostic(diagnostic: ConeDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) {
val coneDiagnostic = when (diagnostic) {
is ConeUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name?.asString())
is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.classId.asString())
is ConeUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name.asString())
is ConeInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.onSource(source, diagnostic.candidates.map { it.symbol })
is ConeAmbiguityError -> FirErrors.AMBIGUITY.onSource(source, diagnostic.candidates)
is ConeOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.onSource(source, diagnostic.candidates)
is ConeVariableExpectedError -> Errors.VARIABLE_EXPECTED.onSource(source)
is ConeTypeMismatchError -> FirErrors.TYPE_MISMATCH.onSource(source, diagnostic.expectedType, diagnostic.actualType)
is ConeSimpleDiagnostic -> diagnostic.getFactory().onSource(source)
is ConeSimpleDiagnosticWithParameters1<*> -> diagnostic.getFactory().tryOnSource(source, diagnostic.a)
is ConeUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.name?.asString())
is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.classId.asString())
is ConeUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.name.asString())
is ConeInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidates.map { it.symbol })
is ConeAmbiguityError -> FirErrors.AMBIGUITY.on(source, diagnostic.candidates)
is ConeOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.on(source, diagnostic.candidates)
is ConeVariableExpectedError -> FirErrors.VARIABLE_EXPECTED.on(source)
is ConeTypeMismatchError -> FirErrors.TYPE_MISMATCH.on(source, diagnostic.expectedType, diagnostic.actualType)
is ConeSimpleDiagnostic -> diagnostic.getFactory().on(source)
is ConeStubDiagnostic -> null
else -> throw IllegalArgumentException("Unsupported diagnostic type: ${diagnostic.javaClass}")
}
reporter.report(coneDiagnostic)
}
private fun ConeSimpleDiagnostic.getFactory(): DiagnosticFactory0<PsiElement> {
private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceElement> {
@Suppress("UNCHECKED_CAST")
return when (kind) {
DiagnosticKind.Syntax -> FirErrors.SYNTAX_ERROR
DiagnosticKind.ReturnNotAllowed -> Errors.RETURN_NOT_ALLOWED
DiagnosticKind.ReturnNotAllowed -> FirErrors.RETURN_NOT_ALLOWED
DiagnosticKind.UnresolvedLabel -> FirErrors.UNRESOLVED_LABEL
DiagnosticKind.IllegalConstExpression -> FirErrors.ILLEGAL_CONST_EXPRESSION
DiagnosticKind.ConstructorInObject -> Errors.CONSTRUCTOR_IN_OBJECT
DiagnosticKind.ConstructorInObject -> FirErrors.CONSTRUCTOR_IN_OBJECT
DiagnosticKind.DeserializationError -> FirErrors.DESERIALIZATION_ERROR
DiagnosticKind.InferenceError -> FirErrors.INFERENCE_ERROR
DiagnosticKind.NoSupertype -> FirErrors.NO_SUPERTYPE
@@ -80,17 +80,10 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect
DiagnosticKind.EnumAsSupertype -> FirErrors.ENUM_AS_SUPERTYPE
DiagnosticKind.RecursionInSupertypes -> FirErrors.RECURSION_IN_SUPERTYPES
DiagnosticKind.RecursionInImplicitTypes -> FirErrors.RECURSION_IN_IMPLICIT_TYPES
DiagnosticKind.SuperNotAllowed -> FirErrors.SUPER_IS_NOT_AN_EXPRESSION
DiagnosticKind.Java -> FirErrors.ERROR_FROM_JAVA_RESOLUTION
DiagnosticKind.Other -> FirErrors.OTHER_ERROR
else -> throw IllegalArgumentException("Unsupported diagnostic kind: $kind at $javaClass")
} as DiagnosticFactory0<PsiElement>
}
private fun ConeSimpleDiagnosticWithParameters1<*>.getFactory(): DiagnosticFactory1<PsiElement, Any?> {
@Suppress("UNCHECKED_CAST")
return when (kind) {
DiagnosticKind.SuperNotAllowed -> Errors.SUPER_IS_NOT_AN_EXPRESSION
else -> throw IllegalArgumentException("Unsupported diagnostic kind: $kind at $javaClass")
} as DiagnosticFactory1<PsiElement, Any?>
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt
+3 -3
View File
@@ -6,13 +6,13 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics
abstract class DiagnosticReporter {
abstract fun report(diagnostic: FirDiagnostic?)
abstract fun report(diagnostic: FirDiagnostic<*>?)
}
class SimpleDiagnosticReporter : DiagnosticReporter() {
val diagnostics: MutableList<FirDiagnostic> = mutableListOf()
val diagnostics: MutableList<FirDiagnostic<*>> = mutableListOf()
override fun report(diagnostic: FirDiagnostic?) {
override fun report(diagnostic: FirDiagnostic<*>?) {
if (diagnostic == null) return
diagnostics += diagnostic
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+13 -25
View File
@@ -5,6 +5,10 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics
import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NULLABLE_STRING
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOLS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.AMBIGUITY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGN_OPERATOR_AMBIGUITY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.DESERIALIZATION_ERROR
@@ -17,40 +21,24 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_SUPERTYPE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OTHER_ERROR
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_IMPLICIT_TYPES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_SUPERTYPES
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_IS_NOT_AN_EXPRESSION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX_ERROR
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_PARAMETER_AS_SUPERTYPE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_LABEL
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNRESOLVED_REFERENCE
import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages
import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap
import org.jetbrains.kotlin.diagnostics.rendering.Renderer
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@Suppress("unused")
class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
override fun getMap(): DiagnosticFactoryToRendererMap {
return MAP
return MAP.psiDiagnosticMap
}
companion object {
private val SYMBOL_COLLECTION_RENDERER = Renderer { symbols: Collection<AbstractFirBasedSymbol<*>> ->
symbols.joinToString(prefix = "[", postfix = "]", separator = ",", limit = 3, truncated = "...") { symbol ->
when (symbol) {
is FirClassLikeSymbol<*> -> symbol.classId.asString()
is FirCallableSymbol<*> -> symbol.callableId.toString()
else -> "???"
}
}
}
private val MAP = DiagnosticFactoryToRendererMap("FIR").also { map ->
map.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", Renderer { it })
map.put(INAPPLICABLE_CANDIDATE, "Inapplicable candidate(s): {0}", SYMBOL_COLLECTION_RENDERER)
map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOL_COLLECTION_RENDERER)
map.put(ASSIGN_OPERATOR_AMBIGUITY, "Ambiguity between assign operator candidates: {0}", SYMBOL_COLLECTION_RENDERER)
val MAP = FirDiagnosticFactoryToRendererMap("FIR").also { map ->
map.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", NULLABLE_STRING)
map.put(INAPPLICABLE_CANDIDATE, "Inapplicable candidate(s): {0}", SYMBOLS)
map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOLS)
map.put(ASSIGN_OPERATOR_AMBIGUITY, "Ambiguity between assign operator candidates: {0}", SYMBOLS)
map.put(SYNTAX_ERROR, "Syntax error")
map.put(UNRESOLVED_LABEL, "Unresolved label")
map.put(ILLEGAL_CONST_EXPRESSION, "Illegal const expression")
@@ -63,7 +51,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
map.put(RECURSION_IN_IMPLICIT_TYPES, "Recursion in implicit types")
map.put(ERROR_FROM_JAVA_RESOLUTION, "Java resolution error")
map.put(OTHER_ERROR, "Unknown (other) error")
map.put(SUPER_IS_NOT_AN_EXPRESSION, "Super cannot be a callee")
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt
+113 -30
View File
@@ -5,44 +5,127 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.diagnostics.Diagnostic
import org.jetbrains.kotlin.diagnostics.Severity
import org.jetbrains.kotlin.fir.FirLightSourceElement
import org.jetbrains.kotlin.fir.FirPsiSourceElement
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.psi
class FirDiagnostic(
val diagnostic: Diagnostic,
val source: FirSourceElement
)
// ------------------------------ diagnostics ------------------------------
inline fun <reified E : PsiElement> DiagnosticFactory0<E>.onSource(source: FirSourceElement): FirDiagnostic? {
val psi = source.psi as? E
?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
return FirDiagnostic(this.on(psi), source)
sealed class FirDiagnostic<out E : FirSourceElement> {
abstract val element: E
abstract val severity: Severity
abstract val factory: AbstractFirDiagnosticFactory<*, *>
}
inline fun <reified E : PsiElement, A> DiagnosticFactory1<E, A>.onSource(source: FirSourceElement, a: A): FirDiagnostic? {
val psi = source.psi as? E
?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
return FirDiagnostic(this.on(psi, a), source)
sealed class FirSimpleDiagnostic<out E : FirSourceElement> : FirDiagnostic<E>() {
abstract override val factory: FirDiagnosticFactory0<*>
}
inline fun <reified E : PsiElement, A, B> DiagnosticFactory2<E, A, B>.onSource(source: FirSourceElement, a: A, b: B): FirDiagnostic? {
val psi = source.psi as? E
?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
return FirDiagnostic(this.on(psi, a, b), source)
sealed class FirDiagnosticWithParameters1<out E : FirSourceElement, A> : FirDiagnostic<E>() {
abstract val a: A
abstract override val factory: FirDiagnosticFactory1<*, A>
}
inline fun <reified E : PsiElement, A, B, C> DiagnosticFactory3<E, A, B, C>.onSource(source: FirSourceElement, a: A, b: B, c: C): FirDiagnostic? {
val psi = source.psi as? E
?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}")
return FirDiagnostic(this.on(psi, a, b, c), source)
sealed class FirDiagnosticWithParameters2<out E : FirSourceElement, A, B> : FirDiagnostic<E>() {
abstract val a: A
abstract val b: B
abstract override val factory: FirDiagnosticFactory2<*, A, B>
}
inline fun <reified E : PsiElement, reified A> DiagnosticFactory1<E, A>.tryOnSource(
source: FirSourceElement,
a: Any?
): FirDiagnostic? {
val aa = a as? A ?: throw IllegalArgumentException("Parameter passed to the factory is of incompatible type!")
return onSource(source, aa)
}
sealed class FirDiagnosticWithParameters3<out E : FirSourceElement, A, B, C> : FirDiagnostic<E>() {
abstract val a: A
abstract val b: B
abstract val c: C
abstract override val factory: FirDiagnosticFactory3<*, A, B, C>
}
// ------------------------------ psi diagnostics ------------------------------
interface FirPsiDiagnostic<out E : FirPsiSourceElement> {
fun asPsiBasedDiagnostic(): Diagnostic
val element: E
}
data class FirPsiSimpleDiagnostic<out E : FirPsiSourceElement>(
override val element: E,
override val severity: Severity,
override val factory: FirDiagnosticFactory0<*>
) : FirSimpleDiagnostic<E>(), FirPsiDiagnostic<E> {
override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi)
}
}
data class FirPsiDiagnosticWithParameters1<out E : FirPsiSourceElement, A>(
override val element: E,
override val a: A,
override val severity: Severity,
override val factory: FirDiagnosticFactory1<*, A>
) : FirDiagnosticWithParameters1<E, A>(), FirPsiDiagnostic<E> {
override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a)
}
}
data class FirPsiDiagnosticWithParameters2<out E : FirPsiSourceElement, A, B>(
override val element: E,
override val a: A,
override val b: B,
override val severity: Severity,
override val factory: FirDiagnosticFactory2<*, A, B>
) : FirDiagnosticWithParameters2<E, A, B>(), FirPsiDiagnostic<E> {
override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a, b)
}
}
data class FirPsiDiagnosticWithParameters3<out E : FirPsiSourceElement, A, B, C>(
override val element: E,
override val a: A,
override val b: B,
override val c: C,
override val severity: Severity,
override val factory: FirDiagnosticFactory3<*, A, B, C>
) : FirDiagnosticWithParameters3<E, A, B, C>(), FirPsiDiagnostic<E> {
override fun asPsiBasedDiagnostic(): Diagnostic {
return factory.psiDiagnosticFactory.on(element.psi, a, b, c)
}
}
// ------------------------------ light tree diagnostics ------------------------------
interface FirLightDiagnostic<out E: FirLightSourceElement> {
val element: E
}
data class FirLightSimpleDiagnostic<out E : FirLightSourceElement>(
override val element: E,
override val severity: Severity,
override val factory: FirDiagnosticFactory0<*>
) : FirSimpleDiagnostic<E>(), FirLightDiagnostic<E>
data class FirLightDiagnosticWithParameters1<out E : FirLightSourceElement, A>(
override val element: E,
override val a: A,
override val severity: Severity,
override val factory: FirDiagnosticFactory1<*, A>
) : FirDiagnosticWithParameters1<E, A>(), FirLightDiagnostic<E>
data class FirLightDiagnosticWithParameters2<out E : FirLightSourceElement, A, B>(
override val element: E,
override val a: A,
override val b: B,
override val severity: Severity,
override val factory: FirDiagnosticFactory2<*, A, B>
) : FirDiagnosticWithParameters2<E, A, B>(), FirLightDiagnostic<E>
data class FirLightDiagnosticWithParameters3<out E : FirLightSourceElement, A, B, C>(
override val element: E,
override val a: A,
override val b: B,
override val c: C,
override val severity: Severity,
override val factory: FirDiagnosticFactory3<*, A, B, C>
) : FirDiagnosticWithParameters3<E, A, B, C>(), FirLightDiagnostic<E>
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactoriesInitializer.kt
+6 -9
View File
@@ -7,13 +7,10 @@
package org.jetbrains.kotlin.diagnostics
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import kotlin.reflect.full.memberProperties
fun FirErrors.registerExternalFactories() {
val klass = FirErrors::class
for (property in klass.memberProperties) {
val factory = property.get(this) as? DiagnosticFactory<*> ?: continue
factory.name = property.name
}
/**
* This methods should me in `org.jetbrains.kotlin.diagnostics` package
* because of `DiagnosticFactory.setName` is package private
*/
fun DiagnosticFactory<*>.initializeName(name: String) {
this.name = name
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactory.kt
+75
View File
@@ -0,0 +1,75 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.fir.FirLightSourceElement
import org.jetbrains.kotlin.fir.FirPsiSourceElement
import org.jetbrains.kotlin.fir.FirSourceElement
sealed class AbstractFirDiagnosticFactory<E : FirSourceElement, D : FirDiagnostic<E>>(
val name: String,
val severity: Severity,
) {
abstract val psiDiagnosticFactory: DiagnosticFactoryWithPsiElement<*, *>
override fun toString(): String {
return name
}
}
class FirDiagnosticFactory0<E : FirSourceElement>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory0<PsiElement>
) : AbstractFirDiagnosticFactory<E, FirSimpleDiagnostic<E>>(name, severity) {
fun on(element: E): FirSimpleDiagnostic<E> {
return when (element) {
is FirPsiSourceElement -> FirPsiSimpleDiagnostic(element, severity, this)
is FirLightSourceElement -> FirLightSimpleDiagnostic(element, severity, this)
else -> incorrectElement(element)
}
}
}
class FirDiagnosticFactory1<E : FirSourceElement, A>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters1<E, A>>(name, severity) {
fun on(element: E, a: A): FirDiagnosticWithParameters1<E, A> {
return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters1(element, a, severity, this)
is FirLightSourceElement -> FirLightDiagnosticWithParameters1(element, a, severity, this)
else -> incorrectElement(element)
}
}
}
class FirDiagnosticFactory2<E : FirSourceElement, A, B>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters2<E, A, B>>(name, severity) {
fun on(element: E, a: A, b: B): FirDiagnosticWithParameters2<E, A, B> {
return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters2(element, a, b, severity, this)
is FirLightSourceElement -> FirLightDiagnosticWithParameters2(element, a, b, severity, this)
else -> incorrectElement(element)
}
}
}
class FirDiagnosticFactory3<E : FirSourceElement, A, B, C>(
name: String, severity: Severity, override val psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C>
) : AbstractFirDiagnosticFactory<E, FirDiagnosticWithParameters3<E, A, B, C>>(name, severity) {
fun on(element: E, a: A, b: B, c: C): FirDiagnosticWithParameters3<E, A, B, C> {
return when (element) {
is FirPsiSourceElement -> FirPsiDiagnosticWithParameters3(element, a, b, c, severity, this)
is FirLightSourceElement -> FirLightDiagnosticWithParameters3(element, a, b, c, severity, this)
else -> incorrectElement(element)
}
}
}
private fun incorrectElement(element: FirSourceElement): Nothing {
throw IllegalArgumentException("Unknown element type: ${element::class}")
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactoryDsl.kt
+120
View File
@@ -0,0 +1,120 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.fir.FirSourceElement
import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty
fun <E : FirSourceElement> warning0(): DiagnosticFactory0DelegateProvider<E> {
return DiagnosticFactory0DelegateProvider(Severity.WARNING, null)
}
fun <E : FirSourceElement, A> warning1(): DiagnosticFactory1DelegateProvider<E, A> {
return DiagnosticFactory1DelegateProvider(Severity.WARNING, null)
}
fun <E : FirSourceElement, A, B> warning2(): DiagnosticFactory2DelegateProvider<E, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.WARNING, null)
}
fun <E : FirSourceElement, A, B, C> warning3(): DiagnosticFactory3DelegateProvider<E, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.WARNING, null)
}
fun <E : FirSourceElement> error0(): DiagnosticFactory0DelegateProvider<E> {
return DiagnosticFactory0DelegateProvider(Severity.ERROR, null)
}
fun <E : FirSourceElement, A> error1(): DiagnosticFactory1DelegateProvider<E, A> {
return DiagnosticFactory1DelegateProvider(Severity.ERROR, null)
}
fun <E : FirSourceElement, A, B> error2(): DiagnosticFactory2DelegateProvider<E, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.ERROR, null)
}
fun <E : FirSourceElement, A, B, C> error3(): DiagnosticFactory3DelegateProvider<E, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.ERROR, null)
}
/**
* Note that those functions can be applicable only for factories
* that takes `PsiElement` as first type parameter
*/
fun <E : FirSourceElement> existing(psiDiagnosticFactory: DiagnosticFactory0<PsiElement>): DiagnosticFactory0DelegateProvider<E> {
return DiagnosticFactory0DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
}
fun <E : FirSourceElement, A> existing(psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A>): DiagnosticFactory1DelegateProvider<E, A> {
return DiagnosticFactory1DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
}
fun <E : FirSourceElement, A, B> existing(psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B>): DiagnosticFactory2DelegateProvider<E, A, B> {
return DiagnosticFactory2DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
}
fun <E : FirSourceElement, A, B, C> existing(psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C>): DiagnosticFactory3DelegateProvider<E, A, B, C> {
return DiagnosticFactory3DelegateProvider(Severity.ERROR, psiDiagnosticFactory)
}
// ------------------------------ Providers ------------------------------
class DiagnosticFactory0DelegateProvider<E : FirSourceElement>(
private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory0<PsiElement>?
) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory0<E>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory0.create<PsiElement>(severity).apply {
initializeName(prop.name)
}
return DummyDelegate(FirDiagnosticFactory0(prop.name, severity, psiFactory))
}
}
class DiagnosticFactory1DelegateProvider<E : FirSourceElement, A>(
private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory1<PsiElement, A>?
) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory1<E, A>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory1.create<PsiElement, A>(severity).apply {
initializeName(prop.name)
}
return DummyDelegate(FirDiagnosticFactory1(prop.name, severity, psiFactory))
}
}
class DiagnosticFactory2DelegateProvider<E : FirSourceElement, A, B>(
private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory2<PsiElement, A, B>?
) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory2<E, A, B>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory2.create<PsiElement, A, B>(severity).apply {
initializeName(prop.name)
}
return DummyDelegate(FirDiagnosticFactory2(prop.name, severity, psiFactory))
}
}
class DiagnosticFactory3DelegateProvider<E : FirSourceElement, A, B, C>(
private val severity: Severity,
private val psiDiagnosticFactory: DiagnosticFactory3<PsiElement, A, B, C>?
) {
operator fun provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, FirDiagnosticFactory3<E, A, B, C>> {
val psiFactory = psiDiagnosticFactory ?: DiagnosticFactory3.create<PsiElement, A, B, C>(severity).apply {
initializeName(prop.name)
}
return DummyDelegate(FirDiagnosticFactory3(prop.name, severity, psiFactory))
}
}
private class DummyDelegate<T>(val value: T) : ReadOnlyProperty<Any?, T> {
override fun getValue(thisRef: Any?, property: KProperty<*>): T {
return value
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticFactoryToRendererMap.kt
+59
View File
@@ -0,0 +1,59 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.diagnostics
import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap
import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticParameterRenderer
import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticRenderer
class FirDiagnosticFactoryToRendererMap(val name: String) {
private val diagnosticsMap: MutableMap<AbstractFirDiagnosticFactory<*, *>, DiagnosticRenderer<*>> = mutableMapOf()
val psiDiagnosticMap: DiagnosticFactoryToRendererMap =
DiagnosticFactoryToRendererMap()
operator fun get(factory: AbstractFirDiagnosticFactory<*, *>): DiagnosticRenderer<*>? = diagnosticsMap[factory]
fun put(factory: FirDiagnosticFactory0<*>, message: String) {
psiDiagnosticMap.put(factory.psiDiagnosticFactory, message)
putToFirMap(factory)
}
fun <A> put(
factory: FirDiagnosticFactory1<*, A>,
message: String,
rendererA: DiagnosticParameterRenderer<A>?
) {
psiDiagnosticMap.put(factory.psiDiagnosticFactory, message, rendererA)
putToFirMap(factory)
}
fun <A, B> put(
factory: FirDiagnosticFactory2<*, A, B>,
message: String,
rendererA: DiagnosticParameterRenderer<A>?,
rendererB: DiagnosticParameterRenderer<B>?
) {
psiDiagnosticMap.put(factory.psiDiagnosticFactory, message, rendererA, rendererB)
putToFirMap(factory)
}
fun <A, B, C> put(
factory: FirDiagnosticFactory3<*, A, B, C>,
message: String,
rendererA: DiagnosticParameterRenderer<A>?,
rendererB: DiagnosticParameterRenderer<B>?,
rendererC: DiagnosticParameterRenderer<C>?
) {
psiDiagnosticMap.put(factory.psiDiagnosticFactory, message, rendererA, rendererB, rendererC)
putToFirMap(factory)
}
private fun putToFirMap(factory: AbstractFirDiagnosticFactory<*, *>) {
psiDiagnosticMap[factory.psiDiagnosticFactory]?.let {
diagnosticsMap[factory] = it
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt
+25
View File
@@ -0,0 +1,25 @@
/*
* Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
* Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
*/
package org.jetbrains.kotlin.fir.analysis.diagnostics
import org.jetbrains.kotlin.diagnostics.rendering.Renderer
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
object FirDiagnosticRenderers {
val NULLABLE_STRING = Renderer<String?> { it ?: "null" }
val SYMBOLS = Renderer { symbols: Collection<AbstractFirBasedSymbol<*>> ->
symbols.joinToString(prefix = "[", postfix = "]", separator = ",", limit = 3, truncated = "...") { symbol ->
when (symbol) {
is FirClassLikeSymbol<*> -> symbol.classId.asString()
is FirCallableSymbol<*> -> symbol.callableId.toString()
else -> "???"
}
}
}
}
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+25 -24
View File
@@ -5,32 +5,33 @@
package org.jetbrains.kotlin.fir.analysis.diagnostics
import org.jetbrains.kotlin.diagnostics.*
import org.jetbrains.kotlin.diagnostics.Severity.ERROR
import org.jetbrains.kotlin.diagnostics.Errors
import org.jetbrains.kotlin.fir.FirSourceElement
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.psi.KtElement
object FirErrors {
val UNRESOLVED_REFERENCE = DiagnosticFactory1.create<KtElement, String?>(ERROR)
val INAPPLICABLE_CANDIDATE = DiagnosticFactory1.create<KtElement, Collection<AbstractFirBasedSymbol<*>>>(ERROR)
val AMBIGUITY = DiagnosticFactory1.create<KtElement, Collection<AbstractFirBasedSymbol<*>>>(ERROR)
val ASSIGN_OPERATOR_AMBIGUITY = DiagnosticFactory1.create<KtElement, Collection<AbstractFirBasedSymbol<*>>>(ERROR)
val SYNTAX_ERROR = DiagnosticFactory0.create<KtElement>(ERROR)
val UNRESOLVED_LABEL = DiagnosticFactory0.create<KtElement>(ERROR)
val ILLEGAL_CONST_EXPRESSION = DiagnosticFactory0.create<KtElement>(ERROR)
val DESERIALIZATION_ERROR = DiagnosticFactory0.create<KtElement>(ERROR)
val INFERENCE_ERROR = DiagnosticFactory0.create<KtElement>(ERROR)
val NO_SUPERTYPE = DiagnosticFactory0.create<KtElement>(ERROR)
val TYPE_PARAMETER_AS_SUPERTYPE = DiagnosticFactory0.create<KtElement>(ERROR)
val ENUM_AS_SUPERTYPE = DiagnosticFactory0.create<KtElement>(ERROR)
val RECURSION_IN_SUPERTYPES = DiagnosticFactory0.create<KtElement>(ERROR)
val RECURSION_IN_IMPLICIT_TYPES = DiagnosticFactory0.create<KtElement>(ERROR)
val ERROR_FROM_JAVA_RESOLUTION = DiagnosticFactory0.create<KtElement>(ERROR)
val OTHER_ERROR = DiagnosticFactory0.create<KtElement>(ERROR)
val TYPE_MISMATCH = DiagnosticFactory2.create<KtElement, ConeKotlinType, ConeKotlinType>(ERROR)
val UNRESOLVED_REFERENCE by error1<FirSourceElement, String?>()
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>()
val AMBIGUITY by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>()
val ASSIGN_OPERATOR_AMBIGUITY by error1<FirSourceElement, Collection<AbstractFirBasedSymbol<*>>>()
val SYNTAX_ERROR by error0<FirSourceElement>()
val UNRESOLVED_LABEL by error0<FirSourceElement>()
val ILLEGAL_CONST_EXPRESSION by error0<FirSourceElement>()
val DESERIALIZATION_ERROR by error0<FirSourceElement>()
val INFERENCE_ERROR by error0<FirSourceElement>()
val NO_SUPERTYPE by error0<FirSourceElement>()
val TYPE_PARAMETER_AS_SUPERTYPE by error0<FirSourceElement>()
val ENUM_AS_SUPERTYPE by error0<FirSourceElement>()
val RECURSION_IN_SUPERTYPES by error0<FirSourceElement>()
val RECURSION_IN_IMPLICIT_TYPES by error0<FirSourceElement>()
val ERROR_FROM_JAVA_RESOLUTION by error0<FirSourceElement>()
val OTHER_ERROR by error0<FirSourceElement>()
val TYPE_MISMATCH by error2<FirSourceElement, ConeKotlinType, ConeKotlinType>()
val VARIABLE_EXPECTED by error0<FirSourceElement>()
val RETURN_NOT_ALLOWED by error0<FirSourceElement>()
val CONSTRUCTOR_IN_OBJECT by error0<FirSourceElement>()
val SUPER_IS_NOT_AN_EXPRESSION by error0<FirSourceElement>()
init {
registerExternalFactories()
}
}
val INAPPLICABLE_INFIX_MODIFIER by existing<FirSourceElement, String>(Errors.INAPPLICABLE_INFIX_MODIFIER)
}
compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt
+2 -3
View File
@@ -18,9 +18,8 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildAnonymousFunction
import org.jetbrains.kotlin.fir.declarations.builder.buildProperty
import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter
import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.*
import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
@@ -504,7 +503,7 @@ class ExpressionsConverter(
buildErrorNamedReference {
val node = superNode!!
source = node.toFirSourceElement()
diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", node.asText, DiagnosticKind.SuperNotAllowed)
diagnostic = ConeSimpleDiagnostic("Super cannot be a callee", DiagnosticKind.SuperNotAllowed)
} to null
}
else -> buildErrorNamedReference {
compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt
+2 -3
View File
@@ -18,9 +18,8 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyGetter
import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertySetter
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1
import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
import org.jetbrains.kotlin.fir.expressions.*
import org.jetbrains.kotlin.fir.expressions.builder.*
import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess
@@ -1493,7 +1492,7 @@ class RawFirBuilder(
is KtSuperExpression -> {
buildErrorNamedReference {
source = calleeExpression.toFirSourceElement()
diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", calleeExpression.text, DiagnosticKind.SuperNotAllowed)
diagnostic = ConeSimpleDiagnostic("Super cannot be a callee", DiagnosticKind.SuperNotAllowed)
} to null
}
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt
-6
View File
@@ -17,13 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
import org.jetbrains.kotlin.fir.references.impl.FirEmptyControlFlowGraphReference
import org.jetbrains.kotlin.fir.symbols.impl.FirErrorFunctionSymbol
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
import org.jetbrains.kotlin.fir.visitors.*
/*
* This file was generated automatically
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt
-3
View File
@@ -12,11 +12,8 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
import org.jetbrains.kotlin.fir.expressions.impl.FirErrorExpressionImpl
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
import org.jetbrains.kotlin.fir.visitors.*
/*
* This file was generated automatically
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt
-4
View File
@@ -12,12 +12,8 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
import org.jetbrains.kotlin.fir.expressions.impl.FirErrorLoopImpl
import org.jetbrains.kotlin.fir.visitors.*
/*
* This file was generated automatically
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt
-1
View File
@@ -12,7 +12,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.expressions.FirBlock
import org.jetbrains.kotlin.fir.expressions.FirErrorLoop
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock
import org.jetbrains.kotlin.fir.visitors.*
/*
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt
-3
View File
@@ -11,9 +11,6 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.references.FirErrorNamedReference
import org.jetbrains.kotlin.fir.references.impl.FirErrorNamedReferenceImpl
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.visitors.*
import org.jetbrains.kotlin.name.Name
/*
* This file was generated automatically
compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt
-4
View File
@@ -11,12 +11,8 @@ import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
import org.jetbrains.kotlin.fir.types.ConeClassErrorType
import org.jetbrains.kotlin.fir.types.ConeKotlinType
import org.jetbrains.kotlin.fir.types.FirErrorTypeRef
import org.jetbrains.kotlin.fir.types.FirTypeRef
import org.jetbrains.kotlin.fir.types.impl.FirErrorTypeRefImpl
import org.jetbrains.kotlin.fir.visitors.*
/*
* This file was generated automatically
compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt
-6
View File
@@ -7,12 +7,6 @@ package org.jetbrains.kotlin.fir.diagnostics
class ConeSimpleDiagnostic(override val reason: String, val kind: DiagnosticKind = DiagnosticKind.Other) : ConeDiagnostic()
class ConeSimpleDiagnosticWithParameters1<A>(
override val reason: String,
val a: A,
val kind: DiagnosticKind = DiagnosticKind.Other
) : ConeDiagnostic()
enum class DiagnosticKind {
Syntax,
ReturnNotAllowed,
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) {
<!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
x * x
}
}<!>
}
class A3 {
compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt
+7 -3
View File
@@ -24,6 +24,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM
import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
import org.jetbrains.kotlin.fir.builder.RawFirBuilder
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.java.FirJavaModuleBasedSession
@@ -196,7 +197,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
}
protected fun TestFile.getActualText(
firDiagnostics: Iterable<FirDiagnostic>,
firDiagnostics: Iterable<FirDiagnostic<*>>,
actualText: StringBuilder
): Boolean {
val ktFile = this.ktFile
@@ -308,9 +309,12 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() {
return ok[0]
}
private fun Iterable<FirDiagnostic>.toActualDiagnostic(root: PsiElement): List<ActualDiagnostic> {
private fun Iterable<FirDiagnostic<*>>.toActualDiagnostic(root: PsiElement): List<ActualDiagnostic> {
val result = mutableListOf<ActualDiagnostic>()
filter { it.diagnostic.factory != FirErrors.SYNTAX_ERROR }.mapTo(result) { ActualDiagnostic(it.diagnostic, null, true) }
filter { it.factory != FirErrors.SYNTAX_ERROR }.mapTo(result) {
val oldDiagnostic = (it as FirPsiDiagnostic<*>).asPsiBasedDiagnostic()
ActualDiagnostic(oldDiagnostic, null, true)
}
for (errorElement in AnalyzingUtils.getSyntaxErrorRanges(root)) {
result.add(ActualDiagnostic(SyntaxErrorDiagnostic(errorElement), null, true))
}
compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirDiagnosticTest.kt
+2 -2
View File
@@ -85,8 +85,8 @@ abstract class AbstractFirDiagnosticsTest : AbstractFirBaseDiagnosticsTest() {
if (firFile != null) {
val session = firFile.session
val collector = collectors.computeIfAbsent(session) { createCollector(session) }
val coneDiagnostics = collector.collectDiagnostics(firFile)
testFile.getActualText(coneDiagnostics, actualText)
val firDiagnostics = collector.collectDiagnostics(firFile)
testFile.getActualText(firDiagnostics, actualText)
} else {
actualText.append(testFile.expectedText)
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt
+7 -8
View File
@@ -8,9 +8,9 @@ package org.jetbrains.kotlin.idea.fir
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
import org.jetbrains.kotlin.fir.analysis.collectors.registerAllComponents
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
import org.jetbrains.kotlin.psi.KtElement
class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState: FirModuleResolveState) : AbstractDiagnosticCollector(session) {
@@ -20,12 +20,11 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState:
}
private inner class Reporter : DiagnosticReporter() {
override fun report(diagnostic: FirDiagnostic?) {
if (diagnostic == null) return
val psi = diagnostic.source.psi as? KtElement ?: return
resolveState.record(psi, diagnostic.diagnostic)
override fun report(diagnostic: FirDiagnostic<*>?) {
if (diagnostic !is FirPsiDiagnostic<*>) return
val psi = diagnostic.element.psi as? KtElement ?: return
resolveState.record(psi, diagnostic.asPsiBasedDiagnostic())
}
}
private lateinit var reporter: Reporter
@@ -34,7 +33,7 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState:
reporter = Reporter()
}
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic> {
override fun getCollectedDiagnostics(): Iterable<FirDiagnostic<*>> {
// Not necessary in IDE
return emptyList()
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt
+6 -4
View File
@@ -12,9 +12,9 @@ import org.jetbrains.kotlin.diagnostics.Diagnostic
import org.jetbrains.kotlin.fir.FirElement
import org.jetbrains.kotlin.fir.FirSession
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
import org.jetbrains.kotlin.fir.declarations.FirFile
import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider
import org.jetbrains.kotlin.fir.psi
import org.jetbrains.kotlin.idea.caches.project.ModuleSourceInfo
import org.jetbrains.kotlin.idea.caches.project.getModuleInfo
import org.jetbrains.kotlin.psi.KtElement
@@ -49,7 +49,7 @@ interface FirModuleResolveState {
fun record(psi: KtElement, diagnostic: Diagnostic)
fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic> = emptyList())
fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic<*>> = emptyList())
}
class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionProvider) : FirModuleResolveState {
@@ -91,9 +91,11 @@ class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionP
list += diagnostic
}
override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic>) {
override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable<FirDiagnostic<*>>) {
for (diagnostic in diagnostics) {
(diagnostic.source.psi as? KtElement)?.let { record(it, diagnostic.diagnostic) }
require(diagnostic is FirPsiDiagnostic<*>)
val psi = diagnostic.element.psi as? KtElement ?: continue
record(psi, diagnostic.asPsiBasedDiagnostic())
}
diagnosedFiles[file] = file.modificationStamp