[clang-format][docs] Fix incorrect 'clang-format 12' option markers

[kuzkry]

Summary

Introduced by 23a5090c6, some style option markers indicated 'clang-format 12',
though their respective options were available in earlier releases.

[kuzkry]

Here's a list of earliest commits where each option changed in this PR was introduced:

AlignOperands - introduced by 3219e43c9467e47be9b1a9e32b3ed42a50f6b280
AllowShortEnumsOnASingleLine - introduced by 292058a5d6d708ec7d285a452d4350b33ba080dc
IndentExternBlock - introduced by 6ef45b0426a8c7b9764e102fb1a49561a3a2c118
InsertTrailingCommas - introduced by a324fcf1ae62d065b957e66a9d2f5c18b6259d27
ObjCBreakBeforeNestedBlockParam - introduced by 70c98671fa7b395a52829b91782393f4c2613562
WhitespaceSensitiveMacros - introduced by 292058a5d6d708ec7d285a452d4350b33ba080dc

[MyDeveloperDay]

once again thank you!

[kuzkry]

In D120631#3348337, @MyDeveloperDay wrote:

once again thank you!

You're welcome :)

Could someone please deliver this one for me? My name and email in git format is "Krystian Kuzniarek <[e-mail]>"

[kuzkry]

Kind reminder, please deliver this one for me.

[HazardyKnusperkeks]

Your patches are not directly applicable.
You have

--- clang/include/clang/Format/Format.h
+++ clang/include/clang/Format/Format.h

instead of

--- a/clang/include/clang/Format/Format.h
+++ b/clang/include/clang/Format/Format.h

which results in

$ git apply diff.patch
error: docs/ClangFormatStyleOptions.rst: No such file or directory
error: include/clang/Format/Format.h: No such file or directory

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
 
       #define A                                                                      \
         int aaaa;                                                                    \
         int b;                                                                       \
         int dddddddddd;
 
 
 
-**AlignOperands** (``OperandAlignmentStyle``) :versionbadge:`clang-format 12`
+**AlignOperands** (``OperandAlignmentStyle``) :versionbadge:`clang-format 3.5`
   If ``true``, horizontally align operands of binary and ternary
   expressions.
 
   Possible values:
 
   * ``OAS_DontAlign`` (in configuration: ``DontAlign``)
     Do not align operands of binary and ternary expressions.
     The wrapped lines are indented ``ContinuationIndentWidth`` spaces from
.. code-block:: c++
     switch (a) {                    vs.     switch (a) {
     case 1: x = 1; break;                   case 1:
     case 2: return;                           x = 1;
     }                                         break;
                                             case 2:
                                               return;
                                             }
 
-**AllowShortEnumsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 12`
+**AllowShortEnumsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 11`
   Allow short enums on a single line.
 
   .. code-block:: c++
 
     true:
     enum { A, B } myEnum;
 
     false:
.. code-block:: c++
      switch (fool) {                vs.     switch (fool) {
      case 1:                                  case 1:
        bar();                                   bar();
        break;                                   break;
      default:                                 default:
        plop();                                  plop();
      }                                      }
 
-**IndentExternBlock** (``IndentExternBlockStyle``) :versionbadge:`clang-format 12`
+**IndentExternBlock** (``IndentExternBlockStyle``) :versionbadge:`clang-format 11`
   IndentExternBlockStyle is the type of indenting of extern blocks.
 
   Possible values:
 
   * ``IEBS_AfterExternBlock`` (in configuration: ``AfterExternBlock``)
     Backwards compatible with AfterExternBlock's indenting.
 
     .. code-block:: c++
while (i--)                      vs.      while (i--) {
         handleAttr(A);                            handleAttr(A);
                                                 }
                                               }
 
     do                               vs.      do {
       --i;                                      --i;
     while (i);                                } while (i);
 
-**InsertTrailingCommas** (``TrailingCommaStyle``) :versionbadge:`clang-format 12`
+**InsertTrailingCommas** (``TrailingCommaStyle``) :versionbadge:`clang-format 11`
   If set to ``TCS_Wrapped`` will insert trailing commas in container
   literals (arrays and objects) that wrap across multiple lines.
   It is currently only available for JavaScript
   and disabled by default ``TCS_None``.
   ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``
   as inserting the comma disables bin-packing.
 
   .. code-block:: c++
**ObjCBlockIndentWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   .. code-block:: objc
 
      ObjCBlockIndentWidth: 4
 
      [operation setCompletionBlock:^{
          [self onOperationDone];
      }];
 
-**ObjCBreakBeforeNestedBlockParam** (``Boolean``) :versionbadge:`clang-format 12`
+**ObjCBreakBeforeNestedBlockParam** (``Boolean``) :versionbadge:`clang-format 11`
   Break parameters list into lines when there is nested block
   parameters in a function call.
 
   .. code-block:: c++
 
     false:
      - (void)_aMethod
      {
* ``UT_AlignWithSpaces`` (in configuration: ``AlignWithSpaces``)
     alignment.
 
   * ``UT_Always`` (in configuration: ``Always``)
     Use tabs whenever we need to fill whitespace that spans at least from
     one tab stop to the next one.
 
 
 
-**WhitespaceSensitiveMacros** (``List of Strings``) :versionbadge:`clang-format 12`
+**WhitespaceSensitiveMacros** (``List of Strings``) :versionbadge:`clang-format 11`
   A vector of macros which are whitespace-sensitive and should not
   be touched.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     STRINGIZE(...)

clang/include/clang/Format/Format.h

enum OperandAlignmentStyle : unsigned char {
     ///   int aaa = bbbbbbbbbbbbbbb
     ///           + ccccccccccccccc;
     /// \endcode
     OAS_AlignAfterOperator,
   };
 
   /// If ``true``, horizontally align operands of binary and ternary
   /// expressions.
-  /// \version 12
+  /// \version 3.5
   OperandAlignmentStyle AlignOperands;
 
   /// If ``true``, aligns trailing comments.
   /// \code
   ///   true:                                   false:
   ///   int a;     // My comment a      vs.     int a; // My comment a
   ///   int b = 2; // comment  b                int b = 2; // comment about b
   /// \endcode
struct FormatStyle {
   ///   enum { A, B } myEnum;
   ///
   ///   false:
   ///   enum {
   ///     A,
   ///     B
   ///   } myEnum;
   /// \endcode
-  /// \version 12
+  /// \version 11
   bool AllowShortEnumsOnASingleLine;
 
   /// Different styles for merging short blocks containing at most one
   /// statement.
   enum ShortBlockStyle : unsigned char {
     /// Never merge blocks into a single line.
     /// \code
     ///   while (true) {
struct FormatStyle {
   ///   TSC_Wrapped:
   ///   const someArray = [
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   //                        ^ inserted
   ///   ]
   /// \endcode
-  /// \version 12
+  /// \version 11
   TrailingCommaStyle InsertTrailingCommas;
 
   /// If ``false``, a function declaration's or function definition's
   /// parameters will either all be on the same line or will have one line each.
   /// \code
   ///   true:
   ///   void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}

   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
   /// \endcode
   ///
   /// For example: BOOST_PP_STRINGIZE
-  /// \version 12
+  /// \version 11
   std::vector<std::string> WhitespaceSensitiveMacros;
 
   tooling::IncludeStyle IncludeStyle;
 
   /// Specify whether access modifiers should have their own indentation level.
   ///
   /// When ``false``, access modifiers are indented (or outdented) relative to
   /// the record members, respecting the ``AccessModifierOffset``. Record
enum IndentExternBlockStyle : unsigned char {
     ///     extern "C" {
     ///       void foo();
     ///     }
     /// \endcode
     IEBS_Indent,
   };
 
   /// IndentExternBlockStyle is the type of indenting of extern blocks.
-  /// \version 12
+  /// \version 11
   IndentExternBlockStyle IndentExternBlock;
 
   /// Indent the requires clause in a template. This only applies when
   /// ``RequiresClausePosition`` is ``OwnLine``, or ``WithFollowing``.
   ///
   /// In clang-format 12, 13 and 14 it was named ``IndentRequires``.
   /// \code
   ///    true:
///    NS_TABLE_.*_END$"
   ///    {
   ///       [self.test1 t:self
   ///                    w:self
   ///           callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
   ///                u = c;
   ///            }]
   ///    }
   /// \endcode
-  /// \version 12
+  /// \version 11
   bool ObjCBreakBeforeNestedBlockParam;
 
   /// Add a space in front of an Objective-C protocol list, i.e. use
   /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
   /// \version 3.7
   bool ObjCSpaceBeforeProtocolList;
 
   /// The penalty for breaking around an assignment operator.