From 1a3fef5fa15eb69cad47cfa13899e634645bfd87 Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 23 Mar 2020 14:11:38 +0300 Subject: [PATCH] [FIR] Switch names of `FirDiagnostic` and `ConeDiagnostic` --- .../collectors/AbstractDiagnosticCollector.kt | 6 +-- .../ParallelDiagnosticsCollector.kt | 8 +-- .../collectors/SimpleDiagnosticsCollector.kt | 4 +- .../ErrorNodeDiagnosticCollectorComponent.kt | 41 ++++++--------- .../diagnostics/DiagnosticReporter.kt | 6 +-- .../{ConeDiagnostic.kt => FirDiagnostic.kt} | 26 ++++++---- .../jetbrains/kotlin/fir/dump/HtmlFirDump.kt | 12 ++--- .../jetbrains/kotlin/fir/java/JavaUtils.kt | 8 +-- .../KotlinDeserializedJvmSymbolsProvider.kt | 6 +-- .../converter/DeclarationsConverter.kt | 20 ++++---- .../converter/ExpressionsConverter.kt | 50 +++++++++---------- .../fir/lightTree/fir/ValueParameter.kt | 4 +- .../kotlin/fir/lightTree/fir/WhenEntry.kt | 7 +-- .../kotlin/fir/builder/BaseFirBuilder.kt | 34 ++++++------- .../kotlin/fir/builder/ConversionUtils.kt | 4 +- .../kotlin/fir/builder/RawFirBuilder.kt | 36 ++++++------- .../jetbrains/kotlin/fir/FirCallResolver.kt | 14 +++--- .../AbstractAnnotationDeserializer.kt | 8 +-- .../kotlin/fir/resolve/ResolveUtils.kt | 8 +-- .../fir/resolve/diagnostics/FirDiagnostics.kt | 20 ++++---- .../inference/PostponedArgumentsAnalyzer.kt | 4 +- ...rCallCompletionResultsWriterTransformer.kt | 5 +- .../transformers/FirSupertypesResolution.kt | 4 +- .../transformers/FirSyntheticCallGenerator.kt | 4 +- .../transformers/ReturnTypeCalculator.kt | 4 +- ...ControlFlowStatementsResolveTransformer.kt | 7 ++- .../FirDeclarationsResolveTransformer.kt | 10 ++-- .../FirExpressionsResolveTransformer.kt | 21 ++++---- .../body/resolve/FirImplicitBodyResolve.kt | 8 +-- .../fir/declarations/FirErrorFunction.kt | 4 +- .../builder/FirErrorFunctionBuilder.kt | 4 +- .../declarations/impl/FirErrorFunctionImpl.kt | 4 +- .../fir/diagnostics/FirDiagnosticHolder.kt | 2 +- .../fir/expressions/FirErrorExpression.kt | 4 +- .../kotlin/fir/expressions/FirErrorLoop.kt | 4 +- .../builder/FirErrorExpressionBuilder.kt | 4 +- .../builder/FirErrorLoopBuilder.kt | 4 +- .../impl/FirErrorExpressionImpl.kt | 4 +- .../fir/expressions/impl/FirErrorLoopImpl.kt | 4 +- .../fir/references/FirErrorNamedReference.kt | 4 +- .../builder/FirErrorNamedReferenceBuilder.kt | 4 +- .../impl/FirErrorNamedReferenceImpl.kt | 4 +- .../kotlin/fir/types/FirErrorTypeRef.kt | 4 +- .../types/builder/FirErrorTypeRefBuilder.kt | 4 +- .../fir/types/impl/FirErrorTypeRefImpl.kt | 4 +- .../{FirDiagnostic.kt => ConeDiagnostic.kt} | 4 +- ...eDiagnostic.kt => ConeSimpleDiagnostic.kt} | 8 ++- .../fir/expressions/FirExpressionUtil.kt | 8 +-- .../fir/tree/generator/NodeConfigurator.kt | 3 +- .../kotlin/fir/tree/generator/Types.kt | 2 +- .../fir/AbstractFirBaseDiagnosticsTest.kt | 8 +-- .../jetbrains/kotlin/fir/FirResolveBench.kt | 6 +-- .../idea/fir/FirIdeDiagnosticsCollector.kt | 6 +-- .../kotlin/idea/fir/FirModuleResolveState.kt | 6 +-- 54 files changed, 248 insertions(+), 254 deletions(-) rename compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/{ConeDiagnostic.kt => FirDiagnostic.kt} (66%) rename compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/{FirDiagnostic.kt => ConeDiagnostic.kt} (76%) rename compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/{FirSimpleDiagnostic.kt => ConeSimpleDiagnostic.kt} (67%) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt index 11febfc170c..f0ff9e6ba67 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/AbstractDiagnosticCollector.kt @@ -9,7 +9,7 @@ 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.ConeDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.resolve.ScopeSession @@ -27,7 +27,7 @@ abstract class AbstractDiagnosticCollector( override val session: FirSession, override val scopeSession: ScopeSession = ScopeSession() ) : SessionHolder { - fun collectDiagnostics(firFile: FirFile): Iterable { + fun collectDiagnostics(firFile: FirFile): Iterable { if (!componentsInitialized) { throw IllegalStateException("Components are not initialized") } @@ -37,7 +37,7 @@ abstract class AbstractDiagnosticCollector( } protected abstract fun initializeCollector() - protected abstract fun getCollectedDiagnostics(): Iterable + protected abstract fun getCollectedDiagnostics(): Iterable abstract fun runCheck(block: (DiagnosticReporter) -> Unit) private val components: MutableList = mutableListOf() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt index 7c1c544bfb7..8c04d7dd907 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/ParallelDiagnosticsCollector.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.analysis.collectors import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter import java.util.* @@ -42,10 +42,10 @@ class ParallelDiagnosticsCollector(session: FirSession, private val numberOfThre futures.clear() } - override fun getCollectedDiagnostics(): Iterable { + override fun getCollectedDiagnostics(): Iterable { futures.forEach { it.get() } return Iterable { - object : Iterator { + object : Iterator { 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(): ConeDiagnostic { + override fun next(): FirDiagnostic { update() return localIterator.next() } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt index 42b01f84c17..b40a44c2e27 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/SimpleDiagnosticsCollector.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.analysis.collectors import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter import org.jetbrains.kotlin.fir.analysis.diagnostics.SimpleDiagnosticReporter @@ -17,7 +17,7 @@ class SimpleDiagnosticsCollector(session: FirSession) : AbstractDiagnosticCollec reporter = SimpleDiagnosticReporter() } - override fun getCollectedDiagnostics(): Iterable { + override fun getCollectedDiagnostics(): Iterable { return reporter.diagnostics } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt index 759d78e24b6..a0baf2ab6af 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt @@ -12,10 +12,7 @@ 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.ConeDiagnostic -import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource +import org.jetbrains.kotlin.fir.analysis.diagnostics.* import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.diagnostics.* import org.jetbrains.kotlin.fir.expressions.FirErrorExpression @@ -50,25 +47,25 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect runCheck { reportFirDiagnostic(errorFunction.diagnostic, source, it) } } - private fun reportFirDiagnostic(diagnostic: FirDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) { + private fun reportFirDiagnostic(diagnostic: ConeDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) { val coneDiagnostic = when (diagnostic) { - is FirUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name?.asString()) - is FirUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.classId.asString()) - is FirUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.onSource(source, diagnostic.name.asString()) - is FirInapplicableCandidateError -> FirErrors.INAPPLICABLE_CANDIDATE.onSource(source, diagnostic.candidates.map { it.symbol }) - is FirAmbiguityError -> FirErrors.AMBIGUITY.onSource(source, diagnostic.candidates) - is FirOperatorAmbiguityError -> FirErrors.ASSIGN_OPERATOR_AMBIGUITY.onSource(source, diagnostic.candidates) - is FirVariableExpectedError -> Errors.VARIABLE_EXPECTED.onSource(source) - is FirTypeMismatchError -> FirErrors.TYPE_MISMATCH.onSource(source, diagnostic.expectedType, diagnostic.actualType) - is FirSimpleDiagnostic -> diagnostic.getFactory().onSource(source) - is FirDiagnosticWithParameters1<*> -> diagnostic.getFactory().tryOnSource(source, diagnostic.a) - is FirStubDiagnostic -> null + 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 ConeStubDiagnostic -> null else -> throw IllegalArgumentException("Unsupported diagnostic type: ${diagnostic.javaClass}") } reporter.report(coneDiagnostic) } - private fun FirSimpleDiagnostic.getFactory(): DiagnosticFactory0 { + private fun ConeSimpleDiagnostic.getFactory(): DiagnosticFactory0 { @Suppress("UNCHECKED_CAST") return when (kind) { DiagnosticKind.Syntax -> FirErrors.SYNTAX_ERROR @@ -89,19 +86,11 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect } as DiagnosticFactory0 } - private fun FirDiagnosticWithParameters1<*>.getFactory(): DiagnosticFactory1 { + private fun ConeSimpleDiagnosticWithParameters1<*>.getFactory(): DiagnosticFactory1 { @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 } - - private inline fun DiagnosticFactory1.tryOnSource( - source: FirSourceElement, - a: Any? - ): ConeDiagnostic? { - val aa = a as? A ?: throw IllegalArgumentException("Parameter passed to the factory is of incompatible type!") - return onSource(source, aa) - } } \ No newline at end of file diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt index d26839a24f1..b7a6b64b774 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/DiagnosticReporter.kt @@ -6,13 +6,13 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics abstract class DiagnosticReporter { - abstract fun report(diagnostic: ConeDiagnostic?) + abstract fun report(diagnostic: FirDiagnostic?) } class SimpleDiagnosticReporter : DiagnosticReporter() { - val diagnostics: MutableList = mutableListOf() + val diagnostics: MutableList = mutableListOf() - override fun report(diagnostic: ConeDiagnostic?) { + override fun report(diagnostic: FirDiagnostic?) { if (diagnostic == null) return diagnostics += diagnostic } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/ConeDiagnostic.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt similarity index 66% rename from compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/ConeDiagnostic.kt rename to compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt index 48ff0bf9fde..0feec4e797f 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/ConeDiagnostic.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnostic.kt @@ -10,31 +10,39 @@ import org.jetbrains.kotlin.diagnostics.* import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.psi -class ConeDiagnostic( +class FirDiagnostic( val diagnostic: Diagnostic, val source: FirSourceElement ) -inline fun DiagnosticFactory0.onSource(source: FirSourceElement): ConeDiagnostic? { +inline fun DiagnosticFactory0.onSource(source: FirSourceElement): FirDiagnostic? { val psi = source.psi as? E ?: throw IllegalArgumentException("Incompatible PSI: expected ${E::class}, actual ${source.psi?.let { it::class }}") - return ConeDiagnostic(this.on(psi), source) + return FirDiagnostic(this.on(psi), source) } -inline fun DiagnosticFactory1.onSource(source: FirSourceElement, a: A): ConeDiagnostic? { +inline fun DiagnosticFactory1.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 ConeDiagnostic(this.on(psi, a), source) + return FirDiagnostic(this.on(psi, a), source) } -inline fun DiagnosticFactory2.onSource(source: FirSourceElement, a: A, b: B): ConeDiagnostic? { +inline fun DiagnosticFactory2.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 ConeDiagnostic(this.on(psi, a, b), source) + return FirDiagnostic(this.on(psi, a, b), source) } -inline fun DiagnosticFactory3.onSource(source: FirSourceElement, a: A, b: B, c: C): ConeDiagnostic? { +inline fun DiagnosticFactory3.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 ConeDiagnostic(this.on(psi, a, b, c), source) + return FirDiagnostic(this.on(psi, a, b, c), source) } + +inline fun DiagnosticFactory1.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) +} \ No newline at end of file diff --git a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt index 05f698edf8e..cc5eb88ff49 100644 --- a/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt +++ b/compiler/fir/dump/src/org/jetbrains/kotlin/fir/dump/HtmlFirDump.kt @@ -17,14 +17,14 @@ import org.jetbrains.kotlin.fir.backend.left import org.jetbrains.kotlin.fir.backend.right import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition import org.jetbrains.kotlin.fir.expressions.impl.FirUnitExpression import org.jetbrains.kotlin.fir.references.* import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirAmbiguityError -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirInapplicableCandidateError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError import org.jetbrains.kotlin.fir.resolve.directExpansionType import org.jetbrains.kotlin.fir.resolve.fullyExpandedType import org.jetbrains.kotlin.fir.resolve.toSymbol @@ -1183,9 +1183,9 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver } } - private fun FlowContent.generate(diagnostic: FirDiagnostic) { + private fun FlowContent.generate(diagnostic: ConeDiagnostic) { when (diagnostic) { - is FirInapplicableCandidateError -> { + is ConeInapplicableCandidateError -> { for (candidate in diagnostic.candidates) { describeVerbose(candidate.symbol) br @@ -1210,7 +1210,7 @@ class HtmlFirDump internal constructor(private var linkResolver: FirLinkResolver } } } - is FirAmbiguityError -> { + is ConeAmbiguityError -> { +"Ambiguity: " br for (candidate in diagnostic.candidates) { diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt index f49b04f969d..e2846b6f203 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter @@ -423,7 +423,7 @@ private fun JavaAnnotationArgument.toFirExpression( } this.calleeReference = calleeReference ?: buildErrorNamedReference { - diagnostic = FirSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java) + diagnostic = ConeSimpleDiagnostic("Strange Java enum value: $classId.$entryName", DiagnosticKind.Java) } } } @@ -437,7 +437,7 @@ private fun JavaAnnotationArgument.toFirExpression( } is JavaAnnotationAsAnnotationArgument -> getAnnotation().toFirAnnotationCall(session, javaTypeParameterStack) else -> buildErrorExpression { - diagnostic = FirSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java) + diagnostic = ConeSimpleDiagnostic("Unknown JavaAnnotationArgument: ${this::class.java}", DiagnosticKind.Java) } } } @@ -475,7 +475,7 @@ internal fun Any?.createConstant(session: FirSession): FirExpression { null -> buildConstExpression(null, FirConstKind.Null, null) else -> buildErrorExpression { - diagnostic = FirSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java) + diagnostic = ConeSimpleDiagnostic("Unknown value in JavaLiteralAnnotationArgument: $this", DiagnosticKind.Java) } } } diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt index b2e2228bf8c..5d5c020a04b 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/deserialization/KotlinDeserializedJvmSymbolsProvider.kt @@ -17,7 +17,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirSimpleFunctionImpl import org.jetbrains.kotlin.fir.deserialization.FirDeserializationContext import org.jetbrains.kotlin.fir.deserialization.deserializeClassToSymbol import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.java.JavaSymbolProvider @@ -167,7 +167,7 @@ class KotlinDeserializedJvmSymbolsProvider( buildResolvedTypeRef { type = it.constructType(emptyList(), isNullable = false) } - } ?: buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java) } + } ?: buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Symbol not found for $classId", DiagnosticKind.Java) } } @@ -210,7 +210,7 @@ class KotlinDeserializedJvmSymbolsProvider( } else -> { buildErrorNamedReference { - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Strange deserialized enum value: ${this@toEnumEntryReferenceExpression}.$name", DiagnosticKind.Java, ) diff --git a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt index eb2338bfd9e..63b5121858e 100644 --- a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt +++ b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt @@ -23,7 +23,7 @@ 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.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock @@ -716,7 +716,7 @@ class DeclarationsConverter( val delegatedSelfTypeRef = if (classWrapper.isObjectLiteral()) buildErrorTypeRef { source = secondaryConstructor.toFirSourceElement() - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Constructor in object", DiagnosticKind.ConstructorInObject ) @@ -774,10 +774,10 @@ class DeclarationsConverter( val delegatedType = if (classWrapper.isObjectLiteral() || classWrapper.isInterface()) when { isThis -> buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject) + diagnostic = ConeSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject) } else -> buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.Syntax) } } else when { @@ -945,7 +945,7 @@ class DeclarationsConverter( var isVar = false val entries = mutableListOf>() var firExpression: FirExpression = - buildErrorExpression(null, FirSimpleDiagnostic("Destructuring declaration without initializer", DiagnosticKind.Syntax)) + buildErrorExpression(null, ConeSimpleDiagnostic("Destructuring declaration without initializer", DiagnosticKind.Syntax)) destructingDeclaration.forEachChildren { when (it.tokenType) { VAR_KEYWORD -> isVar = true @@ -1259,7 +1259,7 @@ class DeclarationsConverter( private fun convertExplicitDelegation(explicitDelegation: LighterASTNode): FirDelegatedTypeRef { lateinit var firTypeRef: FirTypeRef var firExpression: FirExpression? = buildErrorExpression( - explicitDelegation.toFirSourceElement(), FirSimpleDiagnostic("Should have delegate", DiagnosticKind.Syntax) + explicitDelegation.toFirSourceElement(), ConeSimpleDiagnostic("Should have delegate", DiagnosticKind.Syntax) ) explicitDelegation.forEachChildren { when (it.tokenType) { @@ -1355,10 +1355,10 @@ class DeclarationsConverter( */ fun convertType(type: LighterASTNode): FirTypeRef { if (type.asText.isEmpty()) { - return buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) } + return buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) } } var typeModifiers = TypeModifier() //TODO what with suspend? - var firType: FirTypeRef = buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) } + var firType: FirTypeRef = buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) } var afterLPar = false type.forEachChildren { when (it.tokenType) { @@ -1373,7 +1373,7 @@ class DeclarationsConverter( isMarkedNullable = false } TokenType.ERROR_ELEMENT -> firType = - buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) } + buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) } } } @@ -1431,7 +1431,7 @@ class DeclarationsConverter( } if (identifier == null) - return buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) } + return buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) } val qualifierPart = FirQualifierPartImpl(identifier.nameAsSafeName()).apply { typeArguments += firTypeArguments } diff --git a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt index 49d62c2d42c..304f1ca5d6c 100644 --- a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt +++ b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/converter/ExpressionsConverter.kt @@ -19,8 +19,8 @@ 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.FirDiagnosticWithParameters1 -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1 +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess @@ -55,7 +55,7 @@ class ExpressionsConverter( ) : BaseConverter(session, tree, context) { inline fun getAsFirExpression(expression: LighterASTNode?, errorReason: String = ""): R { - return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R) + return expression?.let { convertExpression(it, errorReason) } as? R ?: (buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) as R) } /***** EXPRESSIONS *****/ @@ -103,7 +103,7 @@ class ExpressionsConverter( OBJECT_LITERAL -> declarationsConverter.convertObjectLiteral(expression) FUN -> declarationsConverter.convertFunctionDeclaration(expression) - else -> buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) + else -> buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) } } @@ -176,7 +176,7 @@ class ExpressionsConverter( } }.build() } else { - buildSingleExpressionBlock(buildErrorExpression(null, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))) + buildSingleExpressionBlock(buildErrorExpression(null, ConeSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax))) } context.firFunctionTargets.removeLast() }.also { @@ -192,7 +192,7 @@ class ExpressionsConverter( var isLeftArgument = true lateinit var operationTokenName: String var leftArgNode: LighterASTNode? = null - var rightArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No right operand", DiagnosticKind.Syntax)) + var rightArgAsFir: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No right operand", DiagnosticKind.Syntax)) var rightArg: LighterASTNode? = null binaryExpression.forEachChildren { when (it.tokenType) { @@ -265,7 +265,7 @@ class ExpressionsConverter( toFirOperation: String.() -> FirOperation ): FirTypeOperatorCall { lateinit var operationTokenName: String - var leftArgAsFir: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No left operand", DiagnosticKind.Syntax)) + var leftArgAsFir: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No left operand", DiagnosticKind.Syntax)) lateinit var firType: FirTypeRef binaryExpression.forEachChildren { when (it.tokenType) { @@ -303,7 +303,7 @@ class ExpressionsConverter( context.firLabels.removeLast() //println("Unused label: ${labeledExpression.getAsString()}") } - return firExpression ?: buildErrorExpression(null, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax)) + return firExpression ?: buildErrorExpression(null, ConeSimpleDiagnostic("Empty label", DiagnosticKind.Syntax)) } /** @@ -375,7 +375,7 @@ class ExpressionsConverter( return firExpression?.also { require(it is FirAnnotationContainer) (it.annotations as MutableList) += firAnnotationList - } ?: buildErrorExpression(null, FirSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax)) + } ?: buildErrorExpression(null, ConeSimpleDiagnostic("Strange annotated expression: ${firExpression?.render()}", DiagnosticKind.Syntax)) } /** @@ -383,7 +383,7 @@ class ExpressionsConverter( * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitClassLiteralExpression */ private fun convertClassLiteralExpression(classLiteralExpression: LighterASTNode): FirExpression { - var firReceiverExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax)) + var firReceiverExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No receiver in class literal", DiagnosticKind.Syntax)) classLiteralExpression.forEachChildren { if (it.isExpression()) firReceiverExpression = getAsFirExpression(it, "No receiver in class literal") } @@ -432,7 +432,7 @@ class ExpressionsConverter( private fun convertQualifiedExpression(dotQualifiedExpression: LighterASTNode): FirExpression { var isSelector = false var isSafe = false - var firSelector: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot + var firSelector: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax)) //after dot var firReceiver: FirExpression? = null //before dot dotQualifiedExpression.forEachChildren { when (it.tokenType) { @@ -504,11 +504,11 @@ class ExpressionsConverter( buildErrorNamedReference { val node = superNode!! source = node.toFirSourceElement() - diagnostic = FirDiagnosticWithParameters1("Super cannot be a callee", node.asText, DiagnosticKind.SuperNotAllowed) + diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", node.asText, DiagnosticKind.SuperNotAllowed) } to null } else -> buildErrorNamedReference { - diagnostic = FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null } @@ -541,7 +541,7 @@ class ExpressionsConverter( } private fun LighterASTNode?.convertShortOrLongStringTemplate(errorReason: String): FirExpression { - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) this?.forEachChildren(LONG_TEMPLATE_ENTRY_START, LONG_TEMPLATE_ENTRY_END) { firExpression = getAsFirExpression(it, errorReason) } @@ -647,7 +647,7 @@ class ExpressionsConverter( } private fun convertWhenConditionExpression(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression { - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)) whenCondition.forEachChildren { when (it.tokenType) { else -> if (it.isExpression()) firExpression = getAsFirExpression(it, "No expression in condition with expression") @@ -671,7 +671,7 @@ class ExpressionsConverter( private fun convertWhenConditionInRange(whenCondition: LighterASTNode, subject: FirWhenSubject?): FirExpression { var isNegate = false - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No range in condition with range", DiagnosticKind.Syntax)) whenCondition.forEachChildren { when { it.tokenType == OPERATION_REFERENCE && it.asText == NOT_IN.value -> isNegate = true @@ -686,7 +686,7 @@ class ExpressionsConverter( } else { return buildErrorExpression { source = whenCondition.toFirSourceElement() - diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax) } } @@ -716,7 +716,7 @@ class ExpressionsConverter( } else { return buildErrorExpression { source = whenCondition.toFirSourceElement() - diagnostic = FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax) } } @@ -733,7 +733,7 @@ class ExpressionsConverter( * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitArrayAccessExpression */ private fun convertArrayAccessExpression(arrayAccess: LighterASTNode): FirFunctionCall { - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No array expression", DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No array expression", DiagnosticKind.Syntax)) val indices: MutableList = mutableListOf() arrayAccess.forEachChildren { when (it.tokenType) { @@ -801,7 +801,7 @@ class ExpressionsConverter( */ private fun convertDoWhile(doWhileLoop: LighterASTNode): FirElement { var block: LighterASTNode? = null - var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax)) + var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No condition in do-while loop", DiagnosticKind.Syntax)) doWhileLoop.forEachChildren { when (it.tokenType) { BODY -> block = it @@ -821,7 +821,7 @@ class ExpressionsConverter( */ private fun convertWhile(whileLoop: LighterASTNode): FirElement { var block: LighterASTNode? = null - var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax)) + var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No condition in while loop", DiagnosticKind.Syntax)) whileLoop.forEachChildren { when (it.tokenType) { BODY -> block = it @@ -841,7 +841,7 @@ class ExpressionsConverter( */ private fun convertFor(forLoop: LighterASTNode): FirElement { var parameter: ValueParameter? = null - var rangeExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax)) + var rangeExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("No range in for loop", DiagnosticKind.Syntax)) var blockNode: LighterASTNode? = null forLoop.forEachChildren { when (it.tokenType) { @@ -989,7 +989,7 @@ class ExpressionsConverter( * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitIfExpression */ private fun convertIfExpression(ifExpression: LighterASTNode): FirExpression { - var firCondition: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax)) + var firCondition: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("If statement should have condition", DiagnosticKind.Syntax)) var thenBlock: LighterASTNode? = null var elseBlock: LighterASTNode? = null ifExpression.forEachChildren { @@ -1061,7 +1061,7 @@ class ExpressionsConverter( * @see org.jetbrains.kotlin.fir.builder.RawFirBuilder.Visitor.visitThrowExpression */ private fun convertThrow(throwExpression: LighterASTNode): FirExpression { - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Nothing to throw", DiagnosticKind.Syntax)) throwExpression.forEachChildren { if (it.isExpression()) firExpression = getAsFirExpression(it, "Nothing to throw") } @@ -1128,7 +1128,7 @@ class ExpressionsConverter( private fun convertValueArgument(valueArgument: LighterASTNode): FirExpression { var identifier: String? = null var isSpread = false - var firExpression: FirExpression = buildErrorExpression(null, FirSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax)) + var firExpression: FirExpression = buildErrorExpression(null, ConeSimpleDiagnostic("Argument is absent", DiagnosticKind.Syntax)) valueArgument.forEachChildren { when (it.tokenType) { VALUE_ARGUMENT_NAME -> identifier = it.asText diff --git a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt index a962fdbbd26..93f8f3565e7 100644 --- a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt +++ b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/ValueParameter.kt @@ -14,7 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl 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.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.builder.buildQualifiedAccessExpression import org.jetbrains.kotlin.fir.lightTree.fir.modifier.Modifier import org.jetbrains.kotlin.fir.references.builder.buildPropertyFromParameterResolvedNamedReference @@ -41,7 +41,7 @@ class ValueParameter( type = type.convertToArrayType() } if (type is FirImplicitTypeRef) { - type = buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) } + type = buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("Incomplete code", DiagnosticKind.Syntax) } } return buildProperty { diff --git a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/WhenEntry.kt b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/WhenEntry.kt index 5aff840be16..b84046a88bb 100644 --- a/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/WhenEntry.kt +++ b/compiler/fir/lightTree/src/org/jetbrains/kotlin/fir/lightTree/fir/WhenEntry.kt @@ -5,15 +5,12 @@ package org.jetbrains.kotlin.fir.lightTree.fir -import org.jetbrains.kotlin.fir.FirWhenSubject import org.jetbrains.kotlin.fir.builder.generateLazyLogicalOperation import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.FirBlock import org.jetbrains.kotlin.fir.expressions.FirExpression -import org.jetbrains.kotlin.fir.expressions.FirOperatorCall import org.jetbrains.kotlin.fir.expressions.buildErrorExpression -import org.jetbrains.kotlin.fir.expressions.builder.buildWhenSubjectExpression data class WhenEntry( val conditions: List, @@ -39,7 +36,7 @@ data class WhenEntry( fun toFirWhenConditionWithoutSubject(): FirExpression { return when (val condition = conditions.firstOrNull()) { // is FirOperatorCall -> condition.arguments.first() - null -> buildErrorExpression(null, FirSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)) + null -> buildErrorExpression(null, ConeSimpleDiagnostic("No expression in condition with expression", DiagnosticKind.Syntax)) else -> condition } } diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt index a85edd7c6ae..a09441333b3 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.builder.* import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.buildSingleExpressionBlock @@ -108,7 +108,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte buildErrorFunction { source = baseSource session = this@BaseFirBuilder.baseSession - diagnostic = FirSimpleDiagnostic(message, kind) + diagnostic = ConeSimpleDiagnostic(message, kind) symbol = FirErrorFunctionSymbol() } ) @@ -178,7 +178,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte bind( buildErrorLoop( expression.getSourceOrNull(), - FirSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("Cannot bind unlabeled jump to a loop", DiagnosticKind.Syntax) ) ) } @@ -192,7 +192,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte target = FirLoopTarget(labelName).apply { bind( buildErrorLoop( - expression.getSourceOrNull(), FirSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax) + expression.getSourceOrNull(), ConeSimpleDiagnostic("Cannot bind label $labelName to a loop", DiagnosticKind.Syntax) ) ) } @@ -218,7 +218,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte val kind = when { convertedText !is Long -> return buildErrorExpression { source = expression.getSourceOrNull() - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Incorrect constant expression: $text", DiagnosticKind.IllegalConstExpression ) @@ -243,7 +243,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte expression.getSourceOrNull(), kind, convertedText, - FirSimpleDiagnostic("Incorrect integer literal: $text", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("Incorrect integer literal: $text", DiagnosticKind.Syntax) ) } FLOAT_CONSTANT -> @@ -252,14 +252,14 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte expression.getSourceOrNull(), FirConstKind.Float, convertedText, - FirSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("Incorrect float: $text", DiagnosticKind.Syntax) ) } else { buildConstOrErrorExpression( expression.getSourceOrNull(), FirConstKind.Double, convertedText as Double, - FirSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("Incorrect double: $text", DiagnosticKind.Syntax) ) } CHARACTER_CONSTANT -> @@ -267,7 +267,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte expression.getSourceOrNull(), FirConstKind.Char, text.parseCharacter(), - FirSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("Incorrect character: $text", DiagnosticKind.Syntax) ) BOOLEAN_CONSTANT -> buildConstExpression( @@ -323,7 +323,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte hasExpressions = true buildErrorExpression { source = entry.getSourceOrNull() - diagnostic = FirSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Incorrect template entry: ${entry.asText}", DiagnosticKind.Syntax) } } } @@ -370,7 +370,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte if (argument == null) { return buildErrorExpression { source = argument - diagnostic = FirSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Inc/dec without operand", DiagnosticKind.Syntax) } } return buildBlock { @@ -451,7 +451,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte } else { buildErrorNamedReference { source = left.getSourceOrNull() - diagnostic = FirSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Unsupported qualified LValue: ${left.asText}", DiagnosticKind.Syntax) } } } @@ -462,7 +462,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte } return buildErrorNamedReference { source = left.getSourceOrNull() - diagnostic = FirSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Unsupported LValue: $tokenType", DiagnosticKind.Syntax) } } @@ -497,7 +497,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte argumentList = buildBinaryArgumentList( this@generateAssignment?.convert() ?: buildErrorExpression { source = null - diagnostic = FirSimpleDiagnostic("Unsupported left value of assignment: ${baseSource?.psi?.text}", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Unsupported left value of assignment: ${baseSource?.psi?.text}", DiagnosticKind.Syntax) }, value ) @@ -543,7 +543,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte argumentList = buildArgumentList { arguments += rhs?.convert() ?: buildErrorExpression( null, - FirSimpleDiagnostic("No value for array set", DiagnosticKind.Syntax) + ConeSimpleDiagnostic("No value for array set", DiagnosticKind.Syntax) ) } } @@ -574,7 +574,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte "", baseCall.explicitReceiver ?: buildErrorExpression { source = baseSource - diagnostic = FirSimpleDiagnostic("No receiver for array access", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("No receiver for array access", DiagnosticKind.Syntax) } ) statements += arrayVariable @@ -613,7 +613,7 @@ abstract class BaseFirBuilder(val baseSession: FirSession, val context: Conte argumentList = buildArgumentList { arguments += rhs?.convert() ?: buildErrorExpression( null, - FirSimpleDiagnostic( + ConeSimpleDiagnostic( "No value for array set", DiagnosticKind.Syntax ) diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt index 40723dc6f97..0b13236a649 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/ConversionUtils.kt @@ -18,7 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock @@ -228,7 +228,7 @@ internal fun KtWhenCondition.toFirWhenCondition( } } else -> { - buildErrorExpression(baseSource, FirSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax)) + buildErrorExpression(baseSource, ConeSimpleDiagnostic("Unsupported when condition: ${this.javaClass}", DiagnosticKind.Syntax)) } } } diff --git a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt index 5a3e3c3b036..155523a9b58 100644 --- a/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt +++ b/compiler/fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt @@ -19,8 +19,8 @@ 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.FirDiagnosticWithParameters1 -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnosticWithParameters1 +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.expressions.impl.FirModifiableQualifiedAccess @@ -126,7 +126,7 @@ class RawFirBuilder( private fun KtTypeReference?.toFirOrErrorType(): FirTypeRef = convertSafe() ?: buildErrorTypeRef { source = this@toFirOrErrorType?.toFirSourceElement() - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( if (this@toFirOrErrorType == null) "Incomplete code" else "Conversion failed", DiagnosticKind.Syntax ) } @@ -136,18 +136,18 @@ class RawFirBuilder( if (stubMode) buildExpressionStub() else with(this()) { convertSafe() ?: buildErrorExpression( - this?.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax), + this?.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax), ) } private fun KtExpression?.toFirExpression(errorReason: String): FirExpression = if (stubMode) buildExpressionStub() else convertSafe() ?: buildErrorExpression( - this?.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax), + this?.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax), ) private fun KtExpression.toFirStatement(errorReason: String): FirStatement = - convertSafe() ?: buildErrorExpression(this.toFirSourceElement(), FirSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) + convertSafe() ?: buildErrorExpression(this.toFirSourceElement(), ConeSimpleDiagnostic(errorReason, DiagnosticKind.Syntax)) private fun KtExpression.toFirStatement(): FirStatement = convert() @@ -161,7 +161,7 @@ class RawFirBuilder( delegatedSuperType, delegatedSelfType ?: buildErrorTypeRef { source = this@toFirDeclaration.toFirSourceElement() - diagnostic = FirSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject) + diagnostic = ConeSimpleDiagnostic("Constructor in object", DiagnosticKind.ConstructorInObject) }, owner, hasPrimaryConstructor, @@ -209,7 +209,7 @@ class RawFirBuilder( if (this == null) { return buildErrorExpression( (this as? KtElement)?.toFirSourceElement(), - FirSimpleDiagnostic("No argument given", DiagnosticKind.Syntax), + ConeSimpleDiagnostic("No argument given", DiagnosticKind.Syntax), ) } val name = this.getArgumentName()?.asName @@ -846,7 +846,7 @@ class RawFirBuilder( } val ktBody = literal.bodyExpression body = if (ktBody == null) { - val errorExpression = buildErrorExpression(source, FirSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax)) + val errorExpression = buildErrorExpression(source, ConeSimpleDiagnostic("Lambda has no body", DiagnosticKind.Syntax)) FirSingleExpressionBlock(errorExpression.toReturn()) } else { configureBlockWithoutBuilding(ktBody).apply { @@ -909,7 +909,7 @@ class RawFirBuilder( isThis -> delegatedSelfTypeRef else -> delegatedSuperTypeRef ?: buildErrorTypeRef { this.source = source - diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.Syntax) } } return buildDelegatedConstructorCall { @@ -1034,7 +1034,7 @@ class RawFirBuilder( } else { FirErrorTypeRefBuilder().apply { this.source = source - diagnostic = FirSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Incomplete user type", DiagnosticKind.Syntax) } } } @@ -1055,7 +1055,7 @@ class RawFirBuilder( } null -> FirErrorTypeRefBuilder().apply { this.source = source - diagnostic = FirSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) + diagnostic = ConeSimpleDiagnostic("Unwrapped type is null", DiagnosticKind.Syntax) } else -> throw AssertionError("Unexpected type element: ${unwrappedElement.text}") } @@ -1487,13 +1487,13 @@ class RawFirBuilder( is KtParenthesizedExpression -> splitToCalleeAndReceiver(calleeExpression.expression, defaultSource) null -> { - buildErrorNamedReference { diagnostic = FirSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null + buildErrorNamedReference { diagnostic = ConeSimpleDiagnostic("Call has no callee", DiagnosticKind.Syntax) } to null } is KtSuperExpression -> { buildErrorNamedReference { source = calleeExpression.toFirSourceElement() - diagnostic = FirDiagnosticWithParameters1("Super cannot be a callee", calleeExpression.text, DiagnosticKind.SuperNotAllowed) + diagnostic = ConeSimpleDiagnosticWithParameters1("Super cannot be a callee", calleeExpression.text, DiagnosticKind.SuperNotAllowed) } to null } @@ -1566,7 +1566,7 @@ class RawFirBuilder( override fun visitQualifiedExpression(expression: KtQualifiedExpression, data: Unit): FirElement { val selector = expression.selectorExpression ?: return buildErrorExpression( - expression.toFirSourceElement(), FirSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax), + expression.toFirSourceElement(), ConeSimpleDiagnostic("Qualified expression without selector", DiagnosticKind.Syntax), ) val firSelector = selector.toFirExpression("Incorrect selector expression") if (firSelector is FirModifiableQualifiedAccess) { @@ -1601,7 +1601,7 @@ class RawFirBuilder( override fun visitParenthesizedExpression(expression: KtParenthesizedExpression, data: Unit): FirElement { return expression.expression?.accept(this, data) - ?: buildErrorExpression(expression.toFirSourceElement(), FirSimpleDiagnostic("Empty parentheses", DiagnosticKind.Syntax)) + ?: buildErrorExpression(expression.toFirSourceElement(), ConeSimpleDiagnostic("Empty parentheses", DiagnosticKind.Syntax)) } override fun visitLabeledExpression(expression: KtLabeledExpression, data: Unit): FirElement { @@ -1615,7 +1615,7 @@ class RawFirBuilder( } } val result = expression.baseExpression?.accept(this, data) - ?: buildErrorExpression(sourceElement, FirSimpleDiagnostic("Empty label", DiagnosticKind.Syntax)) + ?: buildErrorExpression(sourceElement, ConeSimpleDiagnostic("Empty label", DiagnosticKind.Syntax)) if (size != context.firLabels.size) { context.firLabels.removeLast() println("Unused label: ${expression.text}") @@ -1633,7 +1633,7 @@ class RawFirBuilder( val result = rawResult as? FirAnnotationContainer ?: return buildErrorExpression( expression.toFirSourceElement(), - FirSimpleDiagnostic("Strange annotated expression: ${rawResult?.render()}", DiagnosticKind.Syntax), + ConeSimpleDiagnostic("Strange annotated expression: ${rawResult?.render()}", DiagnosticKind.Syntax), ) expression.extractAnnotationsTo(result.annotations as MutableList) return result diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt index f4f9a57f531..92e56f1fbd1 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt @@ -20,9 +20,9 @@ import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.resolve.calls.* -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirAmbiguityError -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirInapplicableCandidateError -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeInapplicableCandidateError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError import org.jetbrains.kotlin.fir.resolve.inference.ResolvedCallableReferenceAtom import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference @@ -392,15 +392,15 @@ class FirCallResolver( return when { candidates.isEmpty() -> buildErrorNamedReference { this.source = source - diagnostic = FirUnresolvedNameError(name) + diagnostic = ConeUnresolvedNameError(name) } applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> { buildErrorNamedReference { this.source = source - diagnostic = FirInapplicableCandidateError( + diagnostic = ConeInapplicableCandidateError( applicability, candidates.map { - FirInapplicableCandidateError.CandidateInfo( + ConeInapplicableCandidateError.CandidateInfo( it.symbol, if (it.systemInitialized) it.system.diagnostics else emptyList(), ) @@ -432,7 +432,7 @@ class FirCallResolver( } else -> buildErrorNamedReference { this.source = source - diagnostic = FirAmbiguityError(name, candidates.map { it.symbol }) + diagnostic = ConeAmbiguityError(name, candidates.map { it.symbol }) } } } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt index b4e47bf3b31..e97d856903f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/deserialization/AbstractAnnotationDeserializer.kt @@ -11,13 +11,13 @@ import org.jetbrains.kotlin.fir.declarations.FirConstructor import org.jetbrains.kotlin.fir.declarations.FirRegularClass import org.jetbrains.kotlin.fir.declarations.collectEnumEntries import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.* import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference import org.jetbrains.kotlin.fir.resolve.constructType -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedSymbolError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedSymbolError import org.jetbrains.kotlin.fir.resolve.toSymbol import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol @@ -100,7 +100,7 @@ abstract class AbstractAnnotationDeserializer( buildResolvedTypeRef { type = it.constructType(emptyList(), isNullable = false) } - } ?: buildErrorTypeRef { diagnostic =FirUnresolvedSymbolError(classId) } + } ?: buildErrorTypeRef { diagnostic = ConeUnresolvedSymbolError(classId) } argumentList = buildArgumentList { this.arguments += arguments } @@ -151,7 +151,7 @@ abstract class AbstractAnnotationDeserializer( resolvedSymbol = it.symbol } } ?: buildErrorNamedReference { - diagnostic = FirSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError) + diagnostic = ConeSimpleDiagnostic("Strange deserialized enum value: $classId.$entryName", DiagnosticKind.DeserializationError) } } // ARRAY -> { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt index 0ec732b2bed..bd378510b59 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/ResolveUtils.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.builtins.functions.FunctionClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.expressions.FirResolvable @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.fir.references.FirSuperReference import org.jetbrains.kotlin.fir.references.FirThisReference import org.jetbrains.kotlin.fir.resolve.calls.FirNamedReferenceWithCandidate import org.jetbrains.kotlin.fir.resolve.calls.isSuperReferenceExpression -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError import org.jetbrains.kotlin.fir.resolve.substitution.AbstractConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.resultType import org.jetbrains.kotlin.fir.scopes.impl.FirDeclaredMemberScopeProvider @@ -308,7 +308,7 @@ fun BodyResolveComponents.typeFromCallee(access: T): FirReso is FirErrorNamedReference -> buildErrorTypeRef { source = access.source - diagnostic = FirStubDiagnostic(newCallee.diagnostic) + diagnostic = ConeStubDiagnostic(newCallee.diagnostic) } is FirNamedReferenceWithCandidate -> { typeFromSymbol(newCallee.candidateSymbol, makeNullable) @@ -327,7 +327,7 @@ fun BodyResolveComponents.typeFromCallee(access: T): FirReso is FirSuperReference -> { newCallee.superTypeRef as? FirResolvedTypeRef ?: buildErrorTypeRef { source = newCallee.source - diagnostic = FirUnresolvedNameError(Name.identifier("super")) + diagnostic = ConeUnresolvedNameError(Name.identifier("super")) } } else -> error("Failed to extract type from: $newCallee") diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt index 31640509b46..31be5507661 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/diagnostics/FirDiagnostics.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.fir.resolve.diagnostics -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.resolve.calls.CandidateApplicability import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol @@ -15,40 +15,40 @@ import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.calls.model.KotlinCallDiagnostic -class FirUnresolvedReferenceError(val name: Name? = null) : FirDiagnostic() { +class ConeUnresolvedReferenceError(val name: Name? = null) : ConeDiagnostic() { override val reason: String get() = "Unresolved reference" + if (name != null) ": ${name.asString()}" else "" } -class FirUnresolvedSymbolError(val classId: ClassId) : FirDiagnostic() { +class ConeUnresolvedSymbolError(val classId: ClassId) : ConeDiagnostic() { override val reason: String get() = "Symbol not found for $classId" } -class FirUnresolvedNameError(val name: Name) : FirDiagnostic() { +class ConeUnresolvedNameError(val name: Name) : ConeDiagnostic() { override val reason: String get() = "Unresolved name: $name" } -class FirInapplicableCandidateError( +class ConeInapplicableCandidateError( val applicability: CandidateApplicability, val candidates: Collection -) : FirDiagnostic() { +) : ConeDiagnostic() { data class CandidateInfo(val symbol: AbstractFirBasedSymbol<*>, val diagnostics: List) override val reason: String get() = "Inapplicable($applicability): ${candidates.map { describeSymbol(it.symbol) }}" } -class FirAmbiguityError(val name: Name, val candidates: Collection>) : FirDiagnostic() { +class ConeAmbiguityError(val name: Name, val candidates: Collection>) : ConeDiagnostic() { override val reason: String get() = "Ambiguity: $name, ${candidates.map { describeSymbol(it) }}" } -class FirOperatorAmbiguityError(val candidates: Collection>) : FirDiagnostic() { +class ConeOperatorAmbiguityError(val candidates: Collection>) : ConeDiagnostic() { override val reason: String get() = "Operator overload ambiguity. Compatible candidates: ${candidates.map { describeSymbol(it) }}" } -class FirVariableExpectedError : FirDiagnostic() { +class ConeVariableExpectedError : ConeDiagnostic() { override val reason: String get() = "Variable expected" } -class FirTypeMismatchError(val expectedType: ConeKotlinType, val actualType: ConeKotlinType) : FirDiagnostic() { +class ConeTypeMismatchError(val expectedType: ConeKotlinType, val actualType: ConeKotlinType) : ConeDiagnostic() { override val reason: String get() = "Type mismatch. Expected: $expectedType, Actual: $actualType" } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt index c14b8c084d3..b1ce811841d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/inference/PostponedArgumentsAnalyzer.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.expressions.FirExpression import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference import org.jetbrains.kotlin.fir.resolve.calls.* -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedReferenceError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedReferenceError import org.jetbrains.kotlin.fir.resolve.substitution.ConeSubstitutor import org.jetbrains.kotlin.fir.resolve.transformers.StoreNameReference import org.jetbrains.kotlin.fir.types.ConeKotlinType @@ -81,7 +81,7 @@ class PostponedArgumentsAnalyzer( candidate == null || applicability < CandidateApplicability.SYNTHETIC_RESOLVED -> buildErrorNamedReference { source = callableReferenceAccess.source - diagnostic = FirUnresolvedReferenceError(callableReferenceAccess.calleeReference.name) + diagnostic = ConeUnresolvedReferenceError(callableReferenceAccess.calleeReference.name) } else -> FirNamedReferenceWithCandidate(callableReferenceAccess.source, callableReferenceAccess.calleeReference.name, candidate) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt index 7fe7dfb9918..5bd67a1ebd8 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirCallCompletionResultsWriterTransformer.kt @@ -7,9 +7,8 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* -import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList import org.jetbrains.kotlin.fir.expressions.builder.buildVarargArgumentsExpression import org.jetbrains.kotlin.fir.references.builder.buildResolvedCallableReference import org.jetbrains.kotlin.fir.references.builder.buildResolvedNamedReference @@ -62,7 +61,7 @@ class FirCallCompletionResultsWriterTransformer( typeCalculator.tryCalculateReturnType(it) } ?: buildErrorTypeRef { source = calleeReference.source - diagnostic = FirSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}") + diagnostic = ConeSimpleDiagnostic("Callee reference to candidate without return type: ${candidateFir.render()}") } qualifiedAccessExpression.replaceTypeRefWithSubstituted(calleeReference, typeRef).replaceTypeArguments(typeArguments) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt index 35117d30c59..69da616cec4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSupertypesResolution.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.resolve.* import org.jetbrains.kotlin.fir.scopes.FirIterableScope @@ -266,7 +266,7 @@ private class FirSupertypeResolverVisitor( private fun createErrorTypeRef(fir: FirElement, message: String) = buildErrorTypeRef { source = fir.source - diagnostic = FirSimpleDiagnostic(message) + diagnostic = ConeSimpleDiagnostic(message) } private class SupertypeComputationSession { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt index a67cc88d352..6cf1593fce4 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirSyntheticCallGenerator.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference import org.jetbrains.kotlin.fir.references.impl.FirStubReference import org.jetbrains.kotlin.fir.resolve.BodyResolveComponents import org.jetbrains.kotlin.fir.resolve.calls.* -import org.jetbrains.kotlin.fir.resolve.diagnostics.FirUnresolvedNameError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.FirAbstractBodyResolveTransformer import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.SyntheticCallableId @@ -114,7 +114,7 @@ class FirSyntheticCallGenerator( StoreCalleeReference, buildErrorNamedReference { source = callableReferenceAccess.source - diagnostic = FirUnresolvedNameError(callableReferenceAccess.calleeReference.name) + diagnostic = ConeUnresolvedNameError(callableReferenceAccess.calleeReference.name) } ) val fakeCallElement = buildFunctionCall { diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt index 13aaade8620..01a3c0d0306 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/ReturnTypeCalculator.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers import org.jetbrains.kotlin.fir.declarations.FirTypedDeclaration import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef @@ -23,7 +23,7 @@ class ReturnTypeCalculatorForFullBodyResolve : ReturnTypeCalculator { if (returnTypeRef is FirResolvedTypeRef) return returnTypeRef return buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Cannot calculate return type during full-body resolution (local class/object?): ${declaration.render()}", DiagnosticKind.InferenceError ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt index 7fd51f89ddb..09227ea612f 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirControlFlowStatementsResolveTransformer.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve import org.jetbrains.kotlin.fir.FirTargetElement import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.impl.FirElseIfTrueCondition import org.jetbrains.kotlin.fir.expressions.impl.FirEmptyExpressionBlock @@ -17,7 +17,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.FirSyntheticCallGenerator import org.jetbrains.kotlin.fir.resolve.transformers.FirWhenExhaustivenessTransformer import org.jetbrains.kotlin.fir.resolvedTypeFromPrototype import org.jetbrains.kotlin.fir.scopes.impl.FirLocalScope -import org.jetbrains.kotlin.fir.types.ConeKotlinType import org.jetbrains.kotlin.fir.types.FirImplicitTypeRef import org.jetbrains.kotlin.fir.types.builder.buildErrorTypeRef import org.jetbrains.kotlin.fir.types.coneTypeSafe @@ -77,7 +76,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran whenExpression = whenExpression.transformSingle(whenExhaustivenessTransformer, null) dataFlowAnalyzer.exitWhenExpression(whenExpression, callCompleted = true) whenExpression.resultType = buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("Can't resolve when expression", DiagnosticKind.InferenceError) } return@with whenExpression.compose() } @@ -150,7 +149,7 @@ class FirControlFlowStatementsResolveTransformer(transformer: FirBodyResolveTran completionResult.result } ?: run { tryExpression.resultType = buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("Can't resolve try expression", DiagnosticKind.InferenceError) } callCompleted = true tryExpression diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt index 9a40ea95587..3f756a02943 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt @@ -13,7 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.builder.buildValueParameter import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.buildReturnExpression import org.jetbrains.kotlin.fir.expressions.builder.buildUnitExpression @@ -428,7 +428,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) } else { result.transformReturnTypeRef( transformer, - withExpectedType(buildErrorTypeRef { diagnostic = FirSimpleDiagnostic("empty body", DiagnosticKind.Other) }) + withExpectedType(buildErrorTypeRef { diagnostic = ConeSimpleDiagnostic("empty body", DiagnosticKind.Other) }) ) } } @@ -646,7 +646,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) initializer != null -> { val expectedType = when (val resultType = initializer.resultType) { is FirImplicitTypeRef -> buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("No result type for initializer", DiagnosticKind.InferenceError) } else -> resultType } @@ -658,7 +658,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) variable.getter != null && variable.getter !is FirDefaultPropertyAccessor -> { val expectedType = when (val resultType = variable.getter?.returnTypeRef) { is FirImplicitTypeRef -> buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("No result type for getter", DiagnosticKind.InferenceError) } else -> resultType } @@ -672,7 +672,7 @@ class FirDeclarationsResolveTransformer(transformer: FirBodyResolveTransformer) transformer, withExpectedType( buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Cannot infer variable type without initializer / getter / delegate", DiagnosticKind.InferenceError, ) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt index 923c21acfcf..12b36c5fa00 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirExpressionsResolveTransformer.kt @@ -9,7 +9,7 @@ import com.intellij.openapi.progress.ProcessCanceledException import org.jetbrains.kotlin.fir.* import org.jetbrains.kotlin.fir.declarations.FirTypeParametersOwner import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.* import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression import org.jetbrains.kotlin.fir.expressions.builder.buildFunctionCall @@ -28,7 +28,6 @@ import org.jetbrains.kotlin.fir.resolve.transformers.InvocationKindTransformer import org.jetbrains.kotlin.fir.resolve.transformers.StoreReceiver import org.jetbrains.kotlin.fir.scopes.impl.withReplacedConeType import org.jetbrains.kotlin.fir.symbols.StandardClassIds -import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLookupTagWithFixedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol import org.jetbrains.kotlin.fir.symbols.invoke @@ -52,7 +51,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : val type = buildErrorTypeRef { source = expression.source diagnostic = - FirSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError) + ConeSimpleDiagnostic("Type calculating for ${expression::class} is not supported", DiagnosticKind.InferenceError) } expression.resultType = type } @@ -94,7 +93,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : superTypeRefs?.isNotEmpty() != true -> { buildErrorTypeRef { source = qualifiedAccessExpression.source - diagnostic = FirSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype) + diagnostic = ConeSimpleDiagnostic("No super type", DiagnosticKind.NoSupertype) } } superTypeRefs.size == 1 -> { @@ -210,7 +209,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : block.resultType.resolvedTypeFromPrototype(session.builtinTypes.unitType.type) } else { (resultExpression.resultType as? FirResolvedTypeRef) ?: buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("No type for block", DiagnosticKind.InferenceError) } } dataFlowAnalyzer.exitBlock(block) @@ -290,14 +289,14 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : else buildErrorNamedReference { source = operatorCall.argument.source - diagnostic = FirVariableExpectedError() + diagnostic = ConeVariableExpectedError() } } assignment.transform(transformer, ResolutionMode.ContextIndependent) } else -> buildErrorExpression { source = operatorCall.source - diagnostic = FirOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol)) + diagnostic = ConeOperatorAmbiguityError(listOf(operatorCallReference.resolvedSymbol, assignCallReference.resolvedSymbol)) }.compose() } } @@ -383,7 +382,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : } ?: run { checkNotNullCall.resultType = buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError) + diagnostic = ConeSimpleDiagnostic("Can't resolve !! operator call", DiagnosticKind.InferenceError) } callCompleted = true checkNotNullCall @@ -532,7 +531,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : dataFlowAnalyzer.exitConstExpresion(constExpression as FirConstExpression<*>) constExpression.resultType = buildErrorTypeRef { source = constExpression.source - diagnostic = FirTypeMismatchError(expectedType, integerLiteralType.getApproximatedType()) + diagnostic = ConeTypeMismatchError(expectedType, integerLiteralType.getApproximatedType()) } return constExpression.compose() } @@ -671,7 +670,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : buildErrorNamedReference { // TODO: add better diagnostic source = augmentedArraySetCall.source - diagnostic = FirAmbiguityError(operatorName, emptyList()) + diagnostic = ConeAmbiguityError(operatorName, emptyList()) } ) } @@ -683,7 +682,7 @@ class FirExpressionsResolveTransformer(transformer: FirBodyResolveTransformer) : it.replaceCalleeReference( buildErrorNamedReference { source = augmentedArraySetCall.source - diagnostic = FirUnresolvedNameError(operatorName) + diagnostic = ConeUnresolvedNameError(operatorName) } ) } diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt index 0f1e733d5f9..bc40863ee61 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirImplicitBodyResolve.kt @@ -12,7 +12,7 @@ import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.declarations.synthetic.FirSyntheticProperty import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.diagnostics.FirSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.render import org.jetbrains.kotlin.fir.resolve.ResolutionMode @@ -155,7 +155,7 @@ private class ReturnTypeCalculatorWithJump( declaration.transformReturnTypeRef( TransformImplicitType, buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic("Unsupported: implicit VP type") + diagnostic = ConeSimpleDiagnostic("Unsupported: implicit VP type") } ) } @@ -168,7 +168,7 @@ private class ReturnTypeCalculatorWithJump( return when (val status = implicitBodyResolveComputationSession.getStatus(declaration.symbol)) { is ImplicitBodyResolveComputationStatus.Computed -> status.resolvedTypeRef is ImplicitBodyResolveComputationStatus.Computing -> - buildErrorTypeRef {diagnostic = FirSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes) } + buildErrorTypeRef {diagnostic = ConeSimpleDiagnostic("cycle", DiagnosticKind.RecursionInImplicitTypes) } else -> computeReturnTypeRef(declaration) } } @@ -187,7 +187,7 @@ private class ReturnTypeCalculatorWithJump( if (file == null || outerClasses.any { it == null }) { return buildErrorTypeRef { - diagnostic = FirSimpleDiagnostic( + diagnostic = ConeSimpleDiagnostic( "Cannot calculate return type (local class/object?)", DiagnosticKind.InferenceError ) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt index 9bc92bde06d..4e095c64ec6 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorFunction.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.declarations import org.jetbrains.kotlin.fir.FirPureAbstractElement import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.expressions.FirBlock @@ -33,7 +33,7 @@ abstract class FirErrorFunction : FirPureAbstractElement(), FirFunction abstract override val body: FirBlock? - abstract override val diagnostic: FirDiagnostic + abstract override val diagnostic: ConeDiagnostic abstract override val symbol: FirErrorFunctionSymbol override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorFunction(this, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt index c2a5f495a96..3d3907856e0 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorFunctionBuilder.kt @@ -15,7 +15,7 @@ import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter import org.jetbrains.kotlin.fir.declarations.impl.FirErrorFunctionImpl -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -38,7 +38,7 @@ class FirErrorFunctionBuilder : FirAnnotationContainerBuilder { override val annotations: MutableList = mutableListOf() val typeParameters: MutableList = mutableListOf() val valueParameters: MutableList = mutableListOf() - lateinit var diagnostic: FirDiagnostic + lateinit var diagnostic: ConeDiagnostic lateinit var symbol: FirErrorFunctionSymbol override fun build(): FirErrorFunction { diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt index 64221586a42..ac85dc18c76 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorFunctionImpl.kt @@ -11,7 +11,7 @@ import org.jetbrains.kotlin.fir.declarations.FirErrorFunction import org.jetbrains.kotlin.fir.declarations.FirResolvePhase import org.jetbrains.kotlin.fir.declarations.FirTypeParameter import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -33,7 +33,7 @@ internal class FirErrorFunctionImpl( override val annotations: MutableList, override val typeParameters: MutableList, override val valueParameters: MutableList, - override val diagnostic: FirDiagnostic, + override val diagnostic: ConeDiagnostic, override val symbol: FirErrorFunctionSymbol, ) : FirErrorFunction() { override var returnTypeRef: FirTypeRef = FirErrorTypeRefImpl(null, diagnostic) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt index 4f5c4c8f072..a4665231ef9 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/diagnostics/FirDiagnosticHolder.kt @@ -16,7 +16,7 @@ import org.jetbrains.kotlin.fir.visitors.* interface FirDiagnosticHolder : FirElement { override val source: FirSourceElement? - val diagnostic: FirDiagnostic + val diagnostic: ConeDiagnostic override fun accept(visitor: FirVisitor, data: D): R = visitor.visitDiagnosticHolder(this, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt index d15ebb2d6c0..cb8577074cf 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorExpression.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.fir.visitors.* @@ -20,7 +20,7 @@ abstract class FirErrorExpression : FirExpression(), FirDiagnosticHolder { abstract override val source: FirSourceElement? abstract override val typeRef: FirTypeRef abstract override val annotations: List - abstract override val diagnostic: FirDiagnostic + abstract override val diagnostic: ConeDiagnostic override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorExpression(this, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorLoop.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorLoop.kt index e82e54ec0e9..0af7636a5ee 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorLoop.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirErrorLoop.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirLabel import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.visitors.* @@ -22,7 +22,7 @@ abstract class FirErrorLoop : FirLoop(), FirDiagnosticHolder { abstract override val block: FirBlock abstract override val condition: FirExpression abstract override val label: FirLabel? - abstract override val diagnostic: FirDiagnostic + abstract override val diagnostic: ConeDiagnostic override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorLoop(this, data) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt index 1de3b56c2c4..50ac6615bf8 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorExpressionBuilder.kt @@ -9,7 +9,7 @@ import kotlin.contracts.* import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder import org.jetbrains.kotlin.fir.builder.FirBuilderDsl -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.* @FirBuilderDsl class FirErrorExpressionBuilder : FirAnnotationContainerBuilder, FirExpressionBuilder { override var source: FirSourceElement? = null - lateinit var diagnostic: FirDiagnostic + lateinit var diagnostic: ConeDiagnostic override fun build(): FirErrorExpression { return FirErrorExpressionImpl( diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt index 9ce09723276..d468e62cf1c 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirErrorLoopBuilder.kt @@ -10,7 +10,7 @@ import org.jetbrains.kotlin.fir.FirLabel import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder import org.jetbrains.kotlin.fir.builder.FirBuilderDsl -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -29,7 +29,7 @@ class FirErrorLoopBuilder : FirAnnotationContainerBuilder { override var source: FirSourceElement? = null override val annotations: MutableList = mutableListOf() var label: FirLabel? = null - lateinit var diagnostic: FirDiagnostic + lateinit var diagnostic: ConeDiagnostic override fun build(): FirErrorLoop { return FirErrorLoopImpl( diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt index ce5e682d15e..6b3b93df513 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorExpressionImpl.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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.types.FirTypeRef @@ -20,7 +20,7 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirErrorExpressionImpl( override val source: FirSourceElement?, - override val diagnostic: FirDiagnostic, + override val diagnostic: ConeDiagnostic, ) : FirErrorExpression() { override var typeRef: FirTypeRef = FirErrorTypeRefImpl(source, diagnostic) override val annotations: List get() = emptyList() diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt index 80f50376f04..31bce4d9205 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirErrorLoopImpl.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions.impl import org.jetbrains.kotlin.fir.FirLabel import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -24,7 +24,7 @@ internal class FirErrorLoopImpl( override val source: FirSourceElement?, override val annotations: MutableList, override var label: FirLabel?, - override val diagnostic: FirDiagnostic, + override val diagnostic: ConeDiagnostic, ) : FirErrorLoop() { override var block: FirBlock = FirEmptyExpressionBlock() override var condition: FirExpression = FirErrorExpressionImpl(source, diagnostic) diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt index 5c082fbe25b..babddf20a04 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/FirErrorNamedReference.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.references import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.name.Name @@ -21,7 +21,7 @@ abstract class FirErrorNamedReference : FirNamedReference(), FirDiagnosticHolder abstract override val source: FirSourceElement? abstract override val name: Name abstract override val candidateSymbol: AbstractFirBasedSymbol<*>? - abstract override val diagnostic: FirDiagnostic + abstract override val diagnostic: ConeDiagnostic override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorNamedReference(this, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt index b5f1b208869..94a465b430b 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/builder/FirErrorNamedReferenceBuilder.kt @@ -8,7 +8,7 @@ package org.jetbrains.kotlin.fir.references.builder import kotlin.contracts.* import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.builder.FirBuilderDsl -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.name.Name @FirBuilderDsl class FirErrorNamedReferenceBuilder { var source: FirSourceElement? = null - lateinit var diagnostic: FirDiagnostic + lateinit var diagnostic: ConeDiagnostic fun build(): FirErrorNamedReference { return FirErrorNamedReferenceImpl( diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt index c42335cbec6..0bf201cec11 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/references/impl/FirErrorNamedReferenceImpl.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.references.impl import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.references.FirErrorNamedReference import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.name.Name @@ -19,7 +19,7 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirErrorNamedReferenceImpl( override val source: FirSourceElement?, - override val diagnostic: FirDiagnostic, + override val diagnostic: ConeDiagnostic, ) : FirErrorNamedReference() { override val name: Name = Name.special("<${diagnostic.reason}>") override val candidateSymbol: AbstractFirBasedSymbol<*>? get() = null diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirErrorTypeRef.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirErrorTypeRef.kt index 23a173ada9f..c12054a7e06 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirErrorTypeRef.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/FirErrorTypeRef.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.types import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall import org.jetbrains.kotlin.fir.visitors.* @@ -21,7 +21,7 @@ abstract class FirErrorTypeRef : FirResolvedTypeRef(), FirDiagnosticHolder { abstract override val annotations: List abstract override val type: ConeKotlinType abstract override val delegatedTypeRef: FirTypeRef? - abstract override val diagnostic: FirDiagnostic + abstract override val diagnostic: ConeDiagnostic override fun accept(visitor: FirVisitor, data: D): R = visitor.visitErrorTypeRef(this, data) } diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt index 911b896958d..c8bbd868b4d 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/builder/FirErrorTypeRefBuilder.kt @@ -9,7 +9,7 @@ import kotlin.contracts.* import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder import org.jetbrains.kotlin.fir.builder.FirBuilderDsl -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -26,7 +26,7 @@ import org.jetbrains.kotlin.fir.visitors.* @FirBuilderDsl class FirErrorTypeRefBuilder : FirAnnotationContainerBuilder { override var source: FirSourceElement? = null - lateinit var diagnostic: FirDiagnostic + lateinit var diagnostic: ConeDiagnostic override fun build(): FirErrorTypeRef { return FirErrorTypeRefImpl( diff --git a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt index aac9ed62e18..0e16cdffffb 100644 --- a/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt +++ b/compiler/fir/tree/gen/org/jetbrains/kotlin/fir/types/impl/FirErrorTypeRefImpl.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.fir.types.impl import org.jetbrains.kotlin.fir.FirSourceElement -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +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 @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.fir.visitors.* internal class FirErrorTypeRefImpl( override val source: FirSourceElement?, - override val diagnostic: FirDiagnostic, + override val diagnostic: ConeDiagnostic, ) : FirErrorTypeRef() { override val annotations: MutableList = mutableListOf() override val type: ConeKotlinType = ConeClassErrorType(diagnostic.reason) diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirDiagnostic.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeDiagnostic.kt similarity index 76% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirDiagnostic.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeDiagnostic.kt index 7219e9be4aa..cbad17b4001 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirDiagnostic.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeDiagnostic.kt @@ -5,10 +5,10 @@ package org.jetbrains.kotlin.fir.diagnostics -abstract class FirDiagnostic { +abstract class ConeDiagnostic { abstract val reason: String } -class FirStubDiagnostic(val original: FirDiagnostic) : FirDiagnostic() { +class ConeStubDiagnostic(val original: ConeDiagnostic) : ConeDiagnostic() { override val reason: String get() = original.reason } \ No newline at end of file diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirSimpleDiagnostic.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt similarity index 67% rename from compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirSimpleDiagnostic.kt rename to compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt index 7dbcefa63ca..ac7baa736da 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/FirSimpleDiagnostic.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt @@ -5,9 +5,13 @@ package org.jetbrains.kotlin.fir.diagnostics -class FirSimpleDiagnostic(override val reason: String, val kind: DiagnosticKind = DiagnosticKind.Other) : FirDiagnostic() +class ConeSimpleDiagnostic(override val reason: String, val kind: DiagnosticKind = DiagnosticKind.Other) : ConeDiagnostic() -class FirDiagnosticWithParameters1(override val reason: String, val a: A, val kind: DiagnosticKind = DiagnosticKind.Other) : FirDiagnostic() +class ConeSimpleDiagnosticWithParameters1( + override val reason: String, + val a: A, + val kind: DiagnosticKind = DiagnosticKind.Other +) : ConeDiagnostic() enum class DiagnosticKind { Syntax, diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt index 95ee46fb12a..735ca0beedf 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt @@ -7,7 +7,7 @@ package org.jetbrains.kotlin.fir.expressions import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.declarations.FirValueParameter -import org.jetbrains.kotlin.fir.diagnostics.FirDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic import org.jetbrains.kotlin.fir.expressions.builder.buildConstExpression import org.jetbrains.kotlin.fir.expressions.builder.buildErrorExpression import org.jetbrains.kotlin.fir.expressions.builder.buildErrorLoop @@ -28,7 +28,7 @@ inline val FirAnnotationCall.coneClassLikeType: ConeClassLikeType? inline val FirAnnotationCall.classId: ClassId? get() = coneClassLikeType?.lookupTag?.classId -fun buildConstOrErrorExpression(source: FirSourceElement?, kind: FirConstKind, value: T?, diagnostic: FirDiagnostic): FirExpression = +fun buildConstOrErrorExpression(source: FirSourceElement?, kind: FirConstKind, value: T?, diagnostic: ConeDiagnostic): FirExpression = value?.let { buildConstExpression(source, kind, it) } ?: buildErrorExpression { @@ -51,14 +51,14 @@ fun FirExpression.toResolvedCallableSymbol(): FirCallableSymbol<*>? { return toResolvedCallableReference()?.resolvedSymbol as FirCallableSymbol<*>? } -fun buildErrorLoop(source: FirSourceElement?, diagnostic: FirDiagnostic): FirErrorLoop { +fun buildErrorLoop(source: FirSourceElement?, diagnostic: ConeDiagnostic): FirErrorLoop { return buildErrorLoop { this.source = source this.diagnostic = diagnostic } } -fun buildErrorExpression(source: FirSourceElement?, diagnostic: FirDiagnostic): FirErrorExpression { +fun buildErrorExpression(source: FirSourceElement?, diagnostic: ConeDiagnostic): FirErrorExpression { return buildErrorExpression { this.source = source this.diagnostic = diagnostic diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt index 332ecb67c31..237367c5e0d 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.fir.tree.generator -import org.jetbrains.kotlin.descriptors.effectiveVisibility import org.jetbrains.kotlin.fir.tree.generator.FieldSets.annotations import org.jetbrains.kotlin.fir.tree.generator.FieldSets.arguments import org.jetbrains.kotlin.fir.tree.generator.FieldSets.body @@ -58,7 +57,7 @@ object NodeConfigurator : AbstractFieldConfigurator(FirTreeBuild } diagnosticHolder.configure { - +field("diagnostic", firDiagnosticType) + +field("diagnostic", coneDiagnosticType) } declaration.configure { diff --git a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt index 336e3cb0491..e3c16115f77 100644 --- a/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt +++ b/compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt @@ -64,7 +64,7 @@ val firScopeProviderType = type("fir.scopes", "FirScopeProvider") val pureAbstractElementType = generatedType("FirPureAbstractElement") val effectDeclarationType = type("fir.contracts.description", "ConeEffectDeclaration") val emptyContractDescriptionType = generatedType("contracts.impl", "FirEmptyContractDescription") -val firDiagnosticType = generatedType("diagnostics", "FirDiagnostic") +val coneDiagnosticType = generatedType("diagnostics", "ConeDiagnostic") val dslBuilderAnnotationType = generatedType("builder", "FirBuilderDsl") val firImplementationDetailType = generatedType("FirImplementationDetail") \ No newline at end of file diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt index 36a9068dd9a..1286d15707e 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/AbstractFirBaseDiagnosticsTest.kt @@ -22,7 +22,7 @@ import org.jetbrains.kotlin.checkers.utils.CheckerTestUtil import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.cli.jvm.compiler.TopDownAnalyzerFacadeForJVM import org.jetbrains.kotlin.diagnostics.PsiDiagnosticUtils -import org.jetbrains.kotlin.fir.analysis.diagnostics.ConeDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors import org.jetbrains.kotlin.fir.builder.RawFirBuilder import org.jetbrains.kotlin.fir.declarations.FirFile @@ -196,7 +196,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() { } protected fun TestFile.getActualText( - coneDiagnostics: Iterable, + firDiagnostics: Iterable, actualText: StringBuilder ): Boolean { val ktFile = this.ktFile @@ -211,7 +211,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() { // TODO: report JVM signature diagnostics also for implementing modules val ok = booleanArrayOf(true) - val diagnostics = coneDiagnostics.toActualDiagnostic(ktFile) + val diagnostics = firDiagnostics.toActualDiagnostic(ktFile) val filteredDiagnostics = diagnostics // TODO actualDiagnostics.addAll(filteredDiagnostics) @@ -308,7 +308,7 @@ abstract class AbstractFirBaseDiagnosticsTest : BaseDiagnosticsTest() { return ok[0] } - private fun Iterable.toActualDiagnostic(root: PsiElement): List { + private fun Iterable.toActualDiagnostic(root: PsiElement): List { val result = mutableListOf() filter { it.diagnostic.factory != FirErrors.SYNTAX_ERROR }.mapTo(result) { ActualDiagnostic(it.diagnostic, null, true) } for (errorElement in AnalyzingUtils.getSyntaxErrorRanges(root)) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt index 35b6c0d1a7a..62b28cbf47b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/fir/FirResolveBench.kt @@ -8,7 +8,7 @@ import com.intellij.openapi.fileEditor.FileDocumentManager import com.intellij.psi.PsiElement import org.jetbrains.kotlin.fir.builder.RawFirBuilder import org.jetbrains.kotlin.fir.declarations.FirFile -import org.jetbrains.kotlin.fir.diagnostics.FirStubDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic import org.jetbrains.kotlin.fir.expressions.FirFunctionCall import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression import org.jetbrains.kotlin.fir.lightTree.LightTree2Fir @@ -255,7 +255,7 @@ class FirResolveBench(val withProgress: Boolean) { unresolvedTypes++ if (typeRef.psi != null) { - if (typeRef is FirErrorTypeRef && typeRef.diagnostic is FirStubDiagnostic) { + if (typeRef is FirErrorTypeRef && typeRef.diagnostic is ConeStubDiagnostic) { return } val psi = typeRef.psi!! @@ -278,7 +278,7 @@ class FirResolveBench(val withProgress: Boolean) { implicitTypes++ } else { errorTypes++ - if (resolvedTypeRef is FirErrorTypeRef && resolvedTypeRef.diagnostic is FirStubDiagnostic) { + if (resolvedTypeRef is FirErrorTypeRef && resolvedTypeRef.diagnostic is ConeStubDiagnostic) { return } val psi = resolvedTypeRef.psi!! diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt index 3d0ee775a76..08a695a4c24 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirIdeDiagnosticsCollector.kt @@ -8,7 +8,7 @@ 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.ConeDiagnostic +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.psi.KtElement @@ -20,7 +20,7 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState: } private inner class Reporter : DiagnosticReporter() { - override fun report(diagnostic: ConeDiagnostic?) { + override fun report(diagnostic: FirDiagnostic?) { if (diagnostic == null) return val psi = diagnostic.source.psi as? KtElement ?: return resolveState.record(psi, diagnostic.diagnostic) @@ -34,7 +34,7 @@ class FirIdeDiagnosticsCollector(session: FirSession, private val resolveState: reporter = Reporter() } - override fun getCollectedDiagnostics(): Iterable { + override fun getCollectedDiagnostics(): Iterable { // Not necessary in IDE return emptyList() } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt index f769d1ff94b..e6400ceabe6 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/fir/FirModuleResolveState.kt @@ -11,7 +11,7 @@ import com.intellij.psi.PsiElementVisitor 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.ConeDiagnostic +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnostic import org.jetbrains.kotlin.fir.declarations.FirFile import org.jetbrains.kotlin.fir.java.FirProjectSessionProvider import org.jetbrains.kotlin.fir.psi @@ -49,7 +49,7 @@ interface FirModuleResolveState { fun record(psi: KtElement, diagnostic: Diagnostic) - fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable = emptyList()) + fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable = emptyList()) } class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionProvider) : FirModuleResolveState { @@ -91,7 +91,7 @@ class FirModuleResolveStateImpl(override val sessionProvider: FirProjectSessionP list += diagnostic } - override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable) { + override fun setDiagnosticsForFile(file: KtFile, fir: FirFile, diagnostics: Iterable) { for (diagnostic in diagnostics) { (diagnostic.source.psi as? KtElement)?.let { record(it, diagnostic.diagnostic) } }