*/
public interface KaAnalysisPermissionChecker : KaEngineService {
    public fun isAnalysisAllowed(): Boolean

    public fun getRejectionReason(): String

    public companion object {
        public fun getInstance(project: Project): KaAnalysisPermissionChecker =
            project.getService(KaAnalysisPermissionChecker::class.java)
    }

import org.gradle.api.artifacts.ComponentSelection;

import javax.annotation.Nullable;

public interface ComponentSelectionInternal extends ComponentSelection {
    boolean isRejected();

    @Nullable
    String getRejectionReason();

        if (!ApplicationManager.getApplication().isReadAccessAllowed) return "Called outside a read action."

        if (!permissionChecker.isAnalysisAllowed()) return permissionChecker.getRejectionReason()

        val currentToken = lifetimeTracker.currentToken
        if (currentToken == null) return "Called outside an `analyze` context."

        rejected = true;
        rejectionReason = reason;
    }

    @Override
    public boolean isRejected() {
        return rejected;
    }

    @Override
    public String getRejectionReason() {
        return rejectionReason;
    }

        if (isProhibitedWriteActionAnalysis(application)) return false
        if (permissionRegistry.explicitAnalysisRestriction != null) return false

        return true
    }

    override fun getRejectionReason(): String {
        val application = ApplicationManager.getApplication()

        if (isProhibitedEdtAnalysis(application)) {
            return "Called in the EDT thread."
        }

    }

    private fun beforeEnteringAnalysis(session: KtAnalysisSession) {
        if (!permissionChecker.isAnalysisAllowed()) {
            throw ProhibitedAnalysisException("Analysis is not allowed: ${permissionChecker.getRejectionReason()}")
        }

        lifetimeTracker.beforeEnteringAnalysis(session)
        writeActionStartedChecker.beforeEnteringAnalysis()
    }

                if (selection.isRejected()) {
                    LOGGER.info("Selection of {} rejected by component selection rule: {}", selection.getCandidate().getDisplayName(), selection.getRejectionReason());
                    return false;
                }
            }
        }
        return true;
    }

        rulesProcessor.apply(selection, rules, metadataProvider);
        if (selection.isRejected()) {
            return new RejectedByRuleVersion(candidateIdentifier, selection.getRejectionReason());
        }
        return null;
    }

    private boolean isRejectedBySelector(ModuleComponentIdentifier candidateIdentifier, VersionSelector rejectedVersionSelector) {