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

// These are the supported cases, just make sure they don't trigger errors, op
// syntax is tested elsewhere.

func @mlir_dialect_cast(%0: index, %1: i32, %2: bf16, %3: f16, %4: f32, %5: f64,
                        %6: vector<42xf32>, %7: memref<42xf32>,
                        %8: memref<?xf32>, %9: memref<f32>,
                        %10: memref<*xf32>) {
  llvm.mlir.cast %0 : index to i64
  llvm.mlir.cast %0 : index to i32
  llvm.mlir.cast %7 : memref<42xf32> to !llvm.ptr<f32>
  llvm.mlir.cast %7 : memref<42xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)>
  llvm.mlir.cast %8 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<1xi64>)>
  llvm.mlir.cast %9 : memref<f32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64)>
  llvm.mlir.cast %10 : memref<*xf32> to !llvm.struct<(i64, ptr<i8>)>
  return
}

// -----

func @mlir_dialect_cast_index_non_integer(%0 : index) {
  // expected-error@+1 {{invalid cast between index and non-integer type}}
  %1 = llvm.mlir.cast %0 : index to f32
}

// -----

// Cast verifier is symmetric, so we only check the symmetry once by having an
// std->llvm and llvm->std test. Everything else is std->llvm.

func @mlir_dialect_cast_index_non_integer_symmetry(%0: f32) {
  // expected-error@+1 {{invalid cast between index and non-integer type}}
  llvm.mlir.cast %0 : f32 to index
}

// -----

func @mlir_dialect_cast_f16(%0 : f16) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : f16 to f32
}

// -----

func @mlir_dialect_cast_bf16(%0 : bf16) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : bf16 to f16
}

// -----

func @mlir_dialect_cast_f32(%0 : f32) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : f32 to bf16
}

// -----

func @mlir_dialect_cast_f64(%0 : f64) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : f64 to f32
}

// -----

func @mlir_dialect_cast_integer_non_integer(%0 : i16) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : i16 to f16
}

// -----

func @mlir_dialect_cast_scalable_vector(%0 : vector<2xf32>) {
  // expected-error@+1 {{vector types should not be casted}}
  llvm.mlir.cast %0 : vector<2xf32> to !llvm.vec<?x2xf32>
}

// -----

func @mlir_dialect_cast_dynamic_memref_bare_ptr(%0 : memref<?xf32>) {
  // expected-error@+1 {{unexpected bare pointer for dynamically shaped memref}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.ptr<f32>
}

// -----

func @mlir_dialect_cast_memref_bare_ptr_space(%0 : memref<4xf32, 4>) {
  // expected-error@+1 {{invalid conversion between memref and pointer in different memory spaces}}
  llvm.mlir.cast %0 : memref<4xf32, 4> to !llvm.ptr<f32, 3>
}

// -----

func @mlir_dialect_cast_memref_no_descriptor(%0 : memref<?xf32>) {
  // expected-error@+1 {{invalid cast between a memref and a type other than pointer or memref descriptor}}
  llvm.mlir.cast %0 : memref<?xf32> to f32
}

// -----

func @mlir_dialect_cast_memref_descriptor_wrong_num_elements(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected memref descriptor with 5 elements}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<()>
}

// -----

func @mlir_dialect_cast_0d_memref_descriptor_wrong_num_elements(%0 : memref<f32>) {
  // expected-error@+1 {{expected memref descriptor with 3 elements}}
  llvm.mlir.cast %0 : memref<f32> to !llvm.struct<()>
}

// -----

func @mlir_dialect_cast_memref_descriptor_allocated(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected first element of a memref descriptor to be a pointer in the address space of the memref}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(f32, f32, f32, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_allocated_wrong_space(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected first element of a memref descriptor to be a pointer in the address space of the memref}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32, 2>, f32, f32, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_aligned(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected second element of a memref descriptor to be a pointer in the address space of the memref}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, f32, f32, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_aligned_wrong_space(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected second element of a memref descriptor to be a pointer in the address space of the memref}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32, 2>, f32, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_offset(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected third element of a memref descriptor to be index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, f32, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_sizes(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fourth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, f32, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_sizes_wrong_type(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fourth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<10xf32>, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_sizes_wrong_rank(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fourth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<10xi64>, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_strides(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fifth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, f32)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_strides_wrong_type(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fifth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<10xf32>)>
}

// -----

func @mlir_dialect_cast_memref_descriptor_strides_wrong_rank(%0 : memref<?xf32>) {
  // expected-error@+1 {{expected fifth element of a memref descriptor to be an array of <rank> index-compatible integers}}
  llvm.mlir.cast %0 : memref<?xf32> to !llvm.struct<(ptr<f32>, ptr<f32>, i64, array<1xi64>, array<10xi64>)>
}

// -----

func @mlir_dialect_cast_tensor(%0 : tensor<?xf32>) {
  // expected-error@+1 {{unsupported cast}}
  llvm.mlir.cast %0 : tensor<?xf32> to f32
}

// -----

func @mlir_dialect_cast_unranked_memref(%0: memref<*xf32>) {
  // expected-error@+1 {{expected descriptor to be a struct with two elements}}
  llvm.mlir.cast %0 : memref<*xf32> to !llvm.ptr<f32>
}

// -----

func @mlir_dialect_cast_unranked_memref(%0: memref<*xf32>) {
  // expected-error@+1 {{expected descriptor to be a struct with two elements}}
  llvm.mlir.cast %0 : memref<*xf32> to !llvm.struct<()>
}

// -----

func @mlir_dialect_cast_unranked_rank(%0: memref<*xf32>) {
  // expected-error@+1 {{expected first element of a memref descriptor to be an index-compatible integer}}
  llvm.mlir.cast %0 : memref<*xf32> to !llvm.struct<(f32, f32)>
}

// -----

func @mlir_dialect_cast_unranked_rank(%0: memref<*xf32>) {
  // expected-error@+1 {{expected second element of a memref descriptor to be an !llvm.ptr<i8>}}
  llvm.mlir.cast %0 : memref<*xf32> to !llvm.struct<(i64, f32)>
}