override fun doAnalysis(
        project: Project,
        module: ModuleDescriptor,
        projectContext: ProjectContext,
        files: Collection<KtFile>,
        bindingTrace: BindingTrace,
        componentProvider: ComponentProvider
    ): AnalysisResult? {
        // Single-module [KtFe10AnalysisHandlerExtension] can be registered without specific use-site module.
        // Simple null-check below will skip the bail-out.

            // have an obvious associated `actual` symbol. `shouldStubOrphanedExpectSymbols` generates stubs for such `expect` declarations.
            shouldStubOrphanedExpectSymbols = true,

            // Likewise, the file to compile may be contained in a "platform" multiplatform module, where the `actual` declaration is

<component name="CopyrightManager">
  <settings>
    <module2copyright>
      <element module="Apply copyright" copyright="apache" />
    </module2copyright>
    <LanguageOptions name="Groovy">
      <option name="fileTypeOverride" value="1" />
    </LanguageOptions>
    <LanguageOptions name="HTML">
      <option name="fileTypeOverride" value="1" />
      <option name="prefixLines" value="false" />
    </LanguageOptions>

            </array>
          </value>
        </entry>
        <entry key="$PROJECT_DIR$/js/js.translator/testData/lineNumbers">
          <value>
            <array>

    override fun <T : Any> getRegisteredExtensions(module: KtSourceModule, extensionType: ProjectExtensionDescriptor<T>): List<T> {
        return extensionType.getInstances(module.project)
    }

    @OptIn(InternalNonStableExtensionPoints::class)
    override fun isPluginOfTypeRegistered(module: KtSourceModule, pluginType: CompilerPluginType): Boolean {
        val extension = when (pluginType) {

    /*
     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 {

        val project = ktModule.project
        val correctedClassId = classIdMapping[classId] ?: return null
        require(ktModule is KtBuiltinsModule) {
            "Expected builtin module but found $ktModule"
        }
        return project.createDeclarationProvider(ProjectScope.getLibrariesScope(project), ktModule)
            .getAllClassesByClassId(correctedClassId)

                AnalysisSessionMode.Dependent -> error("Unsupported AnalysisSessionMode.Dependent for fe10")
            }

            else -> {
                error("Unsupported non-source module for fe10")
            }
        }
    }

    override fun supportMode(data: AnalysisApiTestConfiguratorFactoryData): Boolean {
        return when {
            data.frontend != FrontendKind.Fe10 -> false

    // and if a containing delegated property accessor is inline,
    // it might need this accessor's bytecode.
    //
    // If an accessor function is defined in a different module,
    // IDE tries to acquire its bytecode via the index, however,
    // the index doesn't cover classfiles from compiler output,
    // so the lowering fails.
    //

* `intellij-core` is a part of command line compiler and contains only necessary APIs.
* `idea-full` is a full blown IntelliJ IDEA Community Edition to be used in the plugin module.

These dependencies are quite large, so depending on the quality of your internet connection 
you might face timeouts getting them. In this case, you can increase timeout by specifying the following