// RUN: %clang_cc1 -triple i686-windows %s -fsyntax-only -Wno-unused-value -Wno-pointer-to-int-cast -Wmicrosoft -verify -fms-extensions

struct A
{
   int a[];  /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
};

struct PR28407
{
  int : 1;
  int a[]; /* expected-warning {{flexible array member 'a' in otherwise empty struct is a Microsoft extension}} */
};

struct C {
   int l;
   union {
       int c1[];   /* expected-warning {{flexible array member 'c1' in a union is a Microsoft extension}}  */
       char c2[];  /* expected-warning {{flexible array member 'c2' in a union is a Microsoft extension}} */
   };
};


struct D {
   int l;
   int D[];
};

struct __declspec(uuid("00000000-0000-0000-C000-000000000046")) IUnknown {}; /* expected-error {{'uuid' attribute is not supported in C}} */

[uuid("00000000-0000-0000-C000-000000000046")] struct IUnknown2 {}; /* expected-error {{'uuid' attribute is not supported in C}} */

typedef struct notnested {
  long bad1;
  long bad2;
} NOTNESTED;


typedef struct nested1 {
  long a;
  struct notnested var1;
  NOTNESTED var2;
} NESTED1;

struct nested2 {
  long b;
  NESTED1;  // expected-warning {{anonymous structs are a Microsoft extension}}
};

struct nested2 PR20573 = { .a = 3 };

struct nested3 {
  long d;
  struct nested4 { // expected-warning {{anonymous structs are a Microsoft extension}}
    long e;
  };
  union nested5 { // expected-warning {{anonymous unions are a Microsoft extension}}
    long f;
  };
};

typedef union nested6 {
  long f;
} NESTED6;

struct test {
  int c;
  struct nested2;   // expected-warning {{anonymous structs are a Microsoft extension}}
  NESTED6;   // expected-warning {{anonymous unions are a Microsoft extension}}
};

void foo(void)
{
  struct test var;
  var.a;
  var.b;
  var.c;
  var.bad1;   // expected-error {{no member named 'bad1' in 'struct test'}}
  var.bad2;   // expected-error {{no member named 'bad2' in 'struct test'}}
}

// Enumeration types with a fixed underlying type.
const int seventeen = 17;
typedef int Int;

struct X0 {
  enum E1 : Int { SomeOtherValue } field;  // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
  enum E1 : seventeen;
};

enum : long long {  // expected-warning{{enumeration types with a fixed underlying type are a Microsoft extension}}
  SomeValue = 0x100000000
};

void pointer_to_integral_type_conv(char* ptr) {
  char ch = (char)ptr;
  short sh = (short)ptr;
  ch = (char)ptr;
  sh = (short)ptr;

  // This is valid ISO C.
  _Bool b = (_Bool)ptr;
}

typedef struct {
  UNKNOWN u; // expected-error {{unknown type name 'UNKNOWN'}}
} AA;

typedef struct {
  AA; // expected-warning {{anonymous structs are a Microsoft extension}}
} BB;

struct anon_fault {
  struct undefined; // expected-warning {{anonymous structs are a Microsoft extension}}
                    // expected-error@-1 {{field has incomplete type 'struct undefined'}}
                    // expected-note@-2 {{forward declaration of 'struct undefined'}}
};

const int anon_falt_size = sizeof(struct anon_fault);

__declspec(deprecated("This is deprecated")) enum DE1 { one, two } e1; // expected-note {{'e1' has been explicitly marked deprecated here}}
struct __declspec(deprecated) DS1 { int i; float f; }; // expected-note {{'DS1' has been explicitly marked deprecated here}}

#define MY_TEXT		"This is also deprecated"
__declspec(deprecated(MY_TEXT)) void Dfunc1( void ) {} // expected-note {{'Dfunc1' has been explicitly marked deprecated here}}

struct __declspec(deprecated(123)) DS2 {};	// expected-error {{'deprecated' attribute requires a string}}

void test( void ) {
	e1 = one;	// expected-warning {{'e1' is deprecated: This is deprecated}}
	struct DS1 s = { 0 };	// expected-warning {{'DS1' is deprecated}}
	Dfunc1();	// expected-warning {{'Dfunc1' is deprecated: This is also deprecated}}

	enum DE1 no;	// no warning because E1 is not deprecated
}

int __sptr wrong1; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
// The modifier must follow the asterisk
int __sptr *wrong_psp; // expected-error {{'__sptr' attribute only applies to pointer arguments}}
int * __sptr __uptr wrong2; // expected-error {{'__sptr' and '__uptr' attributes are not compatible}}
int * __sptr __sptr wrong3; // expected-warning {{attribute '__sptr' is already applied}}

// It is illegal to overload based on the type attribute.
void ptr_func(int * __ptr32 i) {}  // expected-note {{previous definition is here}}
void ptr_func(int * __ptr64 i) {} // expected-error {{redefinition of 'ptr_func'}}

// It is also illegal to overload based on the pointer type attribute.
void ptr_func2(int * __sptr __ptr32 i) {}  // expected-note {{previous definition is here}}
void ptr_func2(int * __uptr __ptr32 i) {} // expected-error {{redefinition of 'ptr_func2'}}

// Check for warning when return types have the type attribute.
void *__ptr32 ptr_func3(void) { return 0; } // expected-note {{previous definition is here}}
void *__ptr64 ptr_func3(void) { return 0; } // expected-error {{redefinition of 'ptr_func3'}}

// Test that __ptr32/__ptr64 can be passed as arguments with other address
// spaces.
void ptr_func4(int *i);
void ptr_func5(int *__ptr32 i);
void test_ptr_arguments(void) {
  int *__ptr64 i64;
  ptr_func4(i64);
  ptr_func5(i64);
}

int * __sptr __ptr32 __sptr wrong4; // expected-warning {{attribute '__sptr' is already applied}}

__ptr32 int *wrong5; // expected-error {{'__ptr32' attribute only applies to pointer arguments}}

int *wrong6 __ptr32;  // expected-error {{expected ';' after top level declarator}} expected-warning {{declaration does not declare anything}}

int * __ptr32 __ptr64 wrong7;  // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}

int * __ptr32 __ptr32 wrong8;	// expected-warning {{attribute '__ptr32' is already applied}}

int *(__ptr32 __sptr wrong9); // expected-error {{'__sptr' attribute only applies to pointer arguments}} // expected-error {{'__ptr32' attribute only applies to pointer arguments}}

int *(__ptr32 wrong10); // expected-error {{'__ptr32' attribute only applies to pointer arguments}}

int *(__ptr64 wrong11); // expected-error {{'__ptr64' attribute only applies to pointer arguments}}

int *(__ptr32 __ptr64 wrong12); // expected-error {{'__ptr32' attribute only applies to pointer arguments}} // expected-error {{'__ptr64' attribute only applies to pointer arguments}}

typedef int *T;
T __ptr32 ok1;
T __ptr64 ok2;
T __ptr32 __ptr64 wrong13; // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}

typedef int *__ptr32 T1;
T1 ok3;
T1 __ptr32 wrong14;  // expected-warning {{attribute '__ptr32' is already applied}}
T1 __ptr64 wrong15;  // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}

typedef int *__ptr64 T2;
T2 ok4;
T2 __ptr64 wrong16;  // expected-warning {{attribute '__ptr64' is already applied}}
T2 __ptr32 wrong17;  // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}

typedef int *__ptr32 __ptr64 wrong18; // expected-error {{'__ptr32' and '__ptr64' attributes are not compatible}}

typedef char *my_va_list;
void __va_start(my_va_list *ap, ...); // expected-note {{passing argument to parameter 'ap' here}}
void vmyprintf(const char *f, my_va_list ap);
void myprintf(const char *f, ...) {
  my_va_list ap;
  if (1) {
    __va_start(&ap, f);
    vmyprintf(f, ap);
    ap = 0;
  } else {
    __va_start(ap, f); // expected-warning {{incompatible pointer types passing 'my_va_list'}}
  }
}

// __unaligned handling
void test_unaligned(void) {
  __unaligned int *p1 = 0;
  int *p2 = p1; // expected-warning {{initializing 'int *' with an expression of type '__unaligned int *' discards qualifiers}}
  __unaligned int *p3 = p2;
}

void test_unaligned2(int x[__unaligned 4]) {}