*
     * @see getCallableSignatures
     */
    public fun getCallableSignatures(vararg names: Name): Sequence<KaCallableSignature<*>> = withValidityAssertion {
        getCallableSignatures(names.toList())
    }

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes:

                .collect(Collectors.toList());
    }

    @Override
    public List<Profile> getActiveProfiles(
            Collection<Profile> profiles, ProfileActivationContext context, ModelProblemCollector problems) {
        Collection<String> activatedIds = new HashSet<>(context.getActiveProfileIds());
        Collection<String> deactivatedIds = new HashSet<>(context.getInactiveProfileIds());

    }

    private fun getClassLikeDeclarationsByClassId(classId: ClassId): Sequence<KtClassLikeDeclaration> {
        if (classId.isLocal) {
            return emptySequence()
        }

        if (kotlinFile.packageFqName != classId.packageFqName) {
            return emptySequence()
        }

        data class Task(val chunks: List<Name>, val element: KtElement)

        Map<ResolvedVariant, List<TransformedVariant>> variantToTransforms = failure.getTransformedVariants().stream().collect(Collectors.groupingBy(
            TransformedVariant::getRoot,
            () -> new TreeMap<>(Comparator.comparing(variant -> variant.asDescribable().getDisplayName())),
            Collectors.collectingAndThen(Collectors.toList(), list -> list.stream().sorted(variantComparator).collect(Collectors.toList()))));

     */
    public static List<File> mergeToClasspath(
        ArtifactCollection originalDependencies,
        ArtifactCollection externalDependencies,
        ArtifactCollection projectDependencies
    ) {
        List<OriginalArtifactIdentifier> identifiers = originalDependencies.getArtifacts().stream()
            .map(OriginalArtifactIdentifier::of)

            return symbols
        }

        private fun KaSession.findMatchingCallableSymbols(classSymbol: KaClassOrObjectSymbol): List<KaCallableSymbol> {
            val declaredSymbols = classSymbol.getCombinedDeclaredMemberScope()
                .getCallableSymbols(callableId.callableName).toList()

            if (declaredSymbols.isNotEmpty()) {
                return declaredSymbols
            }

     */
    default List<org.apache.maven.api.model.Profile> getActiveProfilesV4(
            Collection<org.apache.maven.api.model.Profile> profiles,
            ProfileActivationContext context,
            ModelProblemCollector problems) {
        return getActiveProfiles(profiles.stream().map(Profile::new).collect(Collectors.toList()), context, problems)
                .stream()

        this.data = IntStream.range(0, points.size())
            .mapToObj(index -> Arrays.<Number>asList(index, points.get(index)))
            .collect(Collectors.toList());
    }

    public String getLabel() {
        return label;
    }

    public List<List<Number>> getData() {
        return data;
    }

        this.readers = Collections.unmodifiableList(
                new ArrayList<>(readers.stream().filter(Objects::nonNull).collect(Collectors.toList())));
        Key key = new Key(this.readers);
        this.repository = new WorkspaceRepository(key.getContentType(), key);
    }

    public List<WorkspaceReader> getReaders() {
        return readers;
    }

    public void addReader(WorkspaceReader workspaceReader) {

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class TableBuilder {

    public static List<List<String>> build() {
        List<MyProductRelease> releases = DataRetriever.retrieve().getReleases();
        return build(releases);
    }

    protected static List<List<String>> build(List<MyProductRelease> releases) {