trees.forEach { import ->
            val fqn = DefaultFqName(
                import.name.nameParts.dropLast(1).joinToString("."), import.name.nameParts.last()
            )

            compute(fqn.simpleName) { _, existing ->
                if (existing != null && existing != fqn) {
                    analysisContext.errorCollector.collect(ResolutionError(import, ErrorReason.AmbiguousImport(fqn)))
                    existing

class ApiClassExtractorTestSupportTest extends ApiClassExtractorTestSupport {

    def "should create implementation class for #fqn"() {
        given:
        def clazz = toClass(fqn, src).clazz

        expect:
        clazz.name == fqn

        where:
        fqn          | src
        'A'          | 'public class A {}'
        'com.acme.A' | '''
                           package com.acme;

            sb.append("In $it\n")
        }

        throw new RuntimeException(sb.toString())
    }

    @CompileStatic
    protected GeneratedClass toClass(String fqn, String script) {
        toApi([(fqn): script]).classes[fqn]
    }

    protected void noSuchMethod(Class c, String name, Class... argTypes) {
        try {
            c.getDeclaredMethod(name, argTypes)

import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.utils.filterIsInstanceAnd

/**
 * This implementation works only for FQN annotations usages (`@foo.Bar` instead of `@Bar`).
 * It does not perform the full resolve of the annotation call, but it checks whether the annotation
 * with such FQN is present in the [scope] with [KotlinDeclarationProvider].
 *
 * Required for and used only in the test infrastructure.
 */

        // TODO: extension functions are not supported now; so it's either an FQN function reference or imported one
        if (receiver is PropertyAccess && receiver.asChainOrNull() != null || receiver == null) {
            val packageNameParts = (receiver as? PropertyAccess)?.asChainOrNull()?.nameParts.orEmpty()
            val candidates = buildList {
                val fqn = DefaultFqName(packageNameParts.joinToString("."), functionCall.name)

    }

    def "getFullyQualifiedName returns FQN"() {
        given:
        def stringType = typeOf(String)

        expect:
        stringType.simpleName == 'String'
        stringType.fullyQualifiedName == 'java.lang.String'
    }

    def "getFullyQualifiedName returns FQN striping generic arguments"() {
        given:
        def listType = typeOf(List<Integer>)

        for (MavenProject project : modules) {
            String fqn = fqn(project, projects);
            File projectDirectory = projectDir(project);
            // don't add project if it's the rootproject
            if (!workingDir.getAsFile().equals(projectDirectory)) {
                moduleNames.add(fqn);

                // Calculate the path to the project, ignore this path if it's the default value

        if (function is DataConstructor) {
            val fqn = when (val ref = function.dataClass) {
                is DataTypeRef.Name -> ref.fqName.toString()
                is DataTypeRef.Type -> (ref.dataType as? DataClass)?.name?.qualifiedName
                    ?: ref.dataType.toString()
            }
            append(fqn)
            append(".")
        }
        append(function.simpleName)

    fun KtFile.isDocumentedAsSince(version: String, declaringClass: CtClass, field: CtField): Boolean =
        "${declaringClass.baseQualifiedKotlinName}.${field.name}".let { fqn ->
            collectDescendantsOfType<KtProperty>()
                .firstOrNull { it.fqName?.asString() == fqn }
                ?.isDocumentedAsSince(version) == true
        }

    private

     * @return this type's simple name
     */
    public String getSimpleName() {
        return type.getDisplayName();
    }

    /**
     * Fully Qualified name.
     *
     * @return this type's FQN
     * @since 7.4
     */
    public String getFullyQualifiedName() {
        return type.getName();
    }

    /**
     * <p>
     * This returns the underlying, concrete Java {@link java.lang.Class}.