ModuleOp module = getOperation();
  module.walk([&](tf_device::LaunchFuncOp launch) {
    OpBuilder builder(launch);
    auto call_op = builder.create<TF::PartitionedCallOp>(
        module.getLoc(), launch.getResultTypes(), launch.getOperands(),
        SymbolRefAttr::get(builder.getContext(), launch.getFunc()),
        /*config=*/builder.getStringAttr(""),
        /*config_proto=*/builder.getStringAttr(""),

func.func @non_replicated(%arg0: tensor<*x!tf_type.resource> {tf.device = "/device:CPU:0"}) -> tensor<i32> {
  // CHECK: %[[COMPILE:.*]]:2 = "tf_device.launch"
  // CHECK-NEXT: "tf._TPUCompileMlir"()
  %compile:2 = "tf_device.launch"() ({
    %1:2 = "tf._TPUCompileMlir"() {
      NumDynamicShapes = 0 : i64,
      // The metadata encodes 2 parameter and two return values.

        fun fromDslContext(): VersionedSettingsBranch {
            val branch = DslContext.getParameter("Branch")
            // TeamCity uses a dummy name when first running the DSL
            if (branch.contains("placeholder-1")) {
                return VersionedSettingsBranch(MASTER_BRANCH)
            }
            return VersionedSettingsBranch(branch)
        }

        // then
        verifyBaselineDetermination("my-branch", false, null, "5.1-commit-master-fork-point")
    }

    @Test
    fun `uses configured version on master branch`() {
        verifyBaselineDetermination("master", false, defaultPerformanceBaselines, defaultPerformanceBaselines)
    }

    @Test
    fun `uses configured version when it is overwritten on feature branch`() {

        if branch["source"]["branch"] != "master":
            raise Exception("cannot find master source branch for destination %s" % rule["destination"])

        # we specify the go version for all master branches through `default-go-version`
        # so ensure we don't specify explicit go version for master branch in rules
        if "go" in branch:

// Test that extract TPUCopyWithDynamicShape from host launch to device launch.

module attributes {tf.devices = {"/job:localhost/replica:0/task:0/device:COMPOSITE:0", "/job:localhost/replica:0/task:0/device:CPU:0", "/job:localhost/replica:0/task:0/device:TPU:0", "/job:localhost/replica:0/task:0/device:TPU_SYSTEM:0"}} {
  // CHECK-LABEL: func @valid_copy_op_in_replicated_host

  // CHECK: "tf_device.launch"
  // CHECK-SAME: "TPU_REPLICATED_HOST_0"

logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`
 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`
 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,
  private val launch: Launch? = null,
) : EventListener.Factory {

    private final String branch;
    private final String ivyStatus;
    private final IvyExtraInfo extraInfo;

    public DefaultIvyModuleDescriptor(Map<NamespaceId, String> extraInfo, @Nullable String branch, String ivyStatus) {
        this.extraInfo = new DefaultIvyExtraInfo(extraInfo);
        this.branch = branch;
        this.ivyStatus = ivyStatus;
    }

    @Override

            var branch = root
            groupPath.forEachIndexed { index, segment ->
                when (val group = branch[segment]) {
                    null -> {
                        val newGroupMap = linkedMapOf<String, PluginTree>()
                        val newGroup = PluginGroup(groupPath.take(index + 1), newGroupMap)
                        branch[segment] = newGroup

package promotion

import common.VersionedSettingsBranch
import vcsroots.gradlePromotionBranches

class PublishNightlySnapshotFromQuickFeedbackStepUpload(branch: VersionedSettingsBranch) : BasePublishGradleDistribution(
    promotedBranch = branch.branchName,
    prepTask = branch.prepNightlyTaskName(),
    triggerName = "QuickFeedback",
    vcsRootId = gradlePromotionBranches
) {
    init {