| <<<javadoc>>>         | <<<javadoc>>> | <<<jar>>>  | java      | classes               |                       |
*-----------------------+---------------+------------+-----------+-----------------------+-----------------------+
| <<<test-jar>>>        | <<<tests>>>   | <<<jar>>>  | java      | classes, patch module |                       |

            args '-Dscala.classpath.closeZip=true'
        }
        classes.baseline()
        buildScript(classes.buildScript())
    }

    @Override
    protected void moveFilesAround() {
        Files.move(file("src/main/scala").toPath(), file("src/main/new-scala").toPath())
        classes.sourceDir = 'src/main/new-scala'
        buildScript(classes.buildScript())
        // Move scala library dependency around on disk

                // Java types
                new DefaultType(
                        Type.JAR, Language.JAVA_FAMILY, "jar", null, false, JavaPathType.CLASSES, JavaPathType.MODULES),
                new DefaultType(Type.JAVADOC, Language.JAVA_FAMILY, "jar", "javadoc", false, JavaPathType.CLASSES),

import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer
import org.jetbrains.kotlin.descriptors.findClassAcrossModuleDependencies
import org.jetbrains.kotlin.name.ClassId

class KaFe10DescNamedClassOrObjectSymbolSymbol(private val classId: ClassId) : KaSymbolPointer<KaNamedClassOrObjectSymbol>() {
    @Deprecated("Consider using org.jetbrains.kotlin.analysis.api.KaSession.restoreSymbol")

public sealed class KaClassLikeSymbol : KaClassifierSymbol(), KaSymbolWithKind, KaPossibleMemberSymbol, KaPossibleMultiplatformSymbol {
    /**
     * The [ClassId] of this class, or `null` if this class is local.
     */
    public abstract val classId: ClassId?

    @Deprecated("Use `classId` instead.", ReplaceWith("classId"))
    public val classIdIfNonLocal: ClassId? get() = classId

import org.jetbrains.kotlin.analysis.api.symbols.KaSymbol
import org.jetbrains.kotlin.analysis.api.symbols.pointers.KaSymbolPointer
import org.jetbrains.kotlin.name.ClassId
import kotlin.reflect.KClass

internal class KaFirClassLikeSymbolPointer<T : KaClassLikeSymbol>(
    private val classId: ClassId,
    private val expectedClass: KClass<T>,
) : KaSymbolPointer<T>() {

Secondary variants (*)
    - Variant : classes
       - Attributes
          - org.gradle.category            = library
          - org.gradle.dependency.bundling = external
          - org.gradle.jvm.version         = 11
          - org.gradle.libraryelements     = classes
          - org.gradle.usage               = java-api
       - Artifacts
          - build/classes/java/main (artifactType = java-classes-directory)

                        case "classes":
                            // first one is "main" from Java sources
                            artifact name: 'main', version: '', extension: '', type: 'java-classes-directory'
                            // second one is "main" from Groovy sources
                            artifact name: 'main', version: '', extension: '', type: 'java-classes-directory'
                            break

    }

    override fun contains(classId: ClassId): Boolean = withValidityAssertion {
        return backingAnnotations.any { it.classId == classId }
    }

    override fun get(classId: ClassId): List<KaAnnotation> = withValidityAssertion {
        return backingAnnotations.filter { it.classId == classId }
    }

    override val classIds: Collection<ClassId>
        get() = withValidityAssertion {

     * A set of Jar files or directories containing compiled code.
     */
    public Set<File> getClasses() {
        return classes;
    }

    /**
     * A set of Jar files or directories containing source code.
     */
    public void setClasses(Set<File> classes) {
        this.classes = classes;
    }

    /**
     * A set of Jar files or directories containing javadoc.
     */
    public Set<File> getJavadoc() {