[pseudo] Placeholder disambiguation strategy: always choose second

[sammccall]

Summary

Mostly mechanics here. Interesting decisions:

• apply disambiguation in-place instead of copying the forest debatable, but even the final tree size is significant
• split decide/apply into different functions - this allows the hard part (decide) to be tested non-destructively and combined with HTML forest easily
• add non-const accessors to forest to enable apply
• unit tests but no lit tests: my plan is to test actual C++ disambiguation heuristics with lit, generic disambiguation mechanics without the C++ grammar

[hokein]

This looks a good start!

clang-tools-extra/pseudo/tool/ClangPseudo.cpp

232

nit: we're going to print the forest *and* the disambiguated tree, is that intended? IMO, if we specify the disambiguate flag, I'd not print the forest as well.

clang-tools-extra/pseudo/unittests/DisambiguateTest.cpp

29

nit: it seems like we write a lot of boilerplate code just for creating a Forest for a single a*b; case below, it is fine currently, but if we're going to add some more unittests , we might want an automate way to do that.

[sammccall]

clang-tools-extra/pseudo/tool/ClangPseudo.cpp

232

I guess you're right. My use case was debugging disambiguation with -print-forest -disambiguate -debug=only=Disambiguate.cpp - I think we need the before + after + log.

However we can log the "before" with LLVM_DEBUG() inside disambiguate() instead.

clang-tools-extra/pseudo/unittests/DisambiguateTest.cpp

29

Hmm, maybe. It's not obvious to me that you can do much better (other approaches have tradeoffs, e.g. I think having all the nodes/rules/symbols as named variables is clearer than what we've done in some other places, and I think depending on the C++ grammar would confuse things).

clang-tools-extra/pseudo/include/clang-pseudo/Disambiguate.h

+//===--- Disambiguate.h - Find the best tree in the forest -------*- C++-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// A GLR parse forest represents every possible parse tree for the source code.
+//
+// Before we can do useful analysis/editing of the code, we need to pick a
+// single tree which we think is accurate. We use three main types of clues:
+//
+// A) Semantic language rules may restrict which parses are allowed.
+//    For example, `string string string X` is *grammatical* C++, but only a
+//    single type-name is allowed in a decl-specifier-sequence.
+//    Where possible, these interpretations are forbidden by guards.
+//    Sometimes this isn't possible, or we want our parser to be lenient.
+//
+// B) Some constructs are rarer, while others are common.
+//    For example `a<b>::c` is often a template specialization, and rarely a
+//    double comparison between a, b, and c.
+//
+// C) Identifier text hints whether they name types/values/templates etc.
+//    "std" is usually a namespace, a project index may also guide us.
+//    Hints may be within the document: if one occurrence of 'foo' is a variable
+//    then the others probably are too.
+//    (Text need not match: similar CaseStyle can be a weak hint, too).
+//
+//----------------------------------------------------------------------------//
+//
+// Mechanically, we replace each ambiguous node with its best alternative.
+//
+// "Best" is determined by assigning bonuses/penalties to nodes, to express
+// the clues of type A and B above. A forest node representing an unlikely
+// parse would apply a penalty to every subtree is is present in.
+// Disambiguation proceeds bottom-up, so that the score of each alternative
+// is known when a decision is made.
+//
+// Identifier-based hints within the document mean some nodes should be
+// *correlated*. Rather than resolve these simultaneously, we make the most
+// certain decisions first and use these results to update bonuses elsewhere.
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-pseudo/Forest.h"
+
+namespace clang::pseudo {
+
+struct DisambiguateParams {};
+
+// Maps ambiguous nodes onto the index of their preferred alternative.
+using Disambiguation = llvm::DenseMap<const ForestNode *, unsigned>;
+
+// Resolve each ambiguous node in the forest.
+// Maps each ambiguous node to the index of the chosen alternative.
+// FIXME: current implementation is a placeholder and chooses arbitrarily.
+Disambiguation disambiguate(const ForestNode *Root,
+                            const DisambiguateParams &Params);
+
+// Remove all ambiguities from the forest, resolving them according to Disambig.
+void removeAmbiguities(ForestNode *&Root, const Disambiguation &Disambig);
+
+} // namespace clang::pseudo

clang-tools-extra/pseudo/include/clang-pseudo/Forest.h

RuleID rule() const {
     return Data & ((1 << RuleBits) - 1);
   }
   // Returns the parses of each element on the RHS of the rule.
   // REQUIRES: this is a Sequence node;
   llvm::ArrayRef<const ForestNode *> elements() const {
     assert(kind() == Sequence);
     return children(Data >> RuleBits);
   }
+  llvm::MutableArrayRef<ForestNode *> elements() {
+    assert(kind() == Sequence);
+    return children(Data >> RuleBits);
+  }
 
   // Returns all possible interpretations of the code.
   // REQUIRES: this is an Ambiguous node.
   llvm::ArrayRef<const ForestNode *> alternatives() const {
     assert(kind() == Ambiguous);
     return children(Data);
   }
+  llvm::MutableArrayRef<ForestNode *> alternatives() {
+    assert(kind() == Ambiguous);
+    return children(Data);
+  }
 
   llvm::ArrayRef<const ForestNode *> children() const {
     switch (kind()) {
     case Sequence:
       return elements();
     case Ambiguous:
       return alternatives();
     case Terminal:
ambiguousData(llvm::ArrayRef<const ForestNode *> Alternatives) {
     return Alternatives.size();
   }
 
   // Retrieves the trailing array.
   llvm::ArrayRef<const ForestNode *> children(uint16_t Num) const {
     return llvm::makeArrayRef(reinterpret_cast<ForestNode *const *>(this + 1),
                               Num);
   }
+  llvm::MutableArrayRef<ForestNode *> children(uint16_t Num) {
+    return llvm::makeMutableArrayRef(reinterpret_cast<ForestNode **>(this + 1),
+                                     Num);
+  }
 
   Token::Index StartIndex;
   Kind K : 4;
   SymbolID Symbol : SymbolBits;
   // Sequence - child count : 4 | RuleID : RuleBits (12)
   // Ambiguous - child count : 16
   // Terminal, Opaque - unused
   uint16_t Data;

clang-tools-extra/pseudo/include/clang-pseudo/GLR.h

 };
 
 // Parses the given token stream as the start symbol with the GLR algorithm,
 // and returns a forest node of the start symbol.
 //
 // A rule `_ := StartSymbol` must exit for the chosen start symbol.
 //
 // If the parsing fails, we model it as an opaque node in the forest.
-const ForestNode &glrParse(const ParseParams &Params, SymbolID StartSymbol,
-                           const Language &Lang);
+ForestNode &glrParse(const ParseParams &Params, SymbolID StartSymbol,
 
 // Shift a token onto all OldHeads, placing the results into NewHeads.
 //
 // Exposed for testing only.
 void glrShift(llvm::ArrayRef<const GSS::Node *> OldHeads,
               const ForestNode &NextTok, const ParseParams &Params,
               const Language &Lang, std::vector<const GSS::Node *> &NewHeads);
 // Applies available reductions on Heads, appending resulting heads to the list.

clang-tools-extra/pseudo/lib/CMakeLists.txt

 add_subdirectory(cli)
 add_subdirectory(cxx)
 add_subdirectory(grammar)
 
 set(LLVM_LINK_COMPONENTS Support)
 
 add_clang_library(clangPseudo
   Bracket.cpp
   DirectiveTree.cpp
+  Disambiguate.cpp
   Forest.cpp
   GLR.cpp
   Lex.cpp
   Token.cpp
 
   LINK_LIBS
   clangBasic
   clangLex
   clangPseudoGrammar
   )
 
   target_include_directories(clangPseudo INTERFACE
   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../include>
   )

clang-tools-extra/pseudo/lib/Disambiguate.cpp

+//===--- Disambiguate.cpp - Find the best tree in the forest --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-pseudo/Disambiguate.h"
+
+namespace clang::pseudo {
+
+Disambiguation disambiguate(const ForestNode *Root,
+                            const DisambiguateParams &Params) {
+  // FIXME: this is a dummy placeholder strategy, implement a real one!
+  Disambiguation Result;
+  for (const ForestNode &N : Root->descendants()) {
+    if (N.kind() == ForestNode::Ambiguous)
+      Result.try_emplace(&N, 1);
+  }
+  return Result;
+}
+
+void removeAmbiguities(ForestNode *&Root, const Disambiguation &D) {
+  std::vector<ForestNode **> Queue = {&Root};
+  while (!Queue.empty()) {
+    ForestNode **Next = Queue.back();
+    Queue.pop_back();
+    switch ((*Next)->kind()) {
+    case ForestNode::Sequence:
+      for (ForestNode *&Child : (*Next)->elements())
+        Queue.push_back(&Child);
+      break;
+    case ForestNode::Ambiguous: {
+      assert(D.count(*Next) != 0 && "disambiguation is incomplete!");
+      ForestNode *ChosenChild = (*Next)->alternatives()[D.lookup(*Next)];
+      *Next = ChosenChild;
+      Queue.push_back(Next);
+      break;
+    }
+    case ForestNode::Terminal:
+    case ForestNode::Opaque:
+      break;
+    }
+  }
+}
+
+} // namespace clang::pseudo

clang-tools-extra/pseudo/lib/GLR.cpp

LLVM_DEBUG(llvm::dbgs()
                << "  Reduce (trivial) " << Lang.G.dumpRule(*RID) << "\n"
                << "    --> S" << Heads->back()->State << "\n");
     return true;
   }
 };
 
 } // namespace
 
-const ForestNode &glrParse(const ParseParams &Params, SymbolID StartSymbol,
-                           const Language &Lang) {
+ForestNode &glrParse(const ParseParams &Params, SymbolID StartSymbol,
   GLRReduce Reduce(Params, Lang);
   assert(isNonterminal(StartSymbol) && "Start symbol must be a nonterminal");
   llvm::ArrayRef<ForestNode> Terminals = Params.Forest.createTerminals(Params.Code);
   auto &GSS = Params.GSStack;
 
   StateID StartState = Lang.Table.getStartState(StartSymbol);
   // Heads correspond to the parse of tokens [0, I), NextHeads to [0, I+1).
   std::vector<const GSS::Node *> Heads = {GSS.addNode(/*State=*/StartState,
for (const auto *Head : Heads) {
         assert(Result == nullptr && "multiple results!");
         Result = Head->parents().front()->Payload;
         assert(Result->symbol() == StartSymbol);
       }
     }
     return Result;
   };
   if (auto *Result = SearchForAccept(Heads))
-    return *Result;
+    return *const_cast<ForestNode *>(Result); // Safe: we created all nodes.
   // We failed to parse the input, returning an opaque forest node for recovery.
   // FIXME: as above, we can add fallback error handling so this is impossible.
   return Params.Forest.createOpaque(StartSymbol, /*Token::Index=*/0);
 }
 
 void glrReduce(std::vector<const GSS::Node *> &Heads, SymbolID Lookahead,
                const ParseParams &Params, const Language &Lang) {
   // Create a new GLRReduce each time for tests, performance doesn't matter.

clang-tools-extra/pseudo/tool/ClangPseudo.cpp

 //===-- ClangPseudo.cpp - Clang pseudoparser tool -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-pseudo/Bracket.h"
 #include "clang-pseudo/DirectiveTree.h"
+#include "clang-pseudo/Disambiguate.h"
 #include "clang-pseudo/Forest.h"
 #include "clang-pseudo/GLR.h"
 #include "clang-pseudo/Language.h"
 #include "clang-pseudo/Token.h"
 #include "clang-pseudo/cli/CLI.h"
 #include "clang-pseudo/grammar/Grammar.h"
 #include "clang-pseudo/grammar/LRGraph.h"
 #include "clang-pseudo/grammar/LRTable.h"

 static opt<bool> PrintSource("print-source", desc("Print token stream"));
 static opt<bool> PrintTokens("print-tokens", desc("Print detailed token info"));
 static opt<bool>
     PrintDirectiveTree("print-directive-tree",
                       desc("Print directive structure of source code"));
 static opt<bool>
     StripDirectives("strip-directives",
                     desc("Strip directives and select conditional sections"));
+static opt<bool> Disambiguate("disambiguate",
+                              desc("Choose best tree from parse forest"));
 static opt<bool> PrintStatistics("print-statistics", desc("Print GLR parser statistics"));
 static opt<bool> PrintForest("print-forest", desc("Print parse forest"));
 static opt<bool> ForestAbbrev("forest-abbrev", desc("Abbreviate parse forest"),
                               init(true));
 static opt<std::string> HTMLForest("html-forest",
                                    desc("output file for HTML forest"));
 static opt<std::string> StartSymbol("start-symbol",
                                     desc("Specify the start symbol to parse"),
static std::string readOrDie(llvm::StringRef Path) {
   }
   return Text.get()->getBuffer().str();
 }
 
 namespace clang {
 namespace pseudo {
 // Defined in HTMLForest.cpp
 void writeHTMLForest(llvm::raw_ostream &OS, const Grammar &,
-                     const ForestNode &Root, const TokenStream &);
+                     const ForestNode &Root, const Disambiguation &,
+                     const TokenStream &);
 namespace {
 
 struct NodeStats {
   unsigned Total = 0;
   std::vector<std::pair<SymbolID, unsigned>> BySymbol;
 
   NodeStats(const ForestNode &Root,
             llvm::function_ref<bool(const ForestNode &)> Filter) {
if (ParseableStream) {
     if (!StartSymID) {
       llvm::errs() << llvm::formatv(
           "The start symbol {0} doesn't exit in the grammar!\n", StartSymbol);
       return 2;
     }
     auto &Root =
         glrParse(clang::pseudo::ParseParams{*ParseableStream, Arena, GSS},
                  *StartSymID, Lang);
-    if (PrintForest)
+    // If we're disambiguating, we'll print at the end instead.
+    if (PrintForest && !Disambiguate)
       llvm::outs() << Root.dumpRecursive(Lang.G, /*Abbreviated=*/ForestAbbrev);
+    clang::pseudo::Disambiguation Disambig;
+    if (Disambiguate)
+      Disambig = clang::pseudo::disambiguate(&Root, {});
 
     if (HTMLForest.getNumOccurrences()) {
       std::error_code EC;
       llvm::raw_fd_ostream HTMLOut(HTMLForest, EC);
       if (EC) {
         llvm::errs() << "Couldn't write " << HTMLForest << ": " << EC.message()
                      << "\n";
         return 2;
       }
-      clang::pseudo::writeHTMLForest(HTMLOut, Lang.G, Root, *ParseableStream);
+      clang::pseudo::writeHTMLForest(HTMLOut, Lang.G, Root, Disambig,
+                                     *ParseableStream);
     }
 
     if (PrintStatistics) {
       llvm::outs() << "Forest bytes: " << Arena.bytes()
                    << " nodes: " << Arena.nodeCount() << "\n";
       llvm::outs() << "GSS bytes: " << GSS.bytes()
                    << " nodes: " << GSS.nodesCreated() << "\n";
 
if (PrintStatistics) {
       unsigned Len = ParseableStream->tokens().size();
       DFS(Root, Len, DFS);
       llvm::outs() << "\n";
       llvm::outs() << llvm::formatv("Ambiguity: {0} misparses/token\n",
                                     double(Misparses) / Len);
       llvm::outs() << llvm::formatv("Unparsed: {0}%\n",
                                     100.0 * UnparsedTokens / Len);
     }
+
+    if (Disambiguate && PrintForest) {
+      ForestNode *DisambigRoot = &Root;
+      removeAmbiguities(DisambigRoot, Disambig);
+      llvm::outs() << "Disambiguated tree:\n";
+      llvm::outs() << DisambigRoot->dumpRecursive(Lang.G,
+                                                  /*Abbreviated=*/ForestAbbrev);
+    }
   }
 
   return 0;
 }

clang-tools-extra/pseudo/tool/HTMLForest.cpp

 // There are two types of 'active' node:
 //  - *highlight* is what the cursor is over, and is colored blue.
 //    Near ancestors are shaded faintly (onion-skin) to show local structure.
 //  - *selection* is set by clicking.
 //    The #info box shows the selection, and selected nodes have a dashed ring.
 //
 //===----------------------------------------------------------------------===//
 
+#include "clang-pseudo/Disambiguate.h"
 #include "clang-pseudo/Forest.h"
 #include "clang-pseudo/grammar/Grammar.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/raw_ostream.h"
 namespace clang {
 namespace pseudo {
 namespace {
 
 // Defines const char HTMLForest_css[] = "...contents of HTMLForest.css..."; etc
 #include "HTMLForestResources.inc"
 
 struct Writer {
   llvm::raw_ostream &Out;
   const Grammar &G;
   const ForestNode &Root;
   const TokenStream &Stream;
+  const Disambiguation &Disambig;
 
   void write() {
     Out << "<!doctype html>\n";
     tag("html", [&] {
       tag("head", [&] {
         tag("title", [&] { Out << "HTMLForest"; });
         tag("script", [&] { Out << HTMLForest_js; });
         tag("style", [&] { Out << HTMLForest_css; });
for (unsigned I = 0; I < Sequence.size(); ++I) {
           Out.attribute("token", TokenID(N->startTokenIndex()));
           break;
         case ForestNode::Sequence:
           Out.attribute("kind", "sequence");
           Out.attribute("rule", G.dumpRule(N->rule()));
           break;
         case ForestNode::Ambiguous:
           Out.attribute("kind", "ambiguous");
-          Out.attribute("selected", AssignID(N->children().front(), End));
+          Out.attribute("selected",
+                        AssignID(N->children()[Disambig.lookup(N)], End));
           break;
         case ForestNode::Opaque:
           Out.attribute("kind", "opaque");
           Out.attribute("firstToken", TokenID(N->startTokenIndex()));
           // [firstToken, lastToken] is a closed range.
           // If empty, lastToken is omitted.
           if (N->startTokenIndex() != End)
             Out.attribute("lastToken", TokenID(End - 1));
void Writer::writeForestJSON() {
   });
 }
 
 } // namespace
 
 // We only accept the derived stream here.
 // FIXME: allow the original stream instead?
 void writeHTMLForest(llvm::raw_ostream &OS, const Grammar &G,
-                     const ForestNode &Root, const TokenStream &Stream) {
-  Writer{OS, G, Root, Stream}.write();
+                     const ForestNode &Root, const Disambiguation &Disambig,
+                     const TokenStream &Stream) {
+  Writer{OS, G, Root, Stream, Disambig}.write();
 }
 
 } // namespace pseudo
 } // namespace clang

clang-tools-extra/pseudo/unittests/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_custom_target(ClangPseudoUnitTests)
 add_unittest(ClangPseudoUnitTests ClangPseudoTests
   BracketTest.cpp
   CXXTest.cpp
   DirectiveTreeTest.cpp
+  DisambiguateTest.cpp
   ForestTest.cpp
   GLRTest.cpp
   GrammarTest.cpp
   LRTableTest.cpp
   TokenTest.cpp
 )
 
 clang_target_link_libraries(ClangPseudoTests

clang-tools-extra/pseudo/unittests/DisambiguateTest.cpp

+//===--- DisambiguateTest.cpp ---------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-pseudo/Disambiguate.h"
+#include "clang-pseudo/Forest.h"
+#include "clang-pseudo/Token.h"
+#include "clang/Basic/TokenKinds.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include <vector>
+
+namespace clang {
+namespace pseudo {
+namespace {
+using testing::ElementsAre;
+using testing::Pair;
+using testing::UnorderedElementsAre;
+
+// Common disambiguation test fixture.
+// This is the ambiguous forest representing parses of 'a * b;'.
+class DisambiguateTest : public ::testing::Test {
+protected:
+  // Greatly simplified C++ grammar.
+  enum Symbol : SymbolID {
+    Statement,
+    Declarator,
+    Expression,
+    DeclSpecifier,
+    Type,
+    Template,
+  };
+  enum Rule : RuleID {
+    /* LHS__RHS1_RHS2 means LHS := RHS1 RHS2 */
+    Statement__DeclSpecifier_Declarator_Semi,
+    Declarator__Star_Declarator,
+    Declarator__Identifier,
+    Statement__Expression_Semi,
+    Expression__Expression_Star_Expression,
+    Expression__Identifier,
+    DeclSpecifier__Type,
+    DeclSpecifier__Template,
+    Type__Identifier,
+    Template__Identifier,
+  };
+
+  ForestArena Arena;
+  ForestNode &A = Arena.createTerminal(tok::identifier, 0);
+  ForestNode &Star = Arena.createTerminal(tok::star, 1);
+  ForestNode &B = Arena.createTerminal(tok::identifier, 2);
+  ForestNode &Semi = Arena.createTerminal(tok::semi, 3);
+
+  // Parse as multiplication expression.
+  ForestNode &AExpr =
+      Arena.createSequence(Expression, Expression__Identifier, &A);
+  ForestNode &BExpr =
+      Arena.createSequence(Expression, Expression__Identifier, &B);
+  ForestNode &Expr =
+      Arena.createSequence(Expression, Expression__Expression_Star_Expression,
+                           {&AExpr, &Star, &BExpr});
+  ForestNode &ExprStmt = Arena.createSequence(
+      Statement, Statement__Expression_Semi, {&Expr, &Semi});
+  // Parse as declaration (`a` may be CTAD or not).
+  ForestNode &AType =
+      Arena.createSequence(DeclSpecifier, DeclSpecifier__Type,
+                           &Arena.createSequence(Type, Type__Identifier, &A));
+  ForestNode &ATemplate = Arena.createSequence(
+      DeclSpecifier, DeclSpecifier__Template,
+      &Arena.createSequence(Template, Template__Identifier, &A));
+  ForestNode &DeclSpec =
+      Arena.createAmbiguous(DeclSpecifier, {&AType, &ATemplate});
+  ForestNode &BDeclarator =
+      Arena.createSequence(Declarator, Declarator__Identifier, &B);
+  ForestNode &BPtr = Arena.createSequence(
+      Declarator, Declarator__Star_Declarator, {&Star, &BDeclarator});
+  ForestNode &DeclStmt =
+      Arena.createSequence(Statement, Statement__DeclSpecifier_Declarator_Semi,
+                           {&DeclSpec, &Star, &BDeclarator});
+  // Top-level ambiguity
+  ForestNode &Stmt = Arena.createAmbiguous(Statement, {&ExprStmt, &DeclStmt});
+};
+
+TEST_F(DisambiguateTest, Remove) {
+  Disambiguation D;
+  D.try_emplace(&Stmt, 1);     // statement is a declaration, not an expression
+  D.try_emplace(&DeclSpec, 0); // a is a type, not a (CTAD) template
+  ForestNode *Root = &Stmt;
+  removeAmbiguities(Root, D);
+
+  EXPECT_EQ(Root, &DeclStmt);
+  EXPECT_THAT(DeclStmt.elements(), ElementsAre(&AType, &Star, &BDeclarator));
+}
+
+TEST_F(DisambiguateTest, DummyStrategy) {
+  Disambiguation D = disambiguate(&Stmt, {});
+  EXPECT_THAT(D, UnorderedElementsAre(Pair(&Stmt, 1), Pair(&DeclSpec, 1)));
+
+  ForestNode *Root = &Stmt;
+  removeAmbiguities(Root, D);
+  EXPECT_EQ(Root, &DeclStmt);
+  EXPECT_THAT(DeclStmt.elements(),
+              ElementsAre(&ATemplate, &Star, &BDeclarator));
+}
+
+} // namespace
+} // namespace pseudo
+} // namespace clang