// RUN: mlir-opt %s -split-input-file -verify-diagnostics | FileCheck %s

func @correct_int_types_success() {
  "test.int_types"() : () -> (i16, si32, ui64, i8)
  "test.int_types"() : () -> (si16, si32, ui64, ui64)
  "test.int_types"() : () -> (ui16, si32, ui64, si128)
  return
}

// -----

func @wrong_int_type_signedness_failure() {
  // expected-error @+1 {{result #1 must be 32-bit signed integer, but got 'ui32'}}
  "test.int_types"() : () -> (ui16, ui32, ui64, si8)
  return
}

// -----

func @wrong_int_type_signedness_failure() {
  // expected-error @+1 {{result #2 must be 64-bit unsigned integer, but got 'si64'}}
  "test.int_types"() : () -> (ui16, si32, si64, ui8)
  return
}

// -----

func @wrong_int_type_failure() {
  // expected-error @+1 {{result #0 must be 16-bit integer, but got 'f16'}}
  "test.int_types"() : () -> (f16, si32, ui64, i16)
  return
}

// -----

func @wrong_int_type_failure() {
  // expected-error @+1 {{result #3 must be integer, but got 'f64'}}
  "test.int_types"() : () -> (i16, si32, ui64, f64)
  return
}

// -----

// CHECK-LABEL: @complex_f64_success
func @complex_f64_success() {
  "test.complex_f64"() : () -> (complex<f64>)
  return
}

// -----

// CHECK-LABEL: @complex_f64_tensor_success
func @complex_f64_tensor_success() {
  "test.complex_f64_tensor"() : () -> (tensor<complex<f64>>)
  return
}

// -----

func @complex_f64_failure() {
  // expected-error@+1 {{op inferred type(s) 'complex<f64>' are incompatible with return type(s) of operation 'f64'}}
  "test.complex_f64"() : () -> (f64)
  return
}

// -----

// CHECK-LABEL: @tuple_success
func @tuple_success() {
  "test.tuple_32_bit"() : () -> (tuple<i32>)
  return
}

// -----

// CHECK-LABEL: @tuple_mixed_success
func @tuple_mixed_success() {
  "test.tuple_32_bit"() : () -> (tuple<i32, f32>)
  return
}

// -----

func @tuple_empty_success() {
  "test.tuple_32_bit"() : () -> (tuple<>)
  return
}

// -----

func @tuple_wrong_type_scalar() {
  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
  "test.tuple_32_bit"() : () -> (tuple<i64>)
  return
}

// -----

func @tuple_wrong_type_tensor() {
  // expected-error@+1 {{must be tuple with any combination of 32-bit signless integer or 32-bit float values}}
  "test.tuple_32_bit"() : () -> (tuple<tensor<i32>>)
  return
}

// -----

// CHECK-LABEL: @nested_tuple_empty_success
func @nested_tuple_empty_success() {
  "test.nested_tuple_32_bit"() : () -> (tuple<>)
  return
}

// -----

// CHECK-LABEL: @nested_tuple_one_level_success
func @nested_tuple_one_level_success() {
  "test.nested_tuple_32_bit"() : () -> (tuple<i32>)
  return
}

// -----

// CHECK-LABEL: @nested_tuple_multi_level_success
func @nested_tuple_multi_level_success() {
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i32>>>)
  return
}

// -----

// CHECK-LABEL: @nested_tuple_multi_level_mixed_success
func @nested_tuple_multi_level_mixed_success() {
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<f32, tuple<i32>>>)
  return
}

// -----

func @nested_tuple_multi_level_wrong_type() {
  // expected-error@+1 {{must be nested tuple with any combination of 32-bit signless integer or 32-bit float values}}
  "test.nested_tuple_32_bit"() : () -> (tuple<i32, tuple<i32, tuple<i64>>>)
  return
}

// -----

// CHECK-LABEL: func @rank_less_than_2_I8_F32_memref_success
func @rank_less_than_2_I8_F32_memref_success() {
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i8>)
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<3xi8>)
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<f32>)
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1xf32>)
  return
}

// -----

func @rank_less_than_2_I8_F32_memref_bad_type() {
  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<i16>)
  return
}

// -----

func @rank_less_than_2_I8_F32_memref_bad_rank() {
  // expected-error@+1 {{must be 0D/1D memref of 8-bit signless integer or 32-bit float values}}
  "test.rank_less_than_2_I8_F32_memref"() : () -> (memref<1x2xi8>)
  return
}

// -----

func @nd_tensor_of_success(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi16>) {
  "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg4) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi16>) -> ()
  return
}

// -----

func @nd_tensor_of_success_wrong_type_0d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
  // expected-error @+1 {{'test.nd_tensor_of' op operand #0 must be 0D tensor of 32-bit float values}}
  "test.nd_tensor_of"(%arg1, %arg1, %arg2, %arg3, %arg4) : (tensor<10xf32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<70x80x90x100xi32>) -> ()
  return
}

// -----

func @nd_tensor_of_success_wrong_type_4d(%arg0: tensor<f32>, %arg1: tensor<10xf32>, %arg2: tensor<20x30xi16>, %arg3: tensor<40x50x60xi16>, %arg4: tensor<70x80x90x100xi32>) {
  // expected-error @+1 {{'test.nd_tensor_of' op operand #4 must be 4D tensor of 16-bit signless integer values}}
  "test.nd_tensor_of"(%arg0, %arg1, %arg2, %arg3, %arg3) : (tensor<f32>, tensor<10xf32>, tensor<20x30xi16>, tensor<40x50x60xi16>, tensor<40x50x60xi16>) -> ()
  return
}

// -----

func @ranked_tensor_success(%arg0: tensor<i8>, %arg1: tensor<1xi32>, %arg2: tensor<?x?xf32>) {
  "test.ranked_tensor_op"(%arg0) : (tensor<i8>) -> ()
  "test.ranked_tensor_op"(%arg1) : (tensor<1xi32>) -> ()
  "test.ranked_tensor_op"(%arg2) : (tensor<?x?xf32>) -> ()
  return
}

// -----

func @ranked_tensor_success(%arg0: tensor<*xf32>) {
  // expected-error @+1 {{must be ranked tensor of any type values}}
  "test.ranked_tensor_op"(%arg0) : (tensor<*xf32>) -> ()
  return
}

// -----

func @ranked_tensor_success(%arg0: vector<2xf32>) {
  // expected-error @+1 {{must be ranked tensor of any type values}}
  "test.ranked_tensor_op"(%arg0) : (vector<2xf32>) -> ()
  return
}

// -----

func @multi_tensor_rank_of_success(%arg0: tensor<i8>, %arg1: tensor<i32>, %arg2: tensor<f32>, %arg3: tensor<1xi8>, %arg4: tensor<1xi32>, %arg5: tensor<1xf32>) {
  "test.multi_tensor_rank_of"(%arg0) : (tensor<i8>) -> ()
  "test.multi_tensor_rank_of"(%arg1) : (tensor<i32>) -> ()
  "test.multi_tensor_rank_of"(%arg2) : (tensor<f32>) -> ()
  "test.multi_tensor_rank_of"(%arg3) : (tensor<1xi8>) -> ()
  "test.multi_tensor_rank_of"(%arg4) : (tensor<1xi32>) -> ()
  "test.multi_tensor_rank_of"(%arg5) : (tensor<1xf32>) -> ()
  return
}

// -----

func @multi_tensor_rank_of_wrong_unranked_type(%arg0: tensor<2x2xi8>) {
  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
  "test.multi_tensor_rank_of"(%arg0) : (tensor<2x2xi8>) -> ()
  return
}

// -----

func @multi_tensor_rank_of_wrong_element_type(%arg0: tensor<2xi16>) {
  // expected-error @+1 {{'test.multi_tensor_rank_of' op operand #0 must be 0D/1D tensor of 8-bit signless integer or 32-bit signless integer or 32-bit float values}}
  "test.multi_tensor_rank_of"(%arg0) : (tensor<2xi16>) -> ()
  return
}

// -----

// CHECK-LABEL: @fixed_element_types
func @fixed_element_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>, %mi32 : memref<2x3xi32>, %vf32 : vector<2xf32>) {
  "test.arg_and_res_have_fixed_element_types"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i16>
  "test.arg_and_res_have_fixed_element_types"(%mi32, %vf32) : (memref<2x3xi32>, vector<2xf32>) -> memref<1x2xi16>
  return
}

// -----

func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
  // expected-error@+1 {{'res' is 16-bit signless integer}}
  "test.arg_and_res_have_fixed_element_types"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
  return
}

// -----

func @fixed_element_types(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
  // expected-error@+1 {{fixed type combination}}
  "test.arg_and_res_have_fixed_element_types"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i16>
  return
}

// -----

// CHECK-LABEL: same_element_types_success
func @same_element_types_success(%ti32: tensor<* x i32>, %i32 : i32, %mi32 : memref<2x3xi32>) {
  "test.operands_have_same_element_type"(%ti32, %ti32): (tensor<* x i32>, tensor<* x i32>) -> ()
  "test.operands_have_same_element_type"(%i32, %ti32): (i32, tensor<* x i32>) -> ()
  "test.operands_have_same_element_type"(%i32, %mi32): (i32, memref<2x3xi32>) -> ()
  return
}


// -----

func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
  // expected-error@+1 {{verify that all of {x, y} have same element type}}
  "test.operands_have_same_element_type"(%arg1, %arg0): (tensor<* x f32>, tensor<* x i32>) -> ()
  return
}

// -----

// CHECK-LABEL: same_element_types_success
func @same_element_types_success(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x f32>
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> memref<2x3xf32>
  "test.operand0_and_result_have_same_element_type"(%tf32, %ti32) : (tensor<* x f32>, tensor<* x i32>) -> f32
  return
}

// -----

func @same_element_types_failure(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
  // expected-error@+1 {{all of {x, res} have same element type}}
  "test.operand0_and_result_have_same_element_type"(%arg1, %arg0) : (tensor<* x f32>, tensor<* x i32>) -> tensor<* x i32>
  return
}

// -----

// CHECK-LABEL: same_types
func @same_types(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
  "test.operands_have_same_type"(%ti32, %ti32) : (tensor<* x i32>, tensor<* x i32>) -> ()
  "test.operand0_and_result_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x i32>
  return
}

// -----

func @same_types_failure(%ti32: tensor<* x i32>, %i32: i32) {
  // expected-error@+1 {{all of {x, y} have same type}}
  "test.operands_have_same_type"(%ti32, %i32) : (tensor<* x i32>, i32) -> ()
  return
}

// -----

func @same_types_element_mismatch(%ti32: tensor<* x i32>, %tf32: tensor<* x f32>) {
  // expected-error@+1 {{all of {x, y} have same type}}
  "test.operands_have_same_type"(%ti32, %tf32) : (tensor<* x i32>, tensor<* x f32>) -> ()
  return
}

// -----

func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
  // expected-error@+1 {{all of {x, y} have same type}}
  "test.operands_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> ()
  return
}

// -----

// CHECK-LABEL: same_rank_success
func @same_rank_success(%t1xi : tensor<1xi32>, %t2xf : tensor<2xf32>, %m3xi : memref<3xi32>, %t1x2xf : tensor<1x2xf32>, %t1x2xi : tensor<1x2xi32>) {
  "test.operands_have_same_rank"(%t1xi, %t2xf) : (tensor<1xi32>, tensor<2xf32>) -> ()
  "test.operands_have_same_rank"(%t1xi, %m3xi) : (tensor<1xi32>, memref<3xi32>) -> ()
  "test.operand0_and_result_have_same_rank"(%t1xi, %t1x2xf) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<3xf32>)
  "test.operand0_and_result_have_same_rank"(%t1x2xi, %t1x2xf) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3x3xf64>)
  return
}

// -----

func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
  // expected-error@+1 {{all of {x, y} have same rank}}
  "test.operands_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> ()
  return
}

// -----

func @same_rank_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
  // expected-error@+1 {{all of {x, res} have same rank}}
  "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<i32>)
  return
}

// -----

func @same_rank_failure(%arg0: tensor<1x2xi32>, %arg1: tensor<1x2xf32>) {
  // expected-error@+1 {{all of {x, res} have same rank}}
  "test.operand0_and_result_have_same_rank"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<1x2xf32>) -> (tensor<3xi32>)
  return
}

// -----

// CHECK-LABEL: same_shape_success
func @same_shape_success(%t2x3: tensor<2x3xi32>, %m2x3: memref<2x3xf32>, %v2x3 : vector<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<2x3xf32>)
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (memref<2x3xf32>)
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (vector<2x3xf32>)
  return
}

// -----

func @same_shape_failure(%t2x3: tensor<2x3xi32>, %t4x5 : tensor<4x5xi32>) {
  // expected-error@+1 {{all of {x, res} have same shape}}
  "test.operand0_and_result_have_same_shape"(%t2x3, %t4x5) : (tensor<2x3xi32>, tensor<4x5xi32>) -> (tensor<1x3xf32>)
  return
}

// -----

// CHECK-LABEL: same_element_count_success
func @same_element_count_success(%arg0: tensor<36xi32>, %arg1: tensor<1x2xf32>, %arg3: tensor<f32>) {
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x4x3xf32>)
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<36xi32>, tensor<1x2xf32>) -> (tensor<3x12xf64>)
  "test.operand0_and_result_have_same_element_count"(%arg3, %arg1) : (tensor<f32>, tensor<1x2xf32>) -> (memref<1x1x1xi32>)
  return
}

// -----

func @same_element_count_failure(%arg0: tensor<1xi32>, %arg1: tensor<1x2xf32>) {
  // expected-error@+1 {{all of {x, res} have same element count}}
  "test.operand0_and_result_have_same_element_count"(%arg0, %arg1) : (tensor<1xi32>, tensor<1x2xf32>) -> (tensor<2xi32>)
  return
}

// -----

func @four_equals_five() {
  // expected-error@+1 {{failed to verify that 4 equals 5}}
  "test.four_equals_five"() : () -> ()
  return
}

// -----

func @operand_rank_equals_result_size_success(%arg : tensor<1x2x3x4xi32>) {
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<4xi32>
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> memref<2x2xf32>
  return
}

// -----

func @operand_rank_equals_result_size_failure(%arg : tensor<1x2x3x4xi32>) {
  // expected-error@+1 {{failed to verify that operand rank equals result size}}
  "test.operand_rank_equals_result_size"(%arg) : (tensor<1x2x3x4xi32>) -> tensor<2xi32>
  return
}

// -----

func @same_types_element_mismatch(%arg0: tensor<* x i32>, %arg1: tensor<* x f32>) {
  // expected-error@+1 {{op inferred type(s) 'tensor<*xi32>' are incompatible with return type(s) of operation 'tensor<*xf32>'}}
  "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<* x i32>, tensor<* x f32>) -> tensor<* x f32>
  return
}

// -----

func @same_types_shape_mismatch(%arg0: tensor<1x2xi32>, %arg1: tensor<2x1xi32>) {
  // expected-error@+1 {{op inferred type(s) 'tensor<1x2xi32>' are incompatible with return type(s) of operation 'tensor<2x1xi32>'}}
  "test.operand0_and_result_have_same_type"(%arg0, %arg1) : (tensor<1x2xi32>, tensor<2x1xi32>) -> tensor<2x1xi32>
  return
}

// -----

func @does_not_have_i32(%arg0: tensor<1x2xi32>, %arg1: none) {
  // expected-error@+1 {{either both none type operands or first is not none}}
  "test.if_first_operand_is_none_then_so_is_second"(%arg1, %arg0) : (none, tensor<1x2xi32>) -> ()
  return
}

// -----

func @does_not_have_static_memref(%arg0: memref<?xi32>) {
  // expected-error@+1 {{'test.takes_static_memref' op operand #0 must be statically shaped memref of any type values}}
  "test.takes_static_memref"(%arg0) : (memref<?xi32>) -> ()
}

// -----

func @elements_attr_not_i32_f32() {
  // expected-error@+1 {{32-bit signless integer elements attribute}}
  "test.i32ElementsAttr"() {attr = dense<[1.0, 20.0]>:tensor<2xf32>} : () -> ()
  return
}

// -----

func @elements_attr_not_i32_i64() {
  // expected-error@+1 {{32-bit signless integer elements attribute}}
  "test.i32ElementsAttr"() {attr = dense<[1, 20]>:tensor<2xi64>} : () -> ()
  return
}


// -----

func @elements_attr_i32(%arg0: tensor<1x2xi32>) {
  "test.i32ElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
  return
}

// -----

func @elements_attr_index() {
  "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xindex>} : () -> ()
  return
}

// -----

func @elements_attr_not_index() {
  // expected-error@+1 {{index elements attribute}}
  "test.indexElementsAttr"() {attr = dense<[1, 2]>:tensor<2xi32>} : () -> ()
  return
}

// -----

// CHECK-LABEL: @struct_success
func @struct_success() {
  "test.simple_struct"() : () -> (!test.struct<{a, i32}, {b, f64}>)
  return
}

// -----

// CHECK-LABEL: @struct_with_field_names_like_types
func @struct_with_field_names_like_types() {
  "test.struct_with_field_names_like_types"() : () -> (!test.struct<{i32, i32}, {f64, f64}>)
  return
}

// -----

func @struct_bad_keywords() {
  // expected-error@+1 {{expected valid keyword}}
  "test.struct_bad_keywords"() : () -> (!test.struct<{42, i32}>)
  return
}