Specs.satisfyAll()
            )
        )

        when: "a processor runs on this metadata through the caching code path"
        def processor = processorWithCacheThatNeverHits()
        def result = processor.processMetadata(metadata.asImmutable())

        then: "the result should have the variant added by the rule"

        !javaClassFile("Bar.class").exists()
    }

    def "can use annotation processor"() {
        given:
        buildFile << """
            dependencies {
                compileOnly project(":processor")
                annotationProcessor project(":processor")
            }
        """
        settingsFile << "include 'processor'"
        writeAnnotationProcessorProject()

import org.gradle.internal.compiler.java.listeners.constants.ConstantDependentsConsumer;
import org.gradle.internal.compiler.java.listeners.constants.ConstantsCollector;

import javax.annotation.processing.Processor;
import javax.tools.JavaCompiler;
import java.io.File;
import java.util.Locale;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.function.BiConsumer;

        val postProcessingFeatures = step.features.filterIsInstance<InterpretationStepFeature.ResolutionResultPostprocessing>()
        val resultHandlers = stepContext.supportedResolutionResultHandlers.filter { processor -> postProcessingFeatures.any(processor::shouldHandleFeature) }
        val resolution = resultHandlers.fold(initialResolution) { acc, it -> it.processResolutionResult(acc) }

        val document = languageModel.toDocument()

}

description = "Collection of test fixtures for both unit tests and integration tests, internal use only"

sourceSets {
    main {
        // Incremental Groovy joint-compilation doesn't work with the Error Prone annotation processor
        errorprone.enabled = false
    }
}

dependencies {
    api(project(":base-services"))
    api(project(":concurrent"))
    api(project(":hashing"))
    api(project(":stdlib-java-extensions"))

    compileOnly(project(":internal-instrumentation-api"))
    compileOnly(libs.asm)
    compileOnly(libs.asmUtil)
    compileOnly(libs.asmTree)
    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))
}

tasks.named<JavaCompile>("compileJava") {
    // Without this, javac will complain about unclaimed org.gradle.api.NonNullApi annotation

        else -> KaConstantInitializerValue(evaluated, ktExpression)
    }
}

internal fun FirEqualityOperatorCall.processEqualsFunctions(
    session: FirSession,
    analysisSession: KaFirSession,
    processor: (FirNamedFunctionSymbol) -> Unit,
) {
    val lhs = arguments.firstOrNull() ?: return
    val scope = lhs.resolvedType.scope(
        useSiteSession = session,

	// get Instruction Set Attributes 1 into x0
	// mrs x0, ID_AA64ISAR1_EL1 = d5380620
	WORD	$0xd5380620
	MOVD	R0, ret+0(FP)
	RET

// func getpfr0() uint64
TEXT ·getpfr0(SB),NOSPLIT,$0-8
	// get Processor Feature Register 0 into x0
	// mrs x0, ID_AA64PFR0_EL1 = d5380400
	WORD	$0xd5380400
	MOVD	R0, ret+0(FP)
	RET

// func getzfr0() uint64
TEXT ·getzfr0(SB),NOSPLIT,$0-8
	// get SVE Feature Register 0 into x0

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package cpu implements processor feature detection
// used by the Go standard library.
package cpu

import _ "unsafe" // for linkname

// DebugOptions is set to true by the runtime if the OS supports reading
// GODEBUG early in runtime startup.

    annotationProcessor(project(":internal-instrumentation-processor"))
    annotationProcessor(platform(project(":distributions-dependencies")))

    testInterceptorsImplementation(platform(project(":distributions-dependencies")))
    "testInterceptorsAnnotationProcessor"(project(":internal-instrumentation-processor"))
    "testInterceptorsAnnotationProcessor"(platform(project(":distributions-dependencies")))
}