.version(settingsOs.getVersion())
                        .location("arch", toLocation(settingsOs.getLocation("arch")))
                        .location("family", toLocation(settingsOs.getLocation("family")))
                        .location("name", toLocation(settingsOs.getLocation("name")))
                        .location("version", toLocation(settingsOs.getLocation("version")))
                        .build());
            }

    private final javax.xml.stream.Location location;

    public static Location getLocation(Exception e) {
        return toLocation(e instanceof XMLStreamException xe ? xe.getLocation() : null);
    }

    public static Location toLocation(javax.xml.stream.Location location) {
        return location != null ? new StaxLocation(location) : null;
    }

    public static String getMessage(Exception e) {

        return new BuildInitDependency(group + ":" + name, version);
    }

    public static BuildInitDependency of(String module) {
        return new BuildInitDependency(module, null);
    }

    public String toNotation() {
        return module + (version != null ? ":" + version : "");
    }

      if (isa<tf_device::ClusterOp>(op)) return WalkResult::advance();
      op->removeAttr(TF::kReplicationInfoAttr);
      op->removeAttr(TF::kCompileDeviceTypeAttr);
      // This attribute is used for op colocation. Since all ops are located
      // on a single device cluster, this private attribute is no longer
      // needed.
      op->removeAttr(kClassAttr);
      if (auto attr = op->getAttrOfType<StringAttr>(kDeviceAttr)) {

namespace TFTPU {

namespace {

#define GEN_PASS_DEF_TPUCOLOCATESPLITSPASS
#include "tensorflow/compiler/mlir/tensorflow/transforms/tf_passes.h.inc"

constexpr char kDeviceAttr[] = "device";
// Attribute of colocation classes.
constexpr char kClassAttr[] = "_class";

bool HasDevice(Operation* op) {
  auto attr = op->getAttrOfType<StringAttr>(kDeviceAttr);
  if (!attr) return false;
  return !attr.getValue().empty();
}

                toContextualLabel(basicProblemDetails.getLabel().getLabel()),
                toProblemDetails(basicProblemDetails.getDetails()),
                toLocations(basicProblemDetails.getLocations()),
                toSolutions(basicProblemDetails.getSolutions()),
                toAdditionalData(basicProblemDetails.getAdditionalData()),

  Scope ColocateWith(const Operation& op) const;
  /// Convenience function for above.
  Scope ColocateWith(const Output& out) const { return ColocateWith(out.op()); }
  /// Clear all colocation constraints.
  Scope ClearColocation() const;

  /// Return a new scope. The op-constructor functions taking the returned scope
  /// as the scope argument will exit as soon as an error is detected, instead

                    statementGroup.add(new DepSpec(configuration, null, versionCatalogRef, true));
                } else {
                    statementGroup.add(new DepSpec(configuration, null, d.toNotation(), false));
                }
            }
            return statementGroup;
        }

        @Override

    minimized when the `Split` is with its predecessor. This colocation
    constraint will be used by the placer graph optimization to assign a device
    to the op.

    This pass should run in the export pipeline after tf-replicate-to-island so
    each replica has its own distinct (predecessor, Split) pair.

    The colocation class (`_class`) of the `Split` is set to the same class as
    its predecessor:

minimized when the `Split` is with its predecessor. This colocation
constraint will be used by the placer graph optimization to assign a device
to the op.

This pass should run in the export pipeline after tf-replicate-to-island so
each replica has its own distinct (predecessor, Split) pair.

The colocation class (`_class`) of the `Split` is set to the same class as
its predecessor: