fun add(diagnostic: KtDiagnosticFactory0, creator: KtFirDiagnostic0Creator) {
        conversions[diagnostic] = creator
    }

    fun <A> add(diagnostic: KtDiagnosticFactory1<A>, creator: KtFirDiagnostic1Creator<A>) {
        conversions[diagnostic] = creator
    }

    fun <A, B> add(diagnostic: KtDiagnosticFactory2<A, B>, creator: KtFirDiagnostic2Creator<A, B>) {

                propertyAccessor.visitProperty(property)
            }
        })

        analyzedElements.add(element)

        if (nextInlineFunctions.isNotEmpty()) {
            for (inlineFunction in nextInlineFunctions) {
                if (inlineFunction.bodyExpression != null) {
                    inlineFunctionsWithBody.add(inlineFunction)
                    analyze(inlineFunction)
                }
            }

            buildSet {
                // Add an empty scope to the shadowed set to give GlobalSearchScope.union something
                // to work with if there are no extension tools.
                // If there are extension tools, any empty scopes, whether from shadowedSearchScope
                // on the extension tools or from this add() call, will be ignored.
                add(GlobalSearchScope.EMPTY_SCOPE)

}

val compileKotlin by tasks

compileKotlin.dependsOn(generateCode)

tasks.withType<KotlinJvmCompile>().configureEach {
    compilerOptions.freeCompilerArgs.add("-Xcontext-receivers")
    compilerOptions.optIn.add("org.jetbrains.kotlin.analysis.api.KtAnalysisApiInternals")

            val seenTopLevelPackages = mutableSetOf<Name>()
            for (tool in tools) {
                for (packageName in tool.packageFilter.getAllSubPackages(FqName.ROOT)) {
                    if (seenTopLevelPackages.add(packageName) && nameFilter(packageName)) {
                        yield(analysisSession.firSymbolBuilder.createPackageSymbol(FqName.ROOT.child(packageName)))
                    }
                }
            }
        }

            }
        }
    }

    class NestedType(val root: PossiblyInnerType, val nested: List<PossiblyInnerType>) {
        val allInnerTypes: List<PossiblyInnerType>
            get() = buildList {
                add(root)
                addAll(nested)
            }
    }

    override val typeContext = KtFe10TypeSystemCommonBackendContextForTypeMapping(resolveSession)

                if (diagnostic.severity == Severity.ERROR) {
                    val ktDiagnostic = KtFe10Diagnostic(diagnostic, token)
                    if (!allowedErrorFilter(ktDiagnostic)) {
                        add(ktDiagnostic)
                    }
                }
            }
        }
    }

    private fun createJvmIrCodegenFactory(configuration: CompilerConfiguration): JvmIrCodegenFactory {

    callableNames.forEach { name ->
        yieldList {
            processFunctionsByName(name) { firSymbol ->
                add(builder.functionLikeBuilder.buildFunctionSymbol(firSymbol))
            }
        }
        yieldList {
            processPropertiesByName(name) { firSymbol ->
                add(builder.callableBuilder.buildCallableSymbol(firSymbol))
            }
        }
    }
}

        if (owner is KtNamedDeclaration) {
            if (owner.nameAsName == name) {
                add(owner.getSymbol())
            }
        }
        if (owner is KtTypeParameterListOwner) {
            for (typeParameter in owner.typeParameters) {
                if (typeParameter.nameAsName == name) {
                    add(typeParameter.getTypeParameterSymbol())
                }
            }
        }

                        importedClassId?.relativeClassName,
                        importedClassId,
                        import.importedName,
                        import.aliasName,
                    ).let(::add)
                }
            }
        }
    }

    override fun getPackageSymbols(nameFilter: KtScopeNameFilter): Sequence<KtPackageSymbol> = withValidityAssertion {
        emptySequence()
    }