[FIR] Make FirErrorConstructor a FirDiagnosticHolder

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/file/structure/FileStructureElement.kt

@@ -18,7 +18,6 @@ import org.jetbrains.kotlin.analysis.low.level.api.fir.util.isScriptStatement
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.correspondingProperty
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirErrorConstructor
 import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCodeFragmentSymbol
@@ -261,13 +260,16 @@ internal class NonReanalyzableClassDeclarationStructureElement(
 
         override fun visitConstructor(constructor: FirConstructor, data: MutableMap<KtElement, FirElement>) {
             if (
-                (constructor is FirPrimaryConstructor || constructor is FirErrorConstructor) &&
+                (constructor is FirPrimaryConstructor || constructor is FirErrorPrimaryConstructor) &&
                 constructor.source?.kind == KtFakeSourceElementKind.ImplicitConstructor
             ) {
                 NonReanalyzableNonClassDeclarationStructureElement.Recorder.visitConstructor(constructor, data)
             }
         }
 
+        override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: MutableMap<KtElement, FirElement>) =
+            visitConstructor(errorPrimaryConstructor, data)
+
         override fun visitAnonymousInitializer(anonymousInitializer: FirAnonymousInitializer, data: MutableMap<KtElement, FirElement>) {
         }
 

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/lazy/resolve/FirLazyBodiesCalculator.kt

@@ -448,6 +448,9 @@ private abstract class FirLazyBodiesCalculatorTransformer : FirTransformer<Persi
         return constructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: PersistentList<FirRegularClass>) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformProperty(property: FirProperty, data: PersistentList<FirRegularClass>): FirProperty {
         if (needCalculatingLazyBodyForProperty(property)) {
             val designation = FirDesignation(data, property)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirCommonConstructorDelegationIssuesChecker.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
@@ -34,7 +35,7 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
 
         for (it in declaration.declarations) {
             if (it is FirConstructor) {
-                if (!it.isPrimary) {
+                if (!it.isPrimary || it is FirErrorPrimaryConstructor) {
                     otherConstructors += it
 
                     it.findCycle(cyclicConstructors)?.let { visited ->
@@ -81,7 +82,7 @@ object FirCommonConstructorDelegationIssuesChecker : FirRegularClassChecker() {
         var it = this
         var delegated = this.getDelegated()
 
-        while (!it.isPrimary && delegated != null) {
+        while (!(it.isPrimary && it !is FirErrorPrimaryConstructor) && delegated != null) {
             if (delegated in visitedConstructors || delegated in knownCyclicConstructors) {
                 return visitedConstructors
             }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirPrimaryConstructorSuperTypeChecker.kt

@@ -14,9 +14,11 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirRegularClass
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny
+import org.jetbrains.kotlin.fir.symbols.SymbolInternals
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitAnyTypeRef
@@ -41,7 +43,8 @@ object FirPrimaryConstructorSuperTypeChecker : FirClassChecker() {
 
         val primaryConstructorSymbol = declaration.primaryConstructorIfAny(context.session)
 
-        if (primaryConstructorSymbol == null) {
+        @OptIn(SymbolInternals::class)
+        if (primaryConstructorSymbol == null || primaryConstructorSymbol.fir is FirErrorPrimaryConstructor) {
             checkSupertypeInitializedWithoutPrimaryConstructor(declaration, reporter, context)
         } else {
             checkSuperTypeNotInitialized(primaryConstructorSymbol, declaration, context, reporter)

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/DeclarationCheckersDiagnosticComponent.kt

@@ -59,6 +59,10 @@ class DeclarationCheckersDiagnosticComponent(
         checkers.allConstructorCheckers.check(constructor, data)
     }
 
+    override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: CheckerContext) {
+        checkers.allConstructorCheckers.check(errorPrimaryConstructor, data)
+    }
+
     override fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: CheckerContext) {
         checkers.allAnonymousFunctionCheckers.check(anonymousFunction, data)
     }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt

@@ -126,6 +126,10 @@ class ErrorNodeDiagnosticCollectorComponent(
         reportFirDiagnostic(errorImport.diagnostic, source, data)
     }
 
+    override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: CheckerContext) {
+        reportFirDiagnostic(errorPrimaryConstructor.diagnostic, errorPrimaryConstructor.source, data)
+    }
+
     private fun reportFirDiagnostic(
         diagnostic: ConeDiagnostic,
         source: KtSourceElement?,

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JvmSupertypeUpdater.kt

@@ -9,10 +9,7 @@ import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirElement
 import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.hasAnnotationSafe
 import org.jetbrains.kotlin.fir.declarations.utils.isData
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
 import org.jetbrains.kotlin.fir.expressions.FirStatement
@@ -79,6 +76,9 @@ class JvmSupertypeUpdater(private val session: FirSession) : PlatformSupertypeUp
             return constructor.transformDelegatedConstructor(this, data)
         }
 
+        override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ScopeSession) =
+            transformConstructor(errorPrimaryConstructor, data)
+
         override fun transformDelegatedConstructorCall(
             delegatedConstructorCall: FirDelegatedConstructorCall,
             data: ScopeSession

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

@@ -968,7 +968,13 @@ class LightTreeRawFirDeclarationBuilder(
             isFromEnumClass = classWrapper.isEnum()
         }
 
-        val builder = if (isErrorConstructor) FirErrorConstructorBuilder() else FirPrimaryConstructorBuilder()
+        val builder = if (isErrorConstructor) {
+            FirErrorConstructorBuilder().apply {
+                diagnostic = ConeNoConstructorError
+            }
+        } else {
+            FirPrimaryConstructorBuilder()
+        }
         builder.apply {
             source = primaryConstructor?.toFirSourceElement()
                 ?: selfTypeSource?.fakeElement(KtFakeSourceElementKind.ImplicitConstructor)

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/PsiRawFirBuilder.kt

@@ -1059,7 +1059,13 @@ open class PsiRawFirBuilder(
                 isFromSealedClass = owner.hasModifier(SEALED_KEYWORD) && explicitVisibility !== Visibilities.Private
                 isFromEnumClass = owner.hasModifier(ENUM_KEYWORD)
             }
-            val builder = if (isErrorConstructor) FirErrorConstructorBuilder() else FirPrimaryConstructorBuilder()
+            val builder = if (isErrorConstructor) {
+                FirErrorConstructorBuilder().apply {
+                    diagnostic = ConeNoConstructorError
+                }
+            } else {
+                FirPrimaryConstructorBuilder()
+            }
             builder.apply {
                 source = constructorSource
                 moduleData = baseModuleData

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

@@ -285,6 +285,9 @@ abstract class AbstractRawFirBuilder<T>(val baseSession: FirSession, val context
         }
     }
 
+    fun createErrorConstructorBuilder(diagnostic: ConeDiagnostic) =
+        FirErrorPrimaryConstructorBuilder().apply { this.diagnostic = diagnostic }
+
     fun FirLoopBuilder.prepareTarget(firLabelUser: Any): FirLoopTarget = prepareTarget(context.getLastLabel(firLabelUser))
 
     fun FirLoopBuilder.prepareTarget(label: FirLabel?): FirLoopTarget {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -12,10 +12,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.hasExplicitBackingField
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.declarations.utils.isInterface
 import org.jetbrains.kotlin.fir.declarations.utils.isReferredViaField
-import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.*
-import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
-import org.jetbrains.kotlin.fir.diagnostics.ConeStubDiagnostic
-import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.buildArgumentList
 import org.jetbrains.kotlin.fir.expressions.builder.buildResolvedReifiedParameterReference

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolveTransformer.kt

@@ -418,6 +418,9 @@ abstract class AbstractFirStatusResolveTransformer(
         return transformDeclaration(constructor, data) as FirStatement
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: FirResolvedDeclarationStatus?) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformSimpleFunction(
         simpleFunction: FirSimpleFunction,
         data: FirResolvedDeclarationStatus?,

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirTypeResolveTransformer.kt

@@ -160,6 +160,9 @@ open class FirTypeResolveTransformer(
         }
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Any?) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformTypeAlias(typeAlias: FirTypeAlias, data: Any?): FirTypeAlias = whileAnalysing(session, typeAlias) {
         withScopeCleanup {
             addTypeParametersScope(typeAlias)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirAbstractBodyResolveTransformerDispatcher.kt

@@ -363,6 +363,10 @@ abstract class FirAbstractBodyResolveTransformerDispatcher(
         return declarationsTransformer?.transformConstructor(constructor, data) ?: constructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ResolutionMode): FirStatement {
+        return declarationsTransformer?.transformErrorPrimaryConstructor(errorPrimaryConstructor, data) ?: errorPrimaryConstructor
+    }
+
     override fun transformAnonymousInitializer(
         anonymousInitializer: FirAnonymousInitializer,
         data: ResolutionMode

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/body/resolve/FirDeclarationsResolveTransformer.kt

@@ -689,6 +689,9 @@ open class FirDeclarationsResolveTransformer(
             return doTransformConstructor(constructor, data)
         }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ResolutionMode) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     private fun doTransformConstructor(constructor: FirConstructor, data: ResolutionMode): FirConstructor {
         val owningClass = context.containerIfAny as? FirRegularClass
 

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/contracts/FirAbstractContractResolveTransformerDispatcher.kt

@@ -300,6 +300,9 @@ abstract class FirAbstractContractResolveTransformerDispatcher(
             }
         }
 
+        override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ResolutionMode) =
+            transformConstructor(errorPrimaryConstructor, data)
+
         override fun transformEnumEntry(enumEntry: FirEnumEntry, data: ResolutionMode): FirEnumEntry {
             return enumEntry
         }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/mpp/FirExpectActualMatcherTransformer.kt

@@ -70,6 +70,9 @@ open class FirExpectActualMatcherTransformer(
         return constructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Nothing?) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformSimpleFunction(simpleFunction: FirSimpleFunction, data: Nothing?): FirStatement {
         transformMemberDeclaration(simpleFunction)
         return simpleFunction

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/AbstractFirSpecificAnnotationResolveTransformer.kt

@@ -480,6 +480,9 @@ abstract class AbstractFirSpecificAnnotationResolveTransformer(
         } as FirConstructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Nothing?) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformEnumEntry(enumEntry: FirEnumEntry, data: Nothing?): FirStatement {
         return transformCallableDeclarationForDeprecations(enumEntry, data)
     }

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsMappingTransformer.kt

@@ -148,6 +148,9 @@ private class FirDeclarationsResolveTransformerForAnnotationArgumentsMapping(
         return constructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ResolutionMode) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
         context.withValueParameter(valueParameter, session) {
             valueParameter

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/plugin/FirAnnotationArgumentsResolveTransformer.kt

@@ -103,6 +103,9 @@ private class FirDeclarationsResolveTransformerForArgumentAnnotations(
         return constructor
     }
 
+    override fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: ResolutionMode) =
+        transformConstructor(errorPrimaryConstructor, data)
+
     override fun transformValueParameter(valueParameter: FirValueParameter, data: ResolutionMode): FirStatement {
         valueParameter
             .transformAnnotations(transformer, data)

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/diagnostics/ConeDiagnostics.kt

@@ -82,10 +82,6 @@ class ConeFunctionExpectedError(val expression: String, val type: ConeKotlinType
     override val reason: String get() = "Expression '$expression' of type '$type' cannot be invoked as a function"
 }
 
-object ConeNoConstructorError : ConeDiagnostic {
-    override val reason: String get() = "This type does not have a constructor"
-}
-
 class ConeResolutionToClassifierError(
     override val candidate: AbstractCandidate,
     override val candidateSymbol: FirRegularClassSymbol

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirErrorPrimaryConstructor.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2010-2023 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.declarations
+
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.contracts.FirContractDescription
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
+import org.jetbrains.kotlin.fir.diagnostics.FirDiagnosticHolder
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
+import org.jetbrains.kotlin.fir.references.FirControlFlowGraphReference
+import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
+import org.jetbrains.kotlin.fir.types.ConeSimpleKotlinType
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.serialization.deserialization.descriptors.DeserializedContainerSource
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+abstract class FirErrorPrimaryConstructor : FirConstructor(), FirDiagnosticHolder {
+    abstract override val source: KtSourceElement?
+    abstract override val moduleData: FirModuleData
+    abstract override val origin: FirDeclarationOrigin
+    abstract override val attributes: FirDeclarationAttributes
+    abstract override val typeParameters: List<FirTypeParameterRef>
+    abstract override val status: FirDeclarationStatus
+    abstract override val returnTypeRef: FirTypeRef
+    abstract override val receiverParameter: FirReceiverParameter?
+    abstract override val deprecationsProvider: DeprecationsProvider
+    abstract override val containerSource: DeserializedContainerSource?
+    abstract override val dispatchReceiverType: ConeSimpleKotlinType?
+    abstract override val contextReceivers: List<FirContextReceiver>
+    abstract override val controlFlowGraphReference: FirControlFlowGraphReference?
+    abstract override val valueParameters: List<FirValueParameter>
+    abstract override val contractDescription: FirContractDescription
+    abstract override val annotations: List<FirAnnotation>
+    abstract override val symbol: FirConstructorSymbol
+    abstract override val delegatedConstructor: FirDelegatedConstructorCall?
+    abstract override val body: FirBlock?
+    abstract override val isPrimary: Boolean
+    abstract override val diagnostic: ConeDiagnostic
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitErrorPrimaryConstructor(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
+        transformer.transformErrorPrimaryConstructor(this, data) as E
+
+    abstract override fun replaceStatus(newStatus: FirDeclarationStatus)
+
+    abstract override fun replaceReturnTypeRef(newReturnTypeRef: FirTypeRef)
+
+    abstract override fun replaceReceiverParameter(newReceiverParameter: FirReceiverParameter?)
+
+    abstract override fun replaceDeprecationsProvider(newDeprecationsProvider: DeprecationsProvider)
+
+    abstract override fun replaceContextReceivers(newContextReceivers: List<FirContextReceiver>)
+
+    abstract override fun replaceControlFlowGraphReference(newControlFlowGraphReference: FirControlFlowGraphReference?)
+
+    abstract override fun replaceValueParameters(newValueParameters: List<FirValueParameter>)
+
+    abstract override fun replaceContractDescription(newContractDescription: FirContractDescription)
+
+    abstract override fun replaceAnnotations(newAnnotations: List<FirAnnotation>)
+
+    abstract override fun replaceDelegatedConstructor(newDelegatedConstructor: FirDelegatedConstructorCall?)
+
+    abstract override fun replaceBody(newBody: FirBlock?)
+
+    abstract override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformReceiverParameter(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformDelegatedConstructor(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+
+    abstract override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructor
+}

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/builder/FirErrorPrimaryConstructorBuilder.kt

@@ -17,11 +17,11 @@ import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.contracts.impl.FirEmptyContractDescription
 import org.jetbrains.kotlin.fir.declarations.DeprecationsProvider
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirResolveState
@@ -31,7 +31,8 @@ import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
 import org.jetbrains.kotlin.fir.declarations.UnresolvedDeprecationProvider
 import org.jetbrains.kotlin.fir.declarations.asResolveState
 import org.jetbrains.kotlin.fir.declarations.builder.FirAbstractConstructorBuilder
-import org.jetbrains.kotlin.fir.declarations.impl.FirErrorConstructor
+import org.jetbrains.kotlin.fir.declarations.impl.FirErrorPrimaryConstructorImpl
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
@@ -48,7 +49,7 @@ import org.jetbrains.kotlin.serialization.deserialization.descriptors.Deserializ
  */
 
 @FirBuilderDsl
-class FirErrorConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationContainerBuilder {
+class FirErrorPrimaryConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationContainerBuilder {
     override var source: KtSourceElement? = null
     override var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
     override lateinit var moduleData: FirModuleData
@@ -68,10 +69,11 @@ class FirErrorConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationC
     override lateinit var symbol: FirConstructorSymbol
     override var delegatedConstructor: FirDelegatedConstructorCall? = null
     override var body: FirBlock? = null
+    lateinit var diagnostic: ConeDiagnostic
 
     @OptIn(FirImplementationDetail::class)
-    override fun build(): FirConstructor {
+    override fun build(): FirErrorPrimaryConstructor {
-        return FirErrorConstructor(
+        return FirErrorPrimaryConstructorImpl(
             source,
             resolvePhase,
             moduleData,
@@ -91,11 +93,12 @@ class FirErrorConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationC
             symbol,
             delegatedConstructor,
             body,
+            diagnostic,
         )
     }
 
 
-    @Deprecated("Modification of 'controlFlowGraphReference' has no impact for FirErrorConstructorBuilder", level = DeprecationLevel.HIDDEN)
+    @Deprecated("Modification of 'controlFlowGraphReference' has no impact for FirErrorPrimaryConstructorBuilder", level = DeprecationLevel.HIDDEN)
     override var controlFlowGraphReference: FirControlFlowGraphReference?
         get() = throw IllegalStateException()
         set(_) {
@@ -104,9 +107,9 @@ class FirErrorConstructorBuilder : FirAbstractConstructorBuilder, FirAnnotationC
 }
 
 @OptIn(ExperimentalContracts::class)
-inline fun buildErrorConstructor(init: FirErrorConstructorBuilder.() -> Unit): FirConstructor {
+inline fun buildErrorPrimaryConstructor(init: FirErrorPrimaryConstructorBuilder.() -> Unit): FirErrorPrimaryConstructor {
     contract {
         callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
     }
-    return FirErrorConstructorBuilder().apply(init).build()
+    return FirErrorPrimaryConstructorBuilder().apply(init).build()
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/impl/FirErrorPrimaryConstructorImpl.kt

@@ -12,17 +12,18 @@ import org.jetbrains.kotlin.fir.FirImplementationDetail
 import org.jetbrains.kotlin.fir.FirModuleData
 import org.jetbrains.kotlin.fir.contracts.FirContractDescription
 import org.jetbrains.kotlin.fir.declarations.DeprecationsProvider
-import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirContextReceiver
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirReceiverParameter
 import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
 import org.jetbrains.kotlin.fir.declarations.FirResolveState
 import org.jetbrains.kotlin.fir.declarations.FirTypeParameterRef
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.declarations.asResolveState
+import org.jetbrains.kotlin.fir.diagnostics.ConeDiagnostic
 import org.jetbrains.kotlin.fir.expressions.FirAnnotation
 import org.jetbrains.kotlin.fir.expressions.FirBlock
 import org.jetbrains.kotlin.fir.expressions.FirDelegatedConstructorCall
@@ -41,7 +42,7 @@ import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
  * DO NOT MODIFY IT MANUALLY
  */
 
-class FirErrorConstructor @FirImplementationDetail constructor(
+class FirErrorPrimaryConstructorImpl @FirImplementationDetail constructor(
     override val source: KtSourceElement?,
     resolvePhase: FirResolvePhase,
     override val moduleData: FirModuleData,
@@ -61,9 +62,10 @@ class FirErrorConstructor @FirImplementationDetail constructor(
     override val symbol: FirConstructorSymbol,
     override var delegatedConstructor: FirDelegatedConstructorCall?,
     override var body: FirBlock?,
-) : FirConstructor() {
+    override val diagnostic: ConeDiagnostic,
+) : FirErrorPrimaryConstructor() {
     override var controlFlowGraphReference: FirControlFlowGraphReference? = null
-    override val isPrimary: Boolean get() = false
+    override val isPrimary: Boolean get() = true
 
     init {
         symbol.bind(this)
@@ -85,7 +87,7 @@ class FirErrorConstructor @FirImplementationDetail constructor(
         body?.accept(visitor, data)
     }
 
-    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         transformTypeParameters(transformer, data)
         transformStatus(transformer, data)
         transformReturnTypeRef(transformer, data)
@@ -100,47 +102,47 @@ class FirErrorConstructor @FirImplementationDetail constructor(
         return this
     }
 
-    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformTypeParameters(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         typeParameters.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformStatus(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         status = status.transform(transformer, data)
         return this
     }
 
-    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformReturnTypeRef(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         returnTypeRef = returnTypeRef.transform(transformer, data)
         return this
     }
 
-    override fun <D> transformReceiverParameter(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformReceiverParameter(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         receiverParameter = receiverParameter?.transform(transformer, data)
         return this
     }
 
-    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformValueParameters(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         valueParameters.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformContractDescription(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         contractDescription = contractDescription.transform(transformer, data)
         return this
     }
 
-    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         annotations.transformInplace(transformer, data)
         return this
     }
 
-    override fun <D> transformDelegatedConstructor(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformDelegatedConstructor(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         delegatedConstructor = delegatedConstructor?.transform(transformer, data)
         return this
     }
 
-    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorConstructor {
+    override fun <D> transformBody(transformer: FirTransformer<D>, data: D): FirErrorPrimaryConstructorImpl {
         body = body?.transform(transformer, data)
         return this
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitor.kt

@@ -100,6 +100,7 @@ import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirDefaultVisitorVoid.kt

@@ -100,6 +100,7 @@ import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirTransformer.kt

@@ -100,6 +100,7 @@ import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
@@ -546,6 +547,10 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformElement(errorProperty, data)
     }
 
+    open fun transformErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): FirStatement {
+        return transformElement(errorPrimaryConstructor, data)
+    }
+
     open fun transformDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): FirDanglingModifierList {
         return transformElement(danglingModifierList, data)
     }
@@ -1166,6 +1171,10 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
         return transformErrorProperty(errorProperty, data)
     }
 
+    final override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): FirStatement {
+        return transformErrorPrimaryConstructor(errorPrimaryConstructor, data)
+    }
+
     final override fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): FirDanglingModifierList {
         return transformDanglingModifierList(danglingModifierList, data)
     }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitor.kt

@@ -100,6 +100,7 @@ import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
@@ -357,6 +358,8 @@ abstract class FirVisitor<out R, in D> {
 
     open fun visitErrorProperty(errorProperty: FirErrorProperty, data: D): R  = visitElement(errorProperty, data)
 
+    open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: D): R  = visitElement(errorPrimaryConstructor, data)
+
     open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: D): R  = visitElement(danglingModifierList, data)
 
     open fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: D): R  = visitElement(qualifiedAccessExpression, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/visitors/FirVisitorVoid.kt

@@ -100,6 +100,7 @@ import org.jetbrains.kotlin.fir.expressions.FirClassReferenceExpression
 import org.jetbrains.kotlin.fir.expressions.FirErrorExpression
 import org.jetbrains.kotlin.fir.declarations.FirErrorFunction
 import org.jetbrains.kotlin.fir.declarations.FirErrorProperty
+import org.jetbrains.kotlin.fir.declarations.FirErrorPrimaryConstructor
 import org.jetbrains.kotlin.fir.declarations.FirDanglingModifierList
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
 import org.jetbrains.kotlin.fir.expressions.FirQualifiedErrorAccessExpression
@@ -545,6 +546,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitElement(errorProperty)
     }
 
+    open fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) {
+        visitElement(errorPrimaryConstructor)
+    }
+
     open fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList) {
         visitElement(danglingModifierList)
     }
@@ -1165,6 +1170,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
         visitErrorProperty(errorProperty)
     }
 
+    final override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor, data: Nothing?) {
+        visitErrorPrimaryConstructor(errorPrimaryConstructor)
+    }
+
     final override fun visitDanglingModifierList(danglingModifierList: FirDanglingModifierList, data: Nothing?) {
         visitDanglingModifierList(danglingModifierList)
     }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt

@@ -79,6 +79,10 @@ object ConeUnsupportedClassLiteralsWithEmptyLhs : ConeDiagnostic {
     override val reason: String get() = "No receiver in class literal"
 }
 
+object ConeNoConstructorError : ConeDiagnostic {
+    override val reason: String get() = "This type does not have a constructor"
+}
+
 enum class DiagnosticKind {
     ExpressionExpected,
     NotLoopLabel,

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirDeclarationRenderer.kt

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.fir.renderer
 
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.impl.FirErrorConstructor
 import org.jetbrains.kotlin.fir.isCatchParameter
 import org.jetbrains.kotlin.util.capitalizeDecapitalize.toLowerCaseAsciiOnly
 
@@ -26,7 +25,7 @@ open class FirDeclarationRenderer(
                 typeRenderer.render(it)
                 printer.print(".")
             }
-            if (declaration is FirErrorConstructor) {
+            if (declaration is FirErrorPrimaryConstructor) {
                 printer.print("error_")
             }
             printer.print("constructor")

compiler/fir/tree/src/org/jetbrains/kotlin/fir/renderer/FirRenderer.kt

@@ -399,6 +399,8 @@ class FirRenderer(
             bodyRenderer?.renderBody(body, listOfNotNull<FirStatement>(delegatedConstructor))
         }
 
+        override fun visitErrorPrimaryConstructor(errorPrimaryConstructor: FirErrorPrimaryConstructor) = visitConstructor(errorPrimaryConstructor)
+
         override fun visitPropertyAccessor(propertyAccessor: FirPropertyAccessor) {
             annotationRenderer?.render(propertyAccessor)
             modifierRenderer?.renderModifiers(propertyAccessor)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -93,7 +93,7 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             fields from functionCall
         }
 
-        for (constructorType in listOf("FirPrimaryConstructor", "FirConstructorImpl", "FirErrorConstructor")) {
+        for (constructorType in listOf("FirPrimaryConstructor", "FirConstructorImpl")) {
             builder(constructor, constructorType) {
                 parents += abstractConstructorBuilder
                 defaultNull("delegatedConstructor")
@@ -103,6 +103,14 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             }
         }
 
+        builder(errorPrimaryConstructor) {
+            parents += abstractConstructorBuilder
+            defaultNull("delegatedConstructor")
+            defaultNull("body")
+            default("contractDescription", "FirEmptyContractDescription")
+            useTypes(emptyContractDescriptionType)
+        }
+
         builder(constructor, "FirConstructorImpl") {
             openBuilder()
             withCopy()

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/FirTreeBuilder.kt

@@ -124,6 +124,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
     val errorExpression by element(Expression, expression, diagnosticHolder)
     val errorFunction by element(Declaration, function, diagnosticHolder)
     val errorProperty by element(Declaration, variable, diagnosticHolder)
+    val errorPrimaryConstructor by element(Declaration, constructor, diagnosticHolder)
     val danglingModifierList by element(Declaration, declaration, diagnosticHolder)
     val qualifiedAccessExpression by element(Expression, expression, resolvable, contextReceiverArgumentListOwner)
     val qualifiedErrorAccessExpression by element(Expression, expression, diagnosticHolder)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -26,9 +26,9 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             defaultTrue("isPrimary", withGetter = true)
         }
 
-        impl(constructor, "FirErrorConstructor") {
+        impl(errorPrimaryConstructor) {
             publicImplementation()
-            defaultFalse("isPrimary", withGetter = true)
+            defaultTrue("isPrimary", withGetter = true)
         }
 
         impl(outerClassTypeParameterRef) {