[Format] Add option to enable coroutines keywords

[modocache]

Summary

In a previous change, https://reviews.llvm.org/D65043, I allowed users to
explicitly opt-in to formatting according to the C++20 standard. Should
a user choose to do so, the formatter would treat coroutine keywords
such as co_yield as keywords, whereas under the C++11 standard they
would be treated as identifiers.

However, this excludes a use case in which, for example, a user's codebase
is written using the C++17 standard, but with an explicit opt-in to
-fcoroutines-ts. This commit adds an option to clang-format to allow
formatting under an arbitrary standard, but with co_yield and friends
treated as keywords.

[sammccall]

Do we have real examples of code that gets formatted incorrectly when parsed as c++20 but lives in a codebase that uses coroutines TS?
This seems very niche (and probably short-lived) - do we really need this option?

[modocache]

I work on a C++17 codebase with coroutines enabled, but yes
just formatting the codebase as if it were C++20 seems fine. Thanks!

clang/docs/ClangFormatStyleOptions.rst

**ContinuationIndentWidth** (``unsigned``)
   .. code-block:: c++
 
      ContinuationIndentWidth: 2
 
      int i =         //  VeryVeryVeryVeryVeryLongComment
        longFunction( // Again a long comment
          arg);
 
+**CoroutinesTS** (``bool``)
+  If ``true``, C++ Coroutines TS keywords will be treated as keywords, not
+  identifiers, regardless of the language standard specified for formatting.
+  If ``false``, their formatting depends on the standard selected.
+
+  .. code-block:: c++
+
+     true, C++11:
+     co_yield ++i;
+
+     false, C++11:
+     co_yield++ i;
+
+     both true and false, C++20:
+     co_yield ++i;
+
 **Cpp11BracedListStyle** (``bool``)
   If ``true``, format braced lists as best suited for C++11 braced
   lists.
 
   Important differences:
   - No spaces inside the braced list.
   - No line break before the closing brace.
   - Indentation with the continuation indent, not with the block indent.

clang/include/clang/Format/Format.h

   ///    ContinuationIndentWidth: 2
   ///
   ///    int i =         //  VeryVeryVeryVeryVeryLongComment
   ///      longFunction( // Again a long comment
   ///        arg);
   /// \endcode
   unsigned ContinuationIndentWidth;
 
+  /// If ``true``, C++ Coroutines TS keywords will be treated as keywords, not
+  /// identifiers, regardless of the language standard specified for formatting.
+  /// If ``false``, their formatting depends on the standard selected.
+  /// \code
+  ///    true, C++11:
+  ///    co_yield ++i;
+  ///
+  ///    false, C++11:
+  ///    co_yield++ i;
+  ///
+  ///    both true and false, C++20:
+  ///    co_yield ++i;
+  /// \endcode
+  bool CoroutinesTS;
+
   /// If ``true``, format braced lists as best suited for C++11 braced
   /// lists.
   ///
   /// Important differences:
   /// - No spaces inside the braced list.
   /// - No line break before the closing brace.
   /// - Indentation with the continuation indent, not with the block indent.
   ///
return AccessModifierOffset == R.AccessModifierOffset &&
            BreakStringLiterals == R.BreakStringLiterals &&
            ColumnLimit == R.ColumnLimit && CommentPragmas == R.CommentPragmas &&
            BreakInheritanceList == R.BreakInheritanceList &&
            ConstructorInitializerAllOnOneLineOrOnePerLine ==
                R.ConstructorInitializerAllOnOneLineOrOnePerLine &&
            ConstructorInitializerIndentWidth ==
                R.ConstructorInitializerIndentWidth &&
            ContinuationIndentWidth == R.ContinuationIndentWidth &&
+           CoroutinesTS == R.CoroutinesTS &&
            Cpp11BracedListStyle == R.Cpp11BracedListStyle &&
            DerivePointerAlignment == R.DerivePointerAlignment &&
            DisableFormat == R.DisableFormat &&
            ExperimentalAutoDetectBinPacking ==
                R.ExperimentalAutoDetectBinPacking &&
            FixNamespaceComments == R.FixNamespaceComments &&
            ForEachMacros == R.ForEachMacros &&
            IncludeStyle.IncludeBlocks == R.IncludeStyle.IncludeBlocks &&

clang/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("ColumnLimit", Style.ColumnLimit);
     IO.mapOptional("CommentPragmas", Style.CommentPragmas);
     IO.mapOptional("CompactNamespaces", Style.CompactNamespaces);
     IO.mapOptional("ConstructorInitializerAllOnOneLineOrOnePerLine",
                    Style.ConstructorInitializerAllOnOneLineOrOnePerLine);
     IO.mapOptional("ConstructorInitializerIndentWidth",
                    Style.ConstructorInitializerIndentWidth);
     IO.mapOptional("ContinuationIndentWidth", Style.ContinuationIndentWidth);
+    IO.mapOptional("CoroutinesTS", Style.CoroutinesTS);
     IO.mapOptional("Cpp11BracedListStyle", Style.Cpp11BracedListStyle);
     IO.mapOptional("DerivePointerAlignment", Style.DerivePointerAlignment);
     IO.mapOptional("DisableFormat", Style.DisableFormat);
     IO.mapOptional("ExperimentalAutoDetectBinPacking",
                    Style.ExperimentalAutoDetectBinPacking);
     IO.mapOptional("FixNamespaceComments", Style.FixNamespaceComments);
     IO.mapOptional("ForEachMacros", Style.ForEachMacros);
     IO.mapOptional("IncludeBlocks", Style.IncludeStyle.IncludeBlocks);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
   LLVMStyle.BreakStringLiterals = true;
   LLVMStyle.ColumnLimit = 80;
   LLVMStyle.CommentPragmas = "^ IWYU pragma:";
   LLVMStyle.CompactNamespaces = false;
   LLVMStyle.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
   LLVMStyle.ConstructorInitializerIndentWidth = 4;
   LLVMStyle.ContinuationIndentWidth = 4;
+  LLVMStyle.CoroutinesTS = false;
   LLVMStyle.Cpp11BracedListStyle = true;
   LLVMStyle.DerivePointerAlignment = false;
   LLVMStyle.ExperimentalAutoDetectBinPacking = false;
   LLVMStyle.FixNamespaceComments = true;
   LLVMStyle.ForEachMacros.push_back("foreach");
   LLVMStyle.ForEachMacros.push_back("Q_FOREACH");
   LLVMStyle.ForEachMacros.push_back("BOOST_FOREACH");
   LLVMStyle.IncludeStyle.IncludeCategories = {
LangOptions getFormattingLangOpts(const FormatStyle &Style) {
   LangOpts.CPlusPlus2a = Style.Standard == FormatStyle::LS_Cpp20 ? 1 : 0;
   LangOpts.LineComment = 1;
   bool AlternativeOperators = Style.isCpp();
   LangOpts.CXXOperatorNames = AlternativeOperators ? 1 : 0;
   LangOpts.Bool = 1;
   LangOpts.ObjC = 1;
   LangOpts.MicrosoftExt = 1;    // To get kw___try, kw___finally.
   LangOpts.DeclSpecKeyword = 1; // To get __declspec.
+  if (!LangOpts.CPlusPlus2a)
+    LangOpts.Coroutines = Style.CoroutinesTS;
   return LangOpts;
 }
 
 const char *StyleOptionHelpDescription =
     "Coding style, currently supports:\n"
     "  LLVM, Google, Chromium, Mozilla, WebKit.\n"
     "Use -style=file to load style configuration from\n"
     ".clang-format file located in one of the parent\n"

clang/unittests/Format/FormatTest.cpp

TEST_F(FormatTest, TypenameMacros) {
   Macros.PointerAlignment = FormatStyle::PAS_Left;
   verifyFormat("STACK_OF(int)* a;", Macros);
   verifyFormat("STACK_OF(int*)* a;", Macros);
 }
 
 TEST_F(FormatTest, Coroutines) {
   FormatStyle Cpp20 = getLLVMStyle();
   Cpp20.Standard = FormatStyle::LS_Cpp20;
+  FormatStyle Coro = getLLVMStyle();
+  Coro.CoroutinesTS = true;
 
   verifyFormat("co_yield++ i;");
   verifyFormat("co_yield ++i;", Cpp20);
+  verifyFormat("co_yield ++i;", Coro);
 
   verifyFormat("co_await[]() { co_return; }\n"
                "();");
   verifyFormat("co_await []() { co_return; }();", Cpp20);
+  verifyFormat("co_await []() { co_return; }();", Coro);
 }
 
 } // end namespace
 } // end namespace format
 } // end namespace clang