* For data classes & enums generated members like `copy` `componentN`, `values` it will return corresponding enum/data class
 * Otherwise, behaves the same way as [findPsi] returns exact PSI declaration corresponding to passed [FirDeclaration]
 */
fun FirDeclaration.findReferencePsi(): PsiElement? {
    return if (this is FirCallableDeclaration) {

/**
 * Whether unbound IR symbols should be stubbed instead of linked.
 * This should be enabled if the compiled file could refer to symbols defined in another file of the same module.
 * Such symbols are not compiled (only the file is passed to the backend) and so they cannot be linked from a dependency.
 */

    /*
     We do not need guava in the generator, but because of a bug in the IJ project importing, we need to have a dependency on intellijCore
     the same as it is in `:fir:tree:tree-generator` module to the project be imported correctly
     */
    compileOnly(intellijCore())
    compileOnly(libs.guava)

    implementation(project(":compiler:psi"))
}

application {

                scopeSession,
                stubBodyResolveTransformer,
                stubBodyResolveTransformer.context,
            )

        // TODO: this doesn't guarantee that the same synthetic function (as a SAM constructor) is created/returned
        fun getSamConstructor(firClass: FirRegularClass): FirSimpleFunction? {
            val samConstructor = bodyResolveComponents.samResolver.getSamConstructor(firClass) ?: return null

{
  "version": "1.0",
  "builds": [
    {
      "teamcity": {
        "configuration": "Kotlin_KotlinDev_SafeMerge",
        "url": "https://buildserver.labs.intellij.net",
        "token": "${space-safe-merge-kt}",
        "ssl-keystore": "BuildServer client"
      }
    }
  ]

<component name="ProjectRunConfigurationManager">
  <configuration default="false" name="Generate Compiler Arguments Copy" type="GradleRunConfiguration" factoryName="Gradle" folderName="Generators">
    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$/generators" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />

import org.jetbrains.kotlin.analysis.api.types.KtType
import org.jetbrains.kotlin.descriptors.ClassDescriptor
import org.jetbrains.kotlin.name.CallableId
import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.Name

internal class KtFe10DescEnumEntrySymbol(
    override val descriptor: ClassDescriptor,
    override val analysisContext: Fe10AnalysisContext

 */

package org.jetbrains.kotlin.analysis.api.fir.scopes

import org.jetbrains.kotlin.name.ClassId
import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name

internal sealed class Import {
    abstract val packageFqName: FqName
    abstract val relativeClassName: FqName?
    abstract val resolvedClassId: ClassId?
}

        val function = assignment.operationReference.mainReference.resolve() as? KtNamedFunction ?: return null
        val name = function.name ?: return null
        return if (Name.identifier(name) in OperatorConventions.ASSIGNMENT_OPERATIONS.values)
            ReferenceAccess.READ to assignment
        else
            null
    }

import org.jetbrains.kotlin.name.Name

internal class FirNoClassifiersScope(
    private val delegate: FirContainingNamesAwareScope,
) : FirDelegatingContainingNamesAwareScope(delegate) {
    override fun getClassifierNames(): Set<Name> = emptySet()

    override fun processClassifiersByNameWithSubstitution(name: Name, processor: (FirClassifierSymbol<*>, ConeSubstitutor) -> Unit) {
    }