// types are static.
    SmallVector<DenseIntElementsAttr, 4> indices;
    indices.reserve(op.getN());
    for (auto it : llvm::zip(op.getIndices(), op.getData())) {
      Value index = std::get<0>(it);
      Value data = std::get<1>(it);

      DenseIntElementsAttr index_attr;
      if (!matchPattern(index, m_Constant(&index_attr))) return failure();

    @Nonnull
    Settings getSettings();

    @Nonnull
    LocalRepository getLocalRepository();

    @Nonnull
    List<RemoteRepository> getRemoteRepositories();

    @Nonnull
    SessionData getData();

    /**
     * Returns immutable user properties to use for interpolation. The user properties have been configured directly
     * by the user, e.g. via the {@code -Dkey=value} parameter on the command line.
     *

                if ( r.getByteCount() > 0 && pad > 0 && pad < 4 )
                    readn(this.in, buffer, 4 + off, pad);

                if ( r.getDataLength() > 0 ) {
                    readn(this.in, r.getData(), r.getOffset(), r.getDataLength()); /* read direct */
                }
            }
            else {
                readn(this.in, buffer, 4 + SMB1_HEADER_LENGTH, size - SMB1_HEADER_LENGTH);

			return nil
		}
		return err
	}

	m.mutex.Lock()
	defer m.mutex.Unlock()
	podDevices, registeredDevs := cp.GetData()
	m.podDevices.fromCheckpointData(podDevices)
	m.allocatedDevices = m.podDevices.devices()
	for resource := range registeredDevs {
		// During start up, creates empty healthyDevices list so that the resource capacity

        eventSpyDispatcher = container.lookup(EventSpyDispatcher.class);

        DefaultEventSpyContext eventSpyContext = new DefaultEventSpyContext();
        Map<String, Object> data = eventSpyContext.getData();
        data.put("plexus", container);
        data.put("workingDirectory", cliRequest.workingDirectory);
        data.put("systemProperties", cliRequest.systemProperties);

  llvm::SmallDenseSet<int64_t, 8> index_values;
  bool all_indices_const = true;
  int32_t max_index = -1;
  std::optional<SmallVector<int64_t, 4>> inferred_item_shape;
  for (auto it : llvm::zip(op.getIndices(), op.getData())) {
    Value index = std::get<0>(it);

    DenseIntElementsAttr index_attr;
    if (matchPattern(index, m_Constant(&index_attr))) {
      for (int32_t index : index_attr.getValues<int32_t>()) {

  LogicalResult matchAndRewrite(OpTy op,
                                PatternRewriter &rewriter) const override {
    auto data_type = mlir::dyn_cast<RankedTensorType>(op.getData().getType());
    if (!data_type) return failure();
    int64_t data_rank = data_type.getRank();

    auto segment_ids_type =
        mlir::dyn_cast<RankedTensorType>(op.getSegmentIds().getType());

    attr = mlir::DenseIntOrFPElementsAttr::getFromRawBuffer(
        mlir::cast<mlir::ShapedType>(
            vhlo_type_converter.convertType(tensor_v1_attr.getType())),
        tensor_v1_attr.getData());
  } else if (auto cst = dyn_cast<tfl::SparseConstOp>(inst)) {
    attr = cst.getCompressedData();
  } else if (auto cst = dyn_cast<tfl::SparseQConstOp>(inst)) {
    attr = cst.getCompressedData();
  } else {

template <class Op>
static LogicalResult VerifyUnsortedSegmentReduction(Op op) {
  if (!HasRankAtMost(op.getNumSegments(), 0))
    return op.emitOpError("number of segments should be a 0-D tensor");

  auto data_type = op.getData().getType().template dyn_cast<RankedTensorType>();
  auto segment_ids_type =
      op.getSegmentIds().getType().template dyn_cast<RankedTensorType>();
  if (data_type && segment_ids_type) {

// Larger example from issue

type InterfaceA[T comparable] interface {
	setData(string) InterfaceA[T]
}

type ImplA[T comparable] struct {
	data string
	args []any
}

func NewInterfaceA[T comparable](args ...any) InterfaceA[T] {
	return &ImplA[T]{
		data: fmt.Sprintf("%v", args...),
		args: args,
	}
}

func (k *ImplA[T]) setData(data string) InterfaceA[T] {
	k.data = data
	return k
}