deploy: v0.12 fix 存档key名

node_modules/@lezer/cpp/test/ambiguities.txt

@@ -0,0 +1,98 @@
+# template functions vs relational expressions
+
+T1 a = b < c > d;
+T2 e = f<T3>(g);
+int a = std::get<0>(t);
+
+==>
+
+Program(
+  Declaration(
+    TypeIdentifier,
+    InitDeclarator(
+      Identifier,
+      BinaryExpression(
+        BinaryExpression(Identifier, CompareOp, Identifier),
+        CompareOp,
+        Identifier))),
+  Declaration(
+    TypeIdentifier,
+    InitDeclarator(
+      Identifier,
+      CallExpression(
+        TemplateFunction(Identifier, TemplateArgumentList(
+          TypeDescriptor(TypeIdentifier))),
+        ArgumentList(Identifier)))),
+  Declaration(
+    PrimitiveType,
+    InitDeclarator(
+      Identifier,
+      CallExpression(
+        TemplateFunction(
+          ScopedIdentifier(NamespaceIdentifier, Identifier),
+          TemplateArgumentList(Number)),
+        ArgumentList(Identifier)))))
+
+
+# function declarations vs variable initializations
+
+// Function declarations
+T1 a(T2 *b);
+T3 c(T4 &d, T5 &&e);
+
+// Variable declarations with initializers
+T7 f(g.h);
+T6 i{j};
+
+==>
+
+Program(
+  LineComment,
+  Declaration(
+    TypeIdentifier,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList(ParameterDeclaration(TypeIdentifier, PointerDeclarator(Identifier))))),
+  Declaration(
+    TypeIdentifier,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList(
+        ParameterDeclaration(TypeIdentifier, ReferenceDeclarator(Identifier)),
+        ParameterDeclaration(TypeIdentifier, ReferenceDeclarator(Identifier))))),
+
+  LineComment,
+  Declaration(
+    TypeIdentifier,
+    InitDeclarator(
+      Identifier,
+      ArgumentList(FieldExpression(Identifier, FieldIdentifier)))),
+  Declaration(
+    TypeIdentifier,
+    InitDeclarator(
+      Identifier,
+      InitializerList(Identifier))))
+
+
+# template classes vs relational expressions
+
+int main() {
+  T1<T2> v1;
+  T1<T2> v2 = v3;
+}
+
+==>
+
+Program(FunctionDefinition(
+  PrimitiveType,
+  FunctionDeclarator(Identifier, ParameterList),
+  CompoundStatement(
+    Declaration(
+      TemplateType(TypeIdentifier,
+        TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+      Identifier),
+    Declaration(
+      TemplateType(TypeIdentifier,
+        TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+      InitDeclarator(Identifier, Identifier)))))
+

node_modules/@lezer/cpp/test/cpp20.txt

@@ -0,0 +1,702 @@
+# Concept definition
+
+template <class T, class U>
+concept Derived = std::is_base_of<U, T>::value;
+
+==>
+
+Program(TemplateDeclaration(
+  template,
+  TemplateParameterList(TypeParameterDeclaration(class,TypeIdentifier),TypeParameterDeclaration(class,TypeIdentifier)),
+  ConceptDefinition(concept,Identifier,ScopedIdentifier(
+    TemplateType(
+      ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier),
+      TemplateArgumentList(TypeDescriptor(TypeIdentifier),TypeDescriptor(TypeIdentifier))),
+    Identifier))))
+
+# Concept definition with requires expression
+
+template<typename T>
+concept Hashable = requires(T a) {
+    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
+};
+
+==>
+
+Program(TemplateDeclaration(
+  template,TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+  ConceptDefinition(concept,Identifier,
+    RequiresExpression(requires,ParameterList(ParameterDeclaration(TypeIdentifier,Identifier)),RequirementList(
+      CompoundRequirement(
+        CallExpression(CompoundLiteralExpression(TemplateType(ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier),
+          TemplateArgumentList(TypeDescriptor(TypeIdentifier))),InitializerList),ArgumentList(Identifier)),
+        ReturnTypeRequirement(TemplateFunction(ScopedIdentifier(NamespaceIdentifier,Identifier),
+          TemplateArgumentList(TypeDescriptor(ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier)))))))))))
+
+# Requires clauses and expressions
+
+template<typename T>
+void f(T&&) requires Eq<T>; // can appear as the last element of a function declarator
+
+template<typename T> requires Addable<T> // or right after a template parameter list
+T add(T a, T b) { return a + b; }
+
+template<typename T>
+concept Addable = requires (T x) { x + x; }; // requires-expression
+
+template<typename T>
+    requires requires (T x) { x + x; } // ad-hoc constraint, note keyword used twice
+T add(T a, T b) { return a + b; }
+
+template<typename T>
+    requires (!std::is_same_v<T, bool>) // parenthesized expressions are allowed
+void f(T);
+
+template<typename T> requires Addable<T> && Subtractable<T> // conjunctions
+T f(T);
+
+template<typename T> requires Addable<T> || Subtractable<T> // disjunctions
+T f(T);
+
+template<typename T> requires false || true // boolean literals
+T f(T);
+
+template<typename... T> requires (... && Addable<T>) // fold expressions
+T f(T);
+
+==>
+
+Program(
+  TemplateDeclaration(template,TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    Declaration(PrimitiveType,FunctionDeclarator(Identifier,
+      ParameterList(ParameterDeclaration(TypeIdentifier,AbstractReferenceDeclarator)),
+      RequiresClause(requires,TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))))))),
+  LineComment,
+  TemplateDeclaration(
+    template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier)))),
+    LineComment,
+    FunctionDefinition(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(
+      ParameterDeclaration(TypeIdentifier,Identifier),
+      ParameterDeclaration(TypeIdentifier,Identifier))),
+      CompoundStatement(ReturnStatement(return,BinaryExpression(Identifier,ArithOp,Identifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    ConceptDefinition(concept,Identifier,
+      RequiresExpression(requires,ParameterList(ParameterDeclaration(TypeIdentifier,Identifier)),
+      RequirementList(SimpleRequirement(BinaryExpression(Identifier,ArithOp,Identifier)))))),
+  LineComment,
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,RequiresExpression(requires,
+      ParameterList(ParameterDeclaration(TypeIdentifier,Identifier)),
+      RequirementList(SimpleRequirement(BinaryExpression(Identifier,ArithOp,Identifier))))),
+    LineComment,
+    FunctionDefinition(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(
+      ParameterDeclaration(TypeIdentifier,Identifier),
+      ParameterDeclaration(TypeIdentifier,Identifier))),
+      CompoundStatement(ReturnStatement(return,BinaryExpression(Identifier,ArithOp,Identifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,ParenthesizedExpression(UnaryExpression(LogicOp,TemplateFunction(
+      ScopedIdentifier(NamespaceIdentifier,Identifier),
+      TemplateArgumentList(TypeDescriptor(TypeIdentifier),TypeDescriptor(PrimitiveType)))))),
+    LineComment,
+    Declaration(PrimitiveType,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,ConstraintConjuction(
+      TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+      LogicOp,
+      TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))))),
+    LineComment,
+    Declaration(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,ConstraintDisjunction(
+      TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+      LogicOp,
+      TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))))),
+    LineComment,
+    Declaration(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,ConstraintDisjunction(False,LogicOp,True)),
+    LineComment,
+    Declaration(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier))))),
+  TemplateDeclaration(template,
+    TemplateParameterList(VariadicTypeParameterDeclaration(typename,TypeIdentifier)),
+    RequiresClause(requires,ParenthesizedExpression(BinaryExpression(
+      ParamPack,
+      LogicOp,
+      TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier)))))),
+    LineComment,
+    Declaration(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier))))))
+
+# Compound requirements
+
+template<typename T> concept C2 =
+requires(T x) {
+    {*x} -> std::convertible_to<typename T::inner>; // the expression *x must be valid
+                                                    // AND the type T::inner must be valid
+                                                    // AND the result of *x must be convertible to T::inner
+    {x + 1} -> std::same_as<int>; // the expression x + 1 must be valid 
+                               // AND std::same_as<decltype((x + 1)), int> must be satisfied
+                               // i.e., (x + 1) must be a prvalue of type int
+    {x * 1} -> std::convertible_to<T>; // the expression x * 1 must be valid
+                                       // AND its result must be convertible to T
+};
+
+==>
+
+Program(
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+    ConceptDefinition(concept,Identifier,RequiresExpression(
+      requires,
+      ParameterList(ParameterDeclaration(TypeIdentifier,Identifier)),
+      RequirementList(CompoundRequirement(
+        PointerExpression(Identifier),
+        ReturnTypeRequirement(TemplateFunction(
+          ScopedIdentifier(NamespaceIdentifier,Identifier),
+          TemplateArgumentList(
+            TypeDescriptor(DependentType(typename,ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier))))))),
+      LineComment,
+      LineComment,
+      LineComment,
+      CompoundRequirement(
+        BinaryExpression(Identifier,ArithOp,Number),
+        ReturnTypeRequirement(TemplateFunction(ScopedIdentifier(NamespaceIdentifier,Identifier),
+          TemplateArgumentList(TypeDescriptor(PrimitiveType))))),
+      LineComment,
+      LineComment,
+      LineComment,
+      CompoundRequirement(
+        BinaryExpression(Identifier,ArithOp,Number),
+        ReturnTypeRequirement(TemplateFunction(ScopedIdentifier(NamespaceIdentifier,Identifier),
+          TemplateArgumentList(TypeDescriptor(TypeIdentifier))))),
+      LineComment,
+      LineComment)))))
+
+# Nested requirements
+
+template <class T>
+concept Semiregular = DefaultConstructible<T> &&
+    CopyConstructible<T> && Destructible<T> && CopyAssignable<T> &&
+requires(T a, size_t n) {  
+    requires Same<T*, decltype(&a)>;  // nested: 
+    { a.~T() } noexcept;  // compound:  is a valid expression that doesn't throw
+    requires Same<T*, decltype(new T)>; // nested: 
+    requires Same<T*, decltype(new T[n])>; // nested
+    { delete new T };  // compound
+    { delete new T[n] }; // compound
+};
+
+==>
+
+Program(TemplateDeclaration(template,
+  TemplateParameterList(TypeParameterDeclaration(class,TypeIdentifier)),
+  ConceptDefinition(concept,Identifier,BinaryExpression(
+    BinaryExpression(
+      BinaryExpression(
+        BinaryExpression(
+          TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+          LogicOp,
+          TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier)))),
+        LogicOp,
+        TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier)))),
+      LogicOp,
+      TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier)))),
+    LogicOp,
+    RequiresExpression(requires,
+      ParameterList(ParameterDeclaration(TypeIdentifier,Identifier),ParameterDeclaration(PrimitiveType,Identifier)),
+      RequirementList(
+        RequiresClause(requires,TemplateType(TypeIdentifier,TemplateArgumentList(
+          TypeDescriptor(TypeIdentifier,AbstractPointerDeclarator),
+          TypeDescriptor(Decltype(decltype,PointerExpression(Identifier)))))),
+        LineComment,
+        CompoundRequirement(CallExpression(FieldExpression(Identifier,DestructorName),ArgumentList),noexcept),
+        LineComment,
+        RequiresClause(requires,TemplateType(TypeIdentifier,TemplateArgumentList(
+          TypeDescriptor(TypeIdentifier,AbstractPointerDeclarator),
+          TypeDescriptor(Decltype(decltype,NewExpression(new,TypeIdentifier)))))),
+        LineComment,
+        RequiresClause(requires,TemplateType(TypeIdentifier,TemplateArgumentList(
+          TypeDescriptor(TypeIdentifier,AbstractPointerDeclarator),
+          TypeDescriptor(Decltype(decltype,NewExpression(new,TypeIdentifier,NewDeclarator(Identifier))))))),
+        LineComment,
+        CompoundRequirement(DeleteExpression(delete,NewExpression(new,TypeIdentifier))),
+        LineComment,
+        CompoundRequirement(DeleteExpression(delete,NewExpression(new,TypeIdentifier,NewDeclarator(Identifier)))),
+        LineComment))))))
+
+# Constraints
+
+template <EqualityComparable T>
+void f(const T&); // constrained function template declaration
+
+void f(const EqualityComparable auto&); // constrained function template declaration
+
+Sortable auto foo = f();
+Sortable<T> auto bar = g();
+NS::Concept<T> auto baz = h();
+
+Sortable decltype(auto) foo = i();
+
+==>
+
+Program(
+  TemplateDeclaration(template,
+    TemplateParameterList(ParameterDeclaration(TypeIdentifier,Identifier)),
+    Declaration(PrimitiveType,FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(
+      const,TypeIdentifier,AbstractReferenceDeclarator))))),
+  LineComment,
+  Declaration(PrimitiveType,FunctionDeclarator(Identifier,ParameterList(
+    ParameterDeclaration(const,PlaceholderTypeSpecifier(TypeIdentifier,auto),AbstractReferenceDeclarator)))),
+  LineComment,
+  Declaration(
+    PlaceholderTypeSpecifier(TypeIdentifier,auto),InitDeclarator(Identifier,CallExpression(Identifier,ArgumentList))),
+  Declaration(
+    PlaceholderTypeSpecifier(TemplateType(TypeIdentifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),auto),
+    InitDeclarator(Identifier,CallExpression(Identifier,ArgumentList))),
+  Declaration(
+    PlaceholderTypeSpecifier(TemplateType(ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier),TemplateArgumentList(TypeDescriptor(TypeIdentifier))),auto),
+    InitDeclarator(Identifier,CallExpression(Identifier,ArgumentList))),
+  Declaration(
+    PlaceholderTypeSpecifier(TypeIdentifier,Decltype(decltype,auto)),
+    InitDeclarator(Identifier,CallExpression(Identifier,ArgumentList))))
+
+# Namespace definitions
+
+namespace std {
+
+int x;
+
+}  // namespace std
+
+namespace A::B { }
+namespace A::B::inline C::D { }
+
+==>
+
+Program(
+  NamespaceDefinition(namespace,Identifier,CompoundStatement(Declaration(PrimitiveType,Identifier))),
+  LineComment,
+  NamespaceDefinition(namespace,Identifier,Identifier,CompoundStatement),
+  NamespaceDefinition(namespace,Identifier,Identifier,inline,Identifier,Identifier,CompoundStatement))
+
+# Namespace alias definitions
+
+namespace A = B;
+namespace C = ::D;
+namespace fs = std::filesystem;
+namespace bfs = ::boost::filesystem;
+namespace literals = std::chono::literals;
+
+==>
+
+Program(
+  NamespaceDefinition(namespace,Identifier,Identifier),
+  NamespaceDefinition(namespace,Identifier,ScopedIdentifier(Identifier)),
+  NamespaceDefinition(namespace,Identifier,ScopedIdentifier(NamespaceIdentifier,Identifier)),
+  NamespaceDefinition(namespace,Identifier,ScopedIdentifier(ScopedNamespaceIdentifier(NamespaceIdentifier),Identifier)),
+  NamespaceDefinition(namespace,Identifier,ScopedIdentifier(
+    ScopedNamespaceIdentifier(NamespaceIdentifier,NamespaceIdentifier),Identifier)))
+
+# Reference declarations
+
+int main() {
+  T &x = y<T &>();
+}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList),CompoundStatement(
+  Declaration(TypeIdentifier,InitDeclarator(ReferenceDeclarator(Identifier),CallExpression(
+    TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier,AbstractReferenceDeclarator))),
+    ArgumentList))))))
+
+# R-value reference declarations
+
+int main(T &&);
+
+int main(T &&t) {
+  const U &&u = v;
+}
+
+==>
+
+Program(
+  Declaration(PrimitiveType,
+    FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier,AbstractReferenceDeclarator)))),
+  FunctionDefinition(PrimitiveType,
+    FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier,ReferenceDeclarator(Identifier)))),
+    CompoundStatement(Declaration(const,TypeIdentifier,InitDeclarator(ReferenceDeclarator(Identifier),Identifier)))))
+
+# Function-try-block definitions
+
+void foo() try {} catch(...) {}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList),TryStatement(
+  try,CompoundStatement,CatchClause(catch,ParameterList,CompoundStatement))))
+
+# Inline try method definitions
+
+struct S {
+  int getF2() const try { throw 1; } catch (...) { return f; }
+};
+
+==>
+
+Program(StructSpecifier(struct,TypeIdentifier,FieldDeclarationList(
+  FunctionDefinition(PrimitiveType,
+    FunctionDeclarator(FieldIdentifier,ParameterList,const),
+    TryStatement(try,
+      CompoundStatement(ThrowStatement(throw,Number)),
+      CatchClause(catch,ParameterList,CompoundStatement(ReturnStatement(return,Identifier))))))))
+
+# Classes with inheritance
+
+class F : [[deprecated]] public G {};
+class H : public virtual I {};
+class J : virtual protected I {};
+
+==>
+
+Program(
+  ClassSpecifier(class,TypeIdentifier,BaseClassClause(Attribute(AttributeName(Identifier)),Access,TypeIdentifier),
+    FieldDeclarationList),
+  ClassSpecifier(class,TypeIdentifier,BaseClassClause(Access,virtual,TypeIdentifier),FieldDeclarationList),
+  ClassSpecifier(class,TypeIdentifier,BaseClassClause(virtual,Access,TypeIdentifier),FieldDeclarationList))
+
+# Attributes on declarations
+
+[[aaa]]
+int f() { }
+
+class [[gnu::visibility("default")]] A {};
+struct [[gnu::visibility("default")]] A {};
+union [[gnu::visibility("default")]] A {};
+
+class [[gnu::visibility("default")]] [[deprecated]] A {};
+class A final : [[deprecated]] public B {};
+
+==>
+
+Program(
+  FunctionDefinition(Attribute(AttributeName(Identifier)),PrimitiveType,
+    FunctionDeclarator(Identifier,ParameterList),CompoundStatement),
+  ClassSpecifier(class,Attribute(AttributeName(Identifier,Identifier),AttributeArgs(String)),TypeIdentifier,
+    FieldDeclarationList),
+  StructSpecifier(struct,Attribute(AttributeName(Identifier,Identifier),AttributeArgs(String)),TypeIdentifier,
+    FieldDeclarationList),
+  UnionSpecifier(union,Attribute(AttributeName(Identifier,Identifier),AttributeArgs(String)),TypeIdentifier,
+    FieldDeclarationList),
+  ClassSpecifier(class,
+    Attribute(AttributeName(Identifier,Identifier),AttributeArgs(String)),
+    Attribute(AttributeName(Identifier)),
+    TypeIdentifier,FieldDeclarationList),
+  ClassSpecifier(class,TypeIdentifier,VirtualSpecifier,
+    BaseClassClause(Attribute(AttributeName(Identifier)),Access,TypeIdentifier),
+    FieldDeclarationList))
+
+# Constinit/consteval declarations
+
+consteval int answer();
+constinit int life = answer();
+
+==>
+
+Program(
+  Declaration(consteval,PrimitiveType,FunctionDeclarator(Identifier,ParameterList)),
+  Declaration(constinit,PrimitiveType,InitDeclarator(Identifier,CallExpression(Identifier,ArgumentList))))
+
+# Ref-qualifiers
+
+class C
+{
+  void f() &;
+  void f() && noexcept;
+  void f() & {}
+  void f() & noexcept {}
+};
+
+void C::f() &;
+void C::f() & noexcept;
+void C::f() && {}
+void C::f() & noexcept {}
+
+==>
+
+Program(
+  ClassSpecifier(class,TypeIdentifier,FieldDeclarationList(
+    FieldDeclaration(PrimitiveType,FunctionDeclarator(FieldIdentifier,ParameterList)),
+    FieldDeclaration(PrimitiveType,FunctionDeclarator(FieldIdentifier,ParameterList,Noexcept(noexcept))),
+    FunctionDefinition(PrimitiveType,FunctionDeclarator(FieldIdentifier,ParameterList),CompoundStatement),
+    FunctionDefinition(PrimitiveType,FunctionDeclarator(FieldIdentifier,ParameterList,Noexcept(noexcept)),
+      CompoundStatement))),
+  Declaration(PrimitiveType,FunctionDeclarator(ScopedIdentifier(NamespaceIdentifier,Identifier),ParameterList)),
+  Declaration(PrimitiveType,
+    FunctionDeclarator(ScopedIdentifier(NamespaceIdentifier,Identifier),ParameterList,Noexcept(noexcept))),
+  FunctionDefinition(PrimitiveType,
+    FunctionDeclarator(ScopedIdentifier(NamespaceIdentifier,Identifier),ParameterList),CompoundStatement),
+  FunctionDefinition(PrimitiveType,
+    FunctionDeclarator(ScopedIdentifier(NamespaceIdentifier,Identifier),ParameterList,Noexcept(noexcept)),CompoundStatement))
+
+# Default comparison declarations
+
+struct A {
+  auto operator<=>(A const &) = default;
+};
+
+==>
+
+Program(StructSpecifier(struct,TypeIdentifier,FieldDeclarationList(
+  FunctionDefinition(auto,FunctionDeclarator(
+    OperatorName(operator,CompareOp),
+    ParameterList(ParameterDeclaration(TypeIdentifier,const,AbstractReferenceDeclarator))),
+    DefaultMethodClause(default)))))
+
+# Parameter pack expansions
+
+container<A,B,C...> t1;
+container<C...,A,B> t2;
+
+typedef Tuple<Pair<Args1, Args2>...> type;
+
+f(&args...); // expands to f(&E1, &E2, &E3)
+f(n, ++args...); // expands to f(n, ++E1, ++E2, ++E3);
+f(++args..., n); // expands to f(++E1, ++E2, ++E3, n);
+f(const_cast<const Args*>(&args)...); // f(const_cast<const E1*>(&X1), const_cast<const E2*>(&X2), const_cast<const E3*>(&X3))
+f(h(args...) + args...); // expands to f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3)
+
+const int size = sizeof...(args) + 2;
+int res[size] = {1,args...,2};
+int dummy[sizeof...(Ts)] = { (std::cout << args, 0)... };
+
+auto lm = [&, args...] { return g(args...); };
+
+class X : public Mixins... {
+public:
+    X(const Mixins&... mixins) : Mixins(mixins)... { }
+};
+
+template <typename... Args>
+void wrap(Args&&... args) {
+    f(forward<Args>(args)...);
+}
+
+void f(T...) {}
+
+==>
+
+Program(
+  Declaration(TemplateType(TypeIdentifier,TemplateArgumentList(
+    TypeDescriptor(TypeIdentifier),
+    TypeDescriptor(TypeIdentifier),
+    ParameterPackExpansion(TypeDescriptor(TypeIdentifier))
+  )),Identifier),
+  Declaration(TemplateType(TypeIdentifier,TemplateArgumentList(
+    ParameterPackExpansion(TypeDescriptor(TypeIdentifier)),
+    TypeDescriptor(TypeIdentifier),
+    TypeDescriptor(TypeIdentifier)
+  )),Identifier),
+  TypeDefinition(typedef,TemplateType(TypeIdentifier,TemplateArgumentList(
+    ParameterPackExpansion(TypeDescriptor(TemplateType(TypeIdentifier,TemplateArgumentList(
+      TypeDescriptor(TypeIdentifier),TypeDescriptor(TypeIdentifier))))))),TypeIdentifier),
+  ExpressionStatement(CallExpression(Identifier,ArgumentList(ParameterPackExpansion(PointerExpression(Identifier))))),
+  LineComment,
+  ExpressionStatement(CallExpression(Identifier,ArgumentList(
+    Identifier,
+    ParameterPackExpansion(UpdateExpression(UpdateOp,Identifier))))),
+  LineComment,
+  ExpressionStatement(CallExpression(Identifier,ArgumentList(
+    ParameterPackExpansion(UpdateExpression(UpdateOp,Identifier)),Identifier))),
+  LineComment,
+  ExpressionStatement(CallExpression(Identifier,ArgumentList(
+    ParameterPackExpansion(CallExpression(TemplateFunction(Identifier,TemplateArgumentList(
+      TypeDescriptor(const,TypeIdentifier,AbstractPointerDeclarator)
+    )),ArgumentList(PointerExpression(Identifier))))))),
+  LineComment,
+  ExpressionStatement(CallExpression(Identifier,ArgumentList(ParameterPackExpansion(BinaryExpression(
+    CallExpression(Identifier,ArgumentList(ParameterPackExpansion(Identifier))),
+    ArithOp,
+    Identifier))))),
+  LineComment,
+  Declaration(const,PrimitiveType,InitDeclarator(Identifier,BinaryExpression(
+    SizeofExpression(sizeof,Identifier),
+    ArithOp,
+    Number))),
+  Declaration(PrimitiveType,
+    InitDeclarator(ArrayDeclarator(Identifier,Identifier),InitializerList(Number,ParameterPackExpansion(Identifier),Number))),
+  Declaration(PrimitiveType,InitDeclarator(
+    ArrayDeclarator(Identifier,SizeofExpression(sizeof,Identifier)),
+    InitializerList(ParameterPackExpansion(ParenthesizedExpression(CommaExpression(
+      BinaryExpression(ScopedIdentifier(NamespaceIdentifier,Identifier),BitOp,Identifier),
+      Number)))))),
+  Declaration(auto,InitDeclarator(Identifier,LambdaExpression(
+    LambdaCaptureSpecifier(ParameterPackExpansion(Identifier)),
+    CompoundStatement(ReturnStatement(return,CallExpression(Identifier,ArgumentList(ParameterPackExpansion(Identifier)))))))),
+  ClassSpecifier(class,TypeIdentifier,BaseClassClause(Access,TypeIdentifier),FieldDeclarationList(
+    AccessSpecifier(Access),
+    FunctionDefinition(FunctionDeclarator(Identifier,ParameterList(
+      VariadicParameterDeclaration(const,TypeIdentifier,ReferenceDeclarator(VariadicDeclarator(Identifier))))
+    ),FieldInitializerList(FieldInitializer(FieldIdentifier,ArgumentList(Identifier))),CompoundStatement))),
+  TemplateDeclaration(template,
+    TemplateParameterList(VariadicTypeParameterDeclaration(typename,TypeIdentifier)),
+    FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList(
+      VariadicParameterDeclaration(TypeIdentifier,ReferenceDeclarator(VariadicDeclarator(Identifier)))
+    )),CompoundStatement(
+      ExpressionStatement(CallExpression(Identifier,ArgumentList(
+        ParameterPackExpansion(CallExpression(TemplateFunction(Identifier,TemplateArgumentList(
+          TypeDescriptor(TypeIdentifier)
+        )),ArgumentList(Identifier))))))))),
+  FunctionDefinition(PrimitiveType,
+    FunctionDeclarator(Identifier,ParameterList(VariadicParameterDeclaration(TypeIdentifier,VariadicDeclarator))),
+    CompoundStatement))
+
+# User-defined literals
+
+1.2_km;
+"foo" "bar"_baz;
+
+==>
+
+Program(
+  ExpressionStatement(UserDefinedLiteral(Number,Identifier)),
+  ExpressionStatement(UserDefinedLiteral(ConcatenatedString(String,String),Identifier)))
+
+# Coroutines
+
+co_await fn() || co_await var;
+co_return 1;
+co_return;
+co_yield 1;
+
+==>
+
+Program(
+  ExpressionStatement(BinaryExpression(
+    CoAwaitExpression(co_await,CallExpression(Identifier,ArgumentList)),
+    LogicOp,
+    CoAwaitExpression(co_await,Identifier))),
+  CoReturnStatement(co_return,Number),
+  CoReturnStatement(co_return),
+  CoYieldStatement(co_yield,Number))
+
+# Fold Expressions
+
+bool t  = (... + IndexOf<T>);
+bool t2 = (IndexOf<T> + ...);
+bool t3 = (1 + ... + IndexOf<T>);
+bool t3 = (IndexOf<T> + ... + 1);
+
+==>
+
+Program(
+  Declaration(PrimitiveType,InitDeclarator(Identifier,ParenthesizedExpression(BinaryExpression(
+    ParamPack,
+    ArithOp,
+    TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))))))),
+  Declaration(PrimitiveType,InitDeclarator(Identifier,ParenthesizedExpression(BinaryExpression(
+    TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+    ArithOp,
+    ParamPack)))),
+  Declaration(PrimitiveType,InitDeclarator(Identifier,ParenthesizedExpression(BinaryExpression(
+    BinaryExpression(Number,ArithOp,ParamPack),
+    ArithOp,
+    TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))))))),
+  Declaration(PrimitiveType,InitDeclarator(Identifier,ParenthesizedExpression(BinaryExpression(
+    BinaryExpression(TemplateFunction(Identifier,TemplateArgumentList(TypeDescriptor(TypeIdentifier))),ArithOp,ParamPack),
+    ArithOp,
+    Number)))))
+
+# Range-based for loops
+
+T main() {
+  for (auto n = v.size(); auto i : v) {
+    cout << --n + i << ' ';
+  }
+
+  for (using elem_t = T::value_type; elem_t i : v) {
+    cout << --n + i << ' ';
+  }
+}
+
+==>
+
+Program(FunctionDefinition(TypeIdentifier,FunctionDeclarator(Identifier,ParameterList),CompoundStatement(
+  ForRangeLoop(for,
+    Declaration(auto,InitDeclarator(Identifier,CallExpression(FieldExpression(Identifier,FieldIdentifier),ArgumentList))),
+    auto,Identifier,Identifier,
+    CompoundStatement(
+      ExpressionStatement(BinaryExpression(
+        BinaryExpression(Identifier,BitOp,BinaryExpression(UpdateExpression(UpdateOp,Identifier),ArithOp,Identifier)),
+        BitOp,
+        CharLiteral)))),
+  ForRangeLoop(for,
+    AliasDeclaration(using,TypeIdentifier,TypeDescriptor(ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier))),
+    TypeIdentifier,Identifier,Identifier,
+    CompoundStatement(
+      ExpressionStatement(BinaryExpression(
+        BinaryExpression(Identifier,BitOp,BinaryExpression(UpdateExpression(UpdateOp,Identifier),ArithOp,Identifier)),
+        BitOp,
+        CharLiteral)))))))
+
+# Attributes
+
+void f() {
+  [[a]] switch (b) {
+   [[c]] case 1: {}
+  }
+  [[a]] while (true) {}
+  [[a]] if (true) {}
+  [[a]] for (auto x : y) {}
+  [[a]] for (;;) {}
+  [[a]] return;
+  [[a]] a;
+  [[a]];
+  [[a]] label: {}
+  [[a]] goto label;
+}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList),CompoundStatement(
+  AttributeStatement(
+    Attribute(AttributeName(Identifier)),
+    SwitchStatement(switch,ConditionClause(Identifier),CompoundStatement(
+      AttributeStatement(Attribute(AttributeName(Identifier)),CaseStatement(case,Number,CompoundStatement))))),
+  AttributeStatement(Attribute(AttributeName(Identifier)),WhileStatement(while,ConditionClause(True),CompoundStatement)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),IfStatement(if,ConditionClause(True),CompoundStatement)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),ForRangeLoop(for,auto,Identifier,Identifier,CompoundStatement)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),ForStatement(for,CompoundStatement)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),ReturnStatement(return)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),ExpressionStatement(Identifier)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),ExpressionStatement),
+  AttributeStatement(Attribute(AttributeName(Identifier)),LabeledStatement(StatementIdentifier,CompoundStatement)),
+  AttributeStatement(Attribute(AttributeName(Identifier)),GotoStatement(goto,StatementIdentifier)))))
+
+# Modules
+
+export module helloworld;
+module a.b;
+module : private;
+import a:C;
+import <iostream>;
+export void hello() {}
+export import :B;
+
+==>
+
+Program(
+  ExportDeclaration(export,ModuleDeclaration(module,ModuleName(Identifier))),
+  ModuleDeclaration(module,ModuleName(Identifier,Identifier)),
+  ModuleDeclaration(module,Access),
+  ImportDeclaration(import,ModuleName(Identifier,PartitionName)),
+  ImportDeclaration(import,HeaderName),
+  ExportDeclaration(export,FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList),CompoundStatement)),
+  ExportDeclaration(export,ImportDeclaration(import,ModuleName(PartitionName))))

node_modules/@lezer/cpp/test/definitions.txt

@@ -0,0 +1,209 @@
+# Scoped function definitions
+
+int T::foo() { return 1; }
+int T::foo() const { return 0; }
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ParameterList),
+    CompoundStatement(ReturnStatement(return, Number))),
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ParameterList,
+      const),
+    CompoundStatement(ReturnStatement(return, Number))))
+
+# Vararg definition
+
+int emit(int... s) {
+}
+
+==>
+
+Program(
+  FunctionDefinition(PrimitiveType,FunctionDeclarator(
+    Identifier,
+    ParameterList(VariadicParameterDeclaration(PrimitiveType,VariadicDeclarator(Identifier)))),
+    CompoundStatement))
+
+# Constructor definitions
+
+T::T() {}
+
+T::T() : f1(0), f2(1, 2) {
+  puts("HI");
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ParameterList),
+    CompoundStatement),
+  FunctionDefinition(
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ParameterList),
+    FieldInitializerList(
+      FieldInitializer(FieldIdentifier, ArgumentList(Number)),
+      FieldInitializer(FieldIdentifier, ArgumentList(Number, Number))),
+    CompoundStatement(
+      ExpressionStatement(CallExpression(Identifier, ArgumentList(String))))))
+
+
+# Explicit constructor definitions
+
+class C {
+  explicit C(int f) : f_(f) {}
+
+ private:
+  int f_;
+};
+
+==>
+
+Program(
+  ClassSpecifier(class,
+    TypeIdentifier,
+    FieldDeclarationList(
+      FunctionDefinition(
+        ExplicitFunctionSpecifier(explicit),
+        FunctionDeclarator(
+          Identifier,
+          ParameterList(ParameterDeclaration(PrimitiveType, Identifier))),
+        FieldInitializerList(
+          FieldInitializer(FieldIdentifier, ArgumentList(Identifier))),
+        CompoundStatement),
+      AccessSpecifier(Access),
+        FieldDeclaration(PrimitiveType, FieldIdentifier))))
+
+
+# Explicit constructor declaration
+
+class C {
+  explicit C(int f);
+  explicit(true) C(long f);
+};
+
+==>
+
+Program(
+  ClassSpecifier(class,
+    TypeIdentifier,
+    FieldDeclarationList(
+      Declaration(
+        ExplicitFunctionSpecifier(explicit),
+        FunctionDeclarator(Identifier, ParameterList(ParameterDeclaration(PrimitiveType, Identifier)))),
+      Declaration(
+        ExplicitFunctionSpecifier(explicit, True),
+        FunctionDeclarator(Identifier, ParameterList(ParameterDeclaration(SizedTypeSpecifier(TypeSize), Identifier)))))))
+
+# Destructor in class
+
+class C {
+  C(int i) {}
+  ~C() {}
+};
+
+==>
+
+Program(ClassSpecifier(class,TypeIdentifier,FieldDeclarationList(
+  FunctionDefinition(FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(PrimitiveType,Identifier))),
+    CompoundStatement),
+  FunctionDefinition(FunctionDeclarator(DestructorName,ParameterList),CompoundStatement))))
+
+
+# Default and deleted methods
+
+class A : public B {
+  A() = default;
+  A(A &&) = delete;
+  void f() = delete;
+  A& operator=(const A&) = default;
+  A& operator=(A&&) = delete;
+};
+
+==>
+
+Program(
+  ClassSpecifier(class,
+    TypeIdentifier,
+    BaseClassClause(Access, TypeIdentifier),
+    FieldDeclarationList(
+      FunctionDefinition(
+        FunctionDeclarator(Identifier, ParameterList),
+        DefaultMethodClause(default)),
+      FunctionDefinition(
+        FunctionDeclarator(
+          Identifier,
+          ParameterList(ParameterDeclaration(TypeIdentifier, AbstractReferenceDeclarator))),
+        DeleteMethodClause(delete)),
+      FunctionDefinition(
+        PrimitiveType,
+        FunctionDeclarator(FieldIdentifier, ParameterList), DeleteMethodClause(delete)),
+      FunctionDefinition(
+        TypeIdentifier,
+        ReferenceDeclarator(
+          FunctionDeclarator(
+            OperatorName(operator),
+            ParameterList(ParameterDeclaration(const, TypeIdentifier, AbstractReferenceDeclarator)))),
+        DefaultMethodClause(default)),
+      FunctionDefinition(
+        TypeIdentifier,
+        ReferenceDeclarator(
+          FunctionDeclarator(
+            OperatorName(operator),
+            ParameterList(ParameterDeclaration(TypeIdentifier, AbstractReferenceDeclarator)))),
+        DeleteMethodClause(delete)))))
+
+
+# Destructor definitions
+
+~T() {}
+T::~T() {}
+
+==>
+
+Program(
+  FunctionDefinition(
+    FunctionDeclarator(DestructorName, ParameterList),
+    CompoundStatement),
+  FunctionDefinition(
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, DestructorName), ParameterList),
+    CompoundStatement))
+
+# Inline template function
+
+template <typename X>
+inline void Foo(X* x) {
+  for (typename X::iterator it = x->begin();
+    it != x->end(); ++it)
+    Bar(&(*it));
+}
+
+==>
+
+Program(TemplateDeclaration(
+  template,TemplateParameterList(TypeParameterDeclaration(typename,TypeIdentifier)),
+  FunctionDefinition(inline,PrimitiveType,
+    FunctionDeclarator(Identifier,ParameterList(ParameterDeclaration(TypeIdentifier,PointerDeclarator(Identifier)))),
+    CompoundStatement(
+      ForStatement(
+        for,
+        Declaration(
+          DependentType(typename,ScopedTypeIdentifier(NamespaceIdentifier,TypeIdentifier)),
+          InitDeclarator(Identifier,CallExpression(FieldExpression(Identifier,FieldIdentifier),ArgumentList))),
+        BinaryExpression(Identifier,CompareOp,CallExpression(FieldExpression(Identifier,FieldIdentifier),ArgumentList)),
+        UpdateExpression(UpdateOp, Identifier),
+        ExpressionStatement(CallExpression(Identifier,ArgumentList(
+          PointerExpression(ParenthesizedExpression(PointerExpression(Identifier)))))))))))

node_modules/@lezer/cpp/test/expressions.txt

@@ -0,0 +1,740 @@
+# Scoped function calls
+
+int main() {
+  abc::def("hello", "world");
+}
+
+==>
+
+Program(FunctionDefinition(
+  PrimitiveType,
+  FunctionDeclarator(Identifier, ParameterList),
+  CompoundStatement(
+    ExpressionStatement(CallExpression(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ArgumentList(
+        String,
+        String))))))
+
+
+# Compound literals without parentheses
+
+T x = T{0};
+U<V> y = U<V>{0};
+
+==>
+
+Program(
+  Declaration(
+    TypeIdentifier,
+    InitDeclarator(
+      Identifier,
+      CompoundLiteralExpression(
+        TypeIdentifier,
+        InitializerList(Number)))),
+  Declaration(
+    TemplateType(TypeIdentifier, TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+    InitDeclarator(
+      Identifier,
+      CompoundLiteralExpression(
+        TemplateType(TypeIdentifier, TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+        InitializerList(Number)))))
+
+
+# Explicit destructor calls
+
+int main() {
+  foo.~Foo();
+  bar->~Bar();
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      ExpressionStatement(CallExpression(
+        FieldExpression(Identifier, DestructorName),
+        ArgumentList)),
+      ExpressionStatement(CallExpression(
+        FieldExpression(Identifier, DestructorName),
+        ArgumentList)))))
+
+
+# New and Delete expressions
+
+int main() {
+  auto a = new T();
+  auto b = new U::V<W, X>{};
+  auto c = new (&d) T;
+  auto d = new T[5][3]();
+  auto e = new int[5];
+  d = new(2, f) T;
+  delete a;
+  ::delete[] c;
+  ::new (foo(x)) T(this, x);
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      Declaration(
+        auto,
+        InitDeclarator(
+          Identifier,
+          NewExpression(new, TypeIdentifier, ArgumentList))),
+      Declaration(
+        auto,
+        InitDeclarator(
+          Identifier,
+          NewExpression(
+            new,
+            TemplateType(
+              ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+              TemplateArgumentList(
+                TypeDescriptor(TypeIdentifier),
+                TypeDescriptor(TypeIdentifier))),
+            InitializerList))),
+      Declaration(
+        auto,
+        InitDeclarator(
+          Identifier,
+          NewExpression(
+            new,
+            ArgumentList(PointerExpression(Identifier)),
+            TypeIdentifier))),
+      Declaration(
+        auto,
+        InitDeclarator(
+          Identifier,
+          NewExpression(
+            new,
+            TypeIdentifier,
+            NewDeclarator(Number, NewDeclarator(Number)),
+            ArgumentList))),
+      Declaration(
+        auto,
+        InitDeclarator(
+          Identifier,
+          NewExpression(new, PrimitiveType, NewDeclarator(Number)))),
+      ExpressionStatement(AssignmentExpression(
+        Identifier,
+        NewExpression(new, ArgumentList(Number, Identifier), TypeIdentifier))),
+      ExpressionStatement(DeleteExpression(delete, Identifier)),
+      ExpressionStatement(DeleteExpression(delete, Identifier)),
+      ExpressionStatement(NewExpression(
+        new,
+        ArgumentList(CallExpression(Identifier, ArgumentList(Identifier))),
+        TypeIdentifier, ArgumentList(this, Identifier))))))
+
+
+
+# Initializer lists as arguments
+
+int main() {
+  pairs.push_back({true, false});
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      ExpressionStatement(CallExpression(
+        FieldExpression(Identifier, FieldIdentifier),
+        ArgumentList(InitializerList(True, False)))))))
+
+
+# Lambda expressions
+
+auto f = [&](int x) -> bool {
+  return true;
+};
+
+auto g = [x, y](int z) {
+  return false;
+};
+
+auto h = [] {
+  return false;
+};
+
+==>
+
+Program(
+  Declaration(
+    auto,
+    InitDeclarator(
+      Identifier,
+      LambdaExpression(
+        LambdaCaptureSpecifier,
+        AbstractFunctionDeclarator(
+          ParameterList(ParameterDeclaration(PrimitiveType, Identifier)),
+          TrailingReturnType(PrimitiveType)),
+        CompoundStatement(ReturnStatement(return, True))))),
+  Declaration(
+    auto,
+    InitDeclarator(
+      Identifier,
+      LambdaExpression(
+        LambdaCaptureSpecifier(Identifier, Identifier),
+        AbstractFunctionDeclarator(
+          ParameterList(ParameterDeclaration(PrimitiveType, Identifier))),
+        CompoundStatement(ReturnStatement(return, False))))),
+  Declaration(
+    auto,
+    InitDeclarator(
+      Identifier,
+      LambdaExpression(
+        LambdaCaptureSpecifier,
+        CompoundStatement(ReturnStatement(return, False))))))
+
+
+# Nested template calls
+
+class A {
+  B<C::D<E, F>>::G field;
+
+  H<I<J>> method() {
+    K::L<M<N>> variable1 = K::L<M<N>>{};
+  }
+};
+
+==>
+
+Program(
+  ClassSpecifier(class, TypeIdentifier, FieldDeclarationList(
+    FieldDeclaration(
+      ScopedTypeIdentifier(
+        TemplateType(
+          TypeIdentifier,
+          TemplateArgumentList(
+            TypeDescriptor(TemplateType(
+              ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+              TemplateArgumentList(
+                TypeDescriptor(TypeIdentifier), TypeDescriptor(TypeIdentifier)))))),
+        TypeIdentifier),
+      FieldIdentifier),
+    FunctionDefinition(
+      TemplateType(
+        TypeIdentifier,
+        TemplateArgumentList(TypeDescriptor(
+          TemplateType(
+            TypeIdentifier,
+            TemplateArgumentList(TypeDescriptor(TypeIdentifier)))))),
+      FunctionDeclarator(FieldIdentifier, ParameterList),
+      CompoundStatement(
+        Declaration(
+          TemplateType(
+            ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+            TemplateArgumentList(TypeDescriptor(
+              TemplateType(TypeIdentifier, TemplateArgumentList(TypeDescriptor(TypeIdentifier)))))),
+          InitDeclarator(
+            Identifier,
+            CompoundLiteralExpression(
+              TemplateType(
+                ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+                TemplateArgumentList(TypeDescriptor(
+                  TemplateType(
+                    TypeIdentifier,
+                    TemplateArgumentList(TypeDescriptor(TypeIdentifier)))))),
+              InitializerList))))))))
+
+
+# Comma expressions at the start of blocks
+
+int main() { a(), b(); }
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      ExpressionStatement(CommaExpression(
+        CallExpression(Identifier, ArgumentList),
+        CallExpression(Identifier, ArgumentList))))))
+
+
+# Nullptr
+
+void *x = nullptr;
+
+==>
+
+Program(
+  Declaration(PrimitiveType, InitDeclarator(PointerDeclarator(Identifier), nullptr)))
+
+
+# Raw string literals
+
+const char *s1 = R"(
+  This is a string. It ends with ')' and a quote.
+)";
+
+const char *s2 = R"FOO(
+  This is a string. It ends with ')FOO' and a quote.
+)FOO";
+
+const char *s3 = uR"FOO(
+  This is a string. It ends with ')FOO' and a quote.
+)FOO";
+
+const char *s4 = UR"FOO(
+  This is a string. It ends with ')FOO' and a quote.
+)FOO";
+
+const char *s5 = u8R"FOO(
+  This is a string. It ends with ')FOO' and a quote.
+)FOO";
+
+const char *s6 = LR"FOO(
+  This is a string. It ends with ')FOO' and a quote.
+)FOO";
+
+==>
+
+Program(
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)),
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)),
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)),
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)),
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)),
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      PointerDeclarator(Identifier),
+      RawString)))
+
+
+# Template calls
+
+int main() {
+  // '<' and '>' as template argument list delimiters
+  if (a<b && c>()) {}
+
+  // '<' and '>' as binary operators
+  if (a < b && c >= d) {}
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+  PrimitiveType,
+  FunctionDeclarator(Identifier, ParameterList),
+  CompoundStatement(
+    LineComment,
+    IfStatement(if,
+      ConditionClause(
+        CallExpression(
+          TemplateFunction(
+            Identifier,
+            TemplateArgumentList(BinaryExpression(Identifier, LogicOp, Identifier))),
+          ArgumentList)),
+      CompoundStatement),
+    LineComment,
+    IfStatement(if,
+      ConditionClause(
+        BinaryExpression(
+          BinaryExpression(Identifier, CompareOp, Identifier),
+          LogicOp,
+          BinaryExpression(Identifier, CompareOp, Identifier))),
+      CompoundStatement))))
+
+# Parameter pack expansions
+
+container<A,B,C...> t1;
+container<C...,A,B> t2;
+
+typedef Tuple<Pair<Args1, Args2>...> type;
+
+f(&args...); // expands to f(&E1, &E2, &E3)
+f(n, ++args...); // expands to f(n, ++E1, ++E2, ++E3);
+f(++args..., n); // expands to f(++E1, ++E2, ++E3, n);
+f(const_cast<const Args*>(&args)...); // f(const_cast<const E1*>(&X1), const_cast<const E2*>(&X2), const_cast<const E3*>(&X3))
+f(h(args...) + args...); // expands to f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3)
+
+const int size = sizeof...(args) + 2;
+int res[size] = {1,args...,2};
+int dummy[sizeof...(Ts)] = { (std::cout << args, 0)... };
+
+auto lm = [&, args...] { return g(args...); };
+
+class X : public Mixins... {
+public:
+    X(const Mixins&... mixins) : Mixins(mixins)... { }
+};
+
+template <typename... Args>
+void wrap(Args&&... args) {
+    f(forward<Args>(args)...);
+}
+
+void f(T...) {}
+
+==>
+
+Program(
+  Declaration(
+    TemplateType(
+      TypeIdentifier,
+      TemplateArgumentList(
+        TypeDescriptor(
+          TypeIdentifier),
+        TypeDescriptor(
+          TypeIdentifier),
+        ParameterPackExpansion(
+          TypeDescriptor(
+            TypeIdentifier)))),
+    Identifier),
+  Declaration(
+    TemplateType(
+      TypeIdentifier,
+      TemplateArgumentList(
+        ParameterPackExpansion(
+          TypeDescriptor(
+            TypeIdentifier)),
+        TypeDescriptor(
+          TypeIdentifier),
+        TypeDescriptor(
+          TypeIdentifier))),
+    Identifier),
+  TypeDefinition(
+    typedef,
+    TemplateType(
+      TypeIdentifier,
+      TemplateArgumentList(
+        ParameterPackExpansion(
+          TypeDescriptor(
+            TemplateType(
+              TypeIdentifier,
+              TemplateArgumentList(
+                TypeDescriptor(
+                  TypeIdentifier),
+                TypeDescriptor(
+                  TypeIdentifier))))))),
+    TypeIdentifier),
+  ExpressionStatement(
+    CallExpression(
+      Identifier,
+      ArgumentList(
+        ParameterPackExpansion(
+          PointerExpression(
+            Identifier))))),
+  LineComment,
+  ExpressionStatement(
+    CallExpression(
+      Identifier,
+      ArgumentList(
+        Identifier,
+        ParameterPackExpansion(
+          UpdateExpression(UpdateOp, Identifier))))),
+  LineComment,
+  ExpressionStatement(
+    CallExpression(
+      Identifier,
+      ArgumentList(
+        ParameterPackExpansion(
+          UpdateExpression(UpdateOp, Identifier)),
+        Identifier))),
+  LineComment,
+  ExpressionStatement(
+    CallExpression(
+      Identifier,
+      ArgumentList(
+        ParameterPackExpansion(
+          CallExpression(
+            TemplateFunction(
+              Identifier,
+              TemplateArgumentList(
+                TypeDescriptor(
+                  const,
+                  TypeIdentifier,
+                  AbstractPointerDeclarator))),
+            ArgumentList(
+              PointerExpression(Identifier))))))),
+  LineComment,
+  ExpressionStatement(
+    CallExpression(
+      Identifier,
+      ArgumentList(
+        ParameterPackExpansion(
+          BinaryExpression(
+            CallExpression(
+              Identifier,
+              ArgumentList(
+                ParameterPackExpansion(Identifier))),
+            ArithOp,
+            Identifier))))),
+  LineComment,
+  Declaration(
+    const,
+    PrimitiveType,
+    InitDeclarator(
+      Identifier,
+      BinaryExpression(
+          SizeofExpression(sizeof, Identifier),
+          ArithOp,
+          Number))),
+  Declaration(
+    PrimitiveType,
+    InitDeclarator(
+      ArrayDeclarator(
+        Identifier,
+        Identifier),
+      InitializerList(
+        Number,
+        ParameterPackExpansion(Identifier),
+        Number))),
+  Declaration(
+    PrimitiveType,
+    InitDeclarator(
+      ArrayDeclarator(
+        Identifier,
+        SizeofExpression(sizeof, Identifier)),
+      InitializerList(
+        ParameterPackExpansion(
+          ParenthesizedExpression(
+            CommaExpression(
+              BinaryExpression(
+                ScopedIdentifier(
+                  NamespaceIdentifier,
+                  Identifier),
+                BitOp,
+                Identifier),
+              Number)))))),
+  Declaration(
+    auto,
+    InitDeclarator(
+      Identifier,
+      LambdaExpression(
+        LambdaCaptureSpecifier(
+          ParameterPackExpansion(Identifier)),
+        CompoundStatement(
+          ReturnStatement(
+            return,
+            CallExpression(
+              Identifier,
+              ArgumentList(
+                ParameterPackExpansion(Identifier)))))))),
+  ClassSpecifier(
+    class, TypeIdentifier,
+    BaseClassClause(
+      Access, TypeIdentifier),
+    FieldDeclarationList(
+      AccessSpecifier(Access),
+      FunctionDefinition(
+        FunctionDeclarator(
+          Identifier,
+          ParameterList(
+            VariadicParameterDeclaration(
+              const,
+              TypeIdentifier,
+              ReferenceDeclarator(
+                VariadicDeclarator(Identifier))))),
+        FieldInitializerList(
+          FieldInitializer(
+            FieldIdentifier,
+            ArgumentList(Identifier))),
+        CompoundStatement))),
+  TemplateDeclaration(
+    template,
+    TemplateParameterList(VariadicTypeParameterDeclaration(typename, TypeIdentifier)),
+    FunctionDefinition(
+      PrimitiveType,
+      FunctionDeclarator(
+        Identifier,
+        ParameterList(
+          VariadicParameterDeclaration(
+            TypeIdentifier,
+            ReferenceDeclarator(VariadicDeclarator(Identifier))))),
+      CompoundStatement(
+        ExpressionStatement(
+          CallExpression(
+            Identifier,
+            ArgumentList(
+              ParameterPackExpansion(
+                CallExpression(
+                  TemplateFunction(
+                    Identifier,
+                    TemplateArgumentList(
+                      TypeDescriptor(TypeIdentifier))),
+                  ArgumentList(Identifier))))))))),
+  FunctionDefinition(
+      PrimitiveType,
+      FunctionDeclarator(
+        Identifier,
+        ParameterList(
+          VariadicParameterDeclaration(
+            TypeIdentifier,
+            VariadicDeclarator))),
+      CompoundStatement))
+
+
+# Concatenated string literals
+
+"a" "b" "c";
+R"(a)" R"(b)" R"(c)";
+"a" R"(b)" L"c" R"FOO(d)FOO";
+==>
+
+Program(
+  ExpressionStatement(ConcatenatedString(String, String, String)),
+  ExpressionStatement(ConcatenatedString(RawString, RawString, RawString)),
+  ExpressionStatement(ConcatenatedString(String, RawString, String, RawString)))
+
+
+# Primitive types ctor
+
+x = int(1);
+x = new int(1);
+x = (int(1) + float(2));
+
+==>
+
+Program(
+  ExpressionStatement(
+    AssignmentExpression(
+      Identifier,
+      CallExpression(PrimitiveType, ArgumentList(Number)))),
+  ExpressionStatement(
+    AssignmentExpression(
+      Identifier,
+      NewExpression(new, PrimitiveType, ArgumentList(Number)))),
+  ExpressionStatement(
+    AssignmentExpression(
+      Identifier,
+      ParenthesizedExpression(
+        BinaryExpression(
+          CallExpression(PrimitiveType, ArgumentList(Number)),
+          ArithOp,
+          CallExpression(PrimitiveType, ArgumentList(Number)))))))
+
+
+# Array assignment expression
+
+array_[i] = s[i];
+
+==>
+
+Program(
+  ExpressionStatement(
+    AssignmentExpression(
+      SubscriptExpression(
+        Identifier,
+        Identifier),
+      SubscriptExpression(
+        Identifier,
+        Identifier))))
+
+# Reference arg
+
+void x() {
+  x_->Y(A(this, &B::C<D, 2>));
+}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType, FunctionDeclarator(Identifier, ParameterList), CompoundStatement(
+  ExpressionStatement(CallExpression(FieldExpression(Identifier, FieldIdentifier), ArgumentList(
+    CallExpression(Identifier, ArgumentList(
+      this,
+      PointerExpression(TemplateFunction(
+        ScopedIdentifier(NamespaceIdentifier, Identifier),
+        TemplateArgumentList(TypeDescriptor(TypeIdentifier), Number)))))))))))
+
+# Numbers
+
+void f() {
+  return 2 + 2.5 + 2u + 2ul + 2uLl + 4e-10;
+}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList()),CompoundStatement(
+  ReturnStatement(return,BinaryExpression(
+    BinaryExpression(BinaryExpression(
+      BinaryExpression(BinaryExpression(Number,ArithOp,Number),ArithOp,Number),
+      ArithOp,Number),ArithOp,Number),ArithOp,Number)))))
+
+# Initializer list
+
+Bar({
+  .a = a, 
+  .b = b.Bar(), 
+  .c = c->Baz
+});
+
+==>
+
+Program(ExpressionStatement(CallExpression(Identifier,ArgumentList(InitializerList(
+  InitializerPair(FieldDesignator(FieldIdentifier),Identifier),
+  InitializerPair(FieldDesignator(FieldIdentifier),CallExpression(FieldExpression(Identifier,FieldIdentifier),ArgumentList)),
+  InitializerPair(FieldDesignator(FieldIdentifier),FieldExpression(Identifier,FieldIdentifier)))))))
+
+# Assignment with Initializer List
+
+void findNextMove() {
+  bestMoveSoFar = {nextMove, second};
+}
+
+==>
+
+Program(FunctionDefinition(PrimitiveType,FunctionDeclarator(Identifier,ParameterList),CompoundStatement(
+  ExpressionStatement(AssignmentExpression(Identifier,InitializerList(Identifier,Identifier))))))
+
+# Chain of less-than operators
+
+if (a < 0 || b < 0 || c < 0 || d < 0) b();
+
+==>
+
+Program(IfStatement(if,
+  ConditionClause(
+    BinaryExpression(
+      BinaryExpression(
+        BinaryExpression(
+          BinaryExpression(Identifier,CompareOp,Number),
+          LogicOp,
+          BinaryExpression(Identifier,CompareOp,Number)),
+        LogicOp,
+        BinaryExpression(Identifier,CompareOp,Number)),
+      LogicOp,
+      BinaryExpression(Identifier,CompareOp,Number))),
+  ExpressionStatement(CallExpression(Identifier,ArgumentList))))

node_modules/@lezer/cpp/test/microsoft.txt

@@ -0,0 +1,28 @@
+# declaration specs
+
+struct __declspec(dllexport) s2
+{
+};
+
+union __declspec(noinline) u2 {
+};
+
+class __declspec(uuid) u2 {
+};
+
+==>
+
+Program(
+  StructSpecifier(struct,
+    MsDeclspecModifier(__declspec, Identifier),
+    TypeIdentifier,
+    FieldDeclarationList),
+  UnionSpecifier(union,
+    MsDeclspecModifier(__declspec, Identifier),
+    TypeIdentifier,
+    FieldDeclarationList),
+  ClassSpecifier(class,
+    MsDeclspecModifier(__declspec, Identifier),
+    TypeIdentifier,
+    FieldDeclarationList))
+

node_modules/@lezer/cpp/test/statements.txt

@@ -0,0 +1,327 @@
+# Returning braced initializer lists
+
+T main() {
+  return {0, 5};
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    TypeIdentifier,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      ReturnStatement(return, InitializerList(Number, Number)))))
+
+
+# Range-based for loops
+
+T main() {
+  for (Value &value : values) {
+    cout << value;
+  }
+
+  for (const auto &value : values) {
+    cout << value;
+  }
+
+  for (const auto &value : {1, 2, 3}) {
+    cout << value;
+  }
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    TypeIdentifier,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList),
+    CompoundStatement(
+      ForRangeLoop(for,
+        TypeIdentifier,
+        ReferenceDeclarator(Identifier),
+        Identifier,
+        CompoundStatement(
+          ExpressionStatement(BinaryExpression(
+            Identifier,
+            BitOp,
+            Identifier)))),
+      ForRangeLoop(for,
+        const,
+        auto,
+        ReferenceDeclarator(Identifier),
+        Identifier,
+        CompoundStatement(
+          ExpressionStatement(BinaryExpression(
+            Identifier,
+            BitOp,
+            Identifier)))),
+      ForRangeLoop(for,
+        const,
+        auto,
+        ReferenceDeclarator(Identifier),
+        InitializerList(Number, Number, Number),
+        CompoundStatement(
+          ExpressionStatement(BinaryExpression(
+            Identifier,
+            BitOp,
+            Identifier)))))))
+
+
+# Constexpr if statements
+
+T f() {
+  if constexpr (std::is_pointer_v<T>)
+    return *t;
+  else
+    return t;
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    TypeIdentifier,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList),
+    CompoundStatement(
+      IfStatement(
+        if, constexpr,
+        ConditionClause(
+          TemplateFunction(
+            ScopedIdentifier(
+              NamespaceIdentifier,
+              Identifier),
+            TemplateArgumentList(
+              TypeDescriptor(TypeIdentifier)))),
+        ReturnStatement(return,
+          PointerExpression(Identifier)),
+        else,
+        ReturnStatement(return, Identifier)))))
+
+
+# If statements with declarations
+
+void f() {
+  if (const int x = foo()) { }
+  if (const int x { foo() }) { }
+  if (const int x = foo(); x != 0) { }
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList),
+    CompoundStatement(
+      IfStatement(if,
+        ConditionClause(
+          Declaration(
+            const,
+            PrimitiveType,
+            Identifier,
+            CallExpression(
+              Identifier,
+              ArgumentList))),
+        CompoundStatement),
+      IfStatement(if,
+        ConditionClause(
+          Declaration(
+            const,
+            PrimitiveType,
+            Identifier,
+          InitializerList(CallExpression(Identifier, ArgumentList)))),
+        CompoundStatement),
+      IfStatement(if,
+        ConditionClause(
+          Declaration(
+            const,
+            PrimitiveType,
+            InitDeclarator(
+              Identifier,
+              CallExpression(Identifier, ArgumentList))),
+          BinaryExpression(Identifier, CompareOp, Number)),
+        CompoundStatement))))
+
+
+# Try/catch statements
+
+void main() {
+  try {
+      f();
+  } catch (const std::overflow_error) {
+      // f() throws std::overflow_error (same type rule)
+  } catch (const exception &e) {
+      // f() throws std::logic_error (base class rule)
+  } catch (...) {
+      // f() throws std::string or int or any other unrelated type
+  }
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      TryStatement(try,
+        CompoundStatement(
+          ExpressionStatement(CallExpression(Identifier, ArgumentList))),
+        CatchClause(catch,
+          ParameterList(ParameterDeclaration(const, ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier))),
+          CompoundStatement(LineComment)),
+        CatchClause(catch,
+          ParameterList(ParameterDeclaration(const, TypeIdentifier, ReferenceDeclarator(Identifier))),
+          CompoundStatement(LineComment)),
+        CatchClause(catch,
+          ParameterList,
+          CompoundStatement(LineComment))))))
+
+
+# Throw statements
+
+void main() {
+     throw e;
+     throw x + 1;
+     throw "exception";
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(
+      Identifier,
+      ParameterList),
+      CompoundStatement(
+        ThrowStatement(throw, Identifier),
+        ThrowStatement(throw, BinaryExpression(Identifier, ArithOp, Number)),
+        ThrowStatement(throw, String))))
+
+
+# Noexcept specifier
+
+void foo() noexcept;
+void foo() noexcept(true);
+template<class T> T foo() noexcept(sizeof(T) < 4);
+
+==>
+
+Program(
+  Declaration(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList,
+      Noexcept(noexcept))),
+  Declaration(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList,
+      Noexcept(noexcept, True))),
+  TemplateDeclaration(template,
+    TemplateParameterList(
+      TypeParameterDeclaration(class, TypeIdentifier)),
+    Declaration(
+      TypeIdentifier,
+      FunctionDeclarator(Identifier, ParameterList,
+        Noexcept(noexcept,
+          BinaryExpression(SizeofExpression(sizeof, TypeDescriptor(TypeIdentifier)), CompareOp, Number))))))
+
+
+# Throw specifier
+
+void foo() throw();
+void foo() throw(int);
+void foo() throw(std::string, char *);
+void foo() throw(float) { }
+
+==>
+
+Program(
+  Declaration(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList,
+      ThrowSpecifier(throw))),
+  Declaration(
+  PrimitiveType,
+  FunctionDeclarator(Identifier, ParameterList,
+    ThrowSpecifier(throw, TypeDescriptor(PrimitiveType)))),
+  Declaration(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList,
+      ThrowSpecifier(throw,
+        TypeDescriptor(ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier)),
+        TypeDescriptor(PrimitiveType, AbstractPointerDeclarator)))),
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList,
+      ThrowSpecifier(throw, TypeDescriptor(PrimitiveType))),
+      CompoundStatement))
+
+
+# Assignment
+
+a::b::c = 1;
+
+==>
+
+Program(
+  ExpressionStatement(
+    AssignmentExpression(
+      ScopedNamespaceIdentifier(
+        ScopedNamespaceIdentifier(NamespaceIdentifier, NamespaceIdentifier),
+        NamespaceIdentifier),
+      Number)))
+
+# Switch statement
+
+string xyzzy(Bar s) {
+  switch (s) {
+    case Bar::OK:
+      return "OK";
+    case Bar::NotOK:
+      return "NOT OK";
+    default:
+      return "AHA";
+  }
+}
+
+==>
+
+Program(FunctionDefinition(TypeIdentifier,FunctionDeclarator(
+  Identifier,
+  ParameterList(ParameterDeclaration(TypeIdentifier,Identifier))),
+  CompoundStatement(
+    SwitchStatement(switch,ConditionClause(Identifier),CompoundStatement(
+      CaseStatement(case,ScopedIdentifier(NamespaceIdentifier,Identifier),
+        ReturnStatement(return,String)),
+      CaseStatement(case,ScopedIdentifier(NamespaceIdentifier,Identifier),
+        ReturnStatement(return,String)),
+      CaseStatement(default,ReturnStatement(return,String)))))))
+
+# For loop
+
+for (int x = 1; x < 5; x++, y++) {
+}
+
+==>
+
+Program(ForStatement(for,
+  Declaration(PrimitiveType,InitDeclarator(Identifier,Number)),
+  BinaryExpression(Identifier,CompareOp,Number),
+  CommaExpression(UpdateExpression(Identifier, UpdateOp),UpdateExpression(Identifier, UpdateOp)),
+  CompoundStatement))
+
+# Prefers Call Expression to Function Declaration
+
+foo(a, b
+
+==>
+
+Program(ExpressionStatement(CallExpression(Identifier,ArgumentList(Identifier,",",Identifier,⚠)),⚠))

node_modules/@lezer/cpp/test/test-cpp.js

@@ -0,0 +1,17 @@
+import {parser} from "../dist/index.js"
+import {fileTests} from "@lezer/generator/dist/test"
+
+import * as fs from "fs"
+import * as path from "path"
+import {fileURLToPath} from "url"
+let caseDir = path.dirname(fileURLToPath(import.meta.url))
+
+for (let file of fs.readdirSync(caseDir)) {
+  if (!/\.txt$/.test(file)) continue
+
+  let name = /^[^\.]*/.exec(file)[0]
+  describe(name, () => {
+    for (let {name, run} of fileTests(fs.readFileSync(path.join(caseDir, file), "utf8"), file))
+      it(name, () => run(parser))
+  })
+}

node_modules/@lezer/cpp/test/types.txt

@@ -0,0 +1,149 @@
+# The auto type
+
+void foo() {
+  auto x = 1;
+}
+
+==>
+
+Program(
+  FunctionDefinition(
+    PrimitiveType,
+    FunctionDeclarator(Identifier, ParameterList),
+    CompoundStatement(
+      Declaration(auto, InitDeclarator(Identifier, Number)))))
+
+
+# Namespaced types
+
+std::string my_string;
+std::vector<int>::size_typ my_string;
+
+==>
+
+Program(
+  Declaration(
+    ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+    Identifier),
+  Declaration(
+    ScopedTypeIdentifier(
+      TemplateType(
+        ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+        TemplateArgumentList(TypeDescriptor(PrimitiveType))),
+      TypeIdentifier),
+    Identifier))
+
+
+# Dependent type names
+
+template<typename T>
+struct X : B<T>
+{
+    typename T::A* pa;
+};
+
+==>
+
+Program(
+  TemplateDeclaration(template,
+    TemplateParameterList(TypeParameterDeclaration(typename, TypeIdentifier)),
+    StructSpecifier(struct,
+      TypeIdentifier,
+      BaseClassClause(
+        TemplateType(TypeIdentifier, TemplateArgumentList(TypeDescriptor(TypeIdentifier)))),
+      FieldDeclarationList(
+        FieldDeclaration(
+          DependentType(typename, ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier)),
+          PointerDeclarator(FieldIdentifier))))))
+
+
+# Template types with empty argument lists
+
+use_future_t<> use_future;
+
+==>
+
+Program(
+  Declaration(TemplateType(TypeIdentifier, TemplateArgumentList), Identifier))
+
+
+# Function types as template arguments
+
+typedef std::function<T(int)> MyFunc;
+typedef std::function<void(int)> b;
+
+==>
+
+Program(
+  TypeDefinition(typedef,
+    TemplateType(
+      ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+      TemplateArgumentList(
+        TypeDescriptor(
+          TypeIdentifier,
+          AbstractFunctionDeclarator(ParameterList(
+            ParameterDeclaration(PrimitiveType)))))),
+    TypeIdentifier),
+  TypeDefinition(typedef,
+    TemplateType(
+      ScopedTypeIdentifier(NamespaceIdentifier, TypeIdentifier),
+      TemplateArgumentList(
+        TypeDescriptor(
+          PrimitiveType,
+          AbstractFunctionDeclarator(ParameterList(
+            ParameterDeclaration(PrimitiveType)))))),
+    TypeIdentifier))
+
+
+# Decltype
+
+decltype(A) x;
+decltype(B) foo(void x, decltype(C) y);
+template<typename T, typename U> auto add(T t, U u) -> decltype(t + u);
+
+==>
+
+Program(
+  Declaration(
+    Decltype(decltype, Identifier),
+    Identifier),
+  Declaration(
+    Decltype(decltype, Identifier),
+    FunctionDeclarator(Identifier,
+      ParameterList(
+        ParameterDeclaration(PrimitiveType, Identifier),
+        ParameterDeclaration(Decltype(decltype, Identifier), Identifier)))),
+  TemplateDeclaration(template,
+    TemplateParameterList(
+      TypeParameterDeclaration(typename, TypeIdentifier),
+      TypeParameterDeclaration(typename, TypeIdentifier)),
+    Declaration(
+      auto,
+      FunctionDeclarator(
+        Identifier,
+        ParameterList(
+          ParameterDeclaration(TypeIdentifier, Identifier),
+          ParameterDeclaration(TypeIdentifier, Identifier)),
+        TrailingReturnType(
+          Decltype(decltype, BinaryExpression(Identifier, ArithOp, Identifier)))))))
+
+
+# Trailing return type
+
+auto a::foo() const -> const A<B>& {}
+
+==>
+
+Program(
+  FunctionDefinition(
+    auto,
+    FunctionDeclarator(
+      ScopedIdentifier(NamespaceIdentifier, Identifier),
+      ParameterList,
+      const,
+      TrailingReturnType(
+        const,
+        TemplateType(TypeIdentifier, TemplateArgumentList(TypeDescriptor(TypeIdentifier))),
+        AbstractReferenceDeclarator)),
+      CompoundStatement))
+