[FIR] Add FirCodeFragment

2023-06-13 15:48:27 +09:00
parent 2760a25e2c
commit 33abe75a74
23 changed files with 320 additions and 5 deletions
@@ -159,7 +159,7 @@ object FirOptInUsageBaseChecker {
                fir.loadCallableSpecificExperimentalities(this, context, visited, fromSetter, dispatchReceiverType, result)
            is FirClassLikeDeclaration ->
                fir.loadClassLikeSpecificExperimentalities(this, context, visited, result)
-            is FirAnonymousInitializer, is FirDanglingModifierList, is FirFile, is FirTypeParameter, is FirScript -> {}
+            is FirAnonymousInitializer, is FirDanglingModifierList, is FirFile, is FirTypeParameter, is FirScript, is FirCodeFragment -> {}
        }

        fir.loadExperimentalitiesFromAnnotationTo(session, result, fromSupertype)
@@ -107,6 +107,10 @@ class DeclarationCheckersDiagnosticComponent(
        checkers.allBasicDeclarationCheckers.check(script, data)
    }

+    override fun visitCodeFragment(codeFragment: FirCodeFragment, data: CheckerContext) {
+        checkers.allBasicDeclarationCheckers.check(codeFragment, data)
+    }
+
    private fun <D : FirDeclaration> Collection<FirDeclarationChecker<D>>.check(
        declaration: D,
        context: CheckerContext
@@ -235,6 +235,17 @@ abstract class FirDataFlowAnalyzer(
        return graph
    }

+    // ----------------------------------- Code Fragment ------------------------------------------
+
+    fun enterCodeFragment(codeFragment: FirCodeFragment) {
+        graphBuilder.enterCodeFragment(codeFragment).mergeIncomingFlow()
+    }
+
+    fun exitCodeFragment(): ControlFlowGraph {
+        val (node, graph) = graphBuilder.exitCodeFragment()
+        node.mergeIncomingFlow()
+        return graph
+    }
    // ----------------------------------- Value parameters (and it's defaults) -----------------------------------

    fun enterValueParameter(valueParameter: FirValueParameter) {
@@ -547,6 +547,16 @@ class ControlFlowGraphBuilder {
        return exitGraph()
    }

+    fun enterCodeFragment(codeFragment: FirCodeFragment): CodeFragmentEnterNode {
+        return enterGraph(codeFragment, "CODE_FRAGMENT_GRAPH", ControlFlowGraph.Kind.Function) {
+            createCodeFragmentEnterNode(it) to createCodeFragmentExitNode(it)
+        }
+    }
+
+    fun exitCodeFragment(): Pair<CodeFragmentExitNode, ControlFlowGraph> {
+        return exitGraph()
+    }
+
    // ----------------------------------- Value parameters (and it's defaults) -----------------------------------

    fun enterValueParameter(valueParameter: FirValueParameter): Pair<EnterValueParameterNode, EnterDefaultArgumentsNode>? {
@@ -229,6 +229,12 @@ fun ControlFlowGraphBuilder.createScriptEnterNode(fir: FirScript): ScriptEnterNo
 fun ControlFlowGraphBuilder.createScriptExitNode(fir: FirScript): ScriptExitNode =
    ScriptExitNode(currentGraph, fir, levelCounter)

+fun ControlFlowGraphBuilder.createCodeFragmentEnterNode(fir: FirCodeFragment): CodeFragmentEnterNode =
+    CodeFragmentEnterNode(currentGraph, fir, levelCounter)
+
+fun ControlFlowGraphBuilder.createCodeFragmentExitNode(fir: FirCodeFragment): CodeFragmentExitNode =
+    CodeFragmentExitNode(currentGraph, fir, levelCounter)
+
 fun ControlFlowGraphBuilder.createClassEnterNode(fir: FirClass): ClassEnterNode =
    ClassEnterNode(currentGraph, fir, levelCounter)

@@ -7,16 +7,13 @@ package org.jetbrains.kotlin.fir.resolve.transformers.body.resolve

 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirSession
-import org.jetbrains.kotlin.fir.PrivateForInline
-import org.jetbrains.kotlin.fir.correspondingProperty
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDefaultPropertyAccessor
 import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.isInner
 import org.jetbrains.kotlin.fir.expressions.FirCallableReferenceAccess
 import org.jetbrains.kotlin.fir.expressions.FirWhenExpression
-import org.jetbrains.kotlin.fir.languageVersionSettings
 import org.jetbrains.kotlin.fir.resolve.*
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitExtensionReceiverValue
 import org.jetbrains.kotlin.fir.resolve.calls.ImplicitReceiverValue
@@ -532,6 +529,27 @@ class BodyResolveContext(
        }
    }

+    fun <T> withScopesForCodeFragment(codeFragment: FirCodeFragment, f: () -> T): T {
+        val towerDataContext = codeFragment.towerDataContext ?: error("Context is not set for a code fragment")
+        val base = towerDataContext.addNonLocalTowerDataElements(towerDataContext.nonLocalTowerDataElements)
+        val baseWithLocalScope = towerDataContext.localScopes.fold(base) { acc, scope -> acc.addLocalScope(scope) }
+
+        val newContext = FirRegularTowerDataContexts(
+            regular = baseWithLocalScope,
+            forClassHeaderAnnotations = baseWithLocalScope,
+            forNestedClasses = baseWithLocalScope,
+            forCompanionObject = baseWithLocalScope,
+            forConstructorHeaders = null,
+            forEnumEntries = null,
+            primaryConstructorPureParametersScope = null,
+            primaryConstructorAllParametersScope = null
+        )
+
+        return withTowerDataContexts(newContext) {
+            f()
+        }
+    }
+
    @OptIn(PrivateForInline::class)
    inline fun <T> withWhenSubjectType(
        subjectType: ConeKotlinType?,
@@ -64,6 +64,10 @@ abstract class FirAbstractBodyResolveTransformerDispatcher(
        return declarationsTransformer.transformScript(script, data)
    }

+    override fun transformCodeFragment(codeFragment: FirCodeFragment, data: ResolutionMode): FirCodeFragment {
+        return declarationsTransformer.transformCodeFragment(codeFragment, data)
+    }
+
    override fun <E : FirElement> transformElement(element: E, data: ResolutionMode): E {
        @Suppress("UNCHECKED_CAST")
        return (element.transformChildren(this, data) as E)
@@ -543,6 +543,15 @@ open class FirDeclarationsResolveTransformer(
        return result
    }

+    override fun transformCodeFragment(codeFragment: FirCodeFragment, data: ResolutionMode): FirCodeFragment {
+        dataFlowAnalyzer.enterCodeFragment(codeFragment)
+        context.withScopesForCodeFragment(codeFragment) {
+            transformBlock(codeFragment.block, data)
+        }
+        dataFlowAnalyzer.exitCodeFragment()
+        return codeFragment
+    }
+
    override fun transformTypeAlias(typeAlias: FirTypeAlias, data: ResolutionMode): FirTypeAlias = whileAnalysing(session, typeAlias) {
        if (typeAlias.isLocal && typeAlias !in context.targetedLocalClasses) {
            return typeAlias.runAllPhasesForLocalClass(transformer, components, data, transformer.firTowerDataContextCollector)
@@ -87,3 +87,7 @@ var FirConstructor.originalConstructorIfTypeAlias: FirConstructor? by FirDeclara

 val FirConstructorSymbol.isTypeAliasedConstructor: Boolean
    get() = fir.originalConstructorIfTypeAlias != null
+
+private object CodeFragmentTowerDataContext : FirDeclarationDataKey()
+
+var FirCodeFragment.towerDataContext: FirTowerDataContext? by FirDeclarationDataRegistry.data(CodeFragmentTowerDataContext)
@@ -300,6 +300,19 @@ class ScriptExitNode(owner: ControlFlowGraph, override val fir: FirScript, level
    }
 }

+// ----------------------------------- Code Fragments ------------------------------------------
+
+class CodeFragmentEnterNode(owner: ControlFlowGraph, override val fir: FirCodeFragment, level: Int) : CFGNode<FirCodeFragment>(owner, level), GraphEnterNodeMarker {
+    override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
+        return visitor.visitCodeFragmentEnterNode(this, data)
+    }
+}
+
+class CodeFragmentExitNode(owner: ControlFlowGraph, override val fir: FirCodeFragment, level: Int) : CFGNode<FirCodeFragment>(owner, level), GraphExitNodeMarker {
+    override fun <R, D> accept(visitor: ControlFlowGraphVisitor<R, D>, data: D): R {
+        return visitor.visitCodeFragmentExitNode(this, data)
+    }
+}
 // ----------------------------------- Property -----------------------------------

 class PropertyInitializerEnterNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int) : CFGNode<FirProperty>(owner, level),
@@ -106,6 +106,9 @@ fun CFGNode<*>.render(): String =
                is ScriptEnterNode -> "Enter class ${fir.name}"
                is ScriptExitNode -> "Exit class ${fir.name}"

+                is CodeFragmentEnterNode -> "Enter code fragment"
+                is CodeFragmentExitNode -> "Exit code fragment"
+
                is FakeExpressionEnterNode -> "Enter fake expression"

                is EnterValueParameterNode -> "Enter default value of ${fir.name}"
@@ -90,6 +90,16 @@ abstract class ControlFlowGraphVisitor<out R, in D> {
        return visitNode(node, data)
    }

+    // ----------------------------------- Code Fragments ------------------------------------------
+
+    open fun visitCodeFragmentEnterNode(node: CodeFragmentEnterNode, data: D): R {
+        return visitNode(node, data)
+    }
+
+    open fun visitCodeFragmentExitNode(node: CodeFragmentExitNode, data: D): R {
+        return visitNode(node, data)
+    }
+
    // ----------------------------------- Property -----------------------------------

    open fun visitPropertyInitializerEnterNode(node: PropertyInitializerEnterNode, data: D): R {
@@ -0,0 +1,42 @@
+/*
+ * 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.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirCodeFragmentSymbol
+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 FirCodeFragment : FirDeclaration() {
+    abstract override val source: KtSourceElement?
+    abstract override val annotations: List<FirAnnotation>
+    abstract override val moduleData: FirModuleData
+    abstract override val origin: FirDeclarationOrigin
+    abstract override val attributes: FirDeclarationAttributes
+    abstract override val symbol: FirCodeFragmentSymbol
+    abstract val block: FirBlock
+
+    override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitCodeFragment(this, data)
+
+    @Suppress("UNCHECKED_CAST")
+    override fun <E : FirElement, D> transform(transformer: FirTransformer<D>, data: D): E =
+        transformer.transformCodeFragment(this, data) as E
+
+    abstract override fun replaceAnnotations(newAnnotations: List<FirAnnotation>)
+
+    abstract override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCodeFragment
+
+    abstract fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirCodeFragment
+}
@@ -0,0 +1,66 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DuplicatedCode", "unused")
+
+package org.jetbrains.kotlin.fir.declarations.builder
+
+import kotlin.contracts.*
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.builder.FirAnnotationContainerBuilder
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirResolveState
+import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
+import org.jetbrains.kotlin.fir.declarations.asResolveState
+import org.jetbrains.kotlin.fir.declarations.impl.FirCodeFragmentImpl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirCodeFragmentSymbol
+import org.jetbrains.kotlin.fir.visitors.*
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+@FirBuilderDsl
+class FirCodeFragmentBuilder : FirAnnotationContainerBuilder {
+    override var source: KtSourceElement? = null
+    var resolvePhase: FirResolvePhase = FirResolvePhase.RAW_FIR
+    override val annotations: MutableList<FirAnnotation> = mutableListOf()
+    lateinit var moduleData: FirModuleData
+    lateinit var origin: FirDeclarationOrigin
+    var attributes: FirDeclarationAttributes = FirDeclarationAttributes()
+    lateinit var symbol: FirCodeFragmentSymbol
+    lateinit var block: FirBlock
+
+    override fun build(): FirCodeFragment {
+        return FirCodeFragmentImpl(
+            source,
+            resolvePhase,
+            annotations.toMutableOrEmpty(),
+            moduleData,
+            origin,
+            attributes,
+            symbol,
+            block,
+        )
+    }
+
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildCodeFragment(init: FirCodeFragmentBuilder.() -> Unit): FirCodeFragment {
+    contract {
+        callsInPlace(init, kotlin.contracts.InvocationKind.EXACTLY_ONCE)
+    }
+    return FirCodeFragmentBuilder().apply(init).build()
+}
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DuplicatedCode", "unused")
+
+package org.jetbrains.kotlin.fir.declarations.impl
+
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.fir.FirModuleData
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationAttributes
+import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin
+import org.jetbrains.kotlin.fir.declarations.FirResolvePhase
+import org.jetbrains.kotlin.fir.declarations.FirResolveState
+import org.jetbrains.kotlin.fir.declarations.asResolveState
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirBlock
+import org.jetbrains.kotlin.fir.symbols.impl.FirCodeFragmentSymbol
+import org.jetbrains.kotlin.fir.visitors.*
+import org.jetbrains.kotlin.fir.MutableOrEmptyList
+import org.jetbrains.kotlin.fir.builder.toMutableOrEmpty
+import org.jetbrains.kotlin.fir.declarations.ResolveStateAccess
+
+/*
+ * This file was generated automatically
+ * DO NOT MODIFY IT MANUALLY
+ */
+
+internal class FirCodeFragmentImpl(
+    override val source: KtSourceElement?,
+    resolvePhase: FirResolvePhase,
+    override var annotations: MutableOrEmptyList<FirAnnotation>,
+    override val moduleData: FirModuleData,
+    override val origin: FirDeclarationOrigin,
+    override val attributes: FirDeclarationAttributes,
+    override val symbol: FirCodeFragmentSymbol,
+    override var block: FirBlock,
+) : FirCodeFragment() {
+    init {
+        symbol.bind(this)
+        @OptIn(ResolveStateAccess::class)
+        resolveState = resolvePhase.asResolveState()
+    }
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        annotations.forEach { it.accept(visitor, data) }
+        block.accept(visitor, data)
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirCodeFragmentImpl {
+        transformAnnotations(transformer, data)
+        transformBlock(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirCodeFragmentImpl {
+        annotations.transformInplace(transformer, data)
+        return this
+    }
+
+    override fun <D> transformBlock(transformer: FirTransformer<D>, data: D): FirCodeFragmentImpl {
+        block = block.transform(transformer, data)
+        return this
+    }
+
+    override fun replaceAnnotations(newAnnotations: List<FirAnnotation>) {
+        annotations = newAnnotations.toMutableOrEmpty()
+    }
+}
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.fir.declarations.FirBackingField
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
 import org.jetbrains.kotlin.fir.FirPackageDirective
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
@@ -188,6 +189,8 @@ abstract class FirDefaultVisitor<out R, in D> : FirVisitor<R, D>() {

    override fun visitScript(script: FirScript, data: D): R  = visitDeclaration(script, data)

+    override fun visitCodeFragment(codeFragment: FirCodeFragment, data: D): R  = visitDeclaration(codeFragment, data)
+
    override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression, data: D): R  = visitExpression(anonymousFunctionExpression, data)

    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject, data: D): R  = visitClass(anonymousObject, data)
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.fir.declarations.FirBackingField
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
 import org.jetbrains.kotlin.fir.FirPackageDirective
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
@@ -188,6 +189,8 @@ abstract class FirDefaultVisitorVoid : FirVisitorVoid() {

    override fun visitScript(script: FirScript)  = visitDeclaration(script)

+    override fun visitCodeFragment(codeFragment: FirCodeFragment)  = visitDeclaration(codeFragment)
+
    override fun visitAnonymousFunctionExpression(anonymousFunctionExpression: FirAnonymousFunctionExpression)  = visitExpression(anonymousFunctionExpression)

    override fun visitAnonymousObject(anonymousObject: FirAnonymousObject)  = visitClass(anonymousObject)
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.fir.declarations.FirBackingField
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
 import org.jetbrains.kotlin.fir.FirPackageDirective
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
@@ -335,6 +336,10 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
        return transformElement(script, data)
    }

+    open fun transformCodeFragment(codeFragment: FirCodeFragment, data: D): FirCodeFragment {
+        return transformElement(codeFragment, data)
+    }
+
    open fun transformPackageDirective(packageDirective: FirPackageDirective, data: D): FirPackageDirective {
        return transformElement(packageDirective, data)
    }
@@ -943,6 +948,10 @@ abstract class FirTransformer<in D> : FirVisitor<FirElement, D>() {
        return transformScript(script, data)
    }

+    final override fun visitCodeFragment(codeFragment: FirCodeFragment, data: D): FirCodeFragment {
+        return transformCodeFragment(codeFragment, data)
+    }
+
    final override fun visitPackageDirective(packageDirective: FirPackageDirective, data: D): FirPackageDirective {
        return transformPackageDirective(packageDirective, data)
    }
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.fir.declarations.FirBackingField
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
 import org.jetbrains.kotlin.fir.FirPackageDirective
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
@@ -250,6 +251,8 @@ abstract class FirVisitor<out R, in D> {

    open fun visitScript(script: FirScript, data: D): R  = visitElement(script, data)

+    open fun visitCodeFragment(codeFragment: FirCodeFragment, data: D): R  = visitElement(codeFragment, data)
+
    open fun visitPackageDirective(packageDirective: FirPackageDirective, data: D): R  = visitElement(packageDirective, data)

    open fun visitAnonymousFunction(anonymousFunction: FirAnonymousFunction, data: D): R  = visitElement(anonymousFunction, data)
@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.fir.declarations.FirBackingField
 import org.jetbrains.kotlin.fir.declarations.FirConstructor
 import org.jetbrains.kotlin.fir.declarations.FirFile
 import org.jetbrains.kotlin.fir.declarations.FirScript
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
 import org.jetbrains.kotlin.fir.FirPackageDirective
 import org.jetbrains.kotlin.fir.declarations.FirAnonymousFunction
 import org.jetbrains.kotlin.fir.expressions.FirAnonymousFunctionExpression
@@ -334,6 +335,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitElement(script)
    }

+    open fun visitCodeFragment(codeFragment: FirCodeFragment) {
+        visitElement(codeFragment)
+    }
+
    open fun visitPackageDirective(packageDirective: FirPackageDirective) {
        visitElement(packageDirective)
    }
@@ -942,6 +947,10 @@ abstract class FirVisitorVoid : FirVisitor<Unit, Nothing?>() {
        visitScript(script)
    }

+    final override fun visitCodeFragment(codeFragment: FirCodeFragment, data: Nothing?) {
+        visitCodeFragment(codeFragment)
+    }
+
    final override fun visitPackageDirective(packageDirective: FirPackageDirective, data: Nothing?) {
        visitPackageDirective(packageDirective)
    }
@@ -0,0 +1,11 @@
+/*
+ * 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.symbols.impl
+
+import org.jetbrains.kotlin.fir.declarations.FirCodeFragment
+import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
+
+class FirCodeFragmentSymbol : FirBasedSymbol<FirCodeFragment>()
@@ -64,6 +64,7 @@ object FirTreeBuilder : AbstractFirTreeBuilder() {
    val constructor by element(Declaration, function, typeParameterRefsOwner, contractDescriptionOwner)
    val file by element(Declaration, declaration)
    val script by element(Declaration, declaration)
+    val codeFragment by element(Declaration, declaration)
    val packageDirective by element(Other)

    val anonymousFunction by element(Declaration, function, typeParametersOwner, contractDescriptionOwner)
@@ -495,6 +495,11 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
            +fieldList(contextReceiver, useMutableOrEmpty = true)
        }

+        codeFragment.configure {
+            +symbol("FirCodeFragmentSymbol")
+            +field(block).withTransform()
+        }
+
        packageDirective.configure {
            +field("packageFqName", fqNameType)
        }