/**
     * The to attributes of the registered transform.
     */
    Map<String, String> getToAttributes();

    /**
     * The file name of the input artifact that is about to be transformed.
     */
    String getArtifactName();

    /**
     * The class of the transform action.
     */
    Class<?> getTransformActionClass();

    /**
     * The combined input hash of the secondary inputs.

 * particular option.</p>
 *
 * <p>This annotation should be attached to a getter method that returns a {@link java.util.Collection} of
 * possible values. The entries in the collection may be of any type. If necessary, they are transformed
 * into {@link String Strings} by calling {@code toString()}.</p>
 *
 * @since 4.6
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Inherited
public @interface OptionValues {

    /**

import org.gradle.api.artifacts.component.ComponentIdentifier;
import org.gradle.internal.DisplayName;

import java.util.Objects;

/**
 * Identifies the transformed artifact of a component. The original file name is tracked in order to guarantee uniqueness,
 * as artifact transformations may result in multiple artifacts with the same file name.
 *

import org.eclipse.aether.metadata.Metadata;
import org.eclipse.aether.util.ConfigUtils;

/**
 * Maven local GAV level metadata generator.
 * <p>
 * Local snapshot metadata contains non-transformed snapshot version.
 */
class LocalSnapshotMetadataGenerator implements MetadataGenerator {

    private final Map<Object, LocalSnapshotMetadata> snapshots;

    private final Date timestamp;

import java.io.File;
import java.io.IOException;

import static org.gradle.internal.classpath.transforms.MrJarUtils.isInUnsupportedMrJarVersionedDirectory;

/**
 * Transformation for legacy instrumentation when transformed JARs are part of the classpath.
 * This is still used when TestKit and TAPI run Gradle in embedded or debug mode.
 * <p>
 * This transformation filters out not yet supported versioned directories of the multi-release JARs.
 */

     * Creates a {@link TransformUpstreamDependenciesResolver} for the given {@code ComponentIdentifier} and {@code TransformChain}.
     *
     * @param componentIdentifier the identifier of the component whose artifacts will be transformed.
     * @param transformChain the transform chain that will be applied.
     *
     * @return an {@code ExecutionGraphDependenciesResolver} based on the provided parameters
     */

	// mapping from "gcp_project" to "2344534543". Keys should be prefixed
	// by the short name for the platform (example: "gcp_").
	Metadata() map[string]string

	// Locality returns the run location for the bootstrap transformed from the
	// platform-specific representation into the Envoy Locality schema.
	Locality() *core.Locality

	// Labels returns a collection of labels that exist on the underlying

        ClassLoader source,
        Predicate<String> shouldLoadTransformedClass,
        ClassTransform transform,
        InstrumentationTypeRegistry typeRegistry
    ) {
        super("test-transformed-loader", source, Collections.emptyList());
        this.shouldLoadTransformedClass = shouldLoadTransformedClass;
        this.transform = transform;
        this.source = source;
        this.typeRegistry = typeRegistry;

	exprCall
	exprConvert
	exprNew
	exprMake
	exprSizeof
	exprAlignof
	exprOffsetof
	exprZero
	exprFuncInst
	exprRecv
	exprReshape
	exprRuntimeBuiltin // a reference to a runtime function from transformed syntax. Followed by string name, e.g., "panicrangeexit"
)

type codeAssign int

func (c codeAssign) Marker() pkgbits.SyncMarker { return pkgbits.SyncAssign }

    }

    def "compileModules is a transformed view of compile"() {
        given:
        compile.incoming >> incoming

        when:
        binary.compileModules.files

        then:
        1 * incoming.artifacts >> Stub(ArtifactCollection)
    }