val token = tokenFactory.create(project, project.createProjectWideOutOfBlockModificationTracker())
        val context = facade.getAnalysisContext(useSiteKtElement, token)
        val useSiteModule = ProjectStructureProvider.getModule(project, useSiteKtElement, contextualModule = null)
        return KaFe10Session(context, useSiteModule, token)
    }

    override fun getAnalysisSessionByUseSiteKtModule(useSiteKtModule: KtModule): KaSession {

     */
    @Nullable
    String getVersion();

    /**
     * The implementation module of the plugin if one was explicitly specified, otherwise null.
     */
    @Nullable
    ModuleVersionSelector getModule();

public interface IvyDependency {

    /**
     * The organisation value for this dependency.
     */
    String getOrganisation();

    /**
     * The module value for this dependency.
     */
    String getModule();

    /**
     * The revision value for this dependency.
     */
    String getRevision();

    /**
     * The configuration mapping string that will be output for this dependency.

    private ModuleDescriptorArtifactMetadata getMetaDataArtifactFor(ModuleComponentIdentifier moduleComponentIdentifier) {
        IvyArtifactName ivyArtifactName = metadataArtifactProvider.getMetaDataArtifactName(moduleComponentIdentifier.getModule());
        return new DefaultModuleDescriptorArtifactMetadata(moduleComponentIdentifier, ivyArtifactName);
    }

     */
    Module getExternalModule(String name) throws UnknownModuleException;

    /**
     * Locates a module by name.
     *
     * @return the module. Does not return null.
     */
    Module getModule(String name) throws UnknownModuleException;

    /**
     * Tries to locate a module by name.
     *
     * @return the optional module, or {@literal null} if it cannot be found

    void createSpecs() {
        withModuleMetadataSpec = new SingleArtifactResolutionResultSpec<T>(module)
        withoutModuleMetadataSpec = new SingleArtifactResolutionResultSpec<T>(module)
    }

    abstract T getModule()

    abstract void validate()

        def coordinates = DefaultModuleVersionIdentifier.newId(group, name, version)

        def descriptor = ivyDescriptor()
        descriptor.coordinates.getOrganisation().set(group)
        descriptor.coordinates.getModule().set(name)
        descriptor.coordinates.getRevision().set(version)

        def publication = new IvyNormalizedPublication("pub-name", coordinates, ivyFile(descriptor), emptySet())

        when:

    }

    private LocalComponentGraphResolveState getLocalComponentState(ProjectState projectState, ProjectInternal project) {
        Module module = project.getDependencyMetaDataProvider().getModule();
        ModuleVersionIdentifier moduleVersionIdentifier = moduleIdentifierFactory.moduleWithVersion(module.getGroup(), module.getName(), module.getVersion());

        Set<Module> modules = new LinkedHashSet<Module>();
        for (String pluginModule : properties.getProperty("plugins").split(",")) {
            try {
                modules.add(moduleRegistry.getModule(pluginModule));
            } catch (UnknownModuleException e) {
                // Ignore
                LOGGER.debug("Cannot find module for plugin {}. Ignoring.", pluginModule);
            }
        }

        this.version = version;
        this.classifier = classifier;
        this.excludedModules = excludedModules;
    }

    public String getGroupId() {
        return group;
    }

    public String getModule() {
        return module;
    }

    public String getVersion() {
        return version;
    }

    public String getClassifier() {
        return classifier;
    }