FIR LT: add syntax error reporting to LT2Fir

use it in the new pipeline

analysis/analysis-api-fir/analysis-api-fir-generator/src/org/jetbrains/kotlin/analysis/api/fir/generator/rendererrs/FirDiagnosticToKtDiagnosticConverterRenderer.kt

@@ -69,6 +69,7 @@ object FirDiagnosticToKtDiagnosticConverterRenderer : AbstractDiagnosticsDataCla
 
     override val defaultImports = listOf(
         "org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic",
+        "org.jetbrains.kotlin.fir.builder.FirSyntaxErrors",
         "org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors",
         "org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors",
     )

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.KtPsiSourceElement
 import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.jvm.FirJvmErrors
+import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
 import org.jetbrains.kotlin.fir.declarations.FirClass
 import org.jetbrains.kotlin.fir.declarations.FirDeclaration
@@ -93,12 +94,6 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
-    add(FirErrors.SYNTAX) { firDiagnostic ->
-        SyntaxImpl(
-            firDiagnostic as KtPsiDiagnostic,
-            token,
-        )
-    }
     add(FirErrors.OTHER_ERROR) { firDiagnostic ->
         OtherErrorImpl(
             firDiagnostic as KtPsiDiagnostic,

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -102,10 +102,6 @@ sealed class KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         abstract val error: String
     }
 
-    abstract class Syntax : KtFirDiagnostic<PsiElement>() {
-        override val diagnosticClass get() = Syntax::class
-    }
-
     abstract class OtherError : KtFirDiagnostic<PsiElement>() {
         override val diagnosticClass get() = OtherError::class
     }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -105,11 +105,6 @@ internal class NewInferenceErrorImpl(
     override val token: ValidityToken,
 ) : KtFirDiagnostic.NewInferenceError(), KtAbstractFirDiagnostic<PsiElement>
 
-internal class SyntaxImpl(
-    override val firDiagnostic: KtPsiDiagnostic,
-    override val token: ValidityToken,
-) : KtFirDiagnostic.Syntax(), KtAbstractFirDiagnostic<PsiElement>
-
 internal class OtherErrorImpl(
     override val firDiagnostic: KtPsiDiagnostic,
     override val token: ValidityToken,

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/pipeline/compilerPipeline.kt

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CodegenFactory
 import org.jetbrains.kotlin.codegen.state.GenerationState
 import org.jetbrains.kotlin.config.*
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.DependencyListForCliModule
 import org.jetbrains.kotlin.fir.FirSession
@@ -123,6 +124,7 @@ fun compileModulesUsingFrontendIrAndLightTree(
             compilerEnvironment,
             emptyList(),
             null,
+            diagnosticsReporter
         )
         // TODO: consider what to do if many modules has main classes
         if (mainClassFqName == null && moduleConfiguration.get(JVMConfigurationKeys.OUTPUT_JAR) != null) {
@@ -224,6 +226,7 @@ fun compileModuleToAnalyzedFir(
     environment: ModuleCompilerEnvironment,
     previousStepsSymbolProviders: List<FirSymbolProvider>,
     incrementalExcludesScope: AbstractProjectFileSearchScope?,
+    diagnosticsReporter: DiagnosticReporter
 ): ModuleCompilerAnalyzedOutput {
     var sourcesScope = environment.projectEnvironment.getSearchScopeByIoFiles(input.platformSources) //!!
     val sessionProvider = FirProjectSessionProvider()
@@ -270,8 +273,8 @@ fun compileModuleToAnalyzedFir(
     }
 
     // raw fir
-    val commonRawFir = commonSession?.buildFirViaLightTree(input.commonSources)
+    val commonRawFir = commonSession?.buildFirViaLightTree(input.commonSources, diagnosticsReporter)
-    val rawFir = session.buildFirViaLightTree(input.platformSources)
+    val rawFir = session.buildFirViaLightTree(input.platformSources, diagnosticsReporter)
 
     // resolution
     commonSession?.apply {

compiler/fir/checkers/build.gradle.kts

@@ -8,6 +8,7 @@ plugins {
 dependencies {
     api(project(":compiler:fir:providers"))
     api(project(":compiler:fir:semantics"))
+    api(project(":compiler:fir:raw-fir:raw-fir.common"))
     implementation(project(":compiler:frontend.common"))
     implementation(project(":compiler:frontend.common-psi"))
     implementation(project(":compiler:psi"))

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -52,7 +52,6 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
     }
 
     val Miscellaneous by object : DiagnosticGroup("Miscellaneous") {
-        val SYNTAX by error<PsiElement>()
         val OTHER_ERROR by error<PsiElement>()
     }
 

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -111,7 +111,6 @@ object FirErrors {
     val NEW_INFERENCE_ERROR by error1<PsiElement, String>()
 
     // Miscellaneous
-    val SYNTAX by error0<PsiElement>()
     val OTHER_ERROR by error0<PsiElement>()
 
     // General syntax

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrorsDefaultMessages.kt

@@ -473,7 +473,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_NOT_INI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_IS_NOT_AN_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_NOT_AVAILABLE
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TAILREC_ON_VIRTUAL_MEMBER_ERROR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TAIL_RECURSION_IN_TRY_IS_NOT_SUPPORTED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.THROWABLE_TYPE_MISMATCH
@@ -586,7 +585,6 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
         map.put(NEW_INFERENCE_ERROR, "New inference error [{0}]", STRING)
 
         // Miscellaneous
-        map.put(SYNTAX, "Syntax error")
         map.put(OTHER_ERROR, "Unknown (other) error")
 
         // General syntax

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember
 import org.jetbrains.kotlin.fir.analysis.getChild
+import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors
 import org.jetbrains.kotlin.fir.declarations.utils.isInfix
 import org.jetbrains.kotlin.fir.declarations.utils.isOperator
 import org.jetbrains.kotlin.fir.diagnostics.*
@@ -386,7 +387,7 @@ private val NewConstraintError.upperConeType: ConeKotlinType get() = upperType a
 private fun ConeSimpleDiagnostic.getFactory(source: KtSourceElement): KtDiagnosticFactory0 {
     @Suppress("UNCHECKED_CAST")
     return when (kind) {
-        DiagnosticKind.Syntax -> FirErrors.SYNTAX
+        DiagnosticKind.Syntax -> FirSyntaxErrors.SYNTAX
         DiagnosticKind.ReturnNotAllowed -> FirErrors.RETURN_NOT_ALLOWED
         DiagnosticKind.NotAFunctionLabel -> FirErrors.NOT_A_FUNCTION_LABEL
         DiagnosticKind.UnresolvedLabel -> FirErrors.UNRESOLVED_LABEL

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/pipeline/buildFir.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.pipeline
 
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
@@ -16,10 +17,10 @@ import org.jetbrains.kotlin.fir.session.sourcesToPathsMapper
 import org.jetbrains.kotlin.psi.KtFile
 import java.io.File
 
-fun FirSession.buildFirViaLightTree(files: Collection<File>): List<FirFile> {
+fun FirSession.buildFirViaLightTree(files: Collection<File>, diagnosticsReporter: DiagnosticReporter? = null): List<FirFile> {
     val firProvider = (firProvider as FirProviderImpl)
     val sourcesToPathsMapper = sourcesToPathsMapper
-    val builder = LightTree2Fir(this, firProvider.kotlinScopeProvider)
+    val builder = LightTree2Fir(this, firProvider.kotlinScopeProvider, diagnosticsReporter)
     return files.map {
         builder.buildFirFile(it).also { firFile ->
             firProvider.recordFile(firFile)

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/FirResolveModularizedTotalKotlinTest.kt

@@ -17,9 +17,9 @@ import org.jetbrains.kotlin.asJava.finder.JavaElementFinder
 import org.jetbrains.kotlin.cli.common.toBooleanLenient
 import org.jetbrains.kotlin.cli.jvm.compiler.*
 import org.jetbrains.kotlin.config.languageVersionSettings
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollector
 import org.jetbrains.kotlin.fir.analysis.collectors.FirDiagnosticsCollector
-import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
 import org.jetbrains.kotlin.fir.builder.PsiHandlingMode
 import org.jetbrains.kotlin.fir.builder.RawFirBuilder
 import org.jetbrains.kotlin.fir.declarations.FirFile
@@ -149,7 +149,7 @@ class FirResolveModularizedTotalKotlinTest : AbstractModularizedTest() {
         val firProvider = session.firProvider as FirProviderImpl
 
         val firFiles = if (USE_LIGHT_TREE) {
-            val lightTree2Fir = LightTree2Fir(session, firProvider.kotlinScopeProvider)
+            val lightTree2Fir = LightTree2Fir(session, firProvider.kotlinScopeProvider, diagnosticsReporter = null)
 
             val allSourceFiles = moduleData.sources.flatMap {
                 if (it.isDirectory) {

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/LightTree2Fir.kt

@@ -10,8 +10,13 @@ import com.intellij.lang.impl.PsiBuilderFactoryImpl
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.util.diff.FlyweightCapableTreeStructure
+import org.jetbrains.kotlin.config.LanguageVersionSettings
+import org.jetbrains.kotlin.diagnostics.DiagnosticContext
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.KtDiagnostic
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.FirFile
+import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.lightTree.converter.DeclarationsConverter
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
 import org.jetbrains.kotlin.lexer.KotlinLexer
@@ -22,7 +27,8 @@ import java.nio.file.Path
 
 class LightTree2Fir(
     val session: FirSession,
-    private val scopeProvider: FirScopeProvider
+    private val scopeProvider: FirScopeProvider,
+    private val diagnosticsReporter: DiagnosticReporter? = null
 ) {
     companion object {
         private val parserDefinition = KotlinParserDefinition()
@@ -66,9 +72,18 @@ class LightTree2Fir(
     fun buildFirFile(code: String, fileName: String, path: String?): FirFile {
         val lightTree = buildLightTree(code)
 
-        return DeclarationsConverter(session, scopeProvider, lightTree)
+        return DeclarationsConverter(
-            .convertFile(lightTree.root, fileName, path)
+            session, scopeProvider, lightTree, diagnosticsReporter = diagnosticsReporter,
+            diagnosticContext = makeDiagnosticContext(path)
+        ).convertFile(lightTree.root, fileName, path)
     }
+
+    private fun makeDiagnosticContext(path: String?) =
+        if (diagnosticsReporter == null) null else object : DiagnosticContext {
+            override val containingFilePath = path
+            override val languageVersionSettings: LanguageVersionSettings get() = session.languageVersionSettings
+            override fun isDiagnosticSuppressed(diagnostic: KtDiagnostic): Boolean = false
+        }
 }
 
 data class LightTreeFile(

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/BaseConverter.kt

@@ -10,9 +10,8 @@ import com.intellij.openapi.util.Ref
 import com.intellij.psi.TokenType
 import com.intellij.psi.tree.IElementType
 import com.intellij.util.diff.FlyweightCapableTreeStructure
-import org.jetbrains.kotlin.ElementTypeUtils.isExpression
-import org.jetbrains.kotlin.KtNodeTypes
 import org.jetbrains.kotlin.*
+import org.jetbrains.kotlin.ElementTypeUtils.isExpression
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.builder.BaseFirBuilder
 import org.jetbrains.kotlin.fir.builder.Context
@@ -32,6 +31,8 @@ abstract class BaseConverter(
 
     protected val implicitType = buildImplicitTypeRef()
 
+    protected open fun reportSyntaxError(node: LighterASTNode) {}
+
     override fun LighterASTNode.toFirSourceElement(kind: KtFakeSourceElementKind?): KtLightSourceElement {
         val startOffset = offset + tree.getStartOffset(this)
         val endOffset = offset + tree.getEndOffset(this)
@@ -183,6 +184,10 @@ abstract class BaseConverter(
             if (kid == null) break
             val tokenType = kid.tokenType
             if (COMMENTS.contains(tokenType) || tokenType == WHITE_SPACE || tokenType == SEMICOLON || tokenType in skipTokens) continue
+            if (tokenType == TokenType.ERROR_ELEMENT) {
+                reportSyntaxError(kid)
+                continue
+            }
             f(kid)
         }
     }
@@ -195,6 +200,10 @@ abstract class BaseConverter(
             if (kid == null) break
             val tokenType = kid.tokenType
             if (COMMENTS.contains(tokenType) || tokenType == WHITE_SPACE || tokenType == SEMICOLON) continue
+            if (tokenType == TokenType.ERROR_ELEMENT) {
+                reportSyntaxError(kid)
+                continue
+            }
             f(kid, container)
         }
 

compiler/fir/raw-fir/light-tree2fir/src/org/jetbrains/kotlin/fir/lightTree/converter/DeclarationsConverter.kt

@@ -19,6 +19,9 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*
+import org.jetbrains.kotlin.diagnostics.DiagnosticContext
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.builder.*
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
@@ -59,7 +62,9 @@ class DeclarationsConverter(
     private val baseScopeProvider: FirScopeProvider,
     tree: FlyweightCapableTreeStructure<LighterASTNode>,
     @set:PrivateForInline override var offset: Int = 0,
-    context: Context<LighterASTNode> = Context()
+    context: Context<LighterASTNode> = Context(),
+    private val diagnosticsReporter: DiagnosticReporter? = null,
+    private val diagnosticContext: DiagnosticContext? = null
 ) : BaseConverter(session, tree, context) {
 
     @OptIn(PrivateForInline::class)
@@ -75,6 +80,10 @@ class DeclarationsConverter(
 
     private val expressionConverter = ExpressionsConverter(session, tree, this, context)
 
+    override fun reportSyntaxError(node: LighterASTNode) {
+        diagnosticsReporter?.reportOn(node.toFirSourceElement(), FirSyntaxErrors.SYNTAX, diagnosticContext!!)
+    }
+
     /**
      * [org.jetbrains.kotlin.parsing.KotlinParsing.parseFile]
      * [org.jetbrains.kotlin.parsing.KotlinParsing.parsePreamble]
@@ -1694,7 +1703,8 @@ class DeclarationsConverter(
 
         val blockTree = LightTree2Fir.buildLightTreeBlockExpression(block.asText)
         return DeclarationsConverter(
-            baseSession, baseScopeProvider, blockTree, offset = offset + tree.getStartOffset(block), context
+            baseSession, baseScopeProvider, blockTree, offset = offset + tree.getStartOffset(block), context,
+            diagnosticsReporter, diagnosticContext
         ).convertBlockExpression(blockTree.root)
     }
 

compiler/fir/raw-fir/light-tree2fir/tests/org/jetbrains/kotlin/fir/lightTree/AbstractLightTree2FirConverterTestCase.kt

@@ -20,7 +20,8 @@ abstract class AbstractLightTree2FirConverterTestCase : AbstractRawFirBuilderTes
     fun doTest(filePath: String) {
         val firFile = LightTree2Fir(
             session = FirSessionFactory.createEmptySession(),
-            scopeProvider = StubFirScopeProvider
+            scopeProvider = StubFirScopeProvider,
+            diagnosticsReporter = null
         ).buildFirFile(Paths.get(filePath))
         val firDump = firFile.render(mode = FirRenderer.RenderMode.WithDeclarationAttributes)
 

compiler/fir/raw-fir/light-tree2fir/tests/org/jetbrains/kotlin/fir/lightTree/TotalKotlinTest.kt

@@ -50,7 +50,8 @@ class TotalKotlinTest : AbstractRawFirBuilderTestCase() {
 
         val lightTreeConverter = LightTree2Fir(
             session = FirSessionFactory.createEmptySession(),
-            scopeProvider = StubFirScopeProvider
+            scopeProvider = StubFirScopeProvider,
+            diagnosticsReporter = null
         )
 
         if (onlyLightTree) println("LightTree generation") else println("Fir from LightTree converter")

compiler/fir/raw-fir/light-tree2fir/tests/org/jetbrains/kotlin/fir/lightTree/compare/TreesCompareTest.kt

@@ -57,7 +57,8 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     private fun compareAll() {
         val lightTreeConverter = LightTree2Fir(
             session = FirSessionFactory.createEmptySession(),
-            scopeProvider = StubFirScopeProvider
+            scopeProvider = StubFirScopeProvider,
+            diagnosticsReporter = null
         )
         compareBase(System.getProperty("user.dir"), withTestData = false) { file ->
             val text = FileUtil.loadFile(file, CharsetToolkit.UTF8, true).trim()
@@ -78,7 +79,8 @@ class TreesCompareTest : AbstractRawFirBuilderTestCase() {
     fun testCompareDiagnostics() {
         val lightTreeConverter = LightTree2Fir(
             session = FirSessionFactory.createEmptySession(),
-            scopeProvider = StubFirScopeProvider
+            scopeProvider = StubFirScopeProvider,
+            diagnosticsReporter = null
         )
         compareBase("compiler/testData/diagnostics/tests", withTestData = true) { file ->
             if (file.name.endsWith(".fir.kt")) {

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/FirSyntaxErrors.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.builder
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
+import org.jetbrains.kotlin.diagnostics.error0
+import org.jetbrains.kotlin.diagnostics.rendering.BaseDiagnosticRendererFactory
+import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory
+
+object FirSyntaxErrors {
+
+    val SYNTAX by error0<PsiElement>()
+
+    init {
+        RootDiagnosticRendererFactory.registerFactory(FirSyntaxErrorsDefaultMessages)
+    }
+}
+
+@Suppress("unused")
+object FirSyntaxErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
+
+    override val MAP = KtDiagnosticFactoryToRendererMap("FIR").also { map ->
+        map.put(FirSyntaxErrors.SYNTAX, "Syntax error")
+    }
+}

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -211,6 +211,7 @@ class IncrementalFirJvmCompilerRunner(
                             compilerEnvironment,
                             emptyList(),
                             incrementalExcludesScope,
+                            diagnosticsReporter
                         )
 
                     // TODO: consider what to do if many compilations find a main class

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/frontend/fir/handlers/FirDiagnosticsHandler.kt

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.diagnostics.*
 import org.jetbrains.kotlin.diagnostics.rendering.Renderers
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.builder.FirSyntaxErrors
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirProperty
@@ -90,7 +91,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
                     )
                 ) return@flatMap emptyList()
                 // SYNTAX errors will be reported later
-                if (diagnostic.factory == FirErrors.SYNTAX) return@flatMap emptyList()
+                if (diagnostic.factory == FirSyntaxErrors.SYNTAX) return@flatMap emptyList()
                 if (!diagnostic.isValid) return@flatMap emptyList()
                 diagnostic.toMetaInfos(
                     file,
@@ -114,7 +115,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
     ) {
         val metaInfos = if (firFile.psi != null) {
             AnalyzingUtils.getSyntaxErrorRanges(firFile.psi!!).flatMap {
-                FirErrors.SYNTAX.on(KtRealPsiSourceElement(it), positioningStrategy = null)
+                FirSyntaxErrors.SYNTAX.on(KtRealPsiSourceElement(it), positioningStrategy = null)
                     .toMetaInfos(
                         testFile,
                         globalMetadataInfoHandler1 = globalMetadataInfoHandler,
@@ -124,7 +125,7 @@ class FirDiagnosticsHandler(testServices: TestServices) : FirAnalysisHandler(tes
             }
         } else {
             collectLightTreeSyntaxErrors(firFile).flatMap { sourceElement ->
-                FirErrors.SYNTAX.on(sourceElement, positioningStrategy = null)
+                FirSyntaxErrors.SYNTAX.on(sourceElement, positioningStrategy = null)
                     .toMetaInfos(
                         testFile,
                         globalMetadataInfoHandler1 = globalMetadataInfoHandler,