// Keep track of transformed artifacts as a given artifact may appear in multiple variants and configurations
        Map<LocalComponentArtifactMetadata, LocalComponentArtifactMetadata> transformedArtifacts = new HashMap<>();

                            }
                        }
                    }
                }
            }
        }
    }

    @TargetGradleVersion(">=8.8")
    def "reports transformed display names with DisplayNameGeneration"() {
        file("src/test/java/org/example/ComplexTests.java") << """package org.example;

import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;

#include "tensorflow/compiler/mlir/lite/experimental/tac/hardwares/target_hardware.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/transforms/device_transform.h"
#include "tensorflow/compiler/mlir/lite/experimental/tac/transforms/passes.h"
#include "tensorflow/compiler/mlir/lite/ir/tfl_ops.h"

namespace mlir {
namespace TFL {
namespace tac {
namespace {

    ```mlir
      %0 = "tf.ReadVariableOp"(%arg0)
      %1 = "tf.ReadVariableOp"(%arg1)
      %2 = "tf.TPUExecute"(%0, %1, %compile)
      %3 = "tf.AssignVariableOp"(%arg0, %2)
    ```

    will be transformed into

    ```mlir
      %2 = "tf.TPUExecuteAndUpdateVariables"(%arg0, %arg1, %compile)
        { device_var_reads_indices = [0, 1],
          device_var_updates_indices = [0, -1] }
    ````

    if (failed((isQuantizableWeight(op)))) {
      return failure();
    }

    // 2. Quantize the constant to the provided data type.
    // After quantization, the graph will be transformed
    // from:
    // const -> some op -> quantizable_op
    // to:
    // q_const -> dequant_op -> some op -> quantizable_op
    //
    // A dequant_op will propagate to further quantize the next ops in another

	return func() (State, error) {
		transformer, encObject, cacheKey, errGen := GenerateTransformer(ctx, string(uuid.NewUUID()), envelopeService, useSeed)
		if errGen != nil {
			return State{}, errGen
		}
		return State{
			Transformer:         transformer,
			EncryptedObject:     *encObject,
			UID:                 "panda",

struct TrivialTransformInfo {
  // Can the op be transformed trivially?
  bool can_transform = false;

  // List of callee names (one for each region).
  llvm::SmallVector<StringRef, 2> callee_names;

  // Analyzes the given calls (from regions attached to the same parent op) to
  // check if the parent op be transformed to functional form trivially (i.e.,

   *
   * <p>If only a {@code Collection} or {@code Iterable} input is available, use {@link
   * Collections2#transform} or {@link Iterables#transform}.
   *
   * <p><b>Note:</b> serializing the returned list is implemented by serializing {@code fromList},
   * its contents, and {@code function} -- <i>not</i> by serializing the transformed values. This
   * can lead to surprising behavior, so serializing the returned list is <b>not recommended</b>.

     *
     * @since 3.5
     */
    public void file(Action<? super XmlFileContentMerger> action) {
        action.execute(file);
    }

    /**
     * Source directories to be transformed into wb-resource elements.
     * <p>
     * For examples see docs for {@link EclipseWtp}
     * <p>
     * Only source dirs that exist will be added to the wtp component file.

    %0 = tfl.add %arg0, %arg1 {fused_activation_function = "RELU6", tac.device = "GPU", tac.inference_type = "FLOAT"} : tensor<1xf32>
    return %0 : tensor<1xf32>
  }
```

Will be transformed into:

```
 func private @func_2_CPU_FLOAT(%arg0: tensor<1xf32>, %arg1: tensor<1xf32>) -> tensor<2x1xf32> attributes {tac.device = "CPU", tac.inference_type = "FLOAT", tac.interface_name = "func_2"} {