*/
    fun analyze(element: KtElement) {
        val project = element.project
        val nextInlineFunctions = HashSet<KtDeclarationWithBody>()
        val collector = InlineFunctionsCollector(project, analyzeOnlyReifiedInlineFunctions) { declaration ->
            if (!analyzedElements.contains(declaration)) {

import com.intellij.openapi.project.Project
import com.intellij.openapi.vfs.VirtualFile
import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
import org.jetbrains.kotlin.analysis.api.symbols.KtSymbolOrigin
import org.jetbrains.kotlin.analysis.project.structure.KtModule
import org.jetbrains.kotlin.analysis.project.structure.KtSourceModule
import org.jetbrains.kotlin.analysis.project.structure.ProjectStructureProvider

  }

  @Test
  @TestMetadata("class_object_call.kt")
  public void testClass_object_call() {
    runTest("analysis/analysis-api/testData/components/psiTypeProvider/psiType/forExpression/class_object_call.kt");
  }

  @Test
  @TestMetadata("class_object_constructor.kt")
  public void testClass_object_constructor() {

@Suppress("AnalysisApiMissingLifetimeCheck")
internal class KtFirAnalysisSession
private constructor(
    val project: Project,
    val firResolveSession: LLFirResolveSession,
    token: KtLifetimeToken,
) : KtAnalysisSession(token) {

    internal val firSymbolBuilder: KtSymbolByFirBuilder = KtSymbolByFirBuilder(project, this, token)

    @Suppress("AnalysisApiMissingLifetimeCheck")

    }

    @Test
    @TestMetadata("nestedType_object.kt")
    public void testNestedType_object() {
      runTest("analysis/analysis-api/testData/components/expressionTypeProvider/expressionType/nameReference/nestedType_object.kt");
    }

    @Test
    @TestMetadata("nestedType_object_extensionInvoke.kt")
    public void testNestedType_object_extensionInvoke() {

            return KtCompilationResult.Failure(frontendErrors)
        }

        // The IR backend will try to regenerate object literals defined in inline functions from generated class files during inlining.
        // Hence, we need to be aware of which object declarations are defined in the relevant inline functions.
        val inlineObjectDeclarations = inlineAnalyzer.inlineObjectDeclarations()

}

dependencies {
    api(project(":compiler:psi"))
    api(project(":compiler:fir:fir2ir"))
    api(project(":compiler:ir.tree"))
    api(project(":compiler:fir:resolve"))
    api(project(":compiler:fir:providers"))
    api(project(":compiler:fir:semantics"))
    api(project(":compiler:fir:checkers"))
    api(project(":compiler:fir:checkers:checkers.jvm"))
    api(project(":compiler:fir:checkers:checkers.js"))

@SuppressWarnings("all")
@TestMetadata("analysis/analysis-api/testData/referenceResolve")
@TestDataPath("$PROJECT_ROOT")
public class Fe10IdeNormalAnalysisSourceModuleReferenceResolveTestGenerated extends AbstractReferenceResolveTest {
  @NotNull
  @Override
  public AnalysisApiTestConfigurator getConfigurator() {

import org.jetbrains.org.objectweb.asm.Type

internal class KtFe10JvmTypeMapperContext(private val resolveSession: ResolveSession) : TypeMappingContext<JvmSignatureWriter> {
    companion object {
        fun getNestedType(type: KotlinType): NestedType {
            val possiblyInnerType = type.buildPossiblyInnerType() ?: throw IllegalArgumentException(type.toString())

    <ExternalSystemSettings>
      <option name="executionName" />
      <option name="externalProjectPath" value="$PROJECT_DIR$/generators" />
      <option name="externalSystemIdString" value="GRADLE" />
      <option name="scriptParameters" value="" />
      <option name="taskDescriptions">
        <list />
      </option>