?: 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 {

                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 {

        }
    }

    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 {

        // The reference may be from another file, so we need to allow all main test files
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

        // Package scope tests may collect symbols from multiple files, so we need to allow all main test files.
        return testServices.ktTestModuleStructure.allMainKtFiles.toSet()
    }

            include 'b'
        """

        when:
        def gradleBuild = withConnection {
            action(new FetchGradleBuild()).run()
        }
        then:
        gradleBuild.projects*.projectIdentifier.toSet().size() == 3
    }

    def "Applies BuildInvocations compatibility mapping"() {
        when:
        def buildInvocations = withConnection {
            action(new FetchBuildInvocations()).run()
        }