val jvmIrDeserializer = JvmIrDeserializerImpl()
        val diagnosticReporter = DiagnosticReporterFactory.createPendingReporter()

        val irGeneratorExtensions = IrGenerationExtension.getInstances(project)

        val dependencyFir2IrResults = dependencyFiles
            .map(::getFullyResolvedFirFile)
            .groupBy { it.llFirSession }
            .map { (dependencySession, dependencyFiles) ->

                    return injector.getInstance(type);
                } catch (DIException e) {
                    throw new MavenException("Unable to locate instance of type " + type, e);
                }
            }

            @Override
            public <T> T lookup(Class<T> type, String name) {
                try {
                    return injector.getInstance(Key.of(type, name));

internal class KtFe10AnalysisSessionProvider(project: Project) : KtAnalysisSessionProvider(project) {
    override fun getAnalysisSession(useSiteKtElement: KtElement): KtAnalysisSession {
        val facade = Fe10AnalysisFacade.getInstance(project)
        val token = tokenFactory.create(project, project.createProjectWideOutOfBlockModificationTracker())
        val context = facade.getAnalysisContext(useSiteKtElement, token)

     */
    internal class SessionInvalidationListener(val project: Project) : LLFirSessionInvalidationListener {
        private val analysisSessionProvider: KtFirAnalysisSessionProvider
            get() = getInstance(project) as? KtFirAnalysisSessionProvider
                ?: error("Expected the analysis session provider to be a `${KtFirAnalysisSessionProvider::class.simpleName}`.")

    override val fqName: FqName
        get() = withValidityAssertion { packageName }

    override val psi: PsiElement? by cached {
        val project = analysisContext.resolveSession.project
        JavaPsiFacade.getInstance(project).findPackage(fqName.asString())
    }

    override fun createPointer(): KtSymbolPointer<KtPackageSymbol> = withValidityAssertion {
        KtFe10PackageSymbolPointer(fqName)
    }

            )

            when {
                analysisSession.targetPlatform.isJvm() -> {
                    val psiPackage = PsiPackageImpl(PsiManager.getInstance(analysisSession.project), packageFqName.asString())
                    forEachNonKotlinPsiElementFinder(analysisSession.project) { finder ->

                        } else if (key.getQualifier() instanceof Annotation a) {
                            binder.annotatedWith(a);
                        }
                        binder.toProvider(() -> injector.getInstance(clazz));
                    }
                });
    }

internal class KtFe10ScopeProvider(
    override val analysisSession: KtFe10AnalysisSession
) : KtScopeProvider(), Fe10KtAnalysisSessionComponent {
    private companion object {
        val LOG = Logger.getInstance(KtFe10ScopeProvider::class.java)
    }

    override val token: KtLifetimeToken
        get() = analysisSession.token

    override fun getMemberScope(classSymbol: KtSymbolWithMembers): KtScope {

        try (Writer writer = new OutputStreamWriter(new FileOutputStream(artifactFile), StandardCharsets.ISO_8859_1)) {
            writer.write(artifact.getId());
        }

        MessageDigest md = MessageDigest.getInstance("MD5");
        md.update(artifact.getId().getBytes());
        byte[] digest = md.digest();

        String md5path = repository.pathOf(artifact) + ".md5";

            injector.bindInstance(org.apache.maven.api.MojoExecution.class, execution);
            injector.bindInstance(org.apache.maven.api.plugin.Log.class, log);
            mojo = mojoInterface.cast(injector.getInstance(
                    Key.of(mojoDescriptor.getImplementationClass(), mojoDescriptor.getRoleHint())));

        } catch (Exception e) {