// RUN: %clang_cc1 %s -verify -fsyntax-only -Wvector-conversion -triple x86_64-apple-darwin10

typedef unsigned int v2u __attribute__ ((ext_vector_type(2)));
typedef int v2s __attribute__ ((ext_vector_type(2)));
typedef float v2f __attribute__ ((ext_vector_type(2)));

void test1(v2u v2ua, v2s v2sa, v2f v2fa) {
  // Bitwise binary operators
  (void)(v2ua & v2ua);
  (void)(v2fa & v2fa); // expected-error{{invalid operands to binary expression}}

  // Unary operators
  (void)(~v2ua);
  (void)(~v2fa); // expected-error{{invalid argument type 'v2f' (vector of 2 'float' values) to unary}}

  // Comparison operators
  v2sa = (v2ua==v2sa);

  // Arrays
  int array1[v2ua]; // expected-error{{size of array has non-integer type 'v2u' (vector of 2 'unsigned int' values}}
  int array2[17];
  // FIXME: error message below needs type!
  (void)(array2[v2ua]); // expected-error{{array subscript is not an integer}}

  v2u *v2u_ptr = 0;
  v2s *v2s_ptr;
}

void test_int_vector_scalar(unsigned int ua, v2u v2ua) {
  // Operations with one integer vector and one scalar. These splat the scalar.
  (void)(v2ua + ua);
  (void)(ua + v2ua);
  (void)(v2ua - ua);
  (void)(ua - v2ua);
  (void)(v2ua * ua);
  (void)(ua * v2ua);
  (void)(v2ua / ua);
  (void)(ua / v2ua);
  (void)(v2ua % ua);
  (void)(ua % v2ua);

  (void)(v2ua == ua);
  (void)(ua == v2ua);
  (void)(v2ua != ua);
  (void)(ua != v2ua);
  (void)(v2ua <= ua);
  (void)(ua <= v2ua);
  (void)(v2ua >= ua);
  (void)(ua >= v2ua);
  (void)(v2ua < ua);
  (void)(ua < v2ua);
  (void)(v2ua > ua);
  (void)(ua > v2ua);
  (void)(v2ua && ua);
  (void)(ua && v2ua);
  (void)(v2ua || ua);
  (void)(ua || v2ua);

  (void)(v2ua & ua);
  (void)(ua & v2ua);
  (void)(v2ua | ua);
  (void)(ua | v2ua);
  (void)(v2ua ^ ua);
  (void)(ua ^ v2ua);
  (void)(v2ua << ua);
  (void)(ua << v2ua);
  (void)(v2ua >> ua);
  (void)(ua >> v2ua);

  v2ua += ua;
  v2ua -= ua;
  v2ua *= ua;
  v2ua /= ua;
  v2ua %= ua;
  v2ua &= ua;
  v2ua |= ua;
  v2ua ^= ua;
  v2ua >>= ua;
  v2ua <<= ua;

  ua += v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua -= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua *= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua /= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua %= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua &= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua |= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua ^= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua >>= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
  ua <<= v2ua; // expected-error{{assigning to 'unsigned int' from incompatible type 'v2u'}}
}

void test_float_vector_scalar(float fa, unsigned int ua, v2f v2fa) {
  // Operations with one float vector and one scalar. These splat the scalar.
  (void)(v2fa + fa);
  (void)(fa + v2fa);
  (void)(v2fa - fa);
  (void)(fa - v2fa);
  (void)(v2fa * fa);
  (void)(fa * v2fa);
  (void)(v2fa / fa);
  (void)(fa / v2fa);
  (void)(v2fa % fa); // expected-error{{invalid operands to binary expression}}
  (void)(fa % v2fa); // expected-error{{invalid operands to binary expression}}

  (void)(v2fa == fa);
  (void)(fa == v2fa);
  (void)(v2fa != fa);
  (void)(fa != v2fa);
  (void)(v2fa <= fa);
  (void)(fa <= v2fa);
  (void)(v2fa >= fa);
  (void)(fa >= v2fa);
  (void)(v2fa < fa);
  (void)(fa < v2fa);
  (void)(v2fa > fa);
  (void)(fa > v2fa);
  (void)(v2fa && fa);
  (void)(fa && v2fa);
  (void)(v2fa || fa);
  (void)(fa || v2fa);

  (void)(v2fa & fa); // expected-error{{invalid operands to binary expression}}
  (void)(fa & v2fa); // expected-error{{invalid operands to binary expression}}
  (void)(v2fa | fa); // expected-error{{invalid operands to binary expression}}
  (void)(fa | v2fa); // expected-error{{invalid operands to binary expression}}
  (void)(v2fa ^ fa); // expected-error{{invalid operands to binary expression}}
  (void)(fa ^ v2fa); // expected-error{{invalid operands to binary expression}}
  (void)(v2fa << fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  (void)(v2fa << ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  (void)(fa << v2fa); // expected-error{{used type 'float' where integer is required}}
  (void)(ua << v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  (void)(v2fa >> fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  (void)(v2fa >> ua); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  (void)(fa >> v2fa); // expected-error{{used type 'float' where integer is required}}
  (void)(ua >> v2fa); // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}

  v2fa += fa;
  v2fa -= fa;
  v2fa *= fa;
  v2fa /= fa;
  v2fa %= fa; // expected-error{{invalid operands to binary expression}}
  v2fa &= fa; // expected-error{{invalid operands to binary expression}}
  v2fa |= fa; // expected-error{{invalid operands to binary expression}}
  v2fa ^= fa; // expected-error{{invalid operands to binary expression}}
  v2fa >>= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}
  v2fa <<= fa; // expected-error{{used type 'v2f' (vector of 2 'float' values) where integer is required}}

  fa += v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
  fa -= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
  fa *= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
  fa /= v2fa; // expected-error{{assigning to 'float' from incompatible type 'v2f'}}
  fa %= v2fa; // expected-error{{invalid operands to binary expression}}
  fa &= v2fa; // expected-error{{invalid operands to binary expression}}
  fa |= v2fa; // expected-error{{invalid operands to binary expression}}
  fa ^= v2fa; // expected-error{{invalid operands to binary expression}}
  fa >>= v2fa; // expected-error{{used type 'float' where integer is required}}
  fa <<= v2fa; // expected-error{{used type 'float' where integer is required}}
}

enum Enum { ENUM };

void test_enum_vector_scalar(enum Enum ea, v2u v2ua) {
  // Operations with one integer vector and one enum scalar.
  // These splat the scalar and do implicit integral conversions.
  (void)(v2ua + ea);
  (void)(ea + v2ua);
  (void)(v2ua - ea);
  (void)(ea - v2ua);
  (void)(v2ua * ea);
  (void)(ea * v2ua);
  (void)(v2ua / ea);
  (void)(ea / v2ua);
  (void)(v2ua % ea);
  (void)(ea % v2ua);

  (void)(v2ua == ea);
  (void)(ea == v2ua);
  (void)(v2ua != ea);
  (void)(ea != v2ua);
  (void)(v2ua <= ea);
  (void)(ea <= v2ua);
  (void)(v2ua >= ea);
  (void)(ea >= v2ua);
  (void)(v2ua < ea);
  (void)(ea < v2ua);
  (void)(v2ua > ea);
  (void)(ea > v2ua);
  (void)(v2ua && ea);
  (void)(ea && v2ua);
  (void)(v2ua || ea);
  (void)(ea || v2ua);

  (void)(v2ua & ea);
  (void)(ea & v2ua);
  (void)(v2ua | ea);
  (void)(ea | v2ua);
  (void)(v2ua ^ ea);
  (void)(ea ^ v2ua);
  (void)(v2ua << ea);
  (void)(ea << v2ua);
  (void)(v2ua >> ea);
  (void)(ea >> v2ua);

  v2ua += ea;
  v2ua -= ea;
  v2ua *= ea;
  v2ua /= ea;
  v2ua %= ea;
  v2ua &= ea;
  v2ua |= ea;
  v2ua ^= ea;
  v2ua >>= ea;
  v2ua <<= ea;

  ea += v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea -= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea *= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea /= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea %= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea &= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea |= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea ^= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea >>= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
  ea <<= v2ua; // expected-error{{assigning to 'enum Enum' from incompatible type 'v2u'}}
}


// An incomplete enum type doesn't count as an integral type.
enum Enum2;

void test_incomplete_enum(enum Enum2 *ea, v2u v2ua) {
  (void)(v2ua + *ea); // expected-error{{cannot convert between vector and non-scalar values}}
  (void)(*ea + v2ua); // expected-error{{cannot convert between vector and non-scalar values}}
}