Set<JavaMethod> getters = gettersAndSetters.get(Boolean.TRUE).stream().map(Accessor::getMethod).collect(toSet());
            Set<JavaMethod> setters = gettersAndSetters.get(Boolean.FALSE).stream().map(Accessor::getMethod).collect(toSet());
            if (!getters.isEmpty() && !setters.isEmpty()) {
                return new Accessors(owningClass, propertyName, getters, setters);
            }

import java.io.File;
import java.util.Collections;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Stream;

import static java.util.stream.Collectors.toSet;

public class FileBasedInstallationFactory {

    public static Set<InstallationLocation> fromDirectory(File rootDirectory, String supplierName, BiFunction<File, String, InstallationLocation> locationFactory) {

                ?: error("Extension file $name must specify exactly one RESOLVE_EXTENSION_PACKAGE")
            val classifierNames = directives[Directives.RESOLVE_EXTENSION_CLASSIFIER].toSet()
            val callableNames = directives[Directives.RESOLVE_EXTENSION_CALLABLE].toSet()
            check(classifierNames.isNotEmpty() || callableNames.isNotEmpty()) {

            .toSet()
    }

    override fun annotationsOnDeclaration(declaration: KtAnnotated): Set<ClassId> {
        return declaration.annotationEntries.asSequence()
            .mapNotNull { it.typeReference?.text }
            .map { ClassId.topLevel(FqName(it)) }
            .filter { it.resolveToAnnotation() != null }
            .toSet()
    }

        }
    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        val namesSet = names.toSet()
        return getCallableSymbols { it in namesSet }
    }

    override fun getClassifierSymbols(nameFilter: KaScopeNameFilter): Sequence<KaClassifierSymbol> = withValidityAssertion {
        sequence {

            .map(pattern -> pattern.replace("/**", ".."))
            .map(pattern -> pattern.replace("/*", ""))
            .map(pattern -> pattern.replace("/", "."))
            .collect(Collectors.toSet());
    }

    private static boolean isClassNamePattern(String pattern) {
        return pattern.endsWith("*") && !(pattern.endsWith("/*") || pattern.endsWith("/**"));
    }

                it.getTopLevelClassIds()
            }
            .filter { it.packageFqName == packageFqName }
            .map { it.shortClassName }

        return generatedTopLevelClassifiers.toSet()
    }

    private fun collectGeneratedTopLevelCallables(packageFqName: FqName, session: FirSession): Set<Name> {
        val generators = session.extensionService.declarationGenerators

    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        val namesSet = names.toSet()
        return getCallableSymbols { it in namesSet }
    }

    override fun getClassifierSymbols(nameFilter: KaScopeNameFilter): Sequence<KaClassifierSymbol> = withValidityAssertion {
        return scope

    }

    override fun getCallableSymbols(names: Collection<Name>): Sequence<KaCallableSymbol> = withValidityAssertion {
        if (names.isEmpty()) return emptySequence()
        val namesSet = names.toSet()
        return getCallableSymbols { it in namesSet }
    }

    override fun getClassifierSymbols(nameFilter: KaScopeNameFilter): Sequence<KaClassifierSymbol> = withValidityAssertion {

        List<RemoteRepository> repos =
                toAdd.stream().map(session::createRemoteRepository).toList();
        if (replace) {
            Set<String> ids = repos.stream().map(RemoteRepository::getId).collect(Collectors.toSet());
            repositories =
                    repositories.stream().filter(r -> !ids.contains(r.getId())).toList();
            pomRepositories = pomRepositories.stream()