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)
    }

    private final VariantDefinition chain;

    public TransformedVariant(ResolvedVariant root, VariantDefinition chain) {
        this.root = root;
        this.chain = chain;
    }

    /**
     * @return The transformed variant which results from applying the transform chain to the root variant.
     */
    public VariantDefinition getTransformedVariantDefinition() {
        return chain;
    }

    /**

        }
        realize()

        then:
        realizeChild("foo").other == "changed"
        specialItemClass.isInstance(realizeChild("bar"))
    }

    def "can create item using transformed DSL rule closure"() {
        // DSL rules are represented using DeferredModelAction
        def action = mockDeferredModelAction()

        given:

// the first transformer.
func (t *prefixTransformers) TransformFromStorage(ctx context.Context, data []byte, dataCtx Context) ([]byte, bool, error) {
	start := time.Now()
	var errs []error
	for i, transformer := range t.transformers {
		if bytes.HasPrefix(data, transformer.Prefix) {
			result, stale, err := transformer.Transformer.TransformFromStorage(ctx, data[len(transformer.Prefix):], dataCtx)

     *
     * @return the extra info for the module
     */
    ImmutableMap<NamespaceId, String> getExtraAttributes();

    /**
     * Returns this metadata with all dependencies transformed to use the dynamic constraint version.
     */
    IvyModuleResolveMetadata withDynamicConstraintVersions();

    ImmutableList<IvyDependencyDescriptor> getDependencies();

    Table<String, Integer, String> table = HashBasedTable.create();
    checkArgument(data.length % 3 == 0);
    for (int i = 0; i < data.length; i += 3) {
      String value = (data[i + 2] == null) ? null : (data[i + 2] + "transformed");
      table.put((String) data[i], (Integer) data[i + 1], value);
    }
    return Tables.transformValues(table, FIRST_CHARACTER);
  }

  // Null support depends on the underlying table and function.

====
<1> Add the attribute to the schema
<2> All JAR files are not minified
<3> Request `minified=true` on all resolvable configurations
<4> Add the dependencies which will be transformed
<5> Add task that requires the transformed artifacts

You can now see what happens when we run the `resolveRuntimeClasspath` task which resolves the `runtimeClasspath` configuration.

// RUN: tf-quant-opt %s -split-input-file -quant-preprocess-op | FileCheck %s

module {
  // For UniformQuantized depthwise convolution, tensor shape should have
  // transformed from [H,W,C,M] to [H,W,1,CxM],
  func.func @depthwise_conv(%arg0: tensor<1x3x4x3xf32>) -> (tensor<*xf32>) {
    %cst_0 = "tf.Const"() {value = dense<0.000000e+00> : tensor<6xf32>} : () -> tensor<6xf32>