files map[string]*fileInfo
}

type fileInfo struct {
	file     *token.File
	lastline int
}

const maxlines = 64 * 1024

func (s *fakeFileSet) pos(file string, line, column int) token.Pos {
	// TODO(mdempsky): Make use of column.

	// Since we don't know the set of needed file positions, we reserve
	// maxlines positions per file. We delay calling token.File.SetLines until

}

type entry[K comparable, V any] struct {
	key   K
	value V
}

// maxSlice is the maximum number of pairs for which a slice is used.
// It is a variable for benchmarking.
var maxSlice int = 8

// add adds a key-value pair to the mapping.
func (h *mapping[K, V]) add(k K, v V) {
	if h.m == nil && len(h.s) < maxSlice {
		h.s = append(h.s, entry[K, V]{k, v})
	} else {
		if h.m == nil {
			h.m = map[K]V{}

        CacheBuilder.newBuilder()
            .maximumSize(MAX_SIZE)
            .removalListener(removalListener)
            .build(loader);
    for (int i = 0; i < 2 * MAX_SIZE; i++) {
      cache.getUnchecked(i);
      assertTrue(cache.size() <= MAX_SIZE);
    }

    assertEquals(MAX_SIZE, CacheTesting.accessQueueSize(cache));
    assertEquals(MAX_SIZE, cache.size());
    CacheTesting.processPendingNotifications(cache);

void SourceCode::IncreaseIndent() { current_indent_++; }

void SourceCode::DecreaseIndent() { current_indent_--; }

void SourceCode::ValidateAndAddLine(int indent, const string& raw_line) {
  StringPiece line(raw_line);
  bool had_trailing_newline = str_util::ConsumeSuffix(&line, "\n");

  if (absl::StrContains(line, '\n')) {
    LOG(ERROR) << "Attempt to add multiple lines; bad formatting is likely.";

                                    int64_t max_size, Operation* op,
                                    Type element_dtype, OpBuilder builder,
                                    Value* buffer);

// Same as above, but uses a Value as max_size and check if it is a constant.
LogicalResult CreateInitBufferValue(ArrayRef<int64_t> element_shape,
                                    Value max_size, Operation* op,

  // CHECK-SAME: _xla_outside_compilation
  "tf_device.cluster"() ({
    %elem_shape = "tf.Const"() {value = dense<> : tensor<0xi32>} : () -> tensor<0xi32>
    %max_size = "tf.Const"() {value = dense<10> : tensor<i32>} : () -> tensor<i32>
    %1 = "tf.EmptyTensorList"(%elem_shape, %max_size) : (tensor<0xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<f32>>>

import (
	"cmp"
	"fmt"
	"slices"
	"strconv"
	"testing"
)

func TestMapping(t *testing.T) {
	var m mapping[int, string]
	for i := 0; i < maxSlice; i++ {
		m.add(i, strconv.Itoa(i))
	}
	if m.m != nil {
		t.Fatal("m.m != nil")
	}
	for i := 0; i < maxSlice; i++ {
		g, _ := m.find(i)
		w := strconv.Itoa(i)
		if g != w {
			t.Fatalf("%d: got %s, want %s", i, g, w)
		}
	}
	m.add(4, "4")
	if m.s != nil {

// -----

// Tests while loop.

// CHECK-LABEL: func @main
func.func @main() -> () {
  %max_size = "tf.Const"() {value = dense<10> : tensor<i32>} : () -> tensor<i32>
  // CHECK-NOT: tf.Stack
  %stack = "tf.StackV2"(%max_size) {elem_type = f32, stack_name = "s"} : (tensor<i32>) -> tensor<!tf_type.resource>
  %1:2 = "tf.While"(%stack, %max_size) {
    body = @while_body, cond = @while_cond, device = "", is_stateless = false}

  %max_size = mhlo.constant dense<2> : tensor<i32>
  // NO_FALLBACK: tf.NonMaxSuppressionV4
  // SUPPORTED_FALLBACK_DEVICE-NOT: tf.NonMaxSuppressionV4
  // UNSPECIFIED_FALLBACK_DEVICE: tf.NonMaxSuppressionV4
  // UNSUPPORTED_FALLBACK_DEVICE:  tf.NonMaxSuppressionV4

  %elem_shape = "tf.Const"() {value = dense<> : tensor<0xi32>} : () -> tensor<0xi32>
  %max_size = "tf.Const"() {value = dense<10> : tensor<i32>} : () -> tensor<i32>
  // CHECK-NOT: tf.EmptyTensorList
  %tl = "tf.EmptyTensorList"(%elem_shape, %max_size) : (tensor<0xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<f32>>>
  %1:2 = "tf.While"(%tl, %max_size) {
    body = @while_body, cond = @while_cond, device = "", is_stateless = false}