[clang-format][docs][NFC] correct the "first supported versions" of some of the clang-format options

[MyDeveloperDay]

Summary

Some of the first supported version field were incorrectly attributed to a later branch.

It wasn't possible to correctly determine the "introduced version" with my naive implementation using git blame alone, (especially if the type had been changed from a bool -> enum)

I saw more things attributed to clang-format 13 than I remembered and reviewed those options to determine their introduced version.

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
           { 7,     5,    "!!"}
       };
 
   * ``AIAS_None`` (in configuration: ``None``)
     Don't align array initializer columns.
 
 
 
-**AlignConsecutiveAssignments** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
+**AlignConsecutiveAssignments** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 3.8`
   Style of aligning consecutive assignments.
 
   ``Consecutive`` will result in formattings like:
 
   .. code-block:: c++
 
     int a            = 1;
     int somelongname = 2;
.. code-block:: c++
        int a            = 1;
        int somelongname = 2;
        double c         = 3;
 
        int d            = 3;
        /* A comment. */
        double e         = 4;
 
-**AlignConsecutiveBitFields** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
+**AlignConsecutiveBitFields** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 11`
   Style of aligning consecutive bit field.
 
   ``Consecutive`` will align the bitfield separators of consecutive lines.
   This will result in formattings like:
 
   .. code-block:: c++
 
     int aaaa : 1;
.. code-block:: c++
        int aaaa : 1;
        int b    : 12;
        int ccc  : 8;
 
        int d    : 2;
        /* A comment. */
        int ee   : 3;
 
-**AlignConsecutiveDeclarations** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
+**AlignConsecutiveDeclarations** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 3.8`
   Style of aligning consecutive declarations.
 
   ``Consecutive`` will align the declaration names of consecutive lines.
   This will result in formattings like:
 
   .. code-block:: c++
 
     int         aaaa = 12;
.. code-block:: c++
        int         aaaa = 12;
        float       b = 23;
        std::string ccc;
 
        int         a = 42;
        /* A comment. */
        bool        c = false;
 
-**AlignConsecutiveMacros** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
+**AlignConsecutiveMacros** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 9`
   Style of aligning consecutive macro definitions.
 
   ``Consecutive`` will result in formattings like:
 
   .. code-block:: c++
 
     #define SHORT_NAME       42
     #define LONGER_NAME      0x007f
.. code-block:: c++
        }
        template <typename T>
        T foo(int aaaaaaaaaaaaaaaaaaaaa,
              int bbbbbbbbbbbbbbbbbbbbb) {
        }
 
 
 
-**AttributeMacros** (``List of Strings``) :versionbadge:`clang-format 13`
+**AttributeMacros** (``List of Strings``) :versionbadge:`clang-format 12`
   A vector of strings that should be interpreted as attributes/qualifiers
   instead of identifiers. This can be useful for language extensions or
   static analyzer annotations.
 
   For example:
 
   .. code-block:: c++
 
.. code-block:: c++
     void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
 
     false:
     void f(int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
 
-**BitFieldColonSpacing** (``BitFieldColonSpacingStyle``) :versionbadge:`clang-format 13`
+**BitFieldColonSpacing** (``BitFieldColonSpacingStyle``) :versionbadge:`clang-format 12`
   The BitFieldColonSpacingStyle to use for bitfields.
 
   Possible values:
 
   * ``BFCS_Both`` (in configuration: ``Both``)
     Add one space on each side of the ``:``
 
     .. code-block:: c++
**PenaltyBreakString** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for each line break introduced inside a string literal.
 
 **PenaltyBreakTemplateDeclaration** (``Unsigned``) :versionbadge:`clang-format 7`
   The penalty for breaking after template declaration.
 
 **PenaltyExcessCharacter** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for each character outside of the column limit.
 
-**PenaltyIndentedWhitespace** (``Unsigned``) :versionbadge:`clang-format 13`
+**PenaltyIndentedWhitespace** (``Unsigned``) :versionbadge:`clang-format 12`
   Penalty for each character of whitespace indentation
   (counted relative to leading non-whitespace column).
 
 **PenaltyReturnTypeOnItsOwnLine** (``Unsigned``) :versionbadge:`clang-format 3.7`
   Penalty for putting the return type of a function onto its own
   line.
 
 **PointerAlignment** (``PointerAlignmentStyle``) :versionbadge:`clang-format 3.7`
Order is an array that can contain any of the following:
     * inline
     * static
     * constexpr
     * volatile
     * restrict
     * type
 
   Note: it MUST contain 'type'.
-  Items to the left of 'type' will be placed to the left of the type and aligned in the order supplied.
-  Items to the right of 'type' will be placed to the right of the type and aligned in the order supplied.
+  Items to the left of 'type' will be placed to the left of the type and
+  aligned in the order supplied. Items to the right of 'type' will be placed
+  to the right of the type and aligned in the order supplied.
 
 
   .. code-block:: yaml
 
     QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
 
 **RawStringFormats** (``List of RawStringFormats``) :versionbadge:`clang-format 6`
   Defines hints for detecting supported languages code blocks in raw
.. code-block:: c++
        #include "A/B.h"
        #include "A/b.h"
        #include "a/b.h"
        #include "B/A.h"
        #include "B/a.h"
 
 
 
-**SortJavaStaticImport** (``SortJavaStaticImportOptions``) :versionbadge:`clang-format 13`
+**SortJavaStaticImport** (``SortJavaStaticImportOptions``) :versionbadge:`clang-format 12`
   When sorting Java imports, by default static imports are placed before
   non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   static imports are placed after non-static imports.
 
   Possible values:
 
   * ``SJSIO_Before`` (in configuration: ``Before``)
     Static imports are placed before non-static imports.

 **SpaceAfterTemplateKeyword** (``Boolean``) :versionbadge:`clang-format 4`
   If ``true``, a space will be inserted after the 'template' keyword.
 
   .. code-block:: c++
 
      true:                                  false:
      template <int> void foo();     vs.     template<int> void foo();
 
-**SpaceAroundPointerQualifiers** (``SpaceAroundPointerQualifiersStyle``) :versionbadge:`clang-format 13`
+**SpaceAroundPointerQualifiers** (``SpaceAroundPointerQualifiersStyle``) :versionbadge:`clang-format 12`
   Defines in which cases to put a space before or after pointer qualifiers
 
   Possible values:
 
   * ``SAPQ_Default`` (in configuration: ``Default``)
     Don't ensure spaces around pointer qualifiers and use PointerAlignment
     instead.
 
**SpaceBeforeAssignmentOperators** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``false``, spaces will be removed before assignment operators.
 
   .. code-block:: c++
 
      true:                                  false:
      int a = 5;                     vs.     int a= 5;
      a += 42;                               a+= 42;
 
-**SpaceBeforeCaseColon** (``Boolean``) :versionbadge:`clang-format 13`
+**SpaceBeforeCaseColon** (``Boolean``) :versionbadge:`clang-format 12`
   If ``false``, spaces will be removed before case colon.
 
   .. code-block:: c++
 
     true:                                   false
     switch (x) {                    vs.     switch (x) {
       case 1 : break;                         case 1: break;
     }                                       }
* ``LS_Latest`` (in configuration: ``Latest``)
     Parse and format using the latest supported language version.
     ``Cpp11`` is a deprecated alias for ``Latest``
 
   * ``LS_Auto`` (in configuration: ``Auto``)
     Automatic detection based on the input.
 
 
 
-**StatementAttributeLikeMacros** (``List of Strings``) :versionbadge:`clang-format 13`
+**StatementAttributeLikeMacros** (``List of Strings``) :versionbadge:`clang-format 12`
   Macros which are ignored in front of a statement, as if they were an
   attribute. So that they are not parsed as identifier, for example for Qts
   emit.
 
   .. code-block:: c++
 
     AlignConsecutiveDeclarations: true
     StatementAttributeLikeMacros: []

clang/include/clang/Format/Format.h

struct FormatStyle {
   ///      #define SHORT_NAME       42
   ///      #define LONGER_NAME      0x007f
   ///      #define EVEN_LONGER_NAME (2)
   ///
   ///      #define foo(x)           (x * x)
   ///      /* some comment */
   ///      #define bar(y, z)        (y + z)
   ///    \endcode
-  /// \version 13
+  /// \version 9
   AlignConsecutiveStyle AlignConsecutiveMacros;
 
   /// Style of aligning consecutive assignments.
   ///
   /// ``Consecutive`` will result in formattings like:
   /// \code
   ///   int a            = 1;
   ///   int somelongname = 2;
struct FormatStyle {
   ///      int a            = 1;
   ///      int somelongname = 2;
   ///      double c         = 3;
   ///
   ///      int d            = 3;
   ///      /* A comment. */
   ///      double e         = 4;
   ///    \endcode
-  /// \version 13
+  /// \version 3.8
   AlignConsecutiveStyle AlignConsecutiveAssignments;
 
   /// Style of aligning consecutive bit field.
   ///
   /// ``Consecutive`` will align the bitfield separators of consecutive lines.
   /// This will result in formattings like:
   /// \code
   ///   int aaaa : 1;
struct FormatStyle {
   ///      int aaaa : 1;
   ///      int b    : 12;
   ///      int ccc  : 8;
   ///
   ///      int d    : 2;
   ///      /* A comment. */
   ///      int ee   : 3;
   ///    \endcode
-  /// \version 13
+  /// \version 11
   AlignConsecutiveStyle AlignConsecutiveBitFields;
 
   /// Style of aligning consecutive declarations.
   ///
   /// ``Consecutive`` will align the declaration names of consecutive lines.
   /// This will result in formattings like:
   /// \code
   ///   int         aaaa = 12;
struct FormatStyle {
   ///      int         aaaa = 12;
   ///      float       b = 23;
   ///      std::string ccc;
   ///
   ///      int         a = 42;
   ///      /* A comment. */
   ///      bool        c = false;
   ///    \endcode
-  /// \version 13
+  /// \version 3.8
   AlignConsecutiveStyle AlignConsecutiveDeclarations;
 
   /// Different styles for aligning escaped newlines.
   enum EscapedNewlineAlignmentStyle : unsigned char {
     /// Don't align escaped newlines.
     /// \code
     ///   #define A \
     ///     int aaaa; \
struct FormatStyle {
   ///   void only_writes_to_buffer(char *__output buffer);
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   AttributeMacros: ['__capability', '__output', '__ununsed']
   /// \endcode
   ///
-  /// \version 13
+  /// \version 12
   std::vector<std::string> AttributeMacros;
 
   /// If ``false``, a function call's arguments will either be all on the
   /// same line or will have one line each.
   /// \code
   ///   true:
   ///   void f() {
   ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,

   ///   * inline
   ///   * static
   ///   * constexpr
   ///   * volatile
   ///   * restrict
   ///   * type
   ///
   /// Note: it MUST contain 'type'.
-  /// Items to the left of 'type' will be placed to the left of the type and aligned in the order supplied.
-  /// Items to the right of 'type' will be placed to the right of the type and aligned in the order supplied.
+  /// Items to the left of 'type' will be placed to the left of the type and
+  /// aligned in the order supplied. Items to the right of 'type' will be placed
+  /// to the right of the type and aligned in the order supplied.
   ///
   /// \code{.yaml}
   ///   QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
   /// \endcode
   /// \version 14
   std::vector<std::string> QualifierOrder;
 
   /// Different ways to break inheritance list.
///    NS_TABLE_.*_END$"
 
   /// Penalty for putting the return type of a function onto its own
   /// line.
   /// \version 3.7
   unsigned PenaltyReturnTypeOnItsOwnLine;
 
   /// Penalty for each character of whitespace indentation
   /// (counted relative to leading non-whitespace column).
-  /// \version 13
+  /// \version 12
   unsigned PenaltyIndentedWhitespace;
 
   /// The ``&``, ``&&`` and ``*`` alignment style.
   enum PointerAlignmentStyle : unsigned char {
     /// Align pointer to the left.
     /// \code
     ///   int* a;
     /// \endcode
enum SortJavaStaticImportOptions : unsigned char {
     ///   import static org.example.function1;
     /// \endcode
     SJSIO_After,
   };
 
   /// When sorting Java imports, by default static imports are placed before
   /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   /// static imports are placed after non-static imports.
-  /// \version 13
+  /// \version 12
   SortJavaStaticImportOptions SortJavaStaticImport;
 
   /// If ``true``, clang-format will sort using declarations.
   ///
   /// The order of using declarations is defined as follows:
   /// Split the strings by "::" and discard any initial empty strings. The last
   /// element of each list is a non-namespace name; all others are namespace
   /// names. Sort the lists of names lexicographically, where the sort order of
enum SpaceAroundPointerQualifiersStyle : unsigned char {
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
     ///    void* const * x = NULL;         vs.     void * const *x = NULL;
     /// \endcode
     SAPQ_Both,
   };
 
   ///  Defines in which cases to put a space before or after pointer qualifiers
-  /// \version 13
+  /// \version 12
   SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers;
 
   /// If ``false``, spaces will be removed before assignment operators.
   /// \code
   ///    true:                                  false:
   ///    int a = 5;                     vs.     int a= 5;
   ///    a += 42;                               a+= 42;
   /// \endcode
   /// \version 3.7
   bool SpaceBeforeAssignmentOperators;
 
   /// If ``false``, spaces will be removed before case colon.
   /// \code
   ///   true:                                   false
   ///   switch (x) {                    vs.     switch (x) {
   ///     case 1 : break;                         case 1: break;
   ///   }                                       }
   /// \endcode
-  /// \version 13
+  /// \version 12
   bool SpaceBeforeCaseColon;
 
   /// If ``true``, a space will be inserted before a C++11 braced list
   /// used to initialize an object (after the preceding identifier or type).
   /// \code
   ///    true:                                  false:
   ///    Foo foo { bar };               vs.     Foo foo{ bar };
   ///    Foo {};                                Foo{};
enum BitFieldColonSpacingStyle : unsigned char {
     /// Add space after the ``:`` only (space may be added before if
     /// needed for ``AlignConsecutiveBitFields``).
     /// \code
     ///   unsigned bf: 2;
     /// \endcode
     BFCS_After
   };
   /// The BitFieldColonSpacingStyle to use for bitfields.
-  /// \version 13
+  /// \version 12
   BitFieldColonSpacingStyle BitFieldColonSpacing;
 
   /// Supported language standards for parsing and formatting C++ constructs.
   /// \code
   ///    Latest:                                vector<set<int>>
   ///    c++03                          vs.     vector<set<int> >
   /// \endcode
   ///
///    NS_TABLE_.*_END$"
   ///   unsigned char data = 'x';
   ///   emit          signal(data); // This is parsed as variable declaration.
   ///
   ///   AlignConsecutiveDeclarations: true
   ///   StatementAttributeLikeMacros: [emit]
   ///   unsigned char data = 'x';
   ///   emit signal(data); // Now it's fine again.
   /// \endcode
-  /// \version 13
+  /// \version 12
   std::vector<std::string> StatementAttributeLikeMacros;
 
   /// The number of columns used for tab stops.
   /// \version 3.7
   unsigned TabWidth;
 
   /// Different ways to use tab in formatting.
   enum UseTabStyle : unsigned char {