}

// -----

// CHECK-LABEL: func @no_args
// CHECK-SAME: (%arg0: tensor<!tf_type.resource<tensor<f32>>> {tf.resource_name = "x"})
// CHECK-NOT: "tf.VarHandleOp"
func.func @no_args() {
  %0 = "tf.VarHandleOp"() {container = "", shape = "tfshape$", shared_name = "x"} : () -> tensor<!tf_type.resource<tensor<f32>>>
  func.return
}

// CHECK-LABEL: func @some_args

  func.return %2 : tensor<1x128x128x8xf32>

  // CHECK-LABEL: testDilatedConvWithNonZeroBasePadding
  // CHECK-SAME: ([[INPUT:%.*]]: tensor<1x128x128x3xf32>, [[FILTER:%.*]]: tensor<5x5x3x8xf32>)
  // CHECK-NEXT: [[RESULT:%.*]] = "tf.Conv2D"([[INPUT]], [[FILTER]]) <{dilations = [1, 2, 2, 1], padding = "SAME", strides = [1, 1, 1, 1]}> : (tensor<1x128x128x3xf32>, tensor<5x5x3x8xf32>) -> tensor<1x128x128x8xf32>

    func.return
  }

  // CHECK-LABEL: func @main
  // CHECK-SAME:    %[[ARG0:.*]]: tensor<10xi32>, %[[ARG1:.*]]: tensor<10xi32>
  func.func @main(%arg0: tensor<10xi32>, %arg1: tensor<10xi32>) -> tensor<10xi32> {
    // CHECK:      %[[RESULT:.*]] = "tf.XlaCallModule"(%[[ARG0]], %[[ARG1]])
    // CHECK-NOT:    function_list
    // CHECK-SAME:   module = ""
    // CHECK-SAME:   _entry_function = @main_0,

    // `module` is stablehlo bytecode for:

# CHECK-SAME: _xla_compile_device_type = "GPU"
# CHECK-SAME: allow_soft_placement
# CHECK-SAME: control_outputs = ""
# CHECK-SAME: inputs = "args_0,args_1,args_2,args_3"
# CHECK-SAME: outputs = "rets_0,rets_1"
# CHECK:          %[[ISLAND_0:.*]], %[[ISLAND_0_control:.*]] = tf_executor.island wraps "tf.Const"

# CHECK:  func {{.*}} tf_saved_model.exported_names = ["key_1"]
# CHECK: "tf.If"
# CHECK-SAME: else_branch = @[[else:[a-zA-Z_0-9]+]]
# CHECK-SAME: then_branch = @[[then:[a-zA-Z_0-9]+]]

# CHECK:  func {{.*}} tf_saved_model.exported_names = ["key_2"]
# CHECK: "tf.If"
# CHECK-SAME: else_branch = @[[else]]
# CHECK-SAME: then_branch = @[[then]]

# CHECK: func private @[[else]](
# CHECK: func private @[[then]](

*/
package p

func f() {
	var x interface{}
	switch x.(type) { // should remain the same
	}
	switch (x.(type)) { // should become: switch x.(type) {
	}

	switch x.(type) { // should remain the same
	case int:
	}
	switch (x.(type)) { // should become: switch x.(type) {
	case int:
	}

	switch x.(type) { // should remain the same
	case []int:
	}

	// Parenthesized (x.(type)) in type switches containing cases

  }
}
library {
}
versions {
  producer: 198
}

# CHECK-LABEL: func @main
# CHECK-SAME:  ([[VAL_0:%.*]]: tensor<1x8x8x2xi32>) -> (tensor<1x8x8x2xi32>, tensor<i32>, tensor<10xi32>)
# CHECK-SAME:  control_outputs = ""
# CHECK-SAME:  inputs = "unranked"
# CHECK-SAME:  outputs = "unranked,static,static_10"
# CHECK-DAG:         [[VAL_2:%.*]] = arith.constant dense<0> : tensor<10xi32>

// CHECK:      %[[SHAPE:[0-9]*]] = "tf.Shape"(%[[ARG_0]])
// CHECK-NEXT: %[[LAUNCH_A:[0-9]*]] = "tf_device.launch"
// CHECK-SAME: device = "a"
// CHECK-NEXT:   %[[OP_A:[0-9]*]] = "tf.opA"(%[[SHAPE]])
// CHECK-NEXT:   tf_device.return %[[OP_A]]
// CHECK:      %[[LAUNCH_B:[0-9]*]] = "tf_device.launch"
// CHECK-SAME: device = "b"
// CHECK-NEXT:   %[[OP_B:[0-9]*]] = "tf.opB"(%[[SHAPE]], %[[LAUNCH_A]])
// CHECK-NEXT:   tf_device.return %[[OP_B]]

                verify(programHost).compileSecondStageOf(
                    same(program),
                    same(scriptHost),
                    argThat { this.sourceHash == sourceHash && this.templateId == scriptTemplateId },
                    same(ProgramKind.TopLevel),
                    same(programTarget),
                    same(accessorsClassPath)
                )

                verifyNoMoreInteractions()

// CHECK-LABEL: func @identity
// CHECK-SAME:    (%[[ARG0:.*]]: tensor<i32>)
func.func @identity(%arg0: tensor<i32>) -> tensor<i32> {
  // CHECK-NOT: "tf.Identity"
  %0 = "tf.Identity"(%arg0) : (tensor<i32>) -> tensor<i32>
  // CHECK: return %[[ARG0]]
  func.return %0 : tensor<i32>
}

// CHECK-LABEL: func @identity_terminator
// CHECK-SAME:    (%[[ARG0:.*]]: tensor<i32>)