[clang-format] PROPOSAL - WIP: Added ability to parse template arguments

[HazardyKnusperkeks]

Summary

Obviously not implemented yet.

For https://github.com/llvm/llvm-project/issues/53864 I need to get the end of the requires clause at the end of the nested template. But parseBracedList() just ends on the first > it finds.

Simply extending it the be recursive on < wouldn't work, since we have to determine if < is a less or a template opener. Analogous for >. Currently we have TokenAnnotator::parseAngle to deal with this stuff. Including // FIXME: This is getting out of hand, write a decent parser.

So my proposal is to add this parsing in UnwrappedLineParser and set TT_TemplateOpener and TT_TempalteCloser already there.

This is going to be a huge change, so I ask for your opinion before I put a lot of effort into that.

[MyDeveloperDay]

A noble effort. It needs someone like yourself to do this as you already have a deep understanding.

[curdeius]

That would be a nice improvement... and a big undertaking at the same time. You have my blessing!

[owenpan]

+1.

clang/lib/Format/UnwrappedLineParser.h

private:
   void parseStructuralElement(IfStmtKind *IfKind = nullptr,
                               bool IsTopLevel = false,
                               TokenType NextLBracesType = TT_Unknown);
   bool tryToParseBracedList();
   bool parseBracedList(bool ContinueOnSemicolons = false, bool IsEnum = false,
                        tok::TokenKind ClosingBraceKind = tok::r_brace);
   void parseParens(TokenType AmpAmpTokenType = TT_Unknown);
   void parseSquare(bool LambdaIntroducer = false);
+  void parseTemplateArguments();
   void keepAncestorBraces();
   FormatToken *parseIfThenElse(IfStmtKind *IfKind, bool KeepBraces = false);
   void parseTryCatch();
   void parseForOrWhileLoop();
   void parseDoWhile();
   void parseLabel(bool LeftAlignLabel = false);
   void parseCaseLabel();
   void parseSwitch();

clang/lib/Format/UnwrappedLineParser.cpp

case tok::at:
       break;
     default:
       nextToken();
       break;
     }
   } while (!eof());
 }
 
+/// \brief Parses a template arguments, that is from the opening < to the
+/// closing >. Returns when it succesfully read the template arguments or
+/// detected that it's not a template argument list.
+void clang::format::UnwrappedLineParser::parseTemplateArguments() {
+  assert(FormatTok->is(tok::less) && "'<' expected.");
+  assert(FormatTok->is(TT_Unknown) && "Type already set on '<'");
+  auto OpeningAngle = FormatTok;
+  nextToken();
+
+
+  do {
+    //Do stuff
+  } while (!eof());
+}
+
 void UnwrappedLineParser::keepAncestorBraces() {
   if (!Style.RemoveBracesLLVM)
     return;
 
   const int MaxNestingLevels = 2;
   const int Size = NestedTooDeep.size();
   if (Size >= MaxNestingLevels)
     NestedTooDeep[Size - MaxNestingLevels] = true;