// Chained for convenience.
// TODO: fix one day?
func (i *IdentifierNode) SetTree(t *Tree) *IdentifierNode {
	i.tr = t
	return i
}

func (i *IdentifierNode) String() string {
	return i.Ident
}

func (i *IdentifierNode) writeTo(sb *strings.Builder) {
	sb.WriteString(i.String())
}

func (i *IdentifierNode) tree() *Tree {
	return i.tr
}

func (i *IdentifierNode) Copy() Node {

func (c *sigctxt) trap() uint32    { return 0 }
func (c *sigctxt) error() uint32   { return 0 }
func (c *sigctxt) oldmask() uint32 { return 0 }

func (c *sigctxt) sigcode() uint32 { return uint32(c.info._code) }
func (c *sigctxt) sigaddr() uint32 { return uint32(c.info._reason) }

func (c *sigctxt) set_pc(x uint32)  { c.regs().__gregs[_REG_R15] = x }
func (c *sigctxt) set_sp(x uint32)  { c.regs().__gregs[_REG_R13] = x }

  func.return %0 : tensor<f32>
}

// -----

// CHECK: module attributes
// CHECK-SAME{LITERAL}: tf2xla.collective_info.group_key = 0
// CHECK-SAME{LITERAL}: tf2xla.collective_info.group_size = 2
// CHECK-LABEL: func @all_reduce_cross_replica_and_partition
func.func @all_reduce_cross_replica_and_partition(%input: tensor<f32>) -> tensor<f32> {

  %7 = "tf.Pack"(%2, %6) : (tensor<f32>, tensor<f32>) -> tensor<2xf32>
  func.return %7 : tensor<2xf32>
}

// -----

// A resource is passed into tf.If
func.func @cond_false(%arg0: tensor<!tf_type.resource<tensor<f32>>>, %arg1: tensor<f32>) -> tensor<f32> {
  func.return %arg1 : tensor<f32>
}

func.func @cond_true(%arg0: tensor<!tf_type.resource<tensor<f32>>>, %arg1: tensor<f32>) -> tensor<f32> {

      func.return %0, %1, %2, %3 : tensor<i32>, tensor<i32>, tensor<i32>, tensor<i32>
    }
    func.func @while_body_with_cluster_attr(%arg0: tensor<i32>) -> tensor<i32> {
      %0 = "tf.some_op"(%arg0) {_xla_compile_device_type = "TPU", _replication_info = "cluster"} : (tensor<i32>) -> tensor<i32>
      func.return %0 : tensor<i32>
    }

// Tests function with multiple blocks.

func.func @main() {
  ^bb:
    cf.br ^bb1
  ^bb1:
    func.return
}

// CHECK: functions must be of a single Graph with single op Islands: only single block functions are supported

// -----

// Tests invalid functions for exporting to Graph/GraphDef.

func.func @main() {
  func.return
}

func _() {
	/*	freestanding comment
		aligned line
	*/
}

func _() {
	/*	freestanding comment
		aligned line */
}

func _() {
	/*
	   freestanding comment
	   aligned line
	*/
}

func _() {
	/*
	   freestanding comment
	   aligned line
	*/
}

func _() {
	/*
	   freestanding comment
	   aligned line */
}

func _() {
	/*

func TestGuaranteedUpdate(t *testing.T) {
	// TODO(#109831): Enable use of this test and run it.
}

func TestGuaranteedUpdateWithTTL(t *testing.T) {
	ctx, cacher, terminate := testSetup(t)
	t.Cleanup(terminate)
	storagetesting.RunTestGuaranteedUpdateWithTTL(ctx, t, cacher)
}

func TestGuaranteedUpdateChecksStoredData(t *testing.T) {
	// TODO(#109831): Enable use of this test and run it.
}

}

//go:nosplit
//go:nowritebarrierrec
func (c *sigctxt) regs() *mcontextt { return &(*ucontextt)(c.ctxt).uc_mcontext }

func (c *sigctxt) eax() uint32 { return c.regs().__gregs[_REG_EAX] }
func (c *sigctxt) ebx() uint32 { return c.regs().__gregs[_REG_EBX] }
func (c *sigctxt) ecx() uint32 { return c.regs().__gregs[_REG_ECX] }
func (c *sigctxt) edx() uint32 { return c.regs().__gregs[_REG_EDX] }

func _[P *T,]() {}
func _[P *T, _ any]() {}
func _[P (*T),]() {}
func _[P (*T), _ any]() {}
func _[P (T),]() {}
func _[P (T), _ any]() {}

func _[P *struct{}] () {}
func _[P (*struct{})] () {}
func _[P ([]int)] () {}

func _ [P(T)]() {}
func _ [P((T))]() {}
func _ [P * *T]() {}
func _ [P * T]() {}
func _ [P(*T)]() {}
func _ [P(**T)]() {}
func _ [P * T]() {}