text: // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
  
  // New exciting ambiguities in C++11
  
  // final 'context sensitive' mess.
  namespace final {
    struct S { int n; };
    struct T { int n; };
    namespace N {
      int n;
      // These declare variables named final..
      extern struct S final;
      extern struct S final [[]];
      extern struct S final, foo;
      struct S final = S();
  
      // This defines a class, not a variable, even though it would successfully
      // parse as a variable but not as a class. DR1318's wording suggests that
      // this disambiguation is only performed on an ambiguity, but that was not
      // the intent.
      struct S final { // expected-note {{here}}
        int(n) // expected-error {{expected ';'}}
      };
      // This too.
      struct T final : S {}; // expected-error {{base 'S' is marked 'final'}}
      struct T bar : S {}; // expected-error {{expected ';' after top level declarator}} expected-error {{expected unqualified-id}}
    }
    // _Alignas isn't allowed in the places where alignas is. We used to
    // assert on this.
    struct U final _Alignas(4) {}; // expected-error 3{{}} expected-note {{}}
  }
  
  // enum versus bitfield. These are always required to be treated as an
  // enum-base, but we disambiguate anyway for better error recovery.
  namespace bitfield {
    enum E {};
  
    struct T {
      constexpr T() {}
      constexpr T(int) {}
      constexpr T(T, T, T, T) {}
      constexpr T operator=(T) const { return *this; }
      constexpr operator int() const { return 4; }
    };
    constexpr T a, b, c, d;
  
    struct S1 {
      enum E : T ( a = 1, b = 2, c = 3, 4 ); // expected-error {{ISO C++ only allows ':' in member enumeration declaration to introduce a fixed underlying type, not an anonymous bit-field}}
    };
    // Enum definition, not a bit-field.
    struct S2 {
      enum E : T { a = 1, b = 2, c = 3, 4 }; // expected-error {{non-integral type}} expected-error {{expected identifier}}
    };
    struct S3 {
      enum E : int { a = 1, b = 2, c = 3, d }; // ok, defines an enum
    };
    // Ambiguous.
    struct S4 {
      enum E : int { a = 1 }; // ok, defines an enum
    };
    // This could be a bit-field, but would be ill-formed due to the anonymous
    // member being initialized.
    struct S5 {
      enum E : int { a = 1 } { b = 2 }; // expected-error {{expected ';' after enum}} expected-error {{expected member name}}
    };
    // This could be a bit-field.
    struct S6 {
      enum E : int { 1 }; // expected-error {{expected identifier}}
    };
  
    struct U {
      constexpr operator T() const { return T(); } // expected-note 2{{candidate}}
    };
    // This could be a bit-field.
    struct S7 {
      enum E : int { a = U() }; // expected-error {{no viable conversion}}
    };
    // This could be a bit-field, and does not conform to the grammar of an
    // enum definition, because 'id(U())' is not a constant-expression.
    constexpr const U &id(const U &u) { return u; }
    struct S8 {
      enum E : int { a = id(U()) }; // expected-error {{no viable conversion}}
    };
  
    // PR26249: Disambiguate 'enum :' as an enum-base always, even if that would
    // be ill-formed. It cannot be an elaborated-type-specifier.
    struct S {
      enum : undeclared_type { v = 0 }; // expected-error {{unknown type name 'undeclared_type'}}
      enum E : undeclared_type { w = 0 }; // expected-error {{unknown type name 'undeclared_type'}}
      enum X : undeclared_type { x = 0 }; // expected-error {{unknown type name 'undeclared_type'}}
    };
  }
  
  namespace trailing_return {
    typedef int n;
    int a;
  
    struct S {
      S(int);
      S *operator()(...) const;
      int n;
    };
  
    namespace N {
      void f() {
        // This parses as a function declaration, but DR1223 makes the presence of
        // 'auto' be used for disambiguation.
        S(a)()->n; // ok, expression; expected-warning{{expression result unused}}
        S(a)(int())->n; // ok, expression; expected-warning{{expression result unused}}
        auto(a)()->n; // ok, function declaration
        auto(b)(int())->n; // ok, function declaration
        using T = decltype(a);
        using T = auto() -> n;
      }
    }
  }
  
  namespace ellipsis {
    template<typename...T>
    struct S {
      void e(S::S()); // expected-error {{is a constructor name}}
      void f(S(...args[sizeof(T)])); // expected-note {{here}} expected-note {{here}}
      void f(S(...args)[sizeof(T)]); // expected-error {{redeclared}}
      void f(S ...args[sizeof(T)]); // expected-error {{redeclared}}
      void g(S(...[sizeof(T)])); // expected-note {{here}} expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
      void g(S(...)[sizeof(T)]); // expected-error {{function cannot return array type}}
      void g(S ...[sizeof(T)]); // expected-error {{redeclared}}
      void h(T(...)); // function type, expected-error {{unexpanded parameter pack}}
      void h(T...); // pack expansion, ok
      void i(int(T...)); // expected-note {{here}}
      void i(int(T...a)); // expected-error {{redeclared}}
      void i(int(T, ...)); // function type, expected-error {{unexpanded parameter pack}}
      void i(int(T, ...a)); // expected-error {{expected ')'}} expected-note {{to match}} expected-error {{unexpanded parameter pack}}
      void j(int(int...)); // function type, ok
      void j(int(int...a)); // expected-error {{does not contain any unexpanded parameter packs}}
      void j(T(int...)); // expected-error {{unexpanded parameter pack}}
      void j(T(T...)); // expected-error {{unexpanded parameter pack}}
      void k(int(...)(T)); // expected-error {{cannot return function type}}
      void k(int ...(T));
      void l(int(&...)(T)); // expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
      void l(int(*...)(T)); // expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
      void l(int(S<int>::*...)(T)); // expected-warning {{ISO C++11 requires a parenthesized pack declaration to have a name}}
    };
  
    struct CtorSink {
      template <typename ...T> constexpr CtorSink(T &&...t) { }
      constexpr operator int() const { return 42; }
    };
  
    template <unsigned ...N> struct UnsignedTmplArgSink;
  
    template <typename ...T>
    void foo(int x, T ...t) {
      // Have a variety of cases where the syntax is technically unambiguous, but hinges on careful treatment of ellipses.
      CtorSink(t ...), x; // ok, expression; expected-warning 2{{expression result unused}}
  
      int x0(CtorSink(t ...)); // ok, declares object x0
      int *p0 = &x0;
      (void)p0;
  
      CtorSink x1(int(t) ..., int(x)); // ok, declares object x1
      CtorSink *p1 = &x1;
      (void)p1;
  
      UnsignedTmplArgSink<T(CtorSink(t ...)) ...> *t0; // ok
      UnsignedTmplArgSink<((T *)0, 42u) ...> **t0p = &t0;
    }
  
    template void foo(int, int, int); // expected-note {{in instantiation of function template specialization 'ellipsis::foo<int, int>' requested here}}
  }
  
  namespace braced_init_list {
    struct X {
      void foo() {}
    };
  
    void (*pf1)() {};
    void (X::*pmf1)() {&X::foo};
    void (X::*pmf2)() = {&X::foo};
  
    void test() {
      void (*pf2)() {};
      void (X::*pmf3)() {&X::foo};
      void (X::*pmf4)() = {&X::foo};
    }
  }
  