text: /* SYNTAX TEST "Packages/C++/C++.sublime-syntax" */
  
  Task<int> natural_numbers()
  {
    int n = 0;
    while (true) {
      co_yield n;
      /*     ^ keyword.control */
      n++;
    }
  }
  Task<int> foo()
  {
    co_return 42;
    /*      ^ keyword.control */
    /*         ^ constant.numeric */
  }
  Task<void> bar()
  {
    co_await natural_numbers();
    /*     ^ keyword.control */
    /*                     ^ variable.function */
  }
  
  int main(){
      int a=5,b=0;
      while(a-->0)++b;
      /*     ^^ keyword.operator.arithmetic */
      /*       ^ keyword.operator.comparison */
      /*        ^ constant.numeric */
      /*          ^^ keyword.operator.arithmetic */
  }
  
  /////////////////////////////////////////////
  // Preprocessor
  /////////////////////////////////////////////
  
  #ifndef IGUARD_
   /* <- keyword.control.import */
  #define IGUARD_
   /* <- keyword.control.import.define */
  struct foo* alloc_foo();
  /* <- storage.type */
         /* <- - entity.name.type */
              /* <- entity.name.function */
  #endif
   /* <- keyword.control.import */
  
  // The following example ensures that comments at the end of preprocessor
  // directives don't mess with context transitions
  int func() {
  /*  ^ entity.name.function */
      #if( EXTAL == 40000 )       /* 40 MHz */
  /*  ^ keyword.control.import */
          #define PLL_RFD_PHI1    10      // PLL0_PH1 = 40MHz
  /*      ^ keyword.control.import */
  /*                              ^^ constant.numeric */
  /*                                      ^ comment.line */
      #endif
  /*  ^ keyword.control.import */
  }
  /* <- meta.function meta.block punctuation.section.block.end */
   /* <- - meta.function meta.block */
  
  int f(int x, \
           /*  ^ punctuation.separator.continuation */
        int y);
  
  int g(int x = 5 \
           /*     ^ punctuation.separator.continuation */
        , int y);
  
  #define MACRO_WITH_CURLY_BRACE {
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.preprocessor.macro */
  /* <- keyword.control.import.define */
  /*      ^ entity.name.constant */
  
  #define MACRO_WITH_CURLY_BRACE_2 }
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.preprocessor.macro */
  /* <- keyword.control.import.define */
  /*      ^ entity.name.constant */
  
  FOOBAR
  hello() {
      /* <- meta.function entity.name.function */
      return 0;
  }
  
  EFIAPI
  UserStructCompare (
    /* <- meta.function entity.name.function */
    IN CONST VOID *UserStruct1,
    IN CONST VOID *UserStruct2
    )
  {
    const USER_STRUCT *CmpStruct1;
    /* <- meta.block storage.modifier */
  
    CmpStruct1 = UserStruct1;
    return KeyCompare (&CmpStruct1->Key, UserStruct2);
    /* <- meta.block keyword.control */
    /*              ^ meta.block meta.function-call variable.function */
  }
  
  LIB_RESULT
  foo()
  /* <- meta.function entity.name.function */
  {
     return LIB_SUCCESS;
  }
  
  LIB_RESULT bar()
  /*           ^ meta.function entity.name.function */
  {
      return LIB_SUCCESS;
  }
  
  THIS_IS_REALLY_JUST_A_MACRO_AND_NOT_A_RETURN_TYPE
  /* <- meta.assumed-macro */
  
  int main() {
  /* <- storage.type */
      /* ^ meta.function entity.name.function */
      return 0;
  }
  
  // This is a method/function with the return type on a separate line and so should not be a
  // constructor.
  FOOLIB_RESULT
  some_namespace::some_function(int a_parameter, double another_parameter) {
    /* <- meta.function meta.toc-list.full-identifier */
    /*            ^ entity.name.function - entity.name.function.constructor */
    return FOOLIB_SUCCESS;
  }
  
  #pragma foo(bar, \
  "baz", \
  1)
  /* <- meta.preprocessor */
  
  #define MY_MACRO(a, b)
  /*^^^^^^^^^^^^^^^^^^^^ meta.preprocessor.macro */
  /*              ^^^^^^ meta.preprocessor.macro.parameters */
  /*      ^^^^^^^^ entity.name.function.preprocessor */
  /*                   ^ punctuation.section.group.end */
  
  #define max(a, b, \
  /*^^^^^^^^^^^^^^^^^ meta.preprocessor.macro */ \
  /*         ^^^^^^^^ meta.preprocessor.macro.parameters */ \
  /* <- keyword.control.import.define */ \
  /*      ^ entity.name.function.preprocessor */ \
  /*         ^ punctuation.section.group.begin */ \
  /*          ^ variable.parameter */ \
  /*           ^ punctuation.separator */ \
  /* */ \
  /* <- comment.block */ \
   c)  ((a>b) ? (a>c?a:c) : (b>c?b:c))
   /* <- meta.preprocessor.macro meta.group variable.parameter */
    /* <- meta.preprocessor.macro meta.group punctuation.section.group.end */
   /*               ^ keyword.operator.ternary */
   /*                 ^ keyword.operator.ternary */
  
  #if 0
  #ifdef moo
  /* <- - keyword.control */
  #endif
  /* <- - keyword.control */
  #endif
  
  FOO()
  /* <- meta.assumed-macro variable.function.assumed-macro */
  FOO
  /* <- meta.assumed-macro */
  
  struct FOO1 FOO2 FOO3 Test {
    /*   ^ meta.struct meta.assumed-macro           */
    /*        ^ meta.struct meta.assumed-macro      */
    /*             ^ meta.struct meta.assumed-macro */
    Test();
    Test() noexcept;
    Test() final;
    Test() noexcept final;
    ~Test();
    ~Test() noexcept;
    ~Test() override noexcept;
    virtual ~Test();
    virtual ~Test() noexcept;
    virtual ~Test() override noexcept;
    DLL_API Test();
    /* <- meta.assumed-macro                   */
    /*      ^ meta.method.constructor          */
    DLL_API Test() noexcept;
    /* <- meta.assumed-macro                   */
    /*      ^ meta.method.constructor          */
    /*             ^ storage.modifier          */
    DLL_API Test() final;
    /* <- meta.assumed-macro                   */
    /*      ^ meta.method.constructor          */
    /*             ^ storage.modifier          */
    DLL_API Test() noexcept final;
    /* <- meta.assumed-macro                   */
    /*      ^ meta.method.constructor          */
    /*             ^ storage.modifier          */
    /*                      ^ storage.modifier */
    DLL_API ~Test();
    /* <- meta.assumed-macro                    */
    /*      ^ meta.method.destructor            */
    DLL_API ~Test() noexcept;
    /* <- meta.assumed-macro                    */
    /*      ^ meta.method.destructor            */
    /*              ^ storage.modifier          */
    DLL_API ~Test() override noexcept;
    /* <- meta.assumed-macro                    */
    /*      ^ meta.method.destructor            */
    /*              ^ storage.modifier          */
    /*                       ^ storage.modifier */
    DLL_API virtual ~Test();
    /* <- meta.assumed-macro                            */
    /*      ^ storage.modifier                          */
    /*              ^ meta.method.destructor            */
    DLL_API virtual ~Test() noexcept;
    /* <- meta.assumed-macro                            */
    /*      ^ storage.modifier                          */
    /*              ^ meta.method.destructor            */
    /*                      ^ storage.modifier          */
    DLL_API virtual ~Test() override noexcept;
    /* <- meta.assumed-macro                            */
    /*      ^ storage.modifier                          */
    /*              ^ meta.method.destructor            */
    /*                      ^ storage.modifier          */
    /*                               ^ storage.modifier */
  }
  
  struct X {
    X();
     /* <- meta.group */
    /*^ meta.group - meta.group meta.group */
  };
  
  #define DEPRECATED(msg) [[deprecated(msg)]]
  
  struct Test {
      DEPRECATED("bla")
      /* <- meta.assumed-macro variable.function.assumed-macro */
      bool foo (bool run=true) {}
      /*   ^ entity.name.function */
  };
  
  namespace Test {
      DEPRECATED("bla")
      /* <- meta.assumed-macro variable.function.assumed-macro */
      bool foo (bool run=true) {}
      /*   ^ entity.name.function */
  }
  
  struct Test {
  DEPRECATED("bla")
  /* <- meta.assumed-macro variable.function.assumed-macro */
  bool foo (bool run=true) {}
  /*   ^ entity.name.function */
  };
  
  /////////////////////////////////////////////
  // Strings
  /////////////////////////////////////////////
  
  char str1[] = "abc";
  /*            ^ punctuation.definition.string.begin */
  /*             ^ string.quoted.double */
  /*                ^ punctuation.definition.string.end */
  
  char str2[] = u8"abc";
  /*            ^ storage.type.string */
  /*              ^ punctuation.definition.string.begin */
  /*               ^ string.quoted.double */
  
  char16_t str3[] = u"abc";
  /*                ^ storage.type.string */
  /*                 ^ punctuation.definition.string.begin */
  /*                  ^ string.quoted.double */
  
  char32_t str4[] = U"abc";
  /*                ^ storage.type.string */
  /*                 ^ punctuation.definition.string.begin */
  /*                  ^ string.quoted.double */
  
  wchar_t str5[] = L"abc";
  /*               ^ storage.type.string */
  /*                ^ punctuation.definition.string.begin */
  /*                 ^ string.quoted.double */
  
  char str6[] = "\a|\b|\e|\f|\n|\r|\t|\v|\'|\"|\?";
  /*             ^^ constant.character.escape */
  /*                ^^ constant.character.escape */
  /*                   ^^ constant.character.escape */
  /*                      ^^ constant.character.escape */
  /*                         ^^ constant.character.escape */
  /*                            ^^ constant.character.escape */
  /*                               ^^ constant.character.escape */
  /*                                  ^^ constant.character.escape */
  /*                                     ^^ constant.character.escape */
  /*                                        ^^ constant.character.escape */
  /*                                           ^^ constant.character.escape */
  
  char str7[] = "\0|\012";
  /*             ^^ constant.character.escape */
  /*                ^^^^ constant.character.escape */
  
  char str8[] = "\x0a|\x41|\xA|\x000065";
  /*             ^^^^ constant.character.escape */
  /*                  ^^^^ constant.character.escape */
  /*                       ^^^ constant.character.escape */
  /*                           ^^^^^^^^ constant.character.escape */
  
  char16_t str9[] = u"\u0063";
  /*                  ^^^^^^ constant.character.escape */
  
  char32_t str10[] = U"\U00000063";
  /*                   ^^^^^^^^^^ constant.character.escape */
  
  char str11[] = "\q";
  /*              ^^ invalid.illegal.unknown-escape */
  
  scanf("%ms %as %*[, ]", &buf);
  /*     ^^^ constant.other.placeholder */
  /*         ^^^ constant.other.placeholder */
  /*             ^^^^^^ constant.other.placeholder */
  
  "foo % baz"
  /*   ^ - invalid */
  
  char rawStr1[] = R"("This is a raw string")";
  /*               ^ storage.type.string */
  /*                ^ punctuation.definition.string.begin */
  /*                  ^ string.quoted.double */
  /*                                        ^ punctuation.definition.string.end */
  
  char rawStr2[] = R"A*!34( )" )A*!34";
  /*               ^ storage.type.string */
  /*                ^ punctuation.definition.string.begin */
  /*                      ^ punctuation.definition.string.begin */
  /*                        ^ string.quoted.double */
  /*                           ^ punctuation.definition.string.end */
  /*                                 ^ punctuation.definition.string.end */
  
  const char IncludeRegexPattern[] =
      R"(^[\t\ ]*#[\t\ ]*(import|include)[^"<]*(["<][^">]*[">]))";
  /*  ^ storage.type.string */
  /*   ^ punctuation.definition.string.begin */
  /*         ^^ - invalid */
  /*                 ^^ - invalid */
  /*                                                            ^ punctuation.definition.string.end */
  
  foo.f<5> /* foo */ ();
  
  /////////////////////////////////////////////
  // Storage Types
  /////////////////////////////////////////////
  
  void* ptr;
  /* <- storage.type */
  
  bool b;
  /* <- storage.type */
  
  char ch;
  /* <- storage.type */
  
  char16_t ch16;
  /* <- storage.type */
  
  char32_t ch32;
  /* <- storage.type */
  
  wchar_t wch;
  /* <- storage.type */
  
  unsigned int ui;
  /* <- storage.type */
  /*       ^ storage.type */
  
  signed long l;
  /* <- storage.type */
  /*     ^ storage.type */
  
  short s;
  /* <- storage.type */
  
  auto a = 2;
  /* <- storage.type */
  
  decltype(s) dt;
  /* <- storage.type */
  /*      ^ punctuation.section.group.begin */
  /*        ^ punctuation.section.group.end */
  
  float f;
  /* <- storage.type */
  
  double d;
  /* <- storage.type */
  
  typedef int my_int;
  /* <- storage.type */
  /*          ^ entity.name.type */
  
  typedef struct Books {
  /*      ^ storage.type */
  /*             ^ - entity.name.type */
     char title[50];
     int book_id;
  } Book;
  /*^ entity.name.type */
  
  using Alias = Foo;
  /* <- keyword.control */
  /*    ^^^^^ entity.name.type.using */
  
  using Alias
    = NewLineFoo;
  /*^ - entity.name */
  
  template <typename T>
  using TemplateAlias = Foo<T>;
  /*    ^^^^^^^^^^^^^ entity.name.type.using */
  
  using std::cout;
  /* <- keyword.control */
  /*    ^ - entity.name */
  
  using std::
    cout;
  /*^ - entity.name */
  
  class MyClass : public SuperClass
  {
      using This = MyClass;
  /*  ^ keyword.control */
  /*        ^^^^ entity.name.type.using */
  
      using MyInt
  /*  ^ keyword.control */
          = int32_t;
  
      using SuperClass::SuperClass;
  /*  ^ keyword.control */
  /*        ^ - entity.name */
  };
  
  class MyClass : public CrtpClass<MyClass>
  {
      using typename CrtpClass<MyClass>::PointerType;
  /*  ^ keyword.control */
  /*        ^ storage.modifier */
      using CrtpClass<
  /*  ^ keyword.control */
          MyClass>::method;
  };
  
  typedef struct Books Book;
  /*             ^ - entity.name.type.struct */
  /*                   ^ entity.name.type.typedef */
  
  template class MyStack<int, 6>;
  /* <- storage.type.template */
  /*                    ^ punctuation.section.generic */
  /*                     ^ storage.type */
  /*                          ^ constant.numeric */
  /*                           ^ punctuation.section.generic */
  
  template<class typeId, int N> class tupleTmpl;
  /* <- storage.type.template */
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.template */
  /*      ^ punctuation.section.generic.begin */
  /*       ^ storage.type */
  /*                      ^ storage.type */
  /*                          ^ punctuation.section.generic.end */
  
  template<typename First = U<V>, typename... Rest> class tupleVariadic;
  /* <- storage.type.template */
  /*      ^ punctuation.section.generic.begin */
  /*       ^ storage.type */
  /*                         ^ punctuation.section.generic.begin */
  /*                           ^ punctuation.section.generic.end */
  /*                            ^ punctuation.separator */
  /*                                      ^^^ keyword.operator.variadic */
  /*                                              ^ punctuation.section.generic.end */
  
  template<typename T...> void SomeClass<T...>::function();
  /*                                      ^^^ keyword.operator.variadic */
  /*                                            ^^^^^^^^ entity.name.function */
  
  template<typename Foo> inline struct Foo* baz()
  /*                     ^^^^^^ storage.modifier */
  /*                                   ^ - entity.name */
  /*                                        ^^^ meta.function entity.name.function */
  {}
  
  template<typename A, typename B>
  void classname<A, B>::methodName() {
  /*   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*            ^ punctuation.section.generic.begin */
  /*                 ^ punctuation.section.generic.end */
  /*                  ^^ punctuation.accessor */
  /*                    ^^^^^^^^^^ entity.name.function */
  }
  
  template<typename C>
  void funcName<C>() {
  /*   ^^^^^^^^^^^^^^^ meta.function */
  /*   ^^^^^^^^ entity.name.function */
  /*           ^ punctuation.section.generic.begin */
  /*             ^ punctuation.section.generic.end */
  }
  bool A::operator<(const A& a) { return false; }
  /* ^ storage.type */
  /*   ^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*      ^^^^^^^^^ entity.name.function */
  /*               ^ meta.function.parameters punctuation.section.group.begin */
  template <class T> bool A<T>::operator<(const A& a) { return false; }
  /*     ^ storage.type.template */
  /*       ^ punctuation.section.generic.begin */
  /*               ^ punctuation.section.generic.end */
  /*                      ^^^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                            ^^^^^^^^^ entity.name.function */
  /*                                     ^ meta.function.parameters meta.group punctuation.section.group.begin */
  template <typename Foo>
  SomeType<OtherType> A<Foo>::foobar(YetAnotherType&& asRValue) {}
  /*                  ^^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                          ^^^^^^ entity.name.function */
  template <typename Foo> SomeType<OtherType> A<Foo>::foobar(YetAnotherType&& asRValue) {}
  /*                                          ^^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                                                  ^^^^^^ entity.name.function */
  
  template <typename Foo> A<Foo>::A(YetAnotherType&& asRValue) {}
  /*                      ^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                              ^ entity.name.function */
  
  template <typename Foo> A<Foo>::A(YetAnotherType&& asRValue) {}
  /*                      ^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                              ^ entity.name.function.constructor */
  
  template <typename Foo> A<Foo>::~A(YetAnotherType&& asRValue) {}
  /*                      ^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*                              ^ entity.name.function.destructor */
  
  template <class T>
  bool A<T>::operator   >    (const A& other) { return false; }
  /*   ^^^^^^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*         ^^^^^^^^^^^^ entity.name.function */
  template <class T>
  bool A<T>::operator    ==    (const A& other) { return false; }
  /*   ^^^^^^^^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*         ^^^^^^^^^^^^^^ entity.name.function */
  
  typedef std :: vector<std::vector<int> > Table;
  /*          ^^ punctuation.accessor */
  /*                   ^ punctuation.section.generic.begin */
  /*                               ^ punctuation.section.generic.begin */
  /*                                   ^ punctuation.section.generic.end */
  /*                                     ^ punctuation.section.generic.end */
  
  template <typename T = float, int a = 3, bool b = true>
                    /* ^ meta.template keyword.operator                               */
                    /*                ^ meta.template keyword.operator                */
                    /*                  ^ meta.template constant.numeric              */
                    /*                            ^ meta.template keyword.operator    */
                    /*                              ^ meta.template constant.language */
  struct Foo
  {
  
  /* <- meta.struct - meta.template */
  
      void bar(int a = 3, bool b = true) {}
                  /* ^ - meta.template keyword.operator                */
                  /*   ^ - meta.template constant.numeric              */
                  /*             ^ - meta.template keyword.operator    */
                  /*               ^ - meta.template constant.language */
  };
  
  /* <- - meta.block - meta.struct - meta.template  */
  
  template <std::size_t Count = 128>
  /*           ^^ meta.template punctuation.accessor             */
  /*                          ^ meta.template keyword.operator   */
  /*                            ^ meta.template constant.numeric */
  class fixed_array : private std::array<int, Count> {};
  
  constexpr std::size_t f() { return 128; }
  template <std::size_t Count = f()>
  /*           ^^ meta.template punctuation.accessor                             */
  /*                          ^ meta.template keyword.operator                   */
  /*                            ^ meta.template variable.function                */
  /*                             ^^ meta.template meta.function-call punctuation */
  /*                               ^ meta.template punctuation                   */
  class fixed_array : private std::array<int, Count> {};
  
  template<class T> class A { /* ... */ };
  template<class T, class U = T> class B { /* ... */ };
  /*                        ^ meta.template keyword.operator */
  /*                          ^ meta.template                */
  /*                           ^ meta.template punctuation   */
  /*                            ^ - meta.template            */
  template <class ...Types> class C { /* ... */ };
  
  // templates inside templates... it's templates all the way down
  template<template<class> class P> class X { /* ... */ };
  /*      ^ meta.template punctuation                              */
  /*               ^ meta.template meta.template punctuation       */
  /*                ^^^^^ meta.template meta.template storage.type */
  /*                     ^ meta.template meta.template punctuation */
  /*                       ^^^^^ meta.template storage.type        */
  /*                              ^ meta.template punctuation      */
  
  X<A> xa; // OK
  X<B> xb; // OK in C++14 after CWG 150
           // Error earlier: not an exact match
  X<C> xc; // OK in C++14 after CWG 150
  
  // template declarations spanning multiple lines
  template
  /* <- meta.template storage.type */
  <
  /* <- meta.template punctuation.section.generic.begin */
      class T,
      class U = T
  >
  class B
  {
      /* ... */
  };
  
  // template declarations spanning multiple lines
  template
  <
  /* <- meta.template punctuation.section.generic.begin */
      std::size_t Count = f()
  /*     ^^ meta.template punctuation.accessor                             */
  /*                    ^ meta.template keyword.operator                   */
  /*                      ^ meta.template variable.function                */
  /*                       ^^ meta.template meta.function-call punctuation */
  >
  /* <- meta.template punctuation.section.generic.end */
  class fixed_array : private std::array<int, Count> {};
  
  template <class T>
  static bool decode(const Node& node, T& sequence) {
    if (!node.IsSequence())
      return false;
    sequence.clear();
    for (const auto& item : node) {
      sequence.push_back(item.template as<typename T::value_type>());
      /*                     ^ punctuation.accessor                           */
      /*                      ^ storage.type - variable.other                 */
      /*                               ^ variable.function                    */
      /*                                 ^ punctuation                        */
      /*                                            ^^ punctuation.accessor   */
      /*                                                        ^ punctuation */
    }
    return true;
  }
  
  #include <functional>
  template <class T> struct A {};
  template <class T> struct B {};
  struct C {};
  A<B<C>> f(std::function<A<B<C>>()> g) {
      /*   ^ punctuation.section.group.begin */
      /*       ^^ punctuation.accessor */
      /*                 ^ punctuation.section.generic.begin */
      /*                   ^ punctuation.section.generic.begin */
      /*                     ^ punctuation.section.generic.begin */
      /*                       ^^ punctuation.section.generic.end */
      /*                         ^ punctuation.section.group.begin */
      /*                          ^ punctuation.section.group.end */
      /*                           ^ punctuation.section.generic.end */
      /*                             ^ variable.parameter */
      /*                              ^ punctuation.section.group.end */
      /*                                ^ punctuation.section.block.begin */
      return g();
  }
  int main() {
      std::function<C()> foo1;
      /*          ^ - variabe.function */
      std::function<B<C>()> foo2;
      /*          ^ - variable.function */
      auto f = [](std::function<A<B<C>>()> g) { return g(); };
      /*         ^ punctuation.section.group.begin */
      /*             ^^ punctuation.accessor */
      /*                       ^ punctuation.section.generic.begin */
      /*                         ^ punctuation.section.generic.begin */
      /*                           ^ punctuation.section.generic.begin */
      /*                             ^^ punctuation.section.generic.end */
      /*                               ^ punctuation.section.group.begin */
      /*                                ^ punctuation.section.group.end */
      /*                                 ^ punctuation.section.generic.end */
      /*                                    ^ punctuation.section.group.end */
      /*                                      ^ punctuation.section.block.begin */
      /*                                                    ^ punctuation.section.block.end */
      return 0;
  }
  /* <- - invalid.illegal */
  
  // Example from section 14.2/4 of
  // http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3690.pdf
  struct X
  {
      template <std::size_t>
      X* alloc();
  
      template <std::size_t>
      static X* adjust();
  };
  template <class T>
  void f(T* p)
  {
      // Be optimistic: scope it as a template member function call anyway.
      T* p1 = p->alloc<200>(); // ill-formed: < means less than
  
      T* p2 = p->template alloc<200>(); // OK: < starts template argument list
      /*        ^ punctuation.accessor           */
      /*         ^ storage.type - variable.other */
      /*                  ^ variable.function    */
  
      // Be optimistic: scope it as a template member function call anyway.
      T::adjust<100>(); // ill-formed: < means less than
  
      T::template adjust<100>(); // OK: < starts template argument list
      /* <- - variable.function                    */
      /*^ punctuation.accessor                     */
      /* ^ storage.type - variable.other           */
      /* ^^^^^^^^^^^^^^^^^^^^^^ meta.function-call */
      /*          ^ variable.function              */
  }
  
  struct X
  {
      void template(); // <-- not allowed to be a function!
      /*   ^ - entity.name.function */
  };
  
  void f()
  {
      X x;
      x.template(); // <-- should not be scoped as variable.function!
      /* ^ - variable.function */
  
      x /**/ . /**/ foo <5> /**/ () /**/ ;
      /*^^^^ comment.block */
      /*     ^ punctuation.accessor */
      /*            ^^^ meta.method-call variable.function */
      /*               ^ meta.method-call - variable.function */
      /*                ^ meta.method-call punctuation.section.generic.begin */
      /*                  ^ meta.method-call punctuation.section.generic.end */
      /*                   ^ meta.method-call - punctuation - comment.block */
      /*                    ^^^^ meta.method-call comment.block */
      /*                        ^ meta.method-call - comment.block - punctuation */
      /*                         ^^ meta.method-call punctuation - comment.block */
      /*                           ^ - meta.method-call */
  };
  
  template<typename T> C<T> f(T t)
  {
      return C<T> { g<X<T>>(t) };
      /*     ^ variable.function */
      /*          ^ punctuation.section.group.begin */
  }
  
  template<typename T> C<X<T>> f(T t)
  {
      return C<X<T>> { g<X<T>>(t) };
      /*     ^ variable.function */
      /*             ^ punctuation.section.group.begin */
  }
  
  struct A { int foo; };
  int main() {
      A a, b;
      a.foo = a.foo < 0 ? 1 : 2;
      /*            ^ - punctuation.section.generic */
      a.operator<(b);
      /*^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^ variable.function.member */
      /*         ^^^ meta.group */
      a.operator>(b);
      /*^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^ variable.function.member */
      /*         ^^^ meta.group */
      a.operator<=(b);
      /*^^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^^ variable.function.member */
      /*          ^^^ meta.group */
      a.operator>=(b);
      /*^^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^^ variable.function.member */
      /*          ^^^ meta.group */
      a.operator==(b);
      /*^^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^^ variable.function.member */
      /*          ^^^ meta.group */
      a.operator!=(b);
      /*^^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^^ variable.function.member */
      /*          ^^^ meta.group */
      a.operator->();
      /*^^^^^^^^^^^^ meta.method-call */
      /*^^^^^^^^^^ variable.function.member */
      /*          ^^ meta.group */
  }
  /* <- - invalid.illegal */
  
  template <typename T>
  struct A<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
      using x = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
      /*                                ^^ keyword.operator */
  };
  /* <- - invalid.illegal */
  
  
  /////////////////////////////////////////////
  // Storage Modifiers
  /////////////////////////////////////////////
  
  alignas(16) char array[256];
  /* <- storage.modifier */
  /*     ^ punctuation.section.group.begin */
  /*        ^ punctuation.section.group.end */
  
  const int XYZ = 2;
  /* <- storage.modifier */
  
  constexpr int ABC = 3 + 5;
  /* <- storage.modifier */
  
  thread_local int x;
  /* <- storage.modifier */
  
  
  /////////////////////////////////////////////
  // Control Keywords
  /////////////////////////////////////////////
  
  static_assert(x >= 0);
  /* <- keyword.operator */
  
  noexcept(f());
  /*       ^^^ meta.function-call */
  /* <- keyword.operator */
  
  if (x < 5)
  /* <- keyword.control */
  {}
  else
  /* <- keyword.control */
  {}
  
  switch (x)
  /* <- keyword.control */
  {
  case 1:
  /* <- keyword.control */
      break;
      /* <- keyword.control.flow.break */
  default:
  /* <- keyword.control */
      break;
      /* <- keyword.control.flow.break */
  }
  
  do
  /* <- keyword.control */
  {
      if (y == 3)
          continue;
          /* <- keyword.control.flow.continue */
  } while (y < x);
  /*^ keyword.control */
  
  switch (a) {
      case 1: break;
  /*        ^ punctuation.separator */
      case 100 - 10: break;
  /*               ^ punctuation.separator */
      default: break;
  /*         ^ punctuation.separator */
  }
  
  goto label;
  /* <- keyword.control.flow.goto */
  
  try
  /* <- keyword.control */
  {
      throw std :: string("xyz");
      /* <- keyword.control.flow.throw */
      /*           ^^^^^^ variable.function */
      /*        ^^ punctuation.accessor */
  }
  catch (...)
  /* <- keyword.control */
  {
  }
  
  int* ptr = new int(2);
  /*         ^ keyword.control */
  
  delete ptr;
  /* <- keyword.control */
  
  return 123;
  /* <- keyword.control.flow.return */
  
  
  /////////////////////////////////////////////
  // Operator Keywords
  /////////////////////////////////////////////
  
  int x = alignof(char);
  /*      ^ keyword.operator.word */
  /*             ^ punctuation.section.group.begin */
  /*                  ^ punctuation.section.group.end */
  
  int x = sizeof(char);
  /*      ^ keyword.operator.word */
  /*            ^ punctuation.section.group.begin */
  /*                 ^ punctuation.section.group.end */
  
  
  /////////////////////////////////////////////
  // Cast Keywords
  /////////////////////////////////////////////
  
  const_cast<int>(2.0);
  /* <- keyword.operator.word.cast */
  /*        ^ punctuation.section.generic.begin */
  /*         ^ storage.type */
  /*            ^ punctuation.section.generic.end */
  
  dynamic_cast<int>(2.0);
  /* <- keyword.operator.word.cast */
  
  reinterpret_cast<int>(2.0);
  /* <- keyword.operator.word.cast */
  
  static_cast<int>(2.0);
  /* <- keyword.operator.word.cast */
  
  auto var = *reinterpret_cast<std::vector<std::shared_ptr<AnyClass>>*>(v);
  /*          ^ keyword.operator.word.cast */
  /*                           ^ - variable.function */
  
  /////////////////////////////////////////////
  // Language Constants
  /////////////////////////////////////////////
  
  bool t = true;
  /*       ^ constant.language */
  
  bool f = false;
  /*       ^ constant.language */
  
  int* p = nullptr;
  /*       ^ constant.language */
  
  char ch[] = __func__;
  /*          ^ constant.language */
  
  
  /////////////////////////////////////////////
  // Support Constants
  /////////////////////////////////////////////
  
  std::cout << __FILE__ << '\n';
  /*           ^ support.constant */
  /* ^^ punctuation.accessor */
  
  std :: cout << __FUNCTION__ << '\n';
  /*  ^^ punctuation.accessor */
  /*             ^ support.constant */
  
  std::cout << __LINE__ << '\n';
  /*           ^ support.constant */
  
  
  /////////////////////////////////////////////
  // Numeric Constants
  /////////////////////////////////////////////
  
  dec1 = 1234567890;
  /*     ^^^^^^^^^^ constant.numeric.integer.decimal */
  /*               ^ punctuation.terminator - constant */
  
  dec2 = 1'924'013;
  /*     ^^^^^^^^^ constant.numeric.integer.decimal */
  /*              ^ punctuation.terminator - constant */
  
  dec3 = 124ul;
  /*     ^^^^^ constant.numeric.integer.decimal */
  /*        ^^ storage.type.numeric */
  /*          ^ punctuation.terminator - constant */
  
  dec4 = 9'204lu;
  /*     ^^^^^^^ constant.numeric.integer.decimal */
  /*          ^^ storage.type.numeric */
  /*            ^ punctuation.terminator - constant */
  
  dec5 = 2'354'202'076LL;
  /*     ^^^^^^^^^^^^^^^ constant.numeric.integer.decimal */
  /*                  ^^ storage.type.numeric */
  /*                    ^ punctuation.terminator - constant */
  
  oct1 = 0123_567;
  /*     ^^^^^^^^ constant.numeric.integer.octal */
  /*     ^ punctuation.definition.numeric.base */
  /*         ^^^^ storage.type.numeric */
  /*             ^ punctuation.terminator - constant */
  
  oct2 = 014'70;
  /*     ^^^^^^ constant.numeric.integer.octal */
  /*     ^ punctuation.definition.numeric.base */
  /*           ^ punctuation.terminator - constant */
  
  hex1 = 0x1234567890ABCDEF;
  /*     ^^^^^^^^^^^^^^^^^^ constant.numeric.integer.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*                       ^ punctuation.terminator - constant */
  
  hex2 = 0X1234567890ABCDEF;
  /*     ^^^^^^^^^^^^^^^^^^ constant.numeric.integer.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*                       ^ punctuation.terminator - constant */
  
  hex3 = 0x1234567890abcdef;
  /*     ^^^^^^^^^^^^^^^^^^ constant.numeric.integer.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*                       ^ punctuation.terminator - constant */
  
  hex4 = 0xA7'45'8C'38;
  /*     ^^^^^^^^^^^^^ constant.numeric.integer.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*                  ^ punctuation.terminator - constant */
  
  hex5 = 0x0+0xFL+0xaull+0xallu+0xfu+0xf'12_4_uz;
  /*     ^^^ constant.numeric.integer.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*         ^^^^ constant.numeric.integer.hexadecimal */
  /*         ^^ punctuation.definition.numeric.base */
  /*            ^ storage.type.numeric */
  /*              ^^^^^^ constant.numeric.integer.hexadecimal */
  /*              ^^ punctuation.definition.numeric.base */
  /*                 ^^^ storage.type.numeric */
  /*                     ^^^^^^ constant.numeric.integer.hexadecimal */
  /*                     ^^ punctuation.definition.numeric.base */
  /*                        ^^^ storage.type.numeric */
  /*                            ^^^^ constant.numeric.integer.hexadecimal */
  /*                            ^^ punctuation.definition.numeric.base */
  /*                               ^ storage.type.numeric */
  /*                                 ^^^^^^^^^^ constant.numeric.integer.hexadecimal */
  /*                                 ^^ punctuation.definition.numeric.base */
  /*                                       ^^^^^ storage.type.numeric */
  /*                                            ^ punctuation.terminator - constant */
  
  hex2 = 0xc1.01AbFp-1;
  /*     ^^^^^^^^^^^^^ constant.numeric.float.hexadecimal */
  /*     ^^ punctuation.definition.numeric.base */
  /*         ^ punctuation.separator.decimal */
  /*                  ^ punctuation.terminator - constant */
  
  bin1 = 0b010110;
  /*     ^^^^^^^^ constant.numeric.integer.binary */
  /*     ^^ punctuation.definition.numeric.base */
  /*             ^ punctuation.terminator - constant */
  
  bin2 = 0B010010;
  /*     ^^^^^^^^ constant.numeric.integer.binary */
  /*     ^^ punctuation.definition.numeric.base */
  /*             ^ punctuation.terminator - constant */
  
  bin3 = 0b1001'1101'0010'1100;
  /*     ^^^^^^^^^^^^^^^^^^^^^ constant.numeric.integer.binary */
  /*     ^^ punctuation.definition.numeric.base */
  /*                          ^ punctuation.terminator - constant */
  
  f = 1.1+1.1e1+1.1e-1+1.1f+1.1e1f+1.1e-1f+1.1L+1.1e1L+1.1e-1L;
  /*  ^^^ constant.numeric.float.decimal */
  /*   ^ punctuation.separator.decimal */
  /*     ^ keyword.operator.arithmetic */
  /*      ^^^^^ constant.numeric.float.decimal */
  /*       ^ punctuation.separator.decimal */
  /*           ^ keyword.operator.arithmetic */
  /*            ^^^^^^ constant.numeric.float.decimal */
  /*             ^ punctuation.separator.decimal */
  /*                  ^ keyword.operator.arithmetic */
  /*                   ^^^^ constant.numeric.float.decimal */
  /*                    ^ punctuation.separator.decimal */
  /*                      ^ storage.type.numeric */
  /*                       ^ keyword.operator.arithmetic */
  /*                        ^^^^^^ constant.numeric.float.decimal */
  /*                         ^ punctuation.separator.decimal */
  /*                             ^ storage.type.numeric */
  /*                              ^ keyword.operator.arithmetic */
  /*                               ^^^^^^^ constant.numeric.float.decimal */
  /*                                ^ punctuation.separator.decimal */
  /*                                     ^ storage.type.numeric */
  /*                                      ^ keyword.operator.arithmetic */
  /*                                       ^^^^ constant.numeric.float.decimal */
  /*                                        ^ punctuation.separator.decimal */
  /*                                          ^ storage.type.numeric */
  /*                                           ^ keyword.operator.arithmetic */
  /*                                            ^^^^^^ constant.numeric.float.decimal */
  /*                                             ^ punctuation.separator.decimal */
  /*                                                 ^ storage.type.numeric */
  /*                                                  ^ keyword.operator.arithmetic */
  /*                                                   ^^^^^^^ constant.numeric.float.decimal */
  /*                                                    ^ punctuation.separator.decimal */
  /*                                                         ^ storage.type.numeric */
  /*                                                          ^ punctuation.terminator - constant */
  
  f = 1.e1+1.e-1+1.e1f+1.e-1f+1.e1L+1.e-1L;
  /*  ^^^^ constant.numeric.float.decimal */
  /*   ^ punctuation.separator.decimal */
  /*      ^ keyword.operator.arithmetic */
  /*       ^^^^^ constant.numeric.float.decimal */
  /*        ^ punctuation.separator.decimal */
  /*            ^ keyword.operator.arithmetic */
  /*             ^^^^^ constant.numeric.float.decimal */
  /*              ^ punctuation.separator.decimal */
  /*                 ^ storage.type.numeric */
  /*                  ^ keyword.operator.arithmetic */
  /*                   ^^^^^^ constant.numeric.float.decimal */
  /*                    ^ punctuation.separator.decimal */
  /*                        ^ storage.type.numeric */
  /*                         ^ keyword.operator.arithmetic */
  /*                          ^^^^^ constant.numeric.float.decimal */
  /*                           ^ punctuation.separator.decimal */
  /*                              ^ storage.type.numeric */
  /*                               ^ keyword.operator.arithmetic */
  /*                                ^^^^^^ constant.numeric.float.decimal */
  /*                                 ^ punctuation.separator.decimal */
  /*                                     ^ storage.type.numeric */
  /*                                      ^ punctuation.terminator - constant */
  
  f = 1.+1.f+1.L+1..;
  /*  ^^ constant.numeric.float.decimal */
  /*   ^ punctuation.separator.decimal */
  /*    ^ keyword.operator.arithmetic */
  /*     ^^^ constant.numeric.float.decimal */
  /*      ^ punctuation.separator.decimal */
  /*       ^ storage.type.numeric */
  /*        ^ keyword.operator.arithmetic */
  /*         ^^^ constant.numeric.float.decimal */
  /*          ^ punctuation.separator.decimal */
  /*           ^ storage.type.numeric */
  /*            ^ keyword.operator.arithmetic */
  /*             ^ constant.numeric.integer.decimal */
  /*              ^^ invalid.illegal.syntax */
  /*                ^ punctuation.terminator - constant */
  
  f = 1e1+1e1f+1e1L;
  /*  ^^^ constant.numeric.float.decimal */
  /*     ^ keyword.operator.arithmetic */
  /*      ^^^^ constant.numeric.float.decimal */
  /*         ^ storage.type.numeric */
  /*          ^ keyword.operator.arithmetic */
  /*           ^^^^ constant.numeric.float.decimal */
  /*              ^ storage.type.numeric */
  /*               ^ punctuation.terminator - constant */
  
  f = .1+.1e1+.1e-1+.1f+.1e1f+.1e-1f+.1L+.1e1L+.1e-1L;
  /*  ^^ constant.numeric.float.decimal */
  /*  ^ punctuation.separator.decimal */
  /*    ^ keyword.operator.arithmetic */
  /*     ^^^^ constant.numeric.float.decimal */
  /*     ^ punctuation.separator.decimal */
  /*         ^ keyword.operator.arithmetic */
  /*          ^^^^^ constant.numeric.float.decimal */
  /*          ^ punctuation.separator.decimal */
  /*               ^ keyword.operator.arithmetic */
  /*                ^^^ constant.numeric.float.decimal */
  /*                ^ punctuation.separator.decimal */
  /*                  ^ storage.type.numeric */
  /*                   ^ keyword.operator.arithmetic */
  /*                    ^^^^^ constant.numeric.float.decimal */
  /*                    ^ punctuation.separator.decimal */
  /*                        ^ storage.type.numeric */
  /*                         ^ keyword.operator.arithmetic */
  /*                          ^^^^^^ constant.numeric.float.decimal */
  /*                          ^ punctuation.separator.decimal */
  /*                               ^ storage.type.numeric */
  /*                                 ^^^ constant.numeric.float.decimal */
  /*                                 ^ punctuation.separator.decimal */
  /*                                   ^ storage.type.numeric */
  /*                                    ^ keyword.operator.arithmetic */
  /*                                     ^^^^^ constant.numeric.float.decimal */
  /*                                     ^ punctuation.separator.decimal */
  /*                                         ^ storage.type.numeric */
  /*                                          ^ keyword.operator.arithmetic */
  /*                                           ^^^^^^ constant.numeric.float.decimal */
  /*                                           ^ punctuation.separator.decimal */
  /*                                                ^ storage.type.numeric */
  /*                                                 ^ punctuation.terminator - constant */
  
  f = 1'843'290.245'123;
  /*  ^^^^^^^^^^^^^^^^^ constant.numeric.float.decimal */
  /*           ^ punctuation.separator.decimal */
  /*                   ^ punctuation.terminator - constant */
  
  f = 2'837e1'000;
  /*  ^^^^^^^^^^^ constant.numeric.float.decimal */
  /*             ^ punctuation.terminator - constant */
  
  f = 23e-1'000;
  /*  ^^^^^^^^^ constant.numeric.float.decimal */
  /*           ^ punctuation.terminator - constant */
  
  units1 = 134h + 123.45h;
  /*       ^^^^ constant.numeric.integer.decimal */
  /*          ^ storage.type.numeric */
  /*           ^^^ - constant */
  /*              ^^^^^^^ constant.numeric.float.decimal */
  /*                 ^ punctuation.separator.decimal */
  /*                    ^ storage.type.numeric */
  /*                     ^ punctuation.terminator - constant */
  
  units2 = 147min + 147.min;
  /*       ^^^^^^ constant.numeric.integer.decimal */
  /*          ^^^ storage.type.numeric */
  /*             ^^^ - constant */
  /*                ^^^^^^^ constant.numeric.float.decimal */
  /*                   ^ punctuation.separator.decimal */
  /*                    ^^^ storage.type.numeric */
  /*                       ^ punctuation.terminator - constant */
  
  units3 = 357s + 34.7s;
  /*       ^^^^ constant.numeric.integer.decimal */
  /*          ^ storage.type.numeric */
  /*           ^^^ - constant */
  /*              ^^^^^ constant.numeric.float.decimal */
  /*                ^ punctuation.separator.decimal */
  /*                  ^ storage.type.numeric */
  /*                   ^ punctuation.terminator - constant */
  
  units4 = 234_custom + 10e-1_custom;
  /*       ^^^^^^^^^^ constant.numeric.integer.decimal */
  /*          ^^^^^^^ storage.type.numeric */
  /*                 ^^^ - constant */
  /*                    ^^^^^^^^^^^^ constant.numeric.float.decimal */
  /*                         ^^^^^^^ storage.type.numeric */
  /*                                ^ punctuation.terminator - constant */
  
  /////////////////////////////////////////////
  // Functions
  /////////////////////////////////////////////
  
  // function prototype
  void abcdWXYZ1234();
  /*   ^^^^^^^^^^^^^^ meta.function */
  /*   ^ entity.name.function */
  /*               ^^ meta.function.parameters meta.group */
  /*               ^ punctuation.section.group.begin */
  /*                ^ punctuation.section.group.end */
  
  // function definition
  void abcdWXYZ1234()
  /*   ^^^^^^^^^^^^^^ meta.function */
  /*   ^ entity.name.function */
  /*               ^^ meta.function.parameters meta.group */
  /*               ^ punctuation.section.group.begin */
  /*                ^ punctuation.section.group.end */
  {
  /* <- meta.function meta.block punctuation.section.block.begin */
  }
  /* <- meta.function meta.block punctuation.section.block.end */
  
  struct foo **alloc_foo();
  /*           ^^^^^^^^^^^ meta.function */
  /*                    ^^ meta.function.parameters meta.group */
  /*                    ^ punctuation.section.group.begin */
  /*                     ^ punctuation.section.group.end */
  /* ^ storage.type */
  /*     ^ - entity.name.struct */
  /*         ^^ keyword.operator */
  /*           ^ entity.name.function */
  
  long func
  /*   ^^^^ meta.function entity.name.function */
  (int x, void *MYMACRO(y) ) {
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters meta.group */
  /* <- meta.function.parameters meta.group punctuation.section.group.begin */
  /*   ^ variable.parameter */
  /*            ^ -entity.name.function */
  /*            ^^^^^^^^^^ meta.function-call */
  /*                   ^^^ meta.group meta.function-call meta.group */
  /*                   ^ punctuation.section.group.begin */
  /*                     ^ punctuation.section.group.end */
  /*                       ^ punctuation.section.group.end */
      // Ensure < and > aren't parsed as a generic
      if (foo < bar && baz > bar ) {
  /*          ^ keyword.operator.comparison */
  /*                       ^ keyword.operator.comparison */
  
      label:
  /*  ^ entity.name.label */
  /*       ^ punctuation.separator */
          do {
              break;
          } while(true);
  
      }
      if (version.major == 10 && version.minor < 11)
  /*                                           ^ keyword.operator.comparison */
      {
  
      }
  }
  /* <- meta.function meta.block punctuation.section.block.end */
  
  MACRO1
  RETURN_TYPE
  /* <- - entity.name.function */
  func_name() {
  /* < entity.name.function */
  }
  
  MACRO1 void * MACRO2 myfuncname () {
  /*     ^ storage.type */
  /*          ^ keyword.operator */
  /*                   ^ entity.name.function */
  
      struct Args {
  /*  ^ storage.type */
  /*         ^ entity.name.struct */
          void* hello;
          void* foobar;
          Args()
  /*      ^ entity.name.function.constructor */
          : hellp(nullptr),
  /*      ^ punctuation.separator.initializer-list */
            foobar(nullptr)
          {
          }
      };
  
      struct Args args2;
  /*  ^ storage.type */
  /*         ^ - entity */
  
      class LocalFoo MYMACRO
  /*  ^ storage.type */
  /*        ^ entity.name.class */
  /*                 ^ - entity */
      {
          LocalFoo() {}
  /*      ^ entity.name.function.constructor */
      }
  
      class LocalFoo test;
  /*  ^ storage.type */
  /*        ^ - entity */
  
  }
  
  static const uint32_t * const MACRO funcname();
  /* ^ storage.modifier */
  /*     ^ storage.modifier */
  /*           ^ support.type */
  /*                    ^ keyword.operator */
  /*                      ^ storage.modifier */
  /*                                  ^ entity.name.function */
  
  void FooBar :: baz(int a)
  /*   ^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*   ^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*             ^^^ entity.name.function */
  /*          ^^ punctuation.accessor */
  /*                ^^^^^^^ meta.function.parameters meta.group */
  /*                ^ punctuation.section.group.begin */
  /*                     ^ variable.parameter */
  /*                      ^ punctuation.section.group.end */
  {
  }
  /* A comment. */ void FooBar :: baz(int a)
  /*                    ^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*                    ^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*                              ^^^ entity.name.function */
  /*                           ^^ punctuation.accessor */
  /*                                 ^^^^^^^ meta.function.parameters meta.group */
  /*                                 ^ punctuation.section.group.begin */
  /*                                      ^ variable.parameter */
  /*                                       ^ punctuation.section.group.end */
  {
  }
  // prevent leading comment from function recognition
  /**/ HRESULT A::b()
  /*           ^ meta.function */
  /*              ^ entity.name.function */
  {
      return S_OK;
  }
  FooBar::FooBar(int a)
  /*^^^^^^^^^^^^^^^^^^^ meta.function */
  /*^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*      ^^^^^^ entity.name.function */
  /*            ^^^^^^^ meta.function.parameters meta.group */
  /*            ^ punctuation.section.group.begin */
  /*             ^^^ storage.type */
  /*                  ^ punctuation.section.group.end */
  {
  }
  
  FooBar :: FooBar(int a) & =
  /*^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*^^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*        ^^^^^^ entity.name.function */
  /*              ^^^^^^^ meta.function.parameters meta.group */
  /*              ^ punctuation.section.group.begin */
  /*               ^^^ storage.type */
  /*                   ^ variable.parameter */
  /*                    ^ punctuation.section.group.end */
  /*                      ^ keyword.operator */
  /*                        ^ keyword.operator.assignment */
  default;
  /*^^^^^ meta.function storage.modifier */
  
  FooBar::~FooBar
  /*^^^^^^^^^^^^^ meta.function meta.toc-list.full-identifier */
  /*      ^^^^^^^ entity.name.function */
  () { }
  /* <- meta.function.parameters meta.group punctuation.section.group.begin */
   /* <- meta.function.parameters meta.group punctuation.section.group.end */
  /*^^^^ meta.function */
  
  ThisIsAReallyReallyLongClassNameThatRequiresWrappingCodeInTheMiddleOfAPath::
      ThisIsAReallyReallyLongClassNameThatRequiresWrappingCodeInTheMiddleOfAPath()
  /* <- meta.function meta.toc-list.full-identifier */
      : var_name(nullptr) {
  }
  
  bool FooBar::operator==() {}
  /*   ^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*   ^^^^^^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*           ^^^^^^^^^^ entity.name.function */
  /*                     ^^ meta.function.parameters meta.group */
  /*                     ^ punctuation.section.group.begin */
  /*                      ^ punctuation.section.group.end */
  /*                        ^^ meta.block */
  /*                        ^ punctuation.section.block.begin */
  /*                         ^ punctuation.section.block.end */
  
  
  myns::FooBar::~FooBar() { }
  /*^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*^^^^^^^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*                   ^^ meta.function.parameters meta.group */
  /*                   ^ punctuation.section.group.begin */
  /*                    ^ punctuation.section.group.end */
  /*                      ^^^ meta.block */
  /*                      ^ punctuation.section.block.begin */
  /*                        ^ punctuation.section.block.end */
  /*^^^^^^^^^^^^^^^^^^^ meta.toc-list.full-identifier */
  /*            ^^^^^^^ entity.name.function */
  
      extern "C" void test_in_extern_c_block()
  /*                  ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*                                        ^^ meta.function.parameters meta.group */
  /*                                        ^ punctuation.section.group.begin */
  /*                                         ^ punctuation.section.group.end */
  /*                  ^ entity.name.function */
  {
  /* <- meta.function meta.block punctuation.section.block.begin */
  }
  /* <- meta.function meta.block punctuation.section.block.end */
  
  #ifdef __cplusplus
  extern "C" {
  #endif
  
  #if 0
  void test_in_extern_c_block()
  /*   ^ comment.block */
  {
  }
  #else
  
  /* temporary C++ preprocessor block */
  #ifdef __cplusplus
  /*                <- meta.preprocessor */
  /*   <- keyword.control.import */
  # ifndef _Bool
  /*            <- meta.preprocessor */
  /*      <- keyword.control.import */
     typedef bool _Bool;   /* semi-hackish: C++ has no _Bool; bool is builtin */
  /* ^ storage.type */
  /*              ^ entity.name.type.typedef */
  # endif
  /*     <- meta.preprocessor */
  /*     <- keyword.control.import */
  #endif
  /*    <- meta.preprocessor */
  /*    <- keyword.control.import */
  
  void test_in_extern_c_block()
  /*   ^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*                         ^^ meta.function.parameters meta.group */
  /*                         ^ punctuation.section.group.begin */
  /*                          ^ punctuation.section.group.end */
  /*   ^ entity.name.function */
  {
  /* <- meta.function meta.block punctuation.section.block.begin */
  }
  /* <- meta.function meta.block punctuation.section.block.end */
  #endif
  
  #ifdef __cplusplus
  }
  #endif
  /* ^ - meta.extern-c */
  
  gener<int> func_returning_generic(int a);
  /*         ^ entity.name.function */
  
  std::vector<std::uint8_t> func_returning_path_generic(int a);
  /*         ^ punctuation.section.generic */
  /*                        ^ entity.name.function */
  
  void f()
  {
      static_assert(false, "oops");
      /* ^ keyword.operator.word */
  }
  
  long double operator "" _km (long double x);
  /*          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*                          ^^^^^^^^^^^^^^^ meta.function.parameters */
  /*          ^^^^^^^^^^^^^^^ entity.name.function */
  
  /////////////////////////////////////////////
  // Namespace
  /////////////////////////////////////////////
  
  namespace myNameSpace {}
  /* <- keyword.control */
  /*        ^ entity.name.namespace */
  
  namespace new_name = current_name;
  /* <- keyword.control */
  
  using namespace NAME __attribute__((visibility ("hidden")));
  /* <- keyword.control */
  /*    ^ keyword.control */
  /*                   ^ storage.modifier */
  /*                                               ^ string */
  
  void func() {
      using namespace NAME __attribute__((visibility ("hidden")));
  /*  ^ keyword.control */
  /*        ^ keyword.control */
  /*                       ^ storage.modifier */
  /*                                                   ^ string */
  }
  
  using namespace
  /* <- keyword.control */
  /*    ^ keyword.control */
  
  using namespace myNameSpace;
  /* <- keyword.control */
  /*    ^ keyword.control */
  
  namespace ns :: abc /* Neither this comment... */
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.namespace */
  /*        ^^^^^^^^^ entity.name.namespace */
  /*           ^^ punctuation.accessor */
  /*                  ^ comment.block */
  // ...nor this comment is highlighted
  /* <- comment.line */
  {
  /* <- meta.namespace meta.block punctuation.section.block.begin */
      void nsfunc() {
          /* ^ entity.name.function */
      }
  }
  /* <- meta.namespace meta.block punctuation.section.block.end */
  
  namespace tl {
  /*^^^^^^^^^^^^ meta.namespace */
  /* ^ keyword.control */
      namespace {
  /*  ^ keyword.control */
  /*  ^^^^^^^^^^^ meta.namespace meta.namespace */
  /*            ^ meta.block meta.block punctuation.section.block.begin */
          void nested_func(){}
  /*           ^ entity.name.function */
      }
  }
  
  MACRONAME namespace ns3 {}
  /*        ^ keyword.control */
  
  extern "C++"
  // ^ storage.modifier
  //     ^^^^^ string.quoted.double
  {
  namespace std _GLIBCXX_VISIBILITY(default)
  //^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.namespace
  // ^ keyword.control
  //        ^ entity.name.namespace
  //            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function-call
  //                               ^^^^^^^^^ meta.group
  //                                ^ keyword.control
  {}
  }
  
  #define MY_NAMESPACE_BEGIN namespace greatapp {
  #define MY_NAMESPACE_END }
  MY_NAMESPACE_BEGIN
  class X {
  private:
  /* <- storage.modifier */
      int a;
  protected:
  /* <- storage.modifier */
      int b;
  public:
  /* <- storage.modifier */
      int c;
  };
  MY_NAMESPACE_END
  
  MY_NAMESPACE_BEGIN int foo(); MY_NAMESPACE_END
  /*                 ^ storage.type */
  /*                     ^ meta.function entity.name.function */
  /*                        ^^^ punctuation */
  
  // Uncomment this some day
  // MY_NAMESPACE_BEGIN class X : public std::true_type {}; MY_NAMESPACE_END
  
  /////////////////////////////////////////////
  // Classes, structs, unions and enums
  /////////////////////////////////////////////
  
  class BaseClass;
  /*^^^^^^^^^^^^^ meta.class */
  /*    ^ - meta.class meta.class */
  /*    ^^^^^^^^^ entity.name.class.forward-decl */
  
  class BaseClass // comment
  /* <- storage.type */
  /*    ^ entity.name.class */
  {
  public :
  /* <- storage.modifier */
      tupleTmpl<int,2> max(tupleGen<int,2> a, tupleGen<int,2> b);
  /*                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method */
  /*                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.parameters meta.group */
  /*                      ^ punctuation.section.group.begin */
  /*                                       ^ variable.parameter */
  /*                                        ^ punctuation.separator */
  /*                                                          ^ variable.parameter */
  /*                                                           ^ punctuation.section.group.end */
  /*           ^ punctuation.section.generic.begin */
  /*            ^ storage.type */
  /*                 ^ punctuation.section.generic.end */
  /*                               ^ punctuation.section.generic.begin */
  /*                                ^ storage.type */
  /*                                     ^ punctuation.section.generic.end */
  protected:
  /* <- storage.modifier */
  private:
  /* <- storage.modifier */
  
      static int a = 1 << 4;
      /* <- storage.modifier */
      /*               ^^ keyword.operator.arithmetic */
  
      static int x;
      /* <- storage.modifier */
  
      virtual void doSomething() const = 0;
      /*           ^^^^^^^^^^^^^^^^^^^^^^^ meta.method */
      /*           ^ - meta.method meta.method */
      /*                      ^^ meta.method.parameters meta.group */
      /*                      ^ punctuation.section.group.begin */
      /*                       ^ punctuation.section.group.end */
      /* <- storage.modifier */
      /*           ^ entity.name.function */
      /*                         ^ storage.modifier */
      /*                                 ^ constant.numeric */
  
      template<typename A>
      void func(){}
  /*       ^^^^^^^^ meta.method */
  /*           ^^ meta.method.parameters meta.group */
  /*           ^ punctuation.section.group.begin */
  /*            ^ punctuation.section.group.end */
  /*             ^^ meta.block */
  /*             ^ punctuation.section.block.begin */
  /*              ^ punctuation.section.block.end */
  /*       ^^^^ entity.name.function */
  
      template<typename A>
      void func<A>(){}
  /*       ^^^^^^^^^^^ meta.method */
  /*       ^^^^ entity.name.function */
  /*           ^ punctuation.section.generic.begin */
  /*             ^ punctuation.section.generic.end */
  /*              ^^ meta.method.parameters meta.group */
  /*              ^ punctuation.section.group.begin */
  /*               ^ punctuation.section.group.end */
  /*                ^^ meta.block */
  /*                ^ punctuation.section.block.begin */
  /*                 ^ punctuation.section.block.end */
  
      template<typename A>
      BaseClass(){}
  /*  ^^^^^^^^^^^^^ meta.method */
  /*  ^^^^^^^^^ meta.method.constructor */
  /*  ^^^^^^^^^ entity.name.function */
  
      ~BaseClass() {}
  /*  ^^^^^^^^^^^^^^^ meta.method */
  /*  ^^^^^^^^^^ meta.method.destructor */
  /*  ^^^^^^^^^^ entity.name.function */
  
      BaseClass operator [] ()
  /*            ^^^^^^^^^^^^^^ meta.method */
  /*                        ^^ meta.method.parameters */
  /*            ^^^^^^^^^^^ entity.name.function */
      {}
  
      BaseClass operator=
  /*            ^^^^^^^^^ meta.method */
  /*            ^^^^^^^^^ entity.name.function */
      () {}
  /*  ^^^^^ meta.method */
  /*  ^^ meta.method.parameters */
  /*     ^^ meta.block */
  };
  
  class DerivedClass : public ::BaseClass // Comment
  /*                          ^ entity.other.inherited-class */
  /*                                      ^ comment.line */
  {
      ~DerivedClass() override;
      /* <- meta.method.destructor */
      /*^^^^^^^^^^^^^^^^^^^^^^ meta.method */
      /*^^^^^^^^^^^ meta.method.destructor */
      /*              ^ storage.modifier */
      virtual void doSomething() const override final;
      /*                         ^ storage.modifier */
      /*                               ^ storage.modifier */
      /*                                        ^ storage.modifier */
   protected:
  /*^^^^^^^^ storage.modifier */
    DerivedClass() override
  /*^^^^^^^^^^^^^^^^^^^^^^^ meta.method */
  /*^^^^^^^^^^^^ meta.method.constructor */
  /*                ^ storage.modifier */
        : a(a),
  /*    ^^^^^^^ meta.method.constructor.initializer-list */
          base_id_(BaseClass::None().ToInt()),
  /*      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.method.constructor.initializer-list */
  /*      ^ variable.other.readwrite.member */
  /*                        ^ punctuation.accessor */
  /*               ^^^^^^^^^^^^^^^^^ meta.function-call */
  /*                          ^^^^ variable.function */
  /*                                ^ punctuation - meta.method-call */
  /*                                 ^^^^^^^ meta.method-call */
  /*                                 ^^^^^ variable.function */
  /*                                         ^ punctuation.separator */
          bounds_(NULL),
  /*      ^^^^^^^^^^^^^^ meta.method.constructor.initializer-list */
          bit_field_(0) {
  /*      ^^^^^^^^^^^^^^^ meta.method */
  /*      ^^^^^^^^^^^^^ meta.method.constructor.initializer-list */
              char * a = "sprintf";
              char * b = sprintf("Testing %s", a);
  /*                     ^^^^^^^^^ meta.function-call */
  /*                     ^^^^^^^ support.function.C99 */
  
              base_id_->foobar(1, "foo");
  /*                  ^^ punctuation.accessor - meta.method-call */
  /*                    ^^^^^^^^^^^^^^^^ meta.method-call        */
  /*                    ^^^^^^ variable.function                 */
  
              base_id_->~BaseClass();
  /*                  ^^ punctuation.accessor - meta.method-call */
  /*                    ^^^^^^^^^^^^ meta.method-call            */
  /*                    ^^^^^^^^^^ variable.function             */
          }
  /*      ^ meta.method meta.block punctuation.section.block.end */
  
  /* <- - meta.class.constructor.initializer-list */
  
      typedef std::vector<int> qux;
  /*                           ^^^ entity.name.type.typedef */
  };
  
  
  template<typename A>
  class class1<A> : class2<A>
  /*    ^^^^^^ entity.name.class */
  /*          ^ punctuation.section.generic */
  /*            ^ punctuation.section.generic */
  /*                ^^^^^^ entity.other.inherited-class */
  /*                      ^ punctuation.section.generic */
  /*                        ^ punctuation.section.generic */
  {}
  
  class FooBar {
  /*           ^ meta.class meta.block punctuation.section.block.begin */
      explicit FooBar(int a);
  /*           ^^^^^^^^^^^^^ meta.method */
  /*  ^^^^^^^^ storage.modifier */
  /*           ^^^^^^ entity.name.function */
      FooBar() =default;
  /*  ^^^^^^ entity.name.function */
  /*           ^ keyword.operator.assignment */
  /*            ^^^^^^^ storage.modifier */
      FooBar(void) =default;
  /*  ^^^^^^ entity.name.function */
  /*         ^^^^ storage.type */
  /*               ^ keyword.operator.assignment */
  /*                ^^^^^^^ storage.modifier */
  
      // If a constructor name is on a line without the opening (, it is not
      // highlighted as a method/constructor. This prevents a bunch of false
      // positives, including data types as they are being typed into a struct.
      FooBar
  /*  ^ - entity.name.function */
      ();
  
      virtual ~FooBar();
  /*          ^^^^^^^ entity.name.function */
  
  #ifndef DEBUG
      ~FooBar();
  /*  ^^^^^^^ entity.name.function */
  #endif
  
      void insert () {}
  /*       ^^^^^^ entity.name.function */
  
      explicit operator bool
  /*                    ^^^^ entity.name.function */
      () {}
  
      FooBar::~FooBar();
  /*  ^^^^^^^^^^^^^^^ entity.name.function */
  
      void FooBar::
      Baz() {
      /* <- entity.name.function */
      }
  
      auto f(int a) -> decltype(a.begin()) override final;
  /*                ^^ punctuation.separator */
  /*                             ^ punctuation.accessor */
  /*                              ^^^^^ variable.function */
  /*                                       ^ storage.modifier */
  /*                                                ^ storage.modifier */
  
      auto g() -> std::vector<int> override final {
  /*           ^^ punctuation.separator */
  /*                 ^^ punctuation.accessor */
  /*                          ^ storage.type */
  /*                               ^ storage.modifier */
  /*                                        ^ storage.modifier */
          this->g(1);
  /*      ^ variable.language */
      }
  
  private:
  /*^^^^^ storage.modifier */
  
      VISIBILITY_MACRO
  /*  ^ - entity.name.function */
      myns::subns::MyDataType
  /*  ^ - entity.name.function */
      and_now_method_name();
  /*  ^ entity.name.function */
  
      VISIBILITY_MACRO
  /*  ^ - entity.name.function */
      std::shared_future<std::vector<myns::mysubns::MyDataType>>
  /*  ^ - entity.name.function */
  /*     ^^ punctuation.accessor */
  /*                    ^ punctuation.section.generic.begin */
  /*                        ^^ punctuation.accessor */
  /*                                ^ punctuation.section.generic.begin */
  /*                                     ^^ punctuation.accessor */
      and_now_method_name2();
  /*  ^ entity.name.function */
  
      enum
  /*  ^^^^ meta.enum storage.type */
      {
  /*  ^ meta.enum punctuation.section.block.begin */
          A = 1,
          B = 20 / 5
      }
  /*  ^ meta.enum punctuation.section.block.end */
  /*   ^ - meta.enum */
  
      friend int func(int a, int b);
  /*  ^ storage.modifier */
  /*         ^ storage.type */
  /*             ^ - entity.name.function */
  /*             ^ - meta.function-call */
  
      friend int func(int a, int b) {
  /*  ^ storage.modifier */
  /*         ^ storage.type */
  /*             ^ entity.name.function */
  /*             ^ - meta.function-call */
  /*                                ^ meta.class meta.block meta.method meta.block punctuation.section.block.begin */
          int a = 1;
      }
  /*  ^ meta.class meta.block meta.block punctuation.section.block.end */
  /*   ^ - meta.class meta.block meta.block */
  
      friend class ::FooBar;
  /*  ^ storage.modifier */
  /*         ^ storage.type
  /*               ^^ punctuation.accessor */
  /*                 ^ - entity */
  
      friend bool operator != (const X& lhs, const X& rhs) {
      /*          ^^^^^^^^^^^ entity.name.function */
          int a = 1;
      }
  /*  ^ meta.class meta.block meta.block punctuation.section.block.end */
  /*   ^ - meta.class meta.block meta.block */
  
      #if 0
      /*  ^ constant.numeric */
      int disabled_func() {
      /*  ^ comment.block */
      }
      #endif
  
      #if 1
      /*  ^ constant.numeric */
      int enabled_func() {}
      /*  ^ entity.name.function */
      #else
      int disabled_func() {
      /*  ^ comment.block */
      }
      #endif
  
      MACRO_NOT_CONSTRUCTOR(FooBar);
  /*  ^ meta.function-call variable.function - entity.name.function */
  
      MACRO_NOT_CONSTRUCTOR2(FooBar,
  /*  ^ meta.function-call variable.function - entity.name.function */
          FriendClass);
  }
  /* <- meta.class meta.block punctuation.section.block.end */
   /* <- - meta.class meta.block */
  
  struct X {
      Y f() override noexcept final;
      /*^ entity.name.function */
      /*    ^ storage.modifier */
      /*             ^ storage.modifier */
      /*                      ^ storage.modifier */
      ::Y g() override noexcept final;
      /* <- punctuation.accessor */
      /*  ^ entity.name.function */
      /*      ^ storage.modifier */
      /*               ^ storage.modifier */
      /*                        ^ storage.modifier */
  };
  
  class X {
    public:
      ::Y g() override noexcept final;
      /* <- punctuation.accessor */
      /*  ^ entity.name.function */
      /*      ^ storage.modifier */
      /*               ^ storage.modifier */
      /*                        ^ storage.modifier */
  };
  
  union Y {
      ::Y g() override noexcept final;
      /* <- punctuation.accessor */
      /*  ^ entity.name.function */
      /*      ^ storage.modifier */
      /*               ^ storage.modifier */
      /*                        ^ storage.modifier */
  };
  
  class Child : public Parent {
      ::anotherClass Func() override;
      /* <- punctuation.accessor */
      /*             ^ entity.name.function */
      /*                    ^ storage.modifier */
  }
  
  class Adapter2 : public Abstraction, private Scenario {
  /*                                 ^ punctuation.separator */
  }
  
  class Adapter : public Abstraction
      #if defined ASPECTO_MACRO
  /*  ^^^ keyword.control.import  */
      , public Scenario
  /*  ^ punctuation.separator */
  /*    ^ storage.modifier */
  /*           ^ entity.other.inherited-class */
      #endif
  /*  ^^^^^^ keyword.control.import  */
  {
  
  }
  
  struct Base {};
  class Derived final : Base {};
  /*             ^ storage.modifier */
  struct Derived final : Base {};
  /*             ^ storage.modifier */
  
  /* C++11 "uniform initialization" in initializer lists */
  class Foo {
  public:
      Foo() : var1(1), var(2), var3{3}, var4(4) {}
                                   /* ^ meta.method.constructor.initializer-list   */
                                   /*   ^ - meta.function-call - variable.function */
  private:
      int var1, var2, var3, var4;
  };
  
  class X {
      int a, b, i, j;
  public:
      const int& r;
      X(int i)
        : r(a) // initializes X::r to refer to X::a
        /* ^ meta.method.constructor.initializer-list punctuation         */
        /*   ^ meta.method.constructor.initializer-list punctuation       */
        , b{i} // initializes X::b to the value of the parameter i
        /* ^ meta.method.constructor.initializer-list punctuation         */
        /*   ^ meta.method.constructor.initializer-list punctuation       */
        , i(i) // initializes X::i to the value of the parameter i
        /* ^ meta.method.constructor.initializer-list punctuation         */
        /*   ^ meta.method.constructor.initializer-list punctuation       */
        , j(this->i) // initializes X::j to the value of X::i
        /* ^ meta.method.constructor.initializer-list punctuation         */
        /*         ^ meta.method.constructor.initializer-list punctuation */
        , j
        /*^ variable */
        (this->i)
        /* <- meta.method.constructor.initializer-list punctuation */
      { }
  /*  ^ punctuation - meta.method.constructor.initializer-list   */
  /*    ^ punctuation - meta.method.constructor.initializer-list */
  };
  
  struct A {
    static_assert(0 < 1, "");
    /* ^ keyword.operator.word                    */
    /*            ^ meta.function-call            */
    /*              ^ keyword.operator.comparison */
  
    A();
  /*^ meta.method.constructor entity.name.function.constructor */
  
    void f();
    /* ^ storage.type                       */
    /*   ^ meta.method entity.name.function */
    /*      ^ punctuation.terminator        */
  };
  /* <- punctuation.section.block.end - invalid.illegal */
  
  struct bar {
  /*^^^^^^^^^^ meta.struct */
  /*^^^^ storage.type */
  /*     ^^^ entity.name.struct */
  /*         ^ meta.block punctuation.section.block.begin */
      bar()
  /*  ^^^^^ meta.method */
  /*  ^^^ entity.name.function */
      {}
  }
  /* <- meta.struct meta.block punctuation.section.block.end */
   /* <- - meta.struct meta.block */
  
  enum baz {
  /*^^^^^^^^ meta.enum */
  /* <- meta.enum storage.type */
  /*   ^^^ entity.name.enum */
  /*       ^ meta.block punctuation.section.block.begin */
      FOO = 1,
  /*      ^ keyword.operator.assignment */
  /*        ^ constant.numeric */
      BAR = 2,
      BAZ = 3,
  #if 0
  /*  ^ constant.numeric */
      QUX = 4,
  /*  ^ comment.block */
  #endif
  }
  /* <- meta.enum meta.block punctuation.section.block.end */
   /* <- - meta.enum meta.block */
  
  int main(void)
  {
      struct UI_BoundingBox decorativeBox = {10, titleHeight-3, width-20, height-10};
  /*         ^ - entity.name */
  /*                        ^ - entity.name */
  }
  
  struct foo MACRO {
  /*     ^ entity.name.struct */
  /*         ^ - entity.name */
  }
  
  // Partially-typed
  struct foo
  /*     ^ entity.name */
  
  struct UI_MenuBoxData
  /* <- storage.type */
  /*     ^ entity.name.struct */
  {
      struct UI_BoundingBox position;
  /*         ^ - entity.name */
  /*                        ^ - entity.name */
      enum UI_BoxCharType borderType;
  /*       ^ - entity.name */
  /*                      ^ - entity.name */
      unsigned int paddingX;
      unsigned int paddingY;
      struct UI_ScrollBoxText boxContents[];
  /*         ^ - entity.name */
  /*                          ^ - entity.name */
  };
  
  enum class qux : std::uint8_t
  /*^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.enum */
  /*^^^^^^^^ storage.type */
  /*         ^^^ entity.name.enum */
  /*             ^ punctuation.separator */
  /*               ^^^^^^^^^^^^ entity.other.inherited-class */
  {
  /* <- meta.block punctuation.section.block.begin */
      FOO = 1,
      BAR = 2,
  /*      ^ keyword.operator.assignment */
  /*        ^ constant.numeric */
      BAZ = 3
  }
  /* <- meta.enum meta.block punctuation.section.block.end */
   /* <- - meta.enum meta.block */
  
  enum LineEnding : uint32_t;
  /*^^^^^^^^^^^^^^^^^^^^^^^^ meta.enum */
  /*   ^^^^^^^^^^ entity.name.enum.forward-decl */
  /*              ^ punctuation.separator */
  /*                ^^^^^^^^ entity.other.inherited-class */
  /*                        ^ - meta.enum */
  
  union foobaz {
  /* <- meta.union storage.type */
  /*    ^^^^^^ entity.name.union */
  /*           ^ meta.block punctuation.section.block.begin */
  }
  /* <- meta.union meta.block punctuation.section.block.end */
   /* <- - meta.union meta.block */
  
  // Class name that looks like a possible macro
  class SP {}
  /*    ^^ entity.name.class */
  
  class MyClass MACRO MACRO2
  /* ^ storage.type */
  /*    ^ entity.name.class */
  /*            ^ - entity */
  /*                  ^ - entity */
  {}
  
  // Class using macro to handle __declspec() on Windows
  class SK_API SkBitmap {}
  /*           ^ entity.name.class */
  class __declspec(property(get=foo)) SkBitmap {}
  /*               ^ storage.modifier */
  /*                        ^ variable.parameter */
  /*                                  ^ entity.name.class */
  class __declspec(align(8)) SkBitmap {}
  /*               ^ storage.modifier */
  /*                     ^ constant.numeric */
  /*                         ^ entity.name.class */
  class __declspec(dllimport) SkBitmap {}
  /*               ^ constant.other */
  /*                          ^ entity.name.class */
  
  // Make sure not to match macros that have "too few characters".
  template <class T> class Sample {
   public:
    // The T here should not be consumed as a macro.
    T operator()  (const foo x) {
      /* <- entity.name.function */
      /*^^^^^^^^ entity.name.function */
      return T;
    }
    int operator == (const int x) {
      /*^^^^^^^^^^^ entity.name.function */
      return 0;
    }
    // The T here should not be consumed as a macro.
    T operator()(int a) {
      /* <- entity.name.function */
      /*^^^^^^^^ entity.name.function */
      return T;
    }
    // The T here should not be consumed as a macro.
    T operator[](int a)  {
      /* <- entity.name.function */
      /*^^^^^^^^ entity.name.function */
       return T;
    }
  };
  
  class Namespace::MyClass MACRO1 MACRO2 : public SuperClass
  /*               ^^^^^^^ entity.name.class */
  /*             ^^ punctuation.accessor */
  /*                       ^ - entity.name */
  {
  };
  
  struct Namespace::MyStruct
  /*                ^^^^^^^^ entity.name.struct */
  /*              ^^ punctuation.accessor */
  {
  };
  
  union Namespace::MyUnion
  /*               ^^^^^^^ entity.name.union */
  /*             ^^ punctuation.accessor */
  {
  };
  
  enum class Namespace::MyEnum
  /*                    ^^^^^^ entity.name.enum */
  /*                  ^^ punctuation.accessor */
  {
  };
  
  class Namespace::
  MyClass MACRO1
  /* <- entity.name.class */
  /*      ^ - entity.name */
  {
  };
  
  struct Namespace::
  MyStruct MACRO1
  /* <- entity.name.struct */
  /*       ^ - entity.name */
  {
  };
  
  union Namespace::
  MyUnion MACRO1
  /* <- entity.name.union */
  /*      ^ - entity.name */
  {
  };
  
  enum class Namespace::
  MyEnum MACRO1
  /* <- entity.name.enum */
  /*     ^ - entity.name */
  {
  };
  
  
  /////////////////////////////////////////////
  // Test preprocessor branching and C blocks
  /////////////////////////////////////////////
  
  int foo(int val, float val2[], bool val3 = false)
  /*  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function */
  /*     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ meta.function.parameters meta.group */
  /*     ^ punctuation.section.group.begin */
  /*                                              ^ punctuation.section.group.end */
  /*          ^^^ variable.parameter */
  /*             ^ punctuation.separator */
  /*                     ^^^^ variable.parameter */
  /*                         ^^ meta.brackets */
  /*                         ^ punctuation.section.brackets.begin */
  /*                          ^ punctuation.section.brackets.end */
  /*                           ^ punctuation.separator */
  /*                             ^^^^ storage.type */
  /*                                  ^^^^ variable.parameter */
  /*                                       ^ keyword.operator.assignment */
  /*                                         ^^^^^ constant.language */
  {
      myClass *result;
      result->kk = func(val);
  /*        ^^ punctuation.accessor */
      if (result == 0) {
          return 0;
  #if CROSS_SCOPE_MACRO
   /* <- keyword.control.import */
      } else if (result > 0) {
          return 1;
  #endif
   /* <- keyword.control.import */
      }
  /*  ^ meta.block meta.block punctuation.section.block.end */
  /*   ^ - meta.block meta.block */
  
  #ifndef DEBUG
      if (check_debug()) {
          val /= 2;
  #endif
          val += 1;
  #ifndef DEBUG
      }
  /*  ^ meta.function meta.block meta.block punctuation.section.block.end */
  /*   ^ - meta.block meta.block */
  #endif
  
  #ifdef FOO
   /* <- keyword.control.import */
      int foobar
  /*      ^^^^^^ - entity.name.function */
      ;
  
      if (val == -1) {
  /*                 ^ meta.block meta.block punctuation.section.block.begin */
  #else
   /* <- keyword.control.import */
      if (val == -2) {
  /*                 ^ meta.block meta.block punctuation.section.block.begin */
  #endif
   /* <- keyword.control.import */
          val += 1;
      }
  /*  ^ meta.block punctuation.section.block.end */
  /*   ^ - meta.block meta.block */
  
      return -1;
  }
  /* <- meta.function punctuation.section.block.end */
   /* <- - meta.function */
  
  #if 0
  /*  ^ constant.numeric */
  int disabled_func() {
  /*  ^ comment.block */
  }
  #endif
  
  #if 1
  /*  ^ constant.numeric */
  int enabled_func() {}
  /*  ^ entity.name.function */
  #else
  int disabled_func() {
  /*  ^ comment.block */
  }
  #endif
  
  #if 1
      int a = 1;
      #if 0
  /*      ^ constant.numeric */
          int b = 2;
  /*      ^ comment.block */
      #else
          int c = 3;
      #endif
  #else
      int d = 4;
  /*  ^ comment.block */
  #endif
  
  BOOL
  GetTextMetrics(
      HDC hdc,
      LPTEXTMETRIC lptm
      )
  {
  #ifdef UNICODE
  /* <- keyword.control.import */
      return GetTextMetricsW(
  /*         ^ variable.function */
  #else
  /* <- keyword.control.import */
      return GetTextMetricsA(
  /*         ^ variable.function */
  #endif
  /* <- keyword.control.import */
          hdc,
          lptm
          );
  /*      ^ meta.function-call */
  /*       ^ - meta.function-call */
  }
   /* <- - meta.function */
   /* <- - meta.block */
  
  /////////////////////////////////////////////
  // Matching various function definitions
  /////////////////////////////////////////////
  
  const int foo = 1;
  /*        ^ - entity.name.function */
  int a;
  /*  ^ - entity.name.function */
  
  int /* comment */ * myfunc
  /* <- storage.type */
  /*  ^ comment.block */
  /*                ^ keyword.operator */
  /*                  ^^^^^^ entity.name.function */
  (int * a)
  /* <- punctuation.section.group.begin */
  /*   ^ keyword.operator */
  /*      ^ punctuation.section.group.end */
  {
  
  }
  
  void MyClass3::
  foo() {
  /* <- entity.name.function */
  }
  
  MyClass3::
  ~MyClass3() {
  /* <- entity.name.function */
  }
  
  struct A
  {
      #ifdef X
      static_assert(false, "asdf");
      /* ^ keyword.operator.word */
      #endif
  
      void f()
      {
          #ifdef X
          static_assert(false, "asdf");
          /* ^ keyword.operator.word */
          #endif
      }
  
      void f()
      {
          static_assert(false, "asdf");
          /* ^ keyword.operator.word */
      }
  };
  
  void f()
  {
      static_assert(false, "asdf");
  /* ^ meta.function meta.block */
  /*  ^ keyword.operator.word   */
  }
  
  void f()
  {
      #ifdef X
      static_assert(false, "asdf");
  /* ^ meta.function meta.block */
  /*  ^ keyword.operator.word   */
      #endif
  }
  
  Glib::ustring Node::_getDragTip(GdkEventMotion */*event*/);
  /*                                              ^^^^^^^^^ comment */
  
  MACRO1 void * MACRO2 myfuncname () {
  /*     ^ storage.type */
  /*          ^ keyword.operator */
  /*                   ^ entity.name.function */
  
      label:
  /*  ^ entity.name.label */
  /*       ^ punctuation.separator */
          do {
              break;
          } while(true);
  
      switch (a) {
          case 1: break;
  /*            ^ punctuation.separator */
          case 100 - 10: break;
  /*                   ^ punctuation.separator */
          default: break;
  /*             ^ punctuation.separator */
      }
  
  }
  
  static const uint32_t * const MACRO funcname();
  /* ^ storage.modifier */
  /*     ^ storage.modifier */
  /*           ^ support.type */
  /*                    ^ keyword.operator */
  /*                      ^ storage.modifier */
  /*                                  ^ entity.name.function */
  
  MACRO int
  /*    ^ storage.type */
  funcname2
  /* ^ entity.name.function */
  ()
  {
  
  }
  
  MACRO_CALL(int) macro_prefixed_func(){}
  /*^^^^^^^^^^^^^ meta.function-call */
  /*        ^^^^^ meta.group */
  /*        ^ punctuation.section.group.begin */
  /*            ^ punctuation.section.group.end */
  /*              ^ entity.name.function */
  
  int* return_type_pointer_no_space(){}
  /*   ^ entity.name.function */
  
  int& return_type_ref_no_space(){}
  /*   ^ entity.name.function */
  
  // Make sure there isn't an incorrect match here since this is not a valid
  // function definition
  int32
  /* <- - entity.name.function */
  () {}
  
  _declspec(deprecated("bla")) void func2(int) {}
  /* <- meta.function-call variable.function                    */
  /*                                ^ entity.name.function      */
  __declspec(deprecated("bla")) void func2(int) {}
  /* <- storage.modifier - variable.function                    */
  /*         ^ storage.modifier - variable.function             */
  /*                    ^ string.quoted.double punctuation      */
  /*                     ^ string.quoted.double - punctuation   */
  /*                       ^ string.quoted.double - punctuation */
  /*                        ^ string.quoted.double punctuation  */
  /*                         ^^ punctuation - invalid           */
  /*                                 ^ entity.name.function     */
  __notdeclspec(deprecated("bla")) void func2(int) {}
  /* <- meta.function-call variable.function                    */
  /*                                    ^ entity.name.function  */
  
  /////////////////////////////////////////////
  // Paths/identifiers
  /////////////////////////////////////////////
  
  void sayHi()
  {
      std::cout << "Hi!\n";
  /*     ^ punctuation.accessor */
      Print<int>(3);
  /*  ^ variable.function */
      func_call(foo
  /*  ^ meta.function-call */
      );
  
      if (::std::foo()) {}
  /*             ^^^ variable.function */
  /*      ^^ punctuation.accessor */
  /*           ^^ punctuation.accessor */
  
      foobaz<int>();
  /*  ^^^^^^^^^^^^^ meta.function-call */
  /*  ^^^^^^ variable.function */
  /*        ^ punctuation.section.generic.begin */
  /*            ^ punctuation.section.generic.end */
  /*             ^^ meta.group */
  
      foobaz<>();
  /*  ^^^^^^^^^^ meta.function-call */
  /*  ^^^^^^ variable.function */
  /*        ^ punctuation.section.generic.begin */
  /*         ^ punctuation.section.generic.end */
  /*          ^^ meta.group */
  
      foobaz<0>();
  /*  ^^^^^^^^^^^ meta.function-call */
  /*  ^^^^^^ variable.function */
  /*        ^ punctuation.section.generic.begin */
  /*         ^ constant.numeric */
  /*          ^ punctuation.section.generic.end */
  /*           ^^ meta.group */
  
      ::myns::foo<int>();
  /*  ^^ punctuation.accessor.double-colon */
  /*        ^^ punctuation.accessor.double-colon */
  /*  ^^^^^^^^^^^^^^^^^^ meta.function-call */
  /*          ^^^ variable.function */
  /*              ^^^ storage.type */
  
      myns::FooClass{42};
  /*      ^^ punctuation.accessor.double-colon */
  /*  ^^^^^^^^^^^^^^^^^^ meta.function-call */
  /*        ^^^^^^^^ variable.function */
  
      ::myns::BarClass<int>{};
  /*  ^^ punctuation.accessor.double-colon */
  /*        ^^ punctuation.accessor.double-colon */
  /*  ^^^^^^^^^^^^^^^^^^^^^ meta.function-call */
  /*          ^^^^^^^^ variable.function */
  /*                   ^^^ storage.type */
  
      int a[5];
  /*       ^^^ meta.brackets */
  /*       ^ punctuation.section.brackets.begin */
  /*         ^ punctuation.section.brackets.end */
  
      std::cout << ">> Hi!\n";
  /*            ^^ keyword.operator.arithmetic.c */
  }
  
  /////////////////////////////////////////////
  // Includes
  /////////////////////////////////////////////
  
  #include "foobar.h"
  /* <- keyword.control.import.include */
  /*       ^ punctuation.definition.string.begin */
  /*        ^^^^^^^^ string.quoted.double.include */
  /*                ^ punctuation.definition.string.end */
  
  #include <cstdlib>
  /* <- keyword.control.import.include */
  /*       ^ punctuation.definition.string.begin */
  /*        ^^^^^^^ string.quoted.other.lt-gt.include */
  /*               ^ punctuation.definition.string.end */
  
  #ifdef _GLIBCXX_INCLUDE_NEXT_C_HEADERS
  #include_next <math.h>
  /* <- keyword.control.import.include */
  /*            ^ punctuation.definition.string.begin */
  /*             ^^^^^^ string.quoted.other.lt-gt.include */
  /*                   ^ punctuation.definition.string.end */
  #endif
  
  #include<iostream>
  /* <- keyword.control.import.include */
  /*      ^ punctuation.definition.string.begin */
  /*       ^^^^^^^^ string.quoted.other.lt-gt.include */
  /*               ^ punctuation.definition.string.end */
  
  /**
        *
  /*    ^ comment.block.c punctuation.definition.comment.c */
  