[pseudo] Collect positions in TokenStream that trigger the error recovery.

[hokein]

Summary

Mainly for making it easier to debug broken code. No intend to land it.

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

 // Parameters for the GLR parsing.
 struct ParseParams {
   // The token stream to parse.
   const TokenStream &Code;
 
   // Arena for data structure used by the GLR algorithm.
   ForestArena &Forest;  // Storage for the output forest.
   GSS &GSStack;         // Storage for parsing stacks.
+
+  // If not null, store the token indices that trigger the error-recovery.
+  std::vector<Token::Index> *FailingPoints = nullptr;
 };
 
 // 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.

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

if (NextHeads.empty()) {
       // consider all possibilities.
       //
       // We discard all heads formed by reduction, and recreate them without
       // this constraint. This may duplicate some nodes, but it's rare.
       LLVM_DEBUG(llvm::dbgs() << "Shift failed, will attempt recovery. "
                                  "Re-reducing without lookahead.\n");
       Heads.resize(HeadsPartition);
       Reduce(Heads, /*allow all reductions*/ tokenSymbol(tok::unknown));
-
+      if (Params.FailingPoints)
+        Params.FailingPoints->push_back(I);
       glrRecover(Heads, I, Params, Lang, NextHeads);
       assert(!NextHeads.empty() &&  "no fallback recovery strategy!" );
     } else
       ++I;
 
     // Form nonterminals containing the token we just consumed.
     SymbolID Lookahead =
         I == Terminals.size() ? tokenSymbol(tok::eof) : Terminals[I].symbol();

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

if (ParseableStream) {
     clang::pseudo::GSS GSS;
     llvm::Optional<clang::pseudo::SymbolID> StartSymID =
         Lang.G.findNonterminal(StartSymbol);
     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},
+    std::vector<Token::Index> FailingPoints;
+    auto &Root = glrParse(clang::pseudo::ParseParams{*ParseableStream, Arena,
+                                                     GSS, &FailingPoints},
                           *StartSymID, Lang);
     if (PrintForest)
       llvm::outs() << Root.dumpRecursive(Lang.G, /*Abbreviated=*/ForestAbbrev);
-
+    if (!FailingPoints.empty()) {
+      llvm::for_each(FailingPoints, [&](Token::Index Pos) {
+        if (Pos >= ParseableStream->tokens().size())
+          return;
+        const auto &T = ParseableStream->tokens()[Pos];
+        std::string LineCode;
+        llvm::for_each(ParseableStream->tokens(), [&](const Token &E) {
+          if (E.Line == T.Line)
+            LineCode += (" " + E.text().str());
+        });
+        llvm::outs() << llvm::formatv("Error on parsing Line {0}: {1}\n",
+                                      T.Line + 1, LineCode);
+      });
+    }
     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;
       }