diff --git a/.github/workflows/update-cpp-parser.yml b/.github/workflows/update-cpp-parser.yml
index 402a710..93e8b01 100644
--- a/.github/workflows/update-cpp-parser.yml
+++ b/.github/workflows/update-cpp-parser.yml
@@ -25,7 +25,7 @@ jobs:
           git submodule init
           git submodule update
           cd tree-sitter-cpp && git checkout origin/master && cd ..
-          cp tree-sitter-cpp/corpus/* test/corpus
+          cp tree-sitter-cpp/test/corpus/* test/corpus
           npm test
       - name: Create Pull Request
         uses: peter-evans/create-pull-request@v3
diff --git a/examples/marker-index.mqh b/examples/marker-index.mqh
new file mode 100644
index 0000000..f7423db
--- /dev/null
+++ b/examples/marker-index.mqh
@@ -0,0 +1,147 @@
+#ifndef MARKER_INDEX_H_
+#define MARKER_INDEX_H_
+
+#include "flat_set.h"
+#include "point.h"
+#include "range.h"
+#include <random>
+#include <unordered_map>
+
+class MarkerIndex {
+public:
+  using MarkerId = unsigned;
+  using MarkerIdSet = flat_set<MarkerId>;
+
+  struct SpliceResult {
+    flat_set<MarkerId> touch;
+    flat_set<MarkerId> inside;
+    flat_set<MarkerId> overlap;
+    flat_set<MarkerId> surround;
+  };
+
+  struct Boundary {
+    Point position;
+    flat_set<MarkerId> starting;
+    flat_set<MarkerId> ending;
+  };
+
+  struct BoundaryQueryResult {
+    std::vector<MarkerId> containing_start;
+    std::vector<Boundary> boundaries;
+  };
+
+  MarkerIndex(unsigned seed = 0u);
+  ~MarkerIndex();
+  int generate_random_number();
+  void insert(MarkerId id, Point start, Point end);
+  void set_exclusive(MarkerId id, bool exclusive);
+  void remove(MarkerId id);
+  bool has(MarkerId id);
+  SpliceResult splice(Point start, Point old_extent, Point new_extent);
+  Point get_start(MarkerId id) const;
+  Point get_end(MarkerId id) const;
+  Range get_range(MarkerId id) const;
+
+  int compare(MarkerId id1, MarkerId id2) const;
+  flat_set<MarkerId> find_intersecting(Point start, Point end);
+  flat_set<MarkerId> find_containing(Point start, Point end);
+  flat_set<MarkerId> find_contained_in(Point start, Point end);
+  flat_set<MarkerId> find_starting_in(Point start, Point end);
+  flat_set<MarkerId> find_starting_at(Point position);
+  flat_set<MarkerId> find_ending_in(Point start, Point end);
+  flat_set<MarkerId> find_ending_at(Point position);
+  BoundaryQueryResult find_boundaries_after(Point start, size_t max_count);
+
+  std::unordered_map<MarkerId, Range> dump();
+
+private:
+  friend class Iterator;
+
+  struct Node {
+    Node *parent;
+    Node *left;
+    Node *right;
+    Point left_extent;
+    flat_set<MarkerId> left_marker_ids;
+    flat_set<MarkerId> right_marker_ids;
+    flat_set<MarkerId> start_marker_ids;
+    flat_set<MarkerId> end_marker_ids;
+    int priority;
+
+    Node(Node *parent, Point left_extent);
+    bool is_marker_endpoint();
+  };
+
+  class Iterator {
+  public:
+    Iterator(MarkerIndex *marker_index);
+    void reset();
+    Node *insert_marker_start(const MarkerId &id, const Point &start_position,
+                              const Point &end_position);
+    Node *insert_marker_end(const MarkerId &id, const Point &start_position,
+                            const Point &end_position);
+    Node *insert_splice_boundary(const Point &position, bool is_insertion_end);
+    void find_intersecting(const Point &start, const Point &end,
+                           flat_set<MarkerId> *result);
+    void find_contained_in(const Point &start, const Point &end,
+                           flat_set<MarkerId> *result);
+    void find_starting_in(const Point &start, const Point &end,
+                          flat_set<MarkerId> *result);
+    void find_ending_in(const Point &start, const Point &end,
+                        flat_set<MarkerId> *result);
+    void find_boundaries_after(Point start, size_t max_count,
+                               BoundaryQueryResult *result);
+    std::unordered_map<MarkerId, Range> dump();
+
+  private:
+    void ascend();
+    void descend_left();
+    void descend_right();
+    void move_to_successor();
+    void seek_to_first_node_greater_than_or_equal_to(const Point &position);
+    void mark_right(const MarkerId &id, const Point &start_position,
+                    const Point &end_position);
+    void mark_left(const MarkerId &id, const Point &start_position,
+                   const Point &end_position);
+    Node *insert_left_child(const Point &position);
+    Node *insert_right_child(const Point &position);
+    void check_intersection(const Point &start, const Point &end,
+                            flat_set<MarkerId> *results);
+    void cache_node_position() const;
+
+    MarkerIndex *marker_index;
+    Node *current_node;
+    Point current_node_position;
+    Point left_ancestor_position;
+    Point right_ancestor_position;
+    std::vector<Point> left_ancestor_position_stack;
+    std::vector<Point> right_ancestor_position_stack;
+  };
+
+  Point get_node_position(const Node *node) const;
+  void delete_node(Node *node);
+  void delete_subtree(Node *node);
+  void bubble_node_up(Node *node);
+  void bubble_node_down(Node *node);
+  void rotate_node_left(Node *pivot);
+  void rotate_node_right(Node *pivot);
+  void
+  get_starting_and_ending_markers_within_subtree(const Node *node,
+                                                 flat_set<MarkerId> *starting,
+                                                 flat_set<MarkerId> *ending);
+  void populate_splice_invalidation_sets(
+      SpliceResult *invalidated, const Node *start_node, const Node *end_node,
+      const flat_set<MarkerId> &starting_inside_splice,
+      const flat_set<MarkerId> &ending_inside_splice);
+
+  std::default_random_engine random_engine;
+  std::uniform_int_distribution<int> random_distribution;
+  Node *root;
+  std::unordered_map<MarkerId, Node *> start_nodes_by_id;
+  std::unordered_map<MarkerId, Node *> end_nodes_by_id;
+  Iterator iterator;
+  flat_set<MarkerId> exclusive_marker_ids;
+  mutable std::unordered_map<const Node *, Point> node_position_cache;
+};
+
+#endif // MARKER_INDEX_H_
diff --git a/examples/rule.mq5 b/examples/rule.mq5
new file mode 100644
index 0000000..d90fbbf
--- /dev/null
+++ b/examples/rule.mq5
@@ -0,0 +1,311 @@
+#include "compiler/rule.h"
+#include "compiler/util/hash_combine.h"
+
+namespace tree_sitter {
+namespace rules {
+
+using std::move;
+using std::vector;
+using util::hash_combine;
+
+Rule::Rule(const Rule &other) : blank_(Blank{}), type(BlankType) {
+  *this = other;
+}
+
+Rule::Rule(Rule &&other) noexcept : blank_(Blank{}), type(BlankType) {
+  *this = move(other);
+}
+
+static void destroy_value(Rule *rule) {
+  switch (rule->type) {
+  case Rule::BlankType:
+    return rule->blank_.~Blank();
+  case Rule::CharacterSetType:
+    return rule->character_set_.~CharacterSet();
+  case Rule::StringType:
+    return rule->string_.~String();
+  case Rule::PatternType:
+    return rule->pattern_.~Pattern();
+  case Rule::NamedSymbolType:
+    return rule->named_symbol_.~NamedSymbol();
+  case Rule::SymbolType:
+    return rule->symbol_.~Symbol();
+  case Rule::ChoiceType:
+    return rule->choice_.~Choice();
+  case Rule::MetadataType:
+    return rule->metadata_.~Metadata();
+  case Rule::RepeatType:
+    return rule->repeat_.~Repeat();
+  case Rule::SeqType:
+    return rule->seq_.~Seq();
+  }
+}
+
+Rule &Rule::operator=(const Rule &other) {
+  destroy_value(this);
+  type = other.type;
+  switch (type) {
+  case BlankType:
+    new (&blank_) Blank(other.blank_);
+    break;
+  case CharacterSetType:
+    new (&character_set_) CharacterSet(other.character_set_);
+    break;
+  case StringType:
+    new (&string_) String(other.string_);
+    break;
+  case PatternType:
+    new (&pattern_) Pattern(other.pattern_);
+    break;
+  case NamedSymbolType:
+    new (&named_symbol_) NamedSymbol(other.named_symbol_);
+    break;
+  case SymbolType:
+    new (&symbol_) Symbol(other.symbol_);
+    break;
+  case ChoiceType:
+    new (&choice_) Choice(other.choice_);
+    break;
+  case MetadataType:
+    new (&metadata_) Metadata(other.metadata_);
+    break;
+  case RepeatType:
+    new (&repeat_) Repeat(other.repeat_);
+    break;
+  case SeqType:
+    new (&seq_) Seq(other.seq_);
+    break;
+  }
+  return *this;
+}
+
+Rule &Rule::operator=(Rule &&other) noexcept {
+  destroy_value(this);
+  type = other.type;
+  switch (type) {
+  case BlankType:
+    new (&blank_) Blank(move(other.blank_));
+    break;
+  case CharacterSetType:
+    new (&character_set_) CharacterSet(move(other.character_set_));
+    break;
+  case StringType:
+    new (&string_) String(move(other.string_));
+    break;
+  case PatternType:
+    new (&pattern_) Pattern(move(other.pattern_));
+    break;
+  case NamedSymbolType:
+    new (&named_symbol_) NamedSymbol(move(other.named_symbol_));
+    break;
+  case SymbolType:
+    new (&symbol_) Symbol(move(other.symbol_));
+    break;
+  case ChoiceType:
+    new (&choice_) Choice(move(other.choice_));
+    break;
+  case MetadataType:
+    new (&metadata_) Metadata(move(other.metadata_));
+    break;
+  case RepeatType:
+    new (&repeat_) Repeat(move(other.repeat_));
+    break;
+  case SeqType:
+    new (&seq_) Seq(move(other.seq_));
+    break;
+  }
+  other.type = BlankType;
+  other.blank_ = Blank{};
+  return *this;
+}
+
+Rule::~Rule() noexcept { destroy_value(this); }
+
+bool Rule::operator==(const Rule &other) const {
+  if (type != other.type)
+    return false;
+  switch (type) {
+  case Rule::CharacterSetType:
+    return character_set_ == other.character_set_;
+  case Rule::StringType:
+    return string_ == other.string_;
+  case Rule::PatternType:
+    return pattern_ == other.pattern_;
+  case Rule::NamedSymbolType:
+    return named_symbol_ == other.named_symbol_;
+  case Rule::SymbolType:
+    return symbol_ == other.symbol_;
+  case Rule::ChoiceType:
+    return choice_ == other.choice_;
+  case Rule::MetadataType:
+    return metadata_ == other.metadata_;
+  case Rule::RepeatType:
+    return repeat_ == other.repeat_;
+  case Rule::SeqType:
+    return seq_ == other.seq_;
+  default:
+    return blank_ == other.blank_;
+  }
+}
+
+template <> bool Rule::is<Blank>() const { return type == BlankType; }
+
+template <> bool Rule::is<Symbol>() const { return type == SymbolType; }
+
+template <> bool Rule::is<Repeat>() const { return type == RepeatType; }
+
+template <> const Symbol &Rule::get_unchecked<Symbol>() const {
+  return symbol_;
+}
+
+static inline void add_choice_element(std::vector<Rule> *elements,
+                                      const Rule &new_rule) {
+  new_rule.match(
+      [elements](Choice choice) {
+        for (auto &element : choice.elements) {
+          add_choice_element(elements, element);
+        }
+      },
+
+      [elements](auto rule) {
+        for (auto &element : *elements) {
+          if (element == rule)
+            return;
+        }
+        elements->push_back(rule);
+      });
+}
+
+Rule Rule::choice(const vector<Rule> &rules) {
+  vector<Rule> elements;
+  for (auto &element : rules) {
+    add_choice_element(&elements, element);
+  }
+  return (elements.size() == 1) ? elements.front() : Choice{elements};
+}
+
+Rule Rule::repeat(const Rule &rule) {
+  return rule.is<Repeat>() ? rule : Repeat{rule};
+}
+
+Rule Rule::seq(const vector<Rule> &rules) {
+  Rule result;
+  for (const auto &rule : rules) {
+    rule.match([](Blank) {},
+               [&](Metadata metadata) {
+                 if (!metadata.rule->is<Blank>()) {
+                   result = Seq{result, rule};
+                 }
+               },
+               [&](auto) {
+                 if (result.is<Blank>()) {
+                   result = rule;
+                 } else {
+                   result = Seq{result, rule};
+                 }
+               });
+  }
+  return result;
+}
+
+} // namespace rules
+} // namespace tree_sitter
+
+namespace std {
+
+size_t hash<Symbol>::operator()(const Symbol &symbol) const {
+  auto result = hash<int>()(symbol.index);
+  hash_combine(&result, hash<int>()(symbol.type));
+  return result;
+}
+
+size_t hash<NamedSymbol>::operator()(const NamedSymbol &symbol) const {
+  return hash<string>()(symbol.value);
+}
+
+size_t hash<Pattern>::operator()(const Pattern &symbol) const {
+  return hash<string>()(symbol.value);
+}
+
+size_t hash<String>::operator()(const String &symbol) const {
+  return hash<string>()(symbol.value);
+}
+
+size_t hash<CharacterSet>::operator()(const CharacterSet &character_set) const {
+  size_t result = 0;
+  hash_combine(&result, character_set.includes_all);
+  hash_combine(&result, character_set.included_chars.size());
+  for (uint32_t c : character_set.included_chars) {
+    hash_combine(&result, c);
+  }
+  hash_combine(&result, character_set.excluded_chars.size());
+  for (uint32_t c : character_set.excluded_chars) {
+    hash_combine(&result, c);
+  }
+  return result;
+}
+
+size_t hash<Blank>::operator()(const Blank &blank) const { return 0; }
+
+size_t hash<Choice>::operator()(const Choice &choice) const {
+  size_t result = 0;
+  for (const auto &element : choice.elements) {
+    symmetric_hash_combine(&result, element);
+  }
+  return result;
+}
+
+size_t hash<Repeat>::operator()(const Repeat &repeat) const {
+  size_t result = 0;
+  hash_combine(&result, *repeat.rule);
+  return result;
+}
+
+size_t hash<Seq>::operator()(const Seq &seq) const {
+  size_t result = 0;
+  hash_combine(&result, *seq.left);
+  hash_combine(&result, *seq.right);
+  return result;
+}
+
+size_t hash<Metadata>::operator()(const Metadata &metadata) const {
+  size_t result = 0;
+  hash_combine(&result, *metadata.rule);
+  hash_combine(&result, metadata.params.precedence);
+  hash_combine<int>(&result, metadata.params.associativity);
+  hash_combine(&result, metadata.params.has_precedence);
+  hash_combine(&result, metadata.params.has_associativity);
+  hash_combine(&result, metadata.params.is_token);
+  hash_combine(&result, metadata.params.is_string);
+  hash_combine(&result, metadata.params.is_active);
+  hash_combine(&result, metadata.params.is_main_token);
+  return result;
+}
+
+size_t hash<Rule>::operator()(const Rule &rule) const {
+  size_t result = hash<int>()(rule.type);
+  switch (rule.type) {
+  case Rule::CharacterSetType:
+    return result ^ hash<CharacterSet>()(rule.character_set_);
+  case Rule::StringType:
+    return result ^ hash<String>()(rule.string_);
+  case Rule::PatternType:
+    return result ^ hash<Pattern>()(rule.pattern_);
+  case Rule::NamedSymbolType:
+    return result ^ hash<NamedSymbol>()(rule.named_symbol_);
+  case Rule::SymbolType:
+    return result ^ hash<Symbol>()(rule.symbol_);
+  case Rule::ChoiceType:
+    return result ^ hash<Choice>()(rule.choice_);
+  case Rule::MetadataType:
+    return result ^ hash<Metadata>()(rule.metadata_);
+  case Rule::RepeatType:
+    return result ^ hash<Repeat>()(rule.repeat_);
+  case Rule::SeqType:
+    return result ^ hash<Seq>()(rule.seq_);
+  default:
+    return result ^ hash<Blank>()(rule.blank_);
+  }
+}
+
+} // namespace std
diff --git a/package.json b/package.json
index 62b9e33..1d3d117 100644
--- a/package.json
+++ b/package.json
@@ -28,7 +28,7 @@
     {
       "scope": "source.mql5",
       "file-types": [
-        "mql5",
+        "mq5",
         "mqh"
       ],
       "highlights": [
diff --git a/test/corpus/ambiguities.txt b/test/corpus/ambiguities.txt
new file mode 100644
index 0000000..6e92536
--- /dev/null
+++ b/test/corpus/ambiguities.txt
@@ -0,0 +1,102 @@
+================================================
+template functions vs relational expressions
+================================================
+
+T1 a = b < c > d;
+T2 e = f<T3>(g);
+int a = std::get<0>(t);
+
+---
+
+(translation_unit
+  (declaration
+    (type_identifier)
+    (init_declarator
+      (identifier)
+      (binary_expression
+        (binary_expression (identifier) (identifier))
+        (identifier))))
+  (declaration
+    (type_identifier)
+    (init_declarator
+      (identifier)
+      (call_expression
+        (template_function (identifier) (template_argument_list
+          (type_descriptor (type_identifier))))
+        (argument_list (identifier)))))
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (call_expression
+        (qualified_identifier
+          (namespace_identifier)
+          (template_function
+            (identifier)
+            (template_argument_list (number_literal))))
+        (argument_list (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};
+
+---
+
+(translation_unit
+  (comment)
+  (declaration
+    (type_identifier)
+    (function_declarator
+      (identifier)
+      (parameter_list (parameter_declaration (type_identifier) (pointer_declarator (identifier))))))
+  (declaration
+    (type_identifier)
+    (function_declarator
+      (identifier)
+      (parameter_list
+        (parameter_declaration (type_identifier) (reference_declarator (identifier)))
+        (parameter_declaration (type_identifier) (reference_declarator (identifier))))))
+
+  (comment)
+  (declaration
+    (type_identifier)
+    (init_declarator
+      (identifier)
+      (argument_list (field_expression (identifier) (field_identifier)))))
+  (declaration
+    (type_identifier)
+    (init_declarator
+      (identifier)
+      (initializer_list (identifier)))))
+
+================================================
+template classes vs relational expressions
+================================================
+
+int main() {
+  T1<T2> v1;
+  T1<T2> v2 = v3;
+}
+
+---
+
+(translation_unit (function_definition
+  (primitive_type)
+  (function_declarator (identifier) (parameter_list))
+  (compound_statement
+    (declaration
+      (template_type (type_identifier)
+        (template_argument_list (type_descriptor (type_identifier))))
+      (identifier))
+    (declaration
+      (template_type (type_identifier)
+        (template_argument_list (type_descriptor (type_identifier))))
+      (init_declarator (identifier) (identifier))))))
diff --git a/test/corpus/concepts.txt b/test/corpus/concepts.txt
new file mode 100644
index 0000000..2ecd15b
--- /dev/null
+++ b/test/corpus/concepts.txt
@@ -0,0 +1,607 @@
+================================================================================
+Concept definition
+================================================================================
+
+template <class T, class U>
+concept Derived = std::is_base_of<U, T>::value;
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier))
+      (type_parameter_declaration
+        (type_identifier)))
+    (concept_definition
+      (identifier)
+      (qualified_identifier
+        (namespace_identifier)
+        (qualified_identifier
+          (template_type
+            (type_identifier)
+            (template_argument_list
+              (type_descriptor
+                (type_identifier))
+              (type_descriptor
+                (type_identifier))))
+          (identifier))))))
+
+================================================================================
+Concept definition with requires expression
+================================================================================
+
+template<typename T>
+concept Hashable = requires(T a) {
+    { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
+};
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (concept_definition
+      (identifier)
+      (requires_expression
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier)))
+        (requirement_seq
+          (compound_requirement
+            (call_expression
+              (compound_literal_expression
+                (qualified_identifier
+                  (namespace_identifier)
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list
+                      (type_descriptor
+                        (type_identifier)))))
+                (initializer_list))
+              (argument_list
+                (identifier)))
+            (trailing_return_type
+              (type_descriptor
+                (qualified_identifier
+                  (namespace_identifier)
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list
+                      (type_descriptor
+                        (qualified_identifier
+                          (namespace_identifier)
+                          (type_identifier))))))))))))))
+
+================================================================================
+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);
+
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (declaration
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (abstract_reference_declarator)))
+        (requires_clause
+          (template_type
+            (type_identifier)
+            (template_argument_list
+              (type_descriptor
+                (type_identifier))))))))
+  (comment)
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (requires_clause
+      (template_type
+        (type_identifier)
+        (template_argument_list
+          (type_descriptor
+            (type_identifier)))))
+    (comment)
+    (function_definition
+      (type_identifier)
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier))
+          (parameter_declaration
+            (type_identifier)
+            (identifier))))
+      (compound_statement
+        (return_statement
+          (binary_expression
+            (identifier)
+            (identifier))))))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (concept_definition
+      (identifier)
+      (requires_expression
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier)))
+        (requirement_seq
+          (simple_requirement
+            (binary_expression
+              (identifier)
+              (identifier)))))))
+  (comment)
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (requires_clause
+      (requires_expression
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier)))
+        (requirement_seq
+          (simple_requirement
+            (binary_expression
+              (identifier)
+              (identifier))))))
+    (comment)
+    (function_definition
+      (type_identifier)
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier))
+          (parameter_declaration
+            (type_identifier)
+            (identifier))))
+      (compound_statement
+        (return_statement
+          (binary_expression
+            (identifier)
+            (identifier))))))
+      (template_declaration
+        (template_parameter_list
+          (type_parameter_declaration
+            (type_identifier)))
+        (requires_clause
+          (unary_expression
+            (qualified_identifier
+              (namespace_identifier)
+              (template_function
+                (identifier)
+                (template_argument_list
+                  (type_descriptor
+                    (type_identifier))
+                  (type_descriptor
+                    (primitive_type)))))))
+        (comment)
+        (declaration
+          (primitive_type)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (parameter_declaration
+                (type_identifier))))))
+      (template_declaration
+        (template_parameter_list
+          (type_parameter_declaration
+            (type_identifier)))
+        (requires_clause
+          (constraint_conjunction
+            (template_type
+              (type_identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier))))
+            (template_type
+              (type_identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier))))))
+        (comment)
+        (declaration
+          (type_identifier)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (parameter_declaration
+                (type_identifier))))))
+      (template_declaration
+        (template_parameter_list
+          (type_parameter_declaration
+            (type_identifier)))
+        (requires_clause
+          (constraint_disjunction
+            (template_type
+              (type_identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier))))
+            (template_type
+              (type_identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier))))))
+        (comment)
+        (declaration
+          (type_identifier)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (parameter_declaration
+                (type_identifier))))))
+      (template_declaration
+        (template_parameter_list
+          (type_parameter_declaration
+            (type_identifier)))
+        (requires_clause
+          (constraint_disjunction
+            (false)
+            (true)))
+        (comment)
+        (declaration
+          (type_identifier)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (parameter_declaration
+                (type_identifier))))))
+      (template_declaration
+        (template_parameter_list
+          (variadic_type_parameter_declaration
+            (type_identifier)))
+        (requires_clause
+          (fold_expression
+            (template_function
+              (identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier))))))
+        (comment)
+        (declaration
+          (type_identifier)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (parameter_declaration
+                (type_identifier)))))))
+
+================================================================================
+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
+};
+
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (concept_definition
+      (identifier)
+      (requires_expression
+        (parameter_list
+          (parameter_declaration
+            (type_identifier)
+            (identifier)))
+        (requirement_seq
+          (compound_requirement
+            (pointer_expression
+              (identifier))
+            (trailing_return_type
+              (type_descriptor
+                (qualified_identifier
+                  (namespace_identifier)
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list
+                      (type_descriptor
+                        (dependent_type
+                          (qualified_identifier
+                            (namespace_identifier)
+                            (type_identifier))))))))))
+          (comment)
+          (comment)
+          (comment)
+          (compound_requirement
+            (binary_expression
+              (identifier)
+              (number_literal))
+            (trailing_return_type
+              (type_descriptor
+                (qualified_identifier
+                  (namespace_identifier)
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list
+                      (type_descriptor
+                        (primitive_type))))))))
+          (comment)
+          (comment)
+          (comment)
+          (compound_requirement
+            (binary_expression
+              (identifier)
+              (number_literal))
+            (trailing_return_type
+              (type_descriptor
+                (qualified_identifier
+                  (namespace_identifier)
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list
+                      (type_descriptor
+                        (type_identifier))))))))
+          (comment)
+          (comment))))))
+
+================================================================================
+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: "Same<...> evaluates to true"
+    { a.~T() } noexcept;  // compound: "a.~T()" is a valid expression that doesn't throw
+    requires Same<T*, decltype(new T)>; // nested: "Same<...> evaluates to true"
+    requires Same<T*, decltype(new T[n])>; // nested
+    { delete new T };  // compound
+    { delete new T[n] }; // compound
+};
+--------------------------------------------------------------------------------
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration
+        (type_identifier)))
+    (concept_definition
+      (identifier)
+      (binary_expression
+        (binary_expression
+          (binary_expression
+            (binary_expression
+              (template_function
+                (identifier)
+                (template_argument_list
+                  (type_descriptor
+                    (type_identifier))))
+              (template_function
+                (identifier)
+                (template_argument_list
+                  (type_descriptor
+                    (type_identifier)))))
+            (template_function
+              (identifier)
+              (template_argument_list
+                (type_descriptor
+                  (type_identifier)))))
+          (template_function
+            (identifier)
+            (template_argument_list
+              (type_descriptor
+                (type_identifier)))))
+        (requires_expression
+          (parameter_list
+            (parameter_declaration
+              (type_identifier)
+              (identifier))
+            (parameter_declaration
+              (primitive_type)
+              (identifier)))
+          (requirement_seq
+            (simple_requirement
+              (requires_clause
+                (template_type
+                  (type_identifier)
+                  (template_argument_list
+                    (type_descriptor
+                      (type_identifier)
+                      (abstract_pointer_declarator))
+                    (type_descriptor
+                      (decltype
+                        (pointer_expression
+                          (identifier))))))))
+            (comment)
+            (compound_requirement
+              (call_expression
+                (field_expression
+                  (identifier)
+                  (destructor_name
+                    (identifier)))
+                (argument_list)))
+            (comment)
+            (simple_requirement
+              (requires_clause
+                (template_type
+                  (type_identifier)
+                  (template_argument_list
+                    (type_descriptor
+                      (type_identifier)
+                      (abstract_pointer_declarator))
+                    (type_descriptor
+                      (decltype
+                        (new_expression
+                          (type_identifier))))))))
+            (comment)
+            (simple_requirement
+              (requires_clause
+                (template_type
+                  (type_identifier)
+                  (template_argument_list
+                    (type_descriptor
+                      (type_identifier)
+                      (abstract_pointer_declarator))
+                    (type_descriptor
+                      (decltype
+                        (new_expression
+                          (type_identifier)
+                          (new_declarator
+                            (identifier)))))))))
+            (comment)
+            (compound_requirement
+              (delete_expression
+                (new_expression
+                  (type_identifier))))
+            (comment)
+            (compound_requirement
+              (delete_expression
+                (new_expression
+                  (type_identifier)
+                  (new_declarator
+                    (identifier)))))
+            (comment)))))))
+
+================================================================================
+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();
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (parameter_declaration
+        (type_identifier)
+        (identifier)))
+    (declaration
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration
+            (type_qualifier)
+            (type_identifier)
+            (abstract_reference_declarator))))))
+  (comment)
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list
+        (parameter_declaration
+          (type_qualifier)
+          (placeholder_type_specifier
+            (type_identifier)
+            (auto))
+          (abstract_reference_declarator)))))
+  (comment)
+  (declaration
+    (placeholder_type_specifier
+      (type_identifier)
+      (auto))
+    (init_declarator
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list))))
+  (declaration
+    (placeholder_type_specifier
+      (template_type
+        (type_identifier)
+        (template_argument_list
+          (type_descriptor
+            (type_identifier))))
+      (auto))
+    (init_declarator
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list))))
+  (declaration
+    (placeholder_type_specifier
+      (qualified_identifier
+        (namespace_identifier)
+        (template_type
+          (type_identifier)
+          (template_argument_list
+            (type_descriptor
+              (type_identifier)))))
+      (auto))
+    (init_declarator
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list))))
+  (declaration
+    (placeholder_type_specifier
+      (type_identifier)
+      (decltype
+        (auto)))
+    (init_declarator
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list)))))
diff --git a/test/corpus/declarations.txt b/test/corpus/declarations.txt
new file mode 100644
index 0000000..ad12ec1
--- /dev/null
+++ b/test/corpus/declarations.txt
@@ -0,0 +1,1466 @@
+=========================================
+Namespace definitions
+=========================================
+
+namespace std {
+
+int x;
+
+}  // namespace std
+
+namespace A::B { }
+namespace A::B::inline C::D { }
+
+---
+
+(translation_unit
+  (namespace_definition
+    name: (identifier)
+    body: (declaration_list
+      (declaration
+        type: (primitive_type)
+        declarator: (identifier))))
+  (comment)
+  (namespace_definition
+    name: (namespace_definition_name (identifier) (identifier))
+    body: (declaration_list))
+  (namespace_definition
+    name: (namespace_definition_name
+      (namespace_definition_name
+        (namespace_definition_name (identifier) (identifier))
+        (identifier))
+      (identifier))
+    body: (declaration_list)))
+
+=========================================
+Namespace alias definitions
+=========================================
+
+namespace A = B;
+namespace C = ::D;
+namespace fs = std::filesystem;
+namespace bfs = ::boost::filesystem;
+namespace literals = std::chono::literals;
+
+---
+
+(translation_unit
+  (namespace_alias_definition
+    name: (identifier)
+    (identifier))
+  (namespace_alias_definition
+    name: (identifier)
+    (qualified_identifier
+      name: (identifier)))
+  (namespace_alias_definition
+    name: (identifier)
+    (qualified_identifier
+      scope: (namespace_identifier)
+      name: (identifier)))
+  (namespace_alias_definition
+    name: (identifier)
+    (qualified_identifier
+      name: (qualified_identifier
+        scope: (namespace_identifier)
+        name: (identifier))))
+  (namespace_alias_definition
+    name: (identifier)
+    (qualified_identifier
+      scope: (namespace_identifier)
+      name: (qualified_identifier
+        scope: (namespace_identifier)
+        name: (identifier)))))
+
+=========================================
+Using declarations
+=========================================
+
+using a;
+using ::b;
+using c::d;
+using ::e::f::g;
+using h = i::j;
+using namespace std;
+using enum Foo;
+
+template <typename T>
+using a = typename b<T>::c;
+
+---
+
+(translation_unit
+  (using_declaration (identifier))
+  (using_declaration (qualified_identifier (identifier)))
+  (using_declaration (qualified_identifier (namespace_identifier) (identifier)))
+  (using_declaration
+    (qualified_identifier
+      (qualified_identifier
+        (namespace_identifier)
+        (qualified_identifier
+            (namespace_identifier)
+            (identifier)))))
+  (alias_declaration
+    (type_identifier)
+    (type_descriptor (qualified_identifier (namespace_identifier) (type_identifier))))
+  (using_declaration (identifier))
+  (using_declaration (identifier))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (alias_declaration
+      (type_identifier)
+      (type_descriptor
+        (dependent_type
+          (qualified_identifier
+            (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
+            (type_identifier)))))))
+
+=========================================
+Reference declarations
+=========================================
+
+int main() {
+  T &x = y<T &>();
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (declaration
+        (type_identifier)
+        (init_declarator
+          (reference_declarator (identifier))
+          (call_expression
+            (template_function
+              (identifier)
+              (template_argument_list
+                (type_descriptor (type_identifier) (abstract_reference_declarator))))
+            (argument_list)))))))
+
+=========================================
+R-value reference declarations
+=========================================
+
+int main(T &&);
+
+int main(T &&t) {
+  const U &&u = v;
+}
+
+---
+
+(translation_unit
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator)))))
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list (parameter_declaration (type_identifier) (reference_declarator (identifier)))))
+    (compound_statement
+      (declaration
+        (type_qualifier)
+        (type_identifier)
+        (init_declarator (reference_declarator (identifier)) (identifier))))))
+
+=========================================
+Inline method definitions
+=========================================
+
+struct S {
+  int f;
+
+  S() : f(0) {}
+
+ private:
+  int getF1() const { return f; }
+  int getF2() const try { throw 1; } catch (...) { return f; }
+};
+
+---
+
+(translation_unit
+  (struct_specifier (type_identifier) (field_declaration_list
+    (field_declaration (primitive_type) (field_identifier))
+    (function_definition
+      (function_declarator (identifier) (parameter_list))
+      (field_initializer_list (field_initializer (field_identifier) (argument_list (number_literal))))
+      (compound_statement))
+    (access_specifier)
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier))
+      (compound_statement (return_statement (identifier))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier))
+      (try_statement
+        (compound_statement (throw_statement (number_literal)))
+        (catch_clause (parameter_list)
+          (compound_statement (return_statement (identifier)))))))))
+
+=========================================
+Inline method definitions with overrides
+=========================================
+
+struct B : A {
+  int foo() override { return 2; }
+  int pho() final { return 3; }
+  int bar() const override { return 4; }
+  int baz() const final { return 5; }
+  int bag() const final override { return 6; }
+  int bah() const override final { return 7; }
+};
+
+---
+
+(translation_unit
+  (struct_specifier (type_identifier) (base_class_clause (type_identifier)) (field_declaration_list
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (virtual_specifier))
+      (compound_statement (return_statement (number_literal))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (virtual_specifier))
+      (compound_statement (return_statement (number_literal))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier) (virtual_specifier))
+      (compound_statement (return_statement (number_literal))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier) (virtual_specifier))
+      (compound_statement (return_statement (number_literal))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier) (virtual_specifier) (virtual_specifier))
+      (compound_statement (return_statement (number_literal))))
+    (function_definition
+      (primitive_type)
+      (function_declarator (field_identifier) (parameter_list) (type_qualifier) (virtual_specifier) (virtual_specifier))
+      (compound_statement (return_statement (number_literal)))))))
+
+=====================================
+Virtual method declarations
+===============================
+
+class A {
+  virtual ~Point();
+  void b();
+  virtual void foo() {}
+  virtual void bar();
+  inline virtual void foo() override;
+  virtual inline void foo() final;
+};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (field_declaration_list
+      (declaration
+        (virtual_function_specifier)
+        (function_declarator (destructor_name (identifier)) (parameter_list)))
+      (field_declaration
+        (primitive_type)
+        (function_declarator (field_identifier) (parameter_list)))
+      (function_definition
+        (virtual_function_specifier)
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list))
+        (compound_statement))
+      (field_declaration
+        (virtual_function_specifier)
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list)))
+      (field_declaration
+        (storage_class_specifier)
+        (virtual_function_specifier)
+        (primitive_type)
+        (function_declarator (field_identifier) (parameter_list) (virtual_specifier)))
+      (field_declaration
+        (virtual_function_specifier)
+        (storage_class_specifier)
+        (primitive_type)
+        (function_declarator (field_identifier) (parameter_list) (virtual_specifier))))))
+
+=========================================
+Constructor and destructor declarations
+=========================================
+
+class C {
+  void *data_;
+
+ public:
+  C();
+  C(int, float);
+  inline C();
+  explicit inline C();
+  [[deprecated]] C();
+  template <typename T>
+  C(T t);
+  C() : NS::Base<C>() {}
+  ~C();
+};
+
+---
+
+(translation_unit
+  (class_specifier (type_identifier) (field_declaration_list
+    (field_declaration (primitive_type) (pointer_declarator (field_identifier)))
+    (access_specifier)
+    (declaration (function_declarator (identifier) (parameter_list)))
+    (declaration (function_declarator (identifier) (parameter_list
+      (parameter_declaration (primitive_type))
+      (parameter_declaration (primitive_type)))))
+    (declaration (storage_class_specifier) (function_declarator (identifier) (parameter_list)))
+    (declaration (explicit_function_specifier) (storage_class_specifier) (function_declarator (identifier) (parameter_list)))
+    (declaration (attribute_declaration (attribute (identifier)))
+      (function_declarator (identifier) (parameter_list)))
+    (template_declaration (template_parameter_list (type_parameter_declaration (type_identifier)))
+      (declaration (function_declarator (identifier) (parameter_list (parameter_declaration (type_identifier) (identifier))))))
+    (function_definition (function_declarator (identifier) (parameter_list))
+      (field_initializer_list
+        (field_initializer
+          (qualified_identifier
+            (namespace_identifier) 
+            (template_method
+              (field_identifier)
+              (template_argument_list (type_descriptor (type_identifier)))))
+          (argument_list)))
+      (compound_statement))
+    (declaration (function_declarator (destructor_name (identifier)) (parameter_list))))))
+
+=========================================
+Classes with inheritance
+=========================================
+
+class A : public B {
+};
+
+class C : C::D, public E {
+};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (base_class_clause (type_identifier))
+    (field_declaration_list))
+  (class_specifier
+    (type_identifier)
+    (base_class_clause
+      (qualified_identifier (namespace_identifier) (type_identifier))
+      (type_identifier))
+    (field_declaration_list)))
+
+=========================================
+Classes with final virt specifier
+=========================================
+
+class A final : public B {
+};
+
+class C final {};
+
+struct D final {};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (virtual_specifier)
+    (base_class_clause (type_identifier))
+    (field_declaration_list))
+  (class_specifier
+    (type_identifier)
+    (virtual_specifier)
+    (field_declaration_list))
+  (struct_specifier
+    (type_identifier)
+    (virtual_specifier)
+    (field_declaration_list)))
+
+=========================================
+Nested classes
+========================================
+
+class A {
+ private:
+  class B : private C, public D {
+  };
+
+  B e, f;
+};
+
+---
+
+(translation_unit
+  (class_specifier (type_identifier) (field_declaration_list
+    (access_specifier)
+    (field_declaration
+      (class_specifier (type_identifier) (base_class_clause (type_identifier) (type_identifier)) (field_declaration_list)))
+    (field_declaration
+      (type_identifier) (field_identifier) (field_identifier)))))
+
+=========================================
+Friend declarations
+=========================================
+
+struct C {
+  friend class D;
+  friend D;
+  friend int f(C &);
+};
+
+---
+
+(translation_unit
+  (struct_specifier (type_identifier) (field_declaration_list
+    (friend_declaration (type_identifier))
+    (friend_declaration (type_identifier))
+    (friend_declaration (declaration (primitive_type) (function_declarator
+      (identifier)
+      (parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator)))))))))
+
+=============================================
+Default member initializers
+=============================================
+
+struct A {
+  bool a = 1;
+  vector<int> b = {c, d, e};
+  F g {h};
+};
+
+---
+
+(translation_unit
+  (struct_specifier (type_identifier) (field_declaration_list
+    (field_declaration
+      (primitive_type)
+      (field_identifier)
+      (number_literal))
+    (field_declaration
+      (template_type (type_identifier) (template_argument_list (type_descriptor (primitive_type))))
+      (field_identifier)
+      (initializer_list (identifier) (identifier) (identifier)))
+    (field_declaration
+      (type_identifier)
+      (field_identifier)
+      (initializer_list (identifier))))))
+
+=========================================
+Function parameters with default values
+=========================================
+
+int foo(bool x = 5) {}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list
+        (optional_parameter_declaration (primitive_type) (identifier) (number_literal))))
+    (compound_statement)))
+
+=========================================
+Attributes
+=========================================
+
+int f([[a::b(c), d]] int x) {}
+
+[[gnu::always_inline]] [[gnu::hot]] [[gnu::const]] [[nodiscard]]
+inline int g();
+
+[[aaa]]
+int f() { }
+
+class [[gnu::visibility("default")]] A {};
+struct [[gnu::visibility("default")]] A {};
+union [[gnu::visibility("default")]] A {};
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list
+        (parameter_declaration
+          (attribute_declaration
+            (attribute (identifier) (identifier) (argument_list (identifier)))
+            (attribute (identifier)))
+          (primitive_type)
+          (identifier))))
+    (compound_statement))
+  (declaration
+    (attribute_declaration (attribute (identifier) (identifier)))
+    (attribute_declaration (attribute (identifier) (identifier)))
+    (attribute_declaration (attribute (identifier) (identifier)))
+    (attribute_declaration (attribute (identifier)))
+    (storage_class_specifier)
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)))
+  (function_definition
+    (attribute_declaration (attribute (identifier)))
+    (primitive_type) (function_declarator (identifier) (parameter_list)) (compound_statement))
+  (class_specifier
+    (attribute_declaration (attribute (identifier) (identifier) (argument_list (string_literal))))
+    (type_identifier)
+    (field_declaration_list))
+  (struct_specifier
+    (attribute_declaration (attribute (identifier) (identifier) (argument_list (string_literal))))
+    (type_identifier)
+    (field_declaration_list))
+  (union_specifier
+    (attribute_declaration (attribute (identifier) (identifier) (argument_list (string_literal))))
+    (type_identifier)
+    (field_declaration_list)))
+
+=========================================
+Operator overload declarations
+=========================================
+
+ostream &operator<<(ostream &, const A &a);
+Foo operator "" _foo(const char* s);
+std::string_view operator ""s_v(const char* s);
+bool A::operator!=(const A &other) const;
+
+bool A::operator ==(const A &other) const;
+
+void * A::operator new(size_t s);
+
+void * A::operator delete   [](void * p);
+
+---
+
+(translation_unit
+  (declaration
+    (type_identifier)
+    (reference_declarator
+      (function_declarator
+        (operator_name)
+        (parameter_list
+          (parameter_declaration (type_identifier) (abstract_reference_declarator))
+          (parameter_declaration (type_qualifier) (type_identifier) (reference_declarator (identifier)))))))
+  (declaration
+    (type_identifier)
+    (function_declarator
+      (operator_name (identifier))
+      (parameter_list
+        (parameter_declaration (type_qualifier) (primitive_type) (pointer_declarator (identifier))))))
+  (declaration
+    (qualified_identifier (namespace_identifier) (type_identifier))
+    (function_declarator
+      (operator_name (identifier))
+      (parameter_list
+        (parameter_declaration (type_qualifier) (primitive_type) (pointer_declarator (identifier))))))
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (operator_name))
+      (parameter_list
+        (parameter_declaration (type_qualifier) (type_identifier) (reference_declarator (identifier))))
+      (type_qualifier)))
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (operator_name))
+      (parameter_list
+        (parameter_declaration (type_qualifier) (type_identifier) (reference_declarator (identifier))))
+      (type_qualifier)))
+   (declaration
+     (primitive_type)
+     (pointer_declarator
+       (function_declarator
+         (qualified_identifier (namespace_identifier) (operator_name))
+         (parameter_list (parameter_declaration (primitive_type) (identifier))))))
+   (declaration
+     (primitive_type)
+     (pointer_declarator
+       (function_declarator
+         (qualified_identifier (namespace_identifier) (operator_name))
+         (parameter_list (parameter_declaration (primitive_type) (pointer_declarator (identifier))))))))
+
+=========================================
+Template declarations
+=========================================
+
+template <typename T>
+void foo(T &t);
+
+template <typename T, int u>
+int bar(T &t) { return u; }
+
+template <typename T>
+class Foo {};
+
+template <typename T>
+Foo<T>::Foo(int mem) : mem_(mem) {}
+
+template <typename T>
+template <typename U>
+void A<T>::foo(U&) {}
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (declaration
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration (type_identifier) (reference_declarator (identifier)))))))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier))
+      (parameter_declaration (primitive_type) (identifier)))
+    (function_definition
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list (parameter_declaration (type_identifier) (reference_declarator (identifier)))))
+      (compound_statement (return_statement (identifier)))))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (class_specifier (type_identifier) (field_declaration_list)))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (function_definition
+      (function_declarator
+        (qualified_identifier
+          (template_type
+            (type_identifier)
+            (template_argument_list (type_descriptor (type_identifier))))
+          (identifier))
+        (parameter_list
+          (parameter_declaration (primitive_type) (identifier))))
+      (field_initializer_list
+        (field_initializer
+          (field_identifier)
+          (argument_list (identifier))))
+      (compound_statement)))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (template_declaration
+      (template_parameter_list
+        (type_parameter_declaration (type_identifier)))
+      (function_definition
+        (primitive_type)
+        (function_declarator
+          (qualified_identifier
+            (template_type
+              (type_identifier)
+              (template_argument_list (type_descriptor (type_identifier))))
+            (identifier))
+          (parameter_list
+            (parameter_declaration
+              (type_identifier)
+              (abstract_reference_declarator))))
+        (compound_statement)))))
+
+=========================================
+Template template declarations
+=========================================
+
+template <template <typename> typename T>
+void foo() {}
+
+template <template <typename...> class>
+void bar() {}
+
+template <template <typename> typename...>
+void baz() {}
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list
+      (template_template_parameter_declaration
+        (template_parameter_list (type_parameter_declaration))
+        (type_parameter_declaration (type_identifier))))
+    (function_definition
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list))
+      (compound_statement)))
+  (template_declaration
+    (template_parameter_list
+      (template_template_parameter_declaration
+        (template_parameter_list (variadic_type_parameter_declaration))
+        (type_parameter_declaration)))
+    (function_definition
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list))
+      (compound_statement)))
+  (template_declaration
+    (template_parameter_list
+      (template_template_parameter_declaration
+        (template_parameter_list (type_parameter_declaration))
+        (variadic_type_parameter_declaration)))
+    (function_definition
+      (primitive_type)
+      (function_declarator
+        (identifier)
+        (parameter_list))
+      (compound_statement))))
+
+=========================================
+Template specializations
+=========================================
+
+template <>
+void foo<T>(T &t);
+
+template <>
+struct foo::bar<T> {};
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list)
+    (declaration
+      (primitive_type)
+      (function_declarator
+        (template_function
+          (identifier)
+          (template_argument_list (type_descriptor (type_identifier))))
+        (parameter_list
+          (parameter_declaration (type_identifier) (reference_declarator (identifier)))))))
+  (template_declaration
+    (template_parameter_list)
+    (struct_specifier
+      (qualified_identifier
+        (namespace_identifier)
+        (template_type
+          (type_identifier)
+          (template_argument_list (type_descriptor (type_identifier)))))
+      (field_declaration_list))))
+
+====================================================
+Template methods
+====================================================
+
+class Person {
+  Person() {
+    this->speak<int>();
+  }
+
+  template <typename T>
+  void speak() {}
+
+  template <>
+  void speak<bool>() {}
+};
+
+---
+
+(translation_unit
+  (class_specifier (type_identifier) (field_declaration_list
+    (function_definition
+      (function_declarator (identifier) (parameter_list))
+      (compound_statement
+        (expression_statement (call_expression
+          (field_expression
+            (this)
+            (template_method
+              (field_identifier)
+              (template_argument_list (type_descriptor (primitive_type)))))
+          (argument_list)))))
+    (template_declaration
+      (template_parameter_list (type_parameter_declaration (type_identifier)))
+      (function_definition
+        (primitive_type)
+        (function_declarator
+          (identifier)
+          (parameter_list))
+        (compound_statement)))
+    (template_declaration
+      (template_parameter_list)
+      (function_definition
+        (primitive_type)
+        (function_declarator
+          (template_function (identifier) (template_argument_list (type_descriptor (primitive_type))))
+          (parameter_list))
+        (compound_statement))))))
+
+==========================================
+Templates with optional type parameters
+==========================================
+
+template <typename T = U::V<void>>
+class X
+{
+};
+
+template <typename = void>
+class Y
+{
+};
+
+---
+
+(translation_unit
+  (template_declaration
+    parameters: (template_parameter_list
+      (optional_type_parameter_declaration
+        name: (type_identifier)
+        default_type: (qualified_identifier
+            scope: (namespace_identifier)
+            name: (template_type
+              name: (type_identifier)
+              arguments: (template_argument_list
+                (type_descriptor type: (primitive_type)))))))
+    (class_specifier
+      name: (type_identifier)
+      body: (field_declaration_list)))
+  (template_declaration
+    parameters: (template_parameter_list
+      (optional_type_parameter_declaration
+        default_type: (primitive_type)))
+    (class_specifier
+      name: (type_identifier)
+      body: (field_declaration_list))))
+
+==============================================
+Templates with optional anonymous parameters
+==============================================
+
+template <class T, typename a::b<!c<T>{} && (d<T>{} || e<T>{})>::type = 0>
+class X
+{
+};
+
+---
+
+(translation_unit
+  (template_declaration
+    parameters: (template_parameter_list
+      (type_parameter_declaration (type_identifier))
+      (optional_parameter_declaration
+        type: (dependent_type (qualified_identifier
+          scope: (namespace_identifier)
+          name:  (qualified_identifier
+            scope: (template_type
+              name: (type_identifier)
+              arguments: (template_argument_list
+                (binary_expression
+                  left: (unary_expression
+                    argument: (compound_literal_expression
+                      type: (template_type
+                        name: (type_identifier)
+                        arguments: (template_argument_list (type_descriptor type: (type_identifier))))
+                      value: (initializer_list)))
+                  right: (parenthesized_expression
+                    (binary_expression
+                      left: (compound_literal_expression
+                        type: (template_type
+                          name: (type_identifier)
+                          arguments: (template_argument_list (type_descriptor type: (type_identifier))))
+                        value: (initializer_list))
+                      right: (compound_literal_expression
+                        type: (template_type
+                          name: (type_identifier)
+                          arguments: (template_argument_list (type_descriptor type: (type_identifier))))
+                        value: (initializer_list)))))))
+        name: (type_identifier))))
+      default_value: (number_literal)))
+    (class_specifier
+      name: (type_identifier)
+      body: (field_declaration_list))))
+
+==========================================
+Declarations with braced initializer lists
+==========================================
+
+A foo{1, 2};
+
+---
+
+(translation_unit
+  (declaration
+    (type_identifier)
+    (init_declarator (identifier) (initializer_list (number_literal) (number_literal)))))
+
+===========================================
+Empty function bodies
+===========================================
+
+int main() {}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement)))
+
+==========================================
+Explicit template instantiations
+==========================================
+
+template A<int, bool>::A(char *, size_t);
+
+---
+
+(translation_unit
+  (template_instantiation
+    (function_declarator
+      (qualified_identifier
+        (template_type
+          (type_identifier)
+          (template_argument_list
+            (type_descriptor (primitive_type))
+            (type_descriptor (primitive_type))))
+        (identifier))
+      (parameter_list
+        (parameter_declaration (primitive_type) (abstract_pointer_declarator))
+        (parameter_declaration (primitive_type))))))
+
+=====================================
+Structured binding declarations
+=====================================
+
+auto [a] = B{};
+
+int main() {
+  auto &&[b, c] = std::make_tuple(c);
+  const auto [x, y] {1, 2};
+
+  for (const auto &[a, b] : c) {}
+}
+
+---
+
+(translation_unit
+  (declaration
+    type: (placeholder_type_specifier (auto))
+    declarator: (init_declarator
+      declarator: (structured_binding_declarator (identifier))
+      value: (compound_literal_expression
+        type: (type_identifier)
+        value: (initializer_list))))
+  (function_definition
+    type: (primitive_type)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement
+      (declaration
+        type: (placeholder_type_specifier (auto))
+        declarator: (init_declarator
+          declarator: (reference_declarator
+            (structured_binding_declarator (identifier) (identifier)))
+          value: (call_expression
+            function: (qualified_identifier
+              scope: (namespace_identifier)
+              name: (identifier))
+            arguments: (argument_list (identifier)))))
+      (declaration
+        (type_qualifier)
+        type: (placeholder_type_specifier (auto))
+        declarator: (init_declarator
+          declarator: (structured_binding_declarator (identifier) (identifier))
+          value: (initializer_list (number_literal) (number_literal))))
+      (for_range_loop
+        (type_qualifier)
+        type: (placeholder_type_specifier (auto))
+        declarator: (reference_declarator (structured_binding_declarator
+          (identifier)
+          (identifier)))
+        right: (identifier)
+        body: (compound_statement)))))
+
+==========================
+Constexpr/constinit/consteval declarations
+==========================
+
+constexpr double pi = 3.14159;
+consteval int answer();
+constinit int life = answer();
+
+---
+
+(translation_unit
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (number_literal)))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list)))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list)))))
+
+============================
+Variadic templates
+============================
+
+template <class T>
+class TT {
+  template <typename... Ts>
+  void func1(Ts ... args) {
+    func3(nullptr);
+  }
+
+  void func2(Ts &&... args) {}
+
+  template <typename...>
+  void func3() {}
+
+  template <std::size_t...>
+  void func4() {}
+};
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list (type_parameter_declaration (type_identifier)))
+    (class_specifier (type_identifier) (field_declaration_list
+      (template_declaration
+        (template_parameter_list (variadic_type_parameter_declaration (type_identifier)))
+        (function_definition
+          (primitive_type)
+          (function_declarator
+            (identifier)
+            (parameter_list
+              (variadic_parameter_declaration
+                (type_identifier)
+                (variadic_declarator (identifier)))))
+          (compound_statement
+            (expression_statement (call_expression (identifier) (argument_list (nullptr)))))))
+        (function_definition
+          (primitive_type)
+          (function_declarator
+            (field_identifier)
+            (parameter_list
+              (variadic_parameter_declaration
+                (type_identifier)
+                (reference_declarator (variadic_declarator (identifier))))))
+          (compound_statement))
+        (template_declaration
+          (template_parameter_list (variadic_type_parameter_declaration))
+          (function_definition
+            (primitive_type)
+            (function_declarator
+              (identifier)
+              (parameter_list))
+            (compound_statement)))
+        (template_declaration
+          (template_parameter_list
+            (variadic_parameter_declaration
+              (qualified_identifier
+                (namespace_identifier)
+                (type_identifier))
+              (variadic_declarator)))
+          (function_definition
+            (primitive_type)
+            (function_declarator
+              (identifier)
+              (parameter_list))
+            (compound_statement)))))))
+
+============================
+Enums
+============================
+
+enum Foo : char { };
+enum Foo : Bar { };
+enum Foo : unsigned int { };
+enum {a, b};
+enum Foo : Bar::Rab { };
+enum Foo::Oof : Bar::Rab { };
+enum class Foo;
+enum struct Foo : char { };
+
+---
+
+(translation_unit
+  (enum_specifier (type_identifier) (type_identifier) (enumerator_list))
+  (enum_specifier (type_identifier) (type_identifier) (enumerator_list))
+  (enum_specifier (type_identifier) (sized_type_specifier (primitive_type)) (enumerator_list))
+  (enum_specifier (enumerator_list (enumerator (identifier)) (enumerator (identifier))))
+  (enum_specifier (type_identifier) (qualified_identifier (namespace_identifier) (type_identifier)) (enumerator_list))
+  (enum_specifier (qualified_identifier (namespace_identifier) (type_identifier)) (qualified_identifier (namespace_identifier) (type_identifier)) (enumerator_list))
+  (enum_specifier (type_identifier))
+  (enum_specifier (type_identifier) (type_identifier) (enumerator_list)))
+
+============================
+static_assert declarations
+============================
+
+class A { static_assert(true, "message"); };
+void f() { static_assert(false); }
+static_assert(std::is_constructible<A>::value);
+static_assert(true, "string1" "string2");
+static_assert(true, R"FOO(string)FOO");
+
+---
+
+(translation_unit
+  (class_specifier
+    name: (type_identifier)
+    body: (field_declaration_list
+    (static_assert_declaration
+      condition: (true)
+      message: (string_literal))))
+  (function_definition
+    type: (primitive_type)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement
+      (static_assert_declaration
+        condition: (false))))
+  (static_assert_declaration
+    condition: (qualified_identifier
+      scope: (namespace_identifier)
+      name: (qualified_identifier
+        scope: (template_type
+          name: (type_identifier)
+          arguments: (template_argument_list
+            (type_descriptor type: (type_identifier))))
+        name: (identifier))))
+  (static_assert_declaration
+    condition: (true)
+    message: (concatenated_string (string_literal) (string_literal)))
+  (static_assert_declaration
+    condition: (true)
+    message: (raw_string_literal delimiter: (raw_string_delimiter) (raw_string_content) (raw_string_delimiter))))
+
+=========================================
+Cast operator overload declarations
+=========================================
+
+operator int() const;
+explicit operator int*() const;
+operator arr_t*();
+operator B&();
+operator auto() const;
+virtual operator A() = 0;
+A::B::operator C();
+template <typename T>
+operator T*();
+[[nodiscard]] operator char *();
+
+---
+
+(translation_unit
+  (declaration
+    (operator_cast
+      (primitive_type)
+      (abstract_function_declarator (parameter_list) (type_qualifier))))
+  (declaration
+    (explicit_function_specifier)
+    (operator_cast
+      (primitive_type)
+      (abstract_pointer_declarator (abstract_function_declarator (parameter_list) (type_qualifier)))))
+  (declaration
+    (operator_cast
+      (type_identifier)
+      (abstract_pointer_declarator (abstract_function_declarator (parameter_list)))))
+  (declaration (operator_cast
+    (type_identifier)
+    (abstract_reference_declarator (abstract_function_declarator (parameter_list)))))
+  (declaration
+    (operator_cast
+      (placeholder_type_specifier (auto))
+      (abstract_function_declarator (parameter_list) (type_qualifier))))
+  (declaration
+    (virtual_function_specifier)
+    (operator_cast (type_identifier) (abstract_function_declarator (parameter_list))) (number_literal))
+  (declaration
+    (qualified_identifier
+      (namespace_identifier)
+      (qualified_identifier
+        (namespace_identifier)
+        (operator_cast
+          (type_identifier)
+          (abstract_function_declarator (parameter_list))))))
+  (template_declaration
+    (template_parameter_list (type_parameter_declaration (type_identifier)))
+    (declaration (operator_cast
+      (type_identifier)
+      (abstract_pointer_declarator (abstract_function_declarator (parameter_list))))))
+  (declaration
+    (attribute_declaration (attribute (identifier)))
+    (operator_cast (primitive_type) (abstract_pointer_declarator (abstract_function_declarator (parameter_list))))))
+
+=========================================
+Class scope cast operator overload declarations
+=========================================
+
+class A {
+  operator int() const {}
+  explicit operator int*() const;
+  operator arr_t*();
+  operator B&();
+  operator auto() const;
+  virtual operator A() = 0;
+  A::B::operator C();
+  template <typename T>
+  operator T*();
+  [[nodiscard]] operator char *();
+};
+
+---
+
+(translation_unit
+  (class_specifier (type_identifier) (field_declaration_list
+    (function_definition
+      (operator_cast
+        (primitive_type)
+        (abstract_function_declarator (parameter_list) (type_qualifier)))
+      (compound_statement))
+    (declaration
+      (explicit_function_specifier)
+      (operator_cast
+        (primitive_type)
+        (abstract_pointer_declarator (abstract_function_declarator (parameter_list) (type_qualifier)))))
+    (declaration
+      (operator_cast
+        (type_identifier)
+        (abstract_pointer_declarator (abstract_function_declarator (parameter_list)))))
+    (declaration (operator_cast
+      (type_identifier)
+      (abstract_reference_declarator (abstract_function_declarator (parameter_list)))))
+    (declaration
+      (operator_cast
+        (placeholder_type_specifier (auto))
+        (abstract_function_declarator (parameter_list) (type_qualifier))))
+    (declaration
+      (virtual_function_specifier)
+      (operator_cast (type_identifier) (abstract_function_declarator (parameter_list))) (number_literal))
+    (declaration
+      (qualified_identifier
+        (namespace_identifier)
+        (qualified_identifier
+          (namespace_identifier)
+          (operator_cast
+            (type_identifier)
+            (abstract_function_declarator (parameter_list))))))
+    (template_declaration
+      (template_parameter_list (type_parameter_declaration (type_identifier)))
+      (declaration (operator_cast
+        (type_identifier)
+        (abstract_pointer_declarator (abstract_function_declarator (parameter_list))))))
+    (declaration
+      (attribute_declaration (attribute (identifier)))
+      (operator_cast (primitive_type) (abstract_pointer_declarator (abstract_function_declarator (parameter_list))))))))
+
+=========================
+Function declarations
+=========================
+
+inline int g();
+inline int h() { }
+
+---
+
+(translation_unit
+  (declaration
+    (storage_class_specifier)
+    type: (primitive_type)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list)))
+  (function_definition
+    (storage_class_specifier)
+    type: (primitive_type)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement)))
+
+============================================
+Variable storage classes
+============================================
+
+int a;
+extern int b, c;
+register int e;
+static int f;
+thread_local int c;
+
+---
+
+(translation_unit
+  (declaration (primitive_type) (identifier))
+  (declaration (storage_class_specifier) (primitive_type) (identifier) (identifier))
+  (declaration (storage_class_specifier) (primitive_type) (identifier))
+  (declaration (storage_class_specifier) (primitive_type) (identifier))
+  (declaration (storage_class_specifier) (primitive_type) (identifier)))
+
+=========================
+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 {}
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (field_declaration_list
+      (field_declaration
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list)
+          (ref_qualifier)))
+      (field_declaration
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list)
+          (ref_qualifier)
+          (noexcept)))
+      (function_definition
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list)
+          (ref_qualifier))
+        (compound_statement))
+      (function_definition
+        (primitive_type)
+        (function_declarator
+          (field_identifier)
+          (parameter_list)
+          (ref_qualifier)
+          (noexcept))
+        (compound_statement))))
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier
+        (namespace_identifier)
+        (identifier))
+      (parameter_list)
+      (ref_qualifier)))
+  (declaration
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier
+        (namespace_identifier)
+        (identifier))
+      (parameter_list)
+      (ref_qualifier)
+      (noexcept)))
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier
+        (namespace_identifier)
+        (identifier))
+      (parameter_list)
+      (ref_qualifier))
+    (compound_statement))
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier
+        (namespace_identifier)
+        (identifier))
+      (parameter_list)
+      (ref_qualifier)
+      (noexcept))
+    (compound_statement)))
+
+=========================
+Default comparison declarations
+=========================
+
+struct A {
+    auto operator<=>(A const &) = default;
+    friend auto operator<=>(A const &, A const &) = default;
+};
+
+---
+
+(translation_unit
+  (struct_specifier
+    (type_identifier)
+    (field_declaration_list
+      (function_definition
+        (placeholder_type_specifier (auto))
+        (function_declarator
+          (operator_name)
+          (parameter_list
+            (parameter_declaration
+              (type_identifier)
+              (type_qualifier)
+              (abstract_reference_declarator))))
+        (default_method_clause))
+      (friend_declaration
+        (declaration
+          (placeholder_type_specifier (auto))
+          (init_declarator
+            (function_declarator
+              (operator_name)
+              (parameter_list
+                (parameter_declaration
+                  (type_identifier)
+                  (type_qualifier)
+                  (abstract_reference_declarator))
+                (parameter_declaration
+                  (type_identifier)
+                  (type_qualifier)
+                  (abstract_reference_declarator))))
+            (identifier)))))))
diff --git a/test/corpus/definitions.txt b/test/corpus/definitions.txt
new file mode 100644
index 0000000..a809189
--- /dev/null
+++ b/test/corpus/definitions.txt
@@ -0,0 +1,243 @@
+=====================================
+Scoped function definitions
+=====================================
+
+int T::foo() { return 1; }
+int T::foo() const { return 0; }
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list))
+    (compound_statement (return_statement (number_literal))))
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list)
+      (type_qualifier))
+    (compound_statement (return_statement (number_literal)))))
+
+=====================================
+Constructor definitions
+=====================================
+
+T::T() {}
+
+T::T() : f1(0), f2(1, 2) {
+  puts("HI");
+}
+
+T::T() : Base<T>() {}
+
+T::T() try : f1(0) {} catch(...) {}
+
+---
+
+(translation_unit
+  (function_definition
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list))
+    (compound_statement))
+  (function_definition
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list))
+    (field_initializer_list
+      (field_initializer (field_identifier) (argument_list (number_literal)))
+      (field_initializer (field_identifier) (argument_list (number_literal) (number_literal))))
+    (compound_statement
+      (expression_statement (call_expression (identifier) (argument_list (string_literal))))))
+  (function_definition
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list))
+    (field_initializer_list
+      (field_initializer
+        (template_method
+          (field_identifier)
+          (template_argument_list (type_descriptor (type_identifier))))
+        (argument_list)))
+    (compound_statement))
+  (function_definition
+    (function_declarator
+      (qualified_identifier
+        (namespace_identifier)
+        (identifier))
+      (parameter_list))
+    (try_statement
+      (field_initializer_list
+        (field_initializer
+          (field_identifier)
+          (argument_list
+            (number_literal))))
+      (compound_statement)
+      (catch_clause
+        (parameter_list)
+        (compound_statement)))))
+
+=====================================
+Explicit constructor definitions
+=====================================
+
+class C {
+  explicit C(int f) : f_(f) {}
+
+ private:
+  int f_;
+};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (field_declaration_list
+      (function_definition
+        (explicit_function_specifier)
+        (function_declarator
+          (identifier)
+          (parameter_list (parameter_declaration (primitive_type) (identifier))))
+        (field_initializer_list
+          (field_initializer (field_identifier) (argument_list (identifier))))
+        (compound_statement))
+      (access_specifier)
+        (field_declaration (primitive_type) (field_identifier)))))
+
+=====================================
+Explicit constructor declaration
+=====================================
+
+class C {
+  explicit C(int f);
+  explicit(true) C(long f);
+};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (field_declaration_list
+      (declaration
+        (explicit_function_specifier)
+        (function_declarator (identifier) (parameter_list (parameter_declaration (primitive_type) (identifier)))))
+      (declaration
+        (explicit_function_specifier (true))
+        (function_declarator (identifier) (parameter_list (parameter_declaration (sized_type_specifier) (identifier))))))))
+
+=====================================
+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;
+};
+
+---
+
+(translation_unit
+  (class_specifier
+    (type_identifier)
+    (base_class_clause (type_identifier))
+    (field_declaration_list
+      (function_definition
+        (function_declarator (identifier) (parameter_list))
+        (default_method_clause))
+      (function_definition
+        (function_declarator
+          (identifier)
+          (parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator))))
+        (delete_method_clause))
+      (function_definition
+        (primitive_type)
+        (function_declarator (field_identifier) (parameter_list)) (delete_method_clause))
+      (function_definition
+        (type_identifier)
+        (reference_declarator
+          (function_declarator
+            (operator_name)
+            (parameter_list (parameter_declaration (type_qualifier) (type_identifier) (abstract_reference_declarator)))))
+        (default_method_clause))
+      (function_definition
+        (type_identifier)
+        (reference_declarator
+          (function_declarator
+            (operator_name)
+            (parameter_list (parameter_declaration (type_identifier) (abstract_reference_declarator)))))
+        (delete_method_clause)))))
+
+=====================================
+Destructor definitions
+=====================================
+
+~T() {}
+T::~T() {}
+
+---
+
+(translation_unit
+  (function_definition
+    (function_declarator (destructor_name (identifier)) (parameter_list))
+    (compound_statement))
+  (function_definition
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (destructor_name (identifier))) (parameter_list))
+    (compound_statement)))
+
+=====================================
+Function-try-block definitions
+=====================================
+
+void foo() try {} catch(...) {}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list))
+    (try_statement
+      (compound_statement)
+      (catch_clause
+        (parameter_list)
+        (compound_statement)))))
+
+
+=====================================
+Conversion operator definitions
+=====================================
+
+T::operator int() try { throw 1; } catch (...) { return 2; }
+
+---
+
+(translation_unit
+  (function_definition
+    (qualified_identifier
+      (namespace_identifier)
+      (operator_cast
+        (primitive_type)
+        (abstract_function_declarator
+          (parameter_list))))
+    (try_statement
+      (compound_statement
+        (throw_statement
+          (number_literal)))
+      (catch_clause
+        (parameter_list)
+        (compound_statement
+          (return_statement
+            (number_literal)))))))
+
diff --git a/test/corpus/expressions.txt b/test/corpus/expressions.txt
new file mode 100644
index 0000000..ecdcbb6
--- /dev/null
+++ b/test/corpus/expressions.txt
@@ -0,0 +1,1050 @@
+================================================
+Scoped function calls
+================================================
+
+int main() {
+  abc::def("hello", "world");
+}
+
+---
+
+(translation_unit (function_definition
+  (primitive_type)
+  (function_declarator (identifier) (parameter_list))
+  (compound_statement
+    (expression_statement (call_expression
+      (qualified_identifier (namespace_identifier) (identifier))
+      (argument_list
+        (string_literal)
+        (string_literal)))))))
+
+=================================================
+Compound literals without parentheses
+=================================================
+
+T x = T{0};
+U<V> y = U<V>{0};
+
+---
+
+(translation_unit
+  (declaration
+    (type_identifier)
+    (init_declarator
+      (identifier)
+      (compound_literal_expression
+        (type_identifier)
+        (initializer_list (number_literal)))))
+  (declaration
+    (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
+    (init_declarator
+      (identifier)
+      (compound_literal_expression
+        (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
+        (initializer_list (number_literal))))))
+
+=================================================
+Explicit destructor calls
+=================================================
+
+int main() {
+  foo.~Foo();
+  bar->~Bar();
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (expression_statement (call_expression
+        (field_expression (identifier) (destructor_name (identifier)))
+        (argument_list)))
+      (expression_statement (call_expression
+        (field_expression (identifier) (destructor_name (identifier)))
+        (argument_list))))))
+
+=================================================
+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);
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (declaration
+        (placeholder_type_specifier (auto))
+        (init_declarator
+          (identifier)
+          (new_expression (type_identifier) (argument_list))))
+      (declaration
+        (placeholder_type_specifier (auto))
+        (init_declarator
+          (identifier)
+          (new_expression
+            (qualified_identifier
+              (namespace_identifier)
+              (template_type
+                (type_identifier)
+                (template_argument_list
+                  (type_descriptor (type_identifier))
+                  (type_descriptor (type_identifier)))))
+            (initializer_list))))
+      (declaration
+        (placeholder_type_specifier (auto))
+        (init_declarator
+          (identifier)
+          (new_expression
+            (argument_list (pointer_expression (identifier)))
+            (type_identifier))))
+      (declaration
+        (placeholder_type_specifier (auto))
+        (init_declarator
+          (identifier)
+          (new_expression
+            (type_identifier)
+            (new_declarator (number_literal) (new_declarator (number_literal)))
+            (argument_list))))
+      (declaration
+        (placeholder_type_specifier (auto))
+        (init_declarator
+          (identifier)
+          (new_expression (primitive_type) (new_declarator (number_literal)))))
+      (expression_statement (assignment_expression
+        (identifier)
+        (new_expression
+          (argument_list (number_literal) (identifier))
+          (type_identifier))))
+      (expression_statement (delete_expression (identifier)))
+      (expression_statement (delete_expression (identifier)))
+      (expression_statement (new_expression
+        (argument_list (call_expression (identifier) (argument_list (identifier))))
+        (type_identifier) (argument_list (this) (identifier)))))))
+
+
+====================================================
+Initializer lists as arguments
+====================================================
+
+int main() {
+  pairs.push_back({true, false});
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (expression_statement (call_expression
+        (field_expression (identifier) (field_identifier))
+        (argument_list (initializer_list (true) (false))))))))
+
+====================================================
+Lambda expressions
+====================================================
+
+auto f = [&](int x) -> bool {
+  return true;
+};
+
+auto g = [x, y](int z) {
+  return false;
+};
+
+auto h = [] {
+  return false;
+};
+
+auto i = [] <typename T> () {
+  return T();
+};
+
+auto i = [] <typename T> requires Hashable<T> {
+  return T();
+};
+
+---
+
+(translation_unit
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (lambda_expression
+        (lambda_capture_specifier (lambda_default_capture))
+        (abstract_function_declarator
+          (parameter_list (parameter_declaration (primitive_type) (identifier)))
+          (trailing_return_type (type_descriptor (primitive_type))))
+        (compound_statement (return_statement (true))))))
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (lambda_expression
+        (lambda_capture_specifier (identifier) (identifier))
+        (abstract_function_declarator
+          (parameter_list (parameter_declaration (primitive_type) (identifier))))
+        (compound_statement (return_statement (false))))))
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (lambda_expression
+        (lambda_capture_specifier)
+        (compound_statement (return_statement (false))))))
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (lambda_expression
+        (lambda_capture_specifier)
+        (template_parameter_list
+          (type_parameter_declaration
+            (type_identifier)))
+        (abstract_function_declarator
+          (parameter_list))
+        (compound_statement
+          (return_statement
+            (call_expression
+              (identifier)
+              (argument_list)))))))
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (lambda_expression
+        (lambda_capture_specifier)
+        (template_parameter_list
+          (type_parameter_declaration (type_identifier)))
+        (requires_clause
+          (template_type
+            (type_identifier)
+            (template_argument_list (type_descriptor (type_identifier)))))
+        (compound_statement
+          (return_statement
+            (call_expression (identifier) (argument_list))))))))
+
+====================================================
+Nested template calls
+====================================================
+
+class A {
+  A() : T::template Nested<int>::type() {}
+  A() : T::template Nested<int>::template Nested2<float>::type() {}
+
+  B<C::D<E, F>>::G field;
+  using B<C>::template D<int>;
+
+  H<I<J>> method() {
+    K::L<M<N>> variable1 = K::L<M<N>>{};
+    typename K::template L<M<N>>::type variable2;
+    typename K::template L<M<N>>::template O<P>::type variable3;
+  }
+
+  typename Z::template Nested<int>::type x;
+  typename X::template Nested<int>::Y::template Nested2<D> x;
+};
+
+---
+
+(translation_unit
+  (class_specifier (type_identifier) (field_declaration_list
+    (function_definition
+      (function_declarator (identifier) (parameter_list))
+      (field_initializer_list
+        (field_initializer
+          (qualified_identifier
+            (namespace_identifier)
+            (qualified_identifier
+              (dependent_name
+                (template_type
+                  (type_identifier)
+                  (template_argument_list (type_descriptor (primitive_type)))))
+              (field_identifier)))
+          (argument_list)))
+      (compound_statement))
+    (function_definition
+      (function_declarator (identifier) (parameter_list))
+      (field_initializer_list
+        (field_initializer
+          (qualified_identifier
+            (namespace_identifier)
+            (qualified_identifier
+              (dependent_name
+                (template_type
+                  (type_identifier)
+                  (template_argument_list (type_descriptor (primitive_type)))))
+              (qualified_identifier
+                (dependent_name
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list (type_descriptor (primitive_type)))))
+                (field_identifier))))
+          (argument_list)))
+      (compound_statement))
+    (field_declaration
+      (qualified_identifier
+        (template_type
+          (type_identifier)
+          (template_argument_list
+            (type_descriptor (qualified_identifier
+              (namespace_identifier)
+              (template_type
+                (type_identifier)
+                (template_argument_list
+                  (type_descriptor (type_identifier)) (type_descriptor (type_identifier))))))))
+        (type_identifier))
+      (field_identifier))
+    (using_declaration
+      (qualified_identifier
+        (template_type
+          (type_identifier)
+          (template_argument_list (type_descriptor (type_identifier))))
+        (dependent_name
+          (template_function
+            (identifier)
+            (template_argument_list (type_descriptor (primitive_type)))))))
+    (function_definition
+      (template_type
+        (type_identifier)
+        (template_argument_list (type_descriptor
+          (template_type
+            (type_identifier)
+            (template_argument_list (type_descriptor (type_identifier)))))))
+      (function_declarator (field_identifier) (parameter_list))
+      (compound_statement
+        (declaration
+          (qualified_identifier
+            (namespace_identifier)
+            (template_type
+              (type_identifier)
+              (template_argument_list (type_descriptor
+                (template_type
+                  (type_identifier)
+                  (template_argument_list (type_descriptor (type_identifier))))))))
+          (init_declarator
+            (identifier)
+            (compound_literal_expression
+              (qualified_identifier
+                (namespace_identifier)
+                (template_type
+                  (type_identifier)
+                  (template_argument_list (type_descriptor
+                    (template_type
+                      (type_identifier)
+                      (template_argument_list (type_descriptor (type_identifier))))))))
+              (initializer_list))))
+        (declaration
+          (dependent_type
+            (qualified_identifier
+              (namespace_identifier)
+              (qualified_identifier
+                (dependent_name
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list (type_descriptor (template_type (type_identifier)
+                      (template_argument_list (type_descriptor (type_identifier))))))))
+                (type_identifier))))
+          (identifier))
+        (declaration
+          (dependent_type
+            (qualified_identifier
+              (namespace_identifier)
+              (qualified_identifier
+                (dependent_name
+                  (template_type
+                    (type_identifier)
+                    (template_argument_list (type_descriptor (template_type (type_identifier)
+                      (template_argument_list (type_descriptor (type_identifier))))))))
+                (qualified_identifier
+                  (dependent_name
+                    (template_type
+                      (type_identifier)
+                      (template_argument_list (type_descriptor (type_identifier)))))
+                  (type_identifier)))))
+          (identifier))))
+    (field_declaration
+      (dependent_type
+        (qualified_identifier
+          (namespace_identifier)
+          (qualified_identifier
+            (dependent_name
+              (template_type
+                (type_identifier)
+                (template_argument_list (type_descriptor (primitive_type)))))
+            (type_identifier))))
+      (field_identifier))
+    (field_declaration
+      (dependent_type
+        (qualified_identifier
+          (namespace_identifier)
+          (qualified_identifier
+            (dependent_name
+              (template_type
+                (type_identifier)
+                (template_argument_list (type_descriptor (primitive_type)))))
+            (qualified_identifier
+              (namespace_identifier)
+              (dependent_name
+                (template_type
+                  (type_identifier)
+                  (template_argument_list (type_descriptor (type_identifier)))))))))
+      (field_identifier)))))
+
+====================================================
+Comma expressions at the start of blocks
+====================================================
+
+int main() { a(), b(); }
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (expression_statement (comma_expression
+        (call_expression (identifier) (argument_list))
+        (call_expression (identifier) (argument_list)))))))
+
+====================================================
+Nullptr
+====================================================
+
+void *x = nullptr;
+
+---
+
+(translation_unit
+  (declaration (primitive_type) (init_declarator (pointer_declarator (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";
+
+---
+
+(translation_unit
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_content))))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_delimiter)
+        (raw_string_content)
+        (raw_string_delimiter))))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_delimiter)
+        (raw_string_content)
+        (raw_string_delimiter))))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_delimiter)
+        (raw_string_content)
+        (raw_string_delimiter))))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_delimiter)
+        (raw_string_content)
+        (raw_string_delimiter))))
+  (declaration
+    (type_qualifier)
+    (primitive_type)
+    (init_declarator
+      (pointer_declarator (identifier))
+      (raw_string_literal
+        (raw_string_delimiter)
+        (raw_string_content)
+        (raw_string_delimiter)))))
+
+====================================================
+Template calls
+====================================================
+
+int main() {
+  // '<' and '>' as template argument list delimiters
+  if (a<b && c>()) {}
+
+  // '<' and '>' as binary operators
+  if (a < b && c >= d) {}
+
+  Q::template R<S>();
+  this->template f<T>();
+  foo.template f<U>();
+}
+---
+
+(translation_unit
+  (function_definition
+  (primitive_type)
+  (function_declarator (identifier) (parameter_list))
+  (compound_statement
+    (comment)
+    (if_statement
+      (condition_clause
+        (call_expression
+          (template_function
+            (identifier)
+            (template_argument_list (binary_expression (identifier) (identifier))))
+          (argument_list)))
+      (compound_statement))
+    (comment)
+    (if_statement
+      (condition_clause
+        (binary_expression
+          (binary_expression (identifier) (identifier))
+          (binary_expression (identifier) (identifier))))
+      (compound_statement))
+    (expression_statement
+      (call_expression
+        (qualified_identifier
+          (namespace_identifier)
+          (dependent_name
+            (template_function
+              (identifier)
+              (template_argument_list (type_descriptor (type_identifier))))))
+        (argument_list)))
+    (expression_statement
+      (call_expression
+        (field_expression
+          (this)
+          (dependent_name
+            (template_method
+              (field_identifier)
+              (template_argument_list (type_descriptor (type_identifier))))))
+      (argument_list)))
+    (expression_statement
+      (call_expression
+        (field_expression
+          (identifier)
+          (dependent_name
+            (template_method
+              (field_identifier)
+              (template_argument_list (type_descriptor (type_identifier))))))
+      (argument_list))))))
+
+====================================================
+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...) {}
+
+---
+
+(translation_unit
+  (declaration
+    type: (template_type
+      name: (type_identifier)
+      arguments: (template_argument_list
+        (type_descriptor
+          type: (type_identifier))
+        (type_descriptor
+          type: (type_identifier))
+        (parameter_pack_expansion
+          pattern: (type_descriptor
+            type: (type_identifier)))))
+    declarator: (identifier))
+  (declaration
+    type: (template_type
+      name: (type_identifier)
+      arguments: (template_argument_list
+        (parameter_pack_expansion
+          pattern: (type_descriptor
+            type: (type_identifier)))
+        (type_descriptor
+          type: (type_identifier))
+        (type_descriptor
+          type: (type_identifier))))
+    declarator: (identifier))
+  (type_definition
+    type: (template_type
+      name: (type_identifier)
+      arguments: (template_argument_list
+        (parameter_pack_expansion
+          pattern: (type_descriptor
+            type: (template_type
+              name: (type_identifier)
+              arguments: (template_argument_list
+                (type_descriptor
+                  type: (type_identifier))
+                (type_descriptor
+                  type: (type_identifier))))))))
+    declarator: (type_identifier))
+  (expression_statement
+    (call_expression
+      function: (identifier)
+      arguments: (argument_list
+        (parameter_pack_expansion
+          pattern: (pointer_expression
+            argument: (identifier))))))
+  (comment)
+  (expression_statement
+    (call_expression
+      function: (identifier)
+      arguments: (argument_list
+        (identifier)
+        (parameter_pack_expansion
+          pattern: (update_expression
+            argument: (identifier))))))
+  (comment)
+  (expression_statement
+    (call_expression
+      function: (identifier)
+      arguments: (argument_list
+        (parameter_pack_expansion
+          pattern: (update_expression
+            argument: (identifier)))
+        (identifier))))
+  (comment)
+  (expression_statement
+    (call_expression
+      function: (identifier)
+      arguments: (argument_list
+        (parameter_pack_expansion
+          pattern: (call_expression
+            function: (template_function
+              name: (identifier)
+              arguments: (template_argument_list
+                (type_descriptor
+                  (type_qualifier)
+                  type: (type_identifier)
+                  declarator: (abstract_pointer_declarator))))
+            arguments: (argument_list
+              (pointer_expression argument: (identifier))))))))
+  (comment)
+  (expression_statement
+    (call_expression
+      function: (identifier)
+      arguments: (argument_list
+        (parameter_pack_expansion
+          pattern: (binary_expression
+            left: (call_expression
+              function: (identifier)
+              arguments: (argument_list
+                (parameter_pack_expansion pattern: (identifier))))
+            right: (identifier))))))
+  (comment)
+  (declaration
+    (type_qualifier)
+    type: (primitive_type)
+    declarator: (init_declarator
+      declarator: (identifier)
+      value: (binary_expression
+          left: (sizeof_expression value: (identifier))
+          right: (number_literal))))
+  (declaration
+    type: (primitive_type)
+    declarator: (init_declarator
+      declarator: (array_declarator
+        declarator: (identifier)
+        size: (identifier))
+      value: (initializer_list
+        (number_literal)
+        (parameter_pack_expansion pattern: (identifier))
+        (number_literal))))
+  (declaration
+    type: (primitive_type)
+    declarator: (init_declarator
+      declarator: (array_declarator
+        declarator: (identifier)
+        size: (sizeof_expression value: (identifier)))
+      value: (initializer_list
+        (parameter_pack_expansion
+          pattern: (parenthesized_expression
+            (comma_expression
+              left: (binary_expression
+                left: (qualified_identifier
+                  scope: (namespace_identifier)
+                  name: (identifier))
+                right: (identifier))
+              right: (number_literal)))))))
+  (declaration
+    type: (placeholder_type_specifier (auto))
+    declarator: (init_declarator
+      declarator: (identifier)
+      value: (lambda_expression
+        captures: (lambda_capture_specifier
+          (lambda_default_capture)
+          (parameter_pack_expansion pattern: (identifier)))
+        body: (compound_statement
+          (return_statement
+            (call_expression
+              function: (identifier)
+              arguments: (argument_list
+                (parameter_pack_expansion pattern: (identifier)))))))))
+  (class_specifier
+    name: (type_identifier)
+    (base_class_clause
+      (type_identifier))
+    body: (field_declaration_list
+      (access_specifier)
+      (function_definition
+        declarator: (function_declarator
+          declarator: (identifier)
+          parameters: (parameter_list
+            (variadic_parameter_declaration
+              (type_qualifier)
+              type: (type_identifier)
+              declarator: (reference_declarator
+                (variadic_declarator (identifier))))))
+        (field_initializer_list
+          (field_initializer
+            (field_identifier)
+            (argument_list (identifier))))
+        body: (compound_statement))))
+  (template_declaration
+    parameters: (template_parameter_list (variadic_type_parameter_declaration (type_identifier)))
+    (function_definition
+      type: (primitive_type)
+      declarator: (function_declarator
+        declarator: (identifier)
+        parameters: (parameter_list
+          (variadic_parameter_declaration
+            type: (type_identifier)
+            declarator: (reference_declarator (variadic_declarator (identifier))))))
+      body: (compound_statement
+        (expression_statement
+          (call_expression
+            function: (identifier)
+            arguments: (argument_list
+              (parameter_pack_expansion
+                pattern: (call_expression
+                  function: (template_function
+                    name: (identifier)
+                    arguments: (template_argument_list
+                      (type_descriptor type: (type_identifier))))
+                  arguments: (argument_list (identifier))))))))))
+  (function_definition
+      type: (primitive_type)
+      declarator: (function_declarator
+        declarator: (identifier)
+        parameters: (parameter_list
+          (variadic_parameter_declaration
+            type: (type_identifier)
+            declarator: (variadic_declarator))))
+      body: (compound_statement)))
+
+============================================
+Concatenated string literals
+============================================
+
+"a" "b" "c";
+R"(a)" R"(b)" R"(c)";
+"a" R"(b)" L"c" R"FOO(d)FOO";
+---
+
+(translation_unit
+  (expression_statement (concatenated_string (string_literal) (string_literal) (string_literal)))
+  (expression_statement (concatenated_string (raw_string_literal (raw_string_content)) (raw_string_literal (raw_string_content)) (raw_string_literal (raw_string_content))))
+  (expression_statement (concatenated_string (string_literal) (raw_string_literal (raw_string_content)) (string_literal) (raw_string_literal (raw_string_delimiter) (raw_string_content) (raw_string_delimiter)))))
+
+============================================
+User-defined literals
+============================================
+
+1.2_km;
+"foo" "bar"_baz;
+---
+
+(translation_unit
+  (expression_statement
+    (user_defined_literal
+	  (number_literal)
+	  (literal_suffix)))
+  (expression_statement
+    (user_defined_literal
+      (concatenated_string (string_literal) (string_literal))
+	  (literal_suffix))))
+
+====================================================
+Primitive types ctor
+====================================================
+
+x = int(1);
+x = new int(1);
+x = (int(1) + float(2));
+
+---
+
+(translation_unit
+  (expression_statement
+    (assignment_expression
+      (identifier)
+      (call_expression (primitive_type) (argument_list (number_literal)))))
+  (expression_statement
+    (assignment_expression
+      (identifier)
+      (new_expression (primitive_type) (argument_list (number_literal)))))
+  (expression_statement
+    (assignment_expression
+      (identifier)
+      (parenthesized_expression
+        (binary_expression
+          (call_expression (primitive_type) (argument_list (number_literal)))
+          (call_expression (primitive_type) (argument_list (number_literal))))))))
+
+============================================
+Array assignment expression
+============================================
+
+array_[i] = s[i];
+array_[{i}] = s[{1,2,3}];
+
+---
+(translation_unit
+  (expression_statement
+    (assignment_expression
+      (subscript_expression
+        (identifier)
+        (identifier))
+      (subscript_expression
+        (identifier)
+        (identifier))))
+  (expression_statement
+    (assignment_expression
+      (subscript_expression
+        (identifier)
+        (initializer_list
+          (identifier)))
+      (subscript_expression
+        (identifier)
+        (initializer_list
+          (number_literal)
+          (number_literal)
+          (number_literal))))))
+
+============================================
+Coroutines
+============================================
+
+co_await fn() || co_await var;
+
+---
+
+(translation_unit
+  (expression_statement
+    (binary_expression
+      (co_await_expression
+        (call_expression
+          (identifier)
+            (argument_list)))
+      (co_await_expression
+        (identifier)))))
+
+============================================
+Three-way comparison
+============================================
+
+auto x = a <=> b;
+
+bool y = 0 > a <=> b;
+
+---
+
+(translation_unit
+  (declaration
+    (placeholder_type_specifier (auto))
+    (init_declarator
+      (identifier)
+      (binary_expression
+        (identifier)
+        (identifier))))
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (binary_expression
+        (number_literal)
+        (binary_expression
+          (identifier)
+          (identifier))))))
+
+============================================
+Fold Expressions
+============================================
+
+bool t  = (... + IndexOf<T>);
+bool t2 = (IndexOf<T> + ...);
+bool t3 = (1 + ... + IndexOf<T>);
+bool t3 = (IndexOf<T> + ... + 1);
+
+---
+
+(translation_unit
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (fold_expression
+        (template_function
+          (identifier)
+          (template_argument_list
+            (type_descriptor
+              (type_identifier)))))))
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (fold_expression
+        (template_function
+          (identifier)
+          (template_argument_list
+            (type_descriptor
+              (type_identifier)))))))
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (fold_expression
+        (number_literal)
+        (template_function
+          (identifier)
+          (template_argument_list
+            (type_descriptor
+              (type_identifier)))))))
+  (declaration
+    (primitive_type)
+    (init_declarator
+      (identifier)
+      (fold_expression
+        (template_function
+          (identifier)
+          (template_argument_list
+            (type_descriptor
+              (type_identifier))))
+        (number_literal)))))
+
+================================================
+Alternative tokens (digraphs)
+=================================================
+
+if (not marked and (x < left or right < x)) {}
+
+operator not_eq(int) { return true; }
+
+foo and_eq bar();
+
+---
+
+(translation_unit
+  (if_statement
+    (condition_clause
+      (binary_expression
+        (unary_expression
+          (identifier))
+        (parenthesized_expression
+          (binary_expression
+            (binary_expression
+              (identifier)
+              (identifier))
+            (binary_expression
+              (identifier)
+              (identifier))))))
+    (compound_statement))
+  (function_definition
+    (function_declarator
+      (operator_name)
+      (parameter_list
+        (parameter_declaration
+          (primitive_type))))
+    (compound_statement
+      (return_statement
+        (true))))
+  (expression_statement
+    (assignment_expression
+      (identifier)
+      (call_expression
+        (identifier)
+        (argument_list)))))
diff --git a/test/corpus/microsoft.txt b/test/corpus/microsoft.txt
new file mode 100644
index 0000000..7698f41
--- /dev/null
+++ b/test/corpus/microsoft.txt
@@ -0,0 +1,32 @@
+================================
+declaration specs
+================================
+
+struct __declspec(dllexport) s2
+{
+};
+
+union __declspec(noinline) u2 {
+};
+
+class __declspec(uuid) u2 {
+};
+
+---
+
+(translation_unit
+  (struct_specifier
+    (ms_declspec_modifier
+      (identifier))
+    name: (type_identifier)
+    body: (field_declaration_list))
+  (union_specifier
+    (ms_declspec_modifier
+      (identifier))
+    name: (type_identifier)
+    body: (field_declaration_list))
+  (class_specifier
+    (ms_declspec_modifier
+      (identifier))
+    name: (type_identifier)
+    body: (field_declaration_list)))
diff --git a/test/corpus/statements.txt b/test/corpus/statements.txt
new file mode 100644
index 0000000..a0012b8
--- /dev/null
+++ b/test/corpus/statements.txt
@@ -0,0 +1,433 @@
+===========================================
+Returning braced initializer lists
+===========================================
+
+T main() {
+  return {0, 5};
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (type_identifier)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (return_statement (initializer_list (number_literal) (number_literal))))))
+
+===========================================
+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;
+  }
+
+  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 << ' ';
+  }
+}
+
+---
+
+(translation_unit
+  (function_definition
+    type: (type_identifier)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement
+      (for_range_loop
+        type: (type_identifier)
+        declarator: (reference_declarator (identifier))
+        right: (identifier)
+        body: (compound_statement
+          (expression_statement (binary_expression
+            left: (identifier)
+            right: (identifier)))))
+      (for_range_loop
+        (type_qualifier)
+        type: (placeholder_type_specifier (auto))
+        declarator: (reference_declarator (identifier))
+        right: (identifier)
+        body: (compound_statement
+          (expression_statement (binary_expression
+            left: (identifier)
+            right: (identifier)))))
+      (for_range_loop
+        (type_qualifier)
+        type: (placeholder_type_specifier (auto))
+        declarator: (reference_declarator (identifier))
+        right: (initializer_list (number_literal) (number_literal) (number_literal))
+        body: (compound_statement
+          (expression_statement (binary_expression
+            left: (identifier)
+            right: (identifier)))))
+      (for_range_loop
+        initializer: (init_statement
+          (declaration
+            type: (placeholder_type_specifier (auto))
+            declarator: (init_declarator
+              declarator: (identifier)
+              value: (call_expression
+                function: (field_expression
+                  argument: (identifier)
+                  field: (field_identifier))
+                arguments: (argument_list)))))
+        type: (placeholder_type_specifier (auto))
+        declarator: (identifier)
+        right: (identifier)
+        body: (compound_statement
+          (expression_statement
+            (binary_expression
+              left: (binary_expression
+                left: (identifier)
+                right: (binary_expression
+                  left: (update_expression
+                    argument: (identifier))
+                  right: (identifier)))
+              right: (char_literal)))))
+      (for_range_loop
+        initializer: (init_statement
+          (alias_declaration
+            name: (type_identifier)
+            type: (type_descriptor
+              type: (qualified_identifier
+                scope: (namespace_identifier)
+                name: (type_identifier)))))
+        type: (type_identifier)
+        declarator: (identifier)
+        right: (identifier)
+        body: (compound_statement
+          (expression_statement
+            (binary_expression
+              left: (binary_expression
+                left: (identifier)
+                right: (binary_expression
+                  left: (update_expression
+                    argument: (identifier))
+                  right: (identifier)))
+              right: (char_literal))))))))
+
+===========================================
+Constexpr if statements
+===========================================
+
+T f() {
+  if constexpr (std::is_pointer_v<T>)
+    return *t;
+  else
+    return t;
+}
+
+---
+
+(translation_unit
+  (function_definition
+    type: (type_identifier)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement
+      (if_statement
+        condition: (condition_clause
+          value: (qualified_identifier
+            scope: (namespace_identifier)
+            name: (template_function
+              name: (identifier)
+              arguments: (template_argument_list
+                (type_descriptor type: (type_identifier))))))
+        consequence: (return_statement
+          (pointer_expression argument: (identifier)))
+        alternative: (return_statement (identifier))))))
+
+=====================================
+If statements with declarations
+====================================
+
+void f() {
+  if (const int x = foo()) { }
+  if (const int x { foo() }) { }
+  if (const int x = foo(); x != 0) { }
+}
+
+---
+
+(translation_unit
+  (function_definition
+    type: (primitive_type)
+    declarator: (function_declarator
+      declarator: (identifier)
+      parameters: (parameter_list))
+    body: (compound_statement
+      (if_statement
+        condition: (condition_clause
+          value: (declaration
+            (type_qualifier)
+            type: (primitive_type)
+            declarator: (identifier)
+            value: (call_expression
+              function: (identifier)
+              arguments: (argument_list))))
+        consequence: (compound_statement))
+      (if_statement
+        condition: (condition_clause
+          value: (declaration
+            (type_qualifier)
+            type: (primitive_type)
+            declarator: (identifier)
+          value: (initializer_list (call_expression function: (identifier) arguments: (argument_list)))))
+        consequence: (compound_statement))
+      (if_statement
+        condition: (condition_clause
+          initializer: (init_statement
+            (declaration
+              (type_qualifier)
+              type: (primitive_type)
+              declarator: (init_declarator
+                declarator: (identifier)
+                value: (call_expression function: (identifier) arguments: (argument_list)))))
+          value: (binary_expression left: (identifier) right: (number_literal)))
+        consequence: (compound_statement)))))
+
+===========================================
+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
+  }
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (try_statement
+        (compound_statement
+          (expression_statement (call_expression (identifier) (argument_list))))
+        (catch_clause
+          (parameter_list (parameter_declaration (type_qualifier) (qualified_identifier (namespace_identifier) (type_identifier))))
+          (compound_statement (comment)))
+        (catch_clause
+          (parameter_list (parameter_declaration (type_qualifier) (type_identifier) (reference_declarator (identifier))))
+          (compound_statement (comment)))
+        (catch_clause
+          (parameter_list)
+          (compound_statement (comment)))))))
+
+===========================================
+Throw statements
+===========================================
+
+void main() {
+     throw e;
+     throw x + 1;
+     throw "exception";
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator
+      (identifier)
+      (parameter_list))
+      (compound_statement
+        (throw_statement (identifier))
+        (throw_statement (binary_expression (identifier) (number_literal)))
+        (throw_statement (string_literal)))))
+
+===========================================
+Noexcept specifier
+===========================================
+
+void foo() noexcept;
+void foo() noexcept(true);
+template<class T> T foo() noexcept(sizeof(T) < 4);
+
+---
+
+(translation_unit
+  (declaration
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)
+      (noexcept)))
+  (declaration
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)
+      (noexcept (true))))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)))
+    (declaration
+      (type_identifier)
+      (function_declarator (identifier) (parameter_list)
+        (noexcept
+          (binary_expression (sizeof_expression (parenthesized_expression (identifier))) (number_literal)))))))
+
+===========================================
+Throw specifier
+===========================================
+
+void foo() throw();
+void foo() throw(int);
+void foo() throw(std::string, char *);
+void foo() throw(float) { }
+
+---
+
+(translation_unit
+  (declaration
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)
+      (throw_specifier)))
+  (declaration
+  (primitive_type)
+  (function_declarator (identifier) (parameter_list)
+    (throw_specifier (type_descriptor (primitive_type)))))
+  (declaration
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)
+      (throw_specifier
+        (type_descriptor (qualified_identifier (namespace_identifier) (type_identifier)))
+        (type_descriptor (primitive_type) (abstract_pointer_declarator)))))
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list)
+      (throw_specifier (type_descriptor (primitive_type))))
+      (compound_statement)))
+
+===========================================
+Assignment
+===========================================
+
+a::b::c = 1;
+
+---
+
+(translation_unit
+  (expression_statement
+    (assignment_expression
+      (qualified_identifier
+        (namespace_identifier)
+        (qualified_identifier
+          (namespace_identifier)
+          (identifier)))
+      (number_literal))))
+
+=========================================
+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;
+}
+
+---
+
+(translation_unit
+  (function_definition (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (attributed_statement (attribute_declaration (attribute (identifier)))
+        (switch_statement
+          (condition_clause (identifier))
+          (compound_statement
+            (attributed_statement (attribute_declaration (attribute (identifier)))
+              (case_statement (number_literal) (compound_statement))))))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (while_statement (condition_clause (true)) (compound_statement)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (if_statement (condition_clause (true)) (compound_statement)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (for_range_loop (placeholder_type_specifier (auto)) (identifier) (identifier) (compound_statement)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (for_statement (compound_statement)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (return_statement))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (expression_statement (identifier)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (expression_statement))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (labeled_statement (statement_identifier) (compound_statement)))
+      (attributed_statement (attribute_declaration (attribute (identifier))) (goto_statement (statement_identifier))))))
+
+===========================================
+Coroutines
+===========================================
+
+co_return 1;
+co_return;
+co_yield 1;
+
+---
+
+(translation_unit
+  (co_return_statement
+    (number_literal))
+  (co_return_statement)
+  (co_yield_statement
+    (number_literal)))
+
+
+===========================================
+Switch statements
+===========================================
+
+void foo(int a) {
+  switch (a) {
+    case 1:
+      for (auto i : vec) {}
+    case 2:
+      try {
+        // do something
+      } catch(...) {}
+      throw 1;
+    case 3:
+      co_return;
+    default:
+      co_yield a;
+  }
+}
+
+---
+
+(translation_unit
+  (function_definition (primitive_type)
+    (function_declarator (identifier) (parameter_list (parameter_declaration (primitive_type) (identifier))))
+    (compound_statement
+      (switch_statement (condition_clause (identifier))
+        (compound_statement
+          (case_statement (number_literal) (for_range_loop (placeholder_type_specifier (auto)) (identifier) (identifier) (compound_statement)))
+          (case_statement (number_literal) (try_statement (compound_statement (comment)) (catch_clause (parameter_list) (compound_statement))) (throw_statement (number_literal)))
+          (case_statement (number_literal) (co_return_statement))
+          (case_statement (co_yield_statement (identifier))))))))
diff --git a/test/corpus/types.txt b/test/corpus/types.txt
new file mode 100644
index 0000000..4e53b28
--- /dev/null
+++ b/test/corpus/types.txt
@@ -0,0 +1,177 @@
+==========================================
+The auto type
+==========================================
+
+void foo() {
+  auto x = 1;
+}
+
+---
+
+(translation_unit
+  (function_definition
+    (primitive_type)
+    (function_declarator (identifier) (parameter_list))
+    (compound_statement
+      (declaration (placeholder_type_specifier (auto)) (init_declarator (identifier) (number_literal))))))
+
+==========================================
+Namespaced types
+==========================================
+
+std::string my_string;
+std::vector<int>::size_typ my_string;
+
+---
+
+(translation_unit
+  (declaration
+    (qualified_identifier (namespace_identifier) (type_identifier))
+    (identifier))
+  (declaration
+    (qualified_identifier
+      (namespace_identifier)
+      (qualified_identifier
+        (template_type
+          (type_identifier)
+          (template_argument_list (type_descriptor (primitive_type))))
+        (type_identifier)))
+    (identifier)))
+
+==========================================
+Dependent type names
+==========================================
+
+template<typename T>
+struct X : B<T>
+{
+    typename T::A* pa;
+};
+
+---
+
+(translation_unit
+  (template_declaration
+    (template_parameter_list (type_parameter_declaration (type_identifier)))
+    (struct_specifier
+      (type_identifier)
+      (base_class_clause
+        (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier)))))
+      (field_declaration_list
+        (field_declaration
+          (dependent_type (qualified_identifier (namespace_identifier) (type_identifier)))
+          (pointer_declarator (field_identifier)))))))
+
+==========================================
+Template types with empty argument lists
+==========================================
+
+use_future_t<> use_future;
+
+---
+
+(translation_unit
+  (declaration (template_type (type_identifier) (template_argument_list)) (identifier)))
+
+================================
+Function types as template arguments
+================================
+
+typedef std::function<T(int)> MyFunc;
+typedef std::function<void(int)> b;
+
+---
+
+(translation_unit
+  (type_definition
+    (qualified_identifier
+      (namespace_identifier)
+      (template_type
+        (type_identifier)
+        (template_argument_list
+          (type_descriptor
+            (type_identifier)
+            (abstract_function_declarator (parameter_list
+              (parameter_declaration (primitive_type))))))))
+    (type_identifier))
+  (type_definition
+    (qualified_identifier
+      (namespace_identifier)
+      (template_type
+        (type_identifier)
+        (template_argument_list
+          (type_descriptor
+            (primitive_type)
+            (abstract_function_declarator (parameter_list
+              (parameter_declaration (primitive_type))))))))
+    (type_identifier)))
+
+====================================================
+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);
+
+---
+
+(translation_unit
+  (declaration
+    (decltype (identifier))
+    (identifier))
+  (declaration
+    (decltype (identifier))
+    (function_declarator (identifier)
+      (parameter_list
+        (parameter_declaration (primitive_type) (identifier))
+        (parameter_declaration (decltype (identifier)) (identifier)))))
+  (template_declaration
+    (template_parameter_list
+      (type_parameter_declaration (type_identifier)) (type_parameter_declaration (type_identifier)))
+    (declaration
+      (placeholder_type_specifier (auto))
+      (function_declarator
+        (identifier)
+        (parameter_list
+          (parameter_declaration (type_identifier) (identifier))
+          (parameter_declaration (type_identifier) (identifier)))
+        (trailing_return_type
+          (type_descriptor
+            (decltype (binary_expression (identifier) (identifier)))))))))
+
+====================================================
+Trailing return type
+====================================================
+
+auto a::foo() const -> const A<B>& {}
+auto b::foo() const -> A<B> const& {}
+
+---
+
+(translation_unit
+  (function_definition
+    (placeholder_type_specifier (auto))
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list)
+      (type_qualifier)
+      (trailing_return_type
+        (type_descriptor
+          (type_qualifier)
+          (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
+          (abstract_reference_declarator))))
+      (compound_statement))
+  (function_definition
+    (placeholder_type_specifier (auto))
+    (function_declarator
+      (qualified_identifier (namespace_identifier) (identifier))
+      (parameter_list)
+      (type_qualifier)
+      (trailing_return_type
+        (type_descriptor
+          (template_type (type_identifier) (template_argument_list (type_descriptor (type_identifier))))
+          (type_qualifier)
+          (abstract_reference_declarator))))
+    (compound_statement))
+)