override fun getPossibleCallableNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleCallableNames())
        addAll(secondWrappedScope.getPossibleCallableNames())
    }

    override fun getPossibleClassifierNames(): Set<Name> = buildSet {
        addAll(firstWrappedScope.getPossibleClassifierNames())
        addAll(secondWrappedScope.getPossibleClassifierNames())
    }

        assertThat(ArrayUtil.addAll((Object[]) null, (Object[]) null), is(nullValue()));
        assertThat(ArrayUtil.addAll(null, emptyArray).length, is(0));
        assertThat(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));
        assertThat(ArrayUtil.addAll(emptyArray, null), is(sameInstance(emptyArray)));
        assertThat(ArrayUtil.addAll(emptyArray, emptyArray), is(sameInstance(emptyArray)));

    override fun getResolutionScope(module: KtModule): GlobalSearchScope {
        val allModules = topologicalSort(listOf(module)) {
            buildList {
                addAll(directDependsOnDependencies)
                addAll(directFriendDependencies)
                addAll(directRegularDependencies)
            }
        }

        return GlobalSearchScope.union(allModules.map { it.contentScope })
    }

    }

    public fun addSourceRoots(paths: Collection<Path>) {
        sourceRoots.addAll(paths)
    }

    public fun addSourceVirtualFile(virtualFile: VirtualFile) {
        sourceVirtualFiles.add(virtualFile)
    }

    public fun addSourceVirtualFiles(virtualFiles: Collection<VirtualFile>) {
        sourceVirtualFiles.addAll(virtualFiles)
    }

    override fun build(): KtSourceModule {

                    }
                }
            }

            addAll(collectGeneratedTopLevelClassifiers(packageFqName, analysisSession.useSiteSession))
        }
    }

    internal fun getTopLevelCallableNamesInPackageProvider(packageFqName: FqName, analysisSession: KaFirSession): Set<Name> {
        return buildSet {
            addAll(

    private <T> Collection<T> getExtensionComponents(Collection<MavenProject> projects, Class<T> role) {
        Collection<T> foundComponents = new LinkedHashSet<>();
        foundComponents.addAll(lookup.lookupList(role));
        foundComponents.addAll(getProjectScopedExtensionComponents(projects, role));
        return foundComponents;
    }

        }
    }

    override fun getSubPackageFqNames(packageFqName: FqName, platform: TargetPlatform, nameFilter: (Name) -> Boolean): Set<Name> =
        buildSet {
            addAll(getKotlinOnlySubPackagesFqNames(packageFqName, nameFilter))
            addAll(getPlatformSpecificSubPackagesFqNames(packageFqName, platform, nameFilter))
        }

    override fun getPlatformSpecificSubPackagesFqNames(
        packageFqName: FqName,

        parent.add(index, element);
    }

    @Override
    public boolean addAll(final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(c);
    }

    @Override
    public boolean addAll(final int index, final Collection<? extends Map<String, Object>> c) {
        return parent.addAll(index, c);
    }

    @Override
    public void clear() {
        parent.clear();

            Collection<String> scopesToCollect, Collection<String> scopesToResolve) {
        return scopesToCollectForAggregatedProjects.addAll(scopesToCollect)
                || scopesToResolveForAggregatedProjects.addAll(scopesToResolve);
    }

    public void synchronizeWithProjectState() {
        lastDependencyArtifacts = project.getDependencyArtifacts();

            return parent.containsAll(c);
        }

        @Override
        public boolean addAll(final Collection<? extends E> c) {
            return parent.addAll(c);
        }

        @Override
        public boolean addAll(final int index, final Collection<? extends E> c) {
            return parent.addAll(index, c);
        }

        @Override
        public boolean removeAll(final Collection<?> c) {