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

[kuzkry]

Summary

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

[kuzkry]

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

AlwaysBreakTemplateDeclarations - 61e6bbf8508a46ad1269c8ea67dc0372b84e9a3b
IncludeBlocks - 4c2c9c3620e3bed9cb6fa709ec3b3cc454eb5748
IncludeCategories - introduced in 85c472dccdf536fb1853139f456a0763311a8a42 and configurable from 8ce1b8df7690bc25788c7da1b464c654461489b0
IncludeIsMainRegex - 9c8ff3551ace965a3232fc4a1b53a75015a706cf
IncludeIsMainSourceRegex - 335ac2eb662ce5f1888e2a50310b01fba2d40d68

[kuzkry]

I forgot to add "Differential revision" footer to the commit message and so I've got to manually close this review. Sorry

clang/docs/ClangFormatStyleOptions.rst

**AlwaysBreakBeforeMultilineStrings** (``Boolean``) :versionbadge:`clang-format 3.4`
 
   .. code-block:: c++
 
      true:                                  false:
      aaaa =                         vs.     aaaa = "bbbb"
          "bbbb"                                    "cccc";
          "cccc";
 
-**AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``) :versionbadge:`clang-format 7`
+**AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``) :versionbadge:`clang-format 3.4`
   The template declaration breaking style to use.
 
   Possible values:
 
   * ``BTDS_No`` (in configuration: ``No``)
     Do not force break before declaration.
     ``PenaltyBreakTemplateDeclaration`` is taken into account.
 
**IfMacros** (``List of Strings``) :versionbadge:`clang-format 13`
 
   .. code-block:: yaml
 
     IfMacros: ['IF']
 
   For example: `KJ_IF_MAYBE
   <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_
 
-**IncludeBlocks** (``IncludeBlocksStyle``) :versionbadge:`clang-format 7`
+**IncludeBlocks** (``IncludeBlocksStyle``) :versionbadge:`clang-format 6`
   Dependent on the value, multiple ``#include`` blocks can be sorted
   as one and divided based on category.
 
   Possible values:
 
   * ``IBS_Preserve`` (in configuration: ``Preserve``)
     Sort each ``#include`` block separately.
 
.. code-block:: c++
 
        #include "b.h"               into      #include "a.h"
                                               #include "b.h"
        #include <lib/main.h>
        #include "a.h"                         #include <lib/main.h>
 
 
 
-**IncludeCategories** (``List of IncludeCategories``) :versionbadge:`clang-format 7`
+**IncludeCategories** (``List of IncludeCategories``) :versionbadge:`clang-format 3.8`
   Regular expressions denoting the different ``#include`` categories
   used for ordering ``#includes``.
 
   `POSIX extended
   <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html>`_
   regular expressions are supported.
 
   These regular expressions are matched against the filename of an include
IncludeCategories:
       - Regex:           '^((<|")(gtest|gmock|isl|json)/)'
         Priority:        3
       - Regex:           '<[[:alnum:].]+>'
         Priority:        4
       - Regex:           '.*'
         Priority:        1
         SortPriority:    0
 
-**IncludeIsMainRegex** (``String``) :versionbadge:`clang-format 7`
+**IncludeIsMainRegex** (``String``) :versionbadge:`clang-format 3.9`
   Specify a regular expression of suffixes that are allowed in the
   file-to-main-include mapping.
 
   When guessing whether a #include is the "main" include (to assign
   category 0, see above), use this regex of allowed suffixes to the header
   stem. A partial match is done, so that:
   - "" means "arbitrary suffix"
   - "$" means "no suffix"
 
   For example, if configured to "(_test)?$", then a header a.h would be seen
   as the "main" include in both a.cc and a_test.cc.
 
-**IncludeIsMainSourceRegex** (``String``) :versionbadge:`clang-format 7`
+**IncludeIsMainSourceRegex** (``String``) :versionbadge:`clang-format 10`
   Specify a regular expression for files being formatted
   that are allowed to be considered "main" in the
   file-to-main-include mapping.
 
   By default, clang-format considers files as "main" only when they end
   with: ``.c``, ``.cc``, ``.cpp``, ``.c++``, ``.cxx``, ``.m`` or ``.mm``
   extensions.
   For these files a guessing of "main" include takes place

clang/include/clang/Format/Format.h

enum BreakTemplateDeclarationsStyle : int8_t {
     ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,
     ///          int bbbbbbbbbbbbbbbbbbbbb) {
     ///    }
     /// \endcode
     BTDS_Yes
   };
 
   /// The template declaration breaking style to use.
-  /// \version 7
+  /// \version 3.4
   BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
 
   /// 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

clang/include/clang/Tooling/Inclusions/IncludeStyle.h

enum IncludeBlocksStyle {
     ///    #include <lib/main.h>
     ///    #include "a.h"                         #include <lib/main.h>
     /// \endcode
     IBS_Regroup,
   };
 
   /// Dependent on the value, multiple ``#include`` blocks can be sorted
   /// as one and divided based on category.
-  /// \version 7
+  /// \version 6
   IncludeBlocksStyle IncludeBlocks;
 
   /// See documentation of ``IncludeCategories``.
   struct IncludeCategory {
     /// The regular expression that this category matches.
     std::string Regex;
     /// The priority to assign to this category.
     int Priority;
struct IncludeStyle {
   ///     - Regex:           '^((<|")(gtest|gmock|isl|json)/)'
   ///       Priority:        3
   ///     - Regex:           '<[[:alnum:].]+>'
   ///       Priority:        4
   ///     - Regex:           '.*'
   ///       Priority:        1
   ///       SortPriority:    0
   /// \endcode
-  /// \version 7
+  /// \version 3.8
   std::vector<IncludeCategory> IncludeCategories;
 
   /// Specify a regular expression of suffixes that are allowed in the
   /// file-to-main-include mapping.
   ///
   /// When guessing whether a #include is the "main" include (to assign
   /// category 0, see above), use this regex of allowed suffixes to the header
   /// stem. A partial match is done, so that:
   /// - "" means "arbitrary suffix"
   /// - "$" means "no suffix"
   ///
   /// For example, if configured to "(_test)?$", then a header a.h would be seen
   /// as the "main" include in both a.cc and a_test.cc.
-  /// \version 7
+  /// \version 3.9
   std::string IncludeIsMainRegex;
 
   /// Specify a regular expression for files being formatted
   /// that are allowed to be considered "main" in the
   /// file-to-main-include mapping.
   ///
   /// By default, clang-format considers files as "main" only when they end
   /// with: ``.c``, ``.cc``, ``.cpp``, ``.c++``, ``.cxx``, ``.m`` or ``.mm``
   /// extensions.
   /// For these files a guessing of "main" include takes place
   /// (to assign category 0, see above). This config option allows for
   /// additional suffixes and extensions for files to be considered as "main".
   ///
   /// For example, if this option is configured to ``(Impl\.hpp)$``,
   /// then a file ``ClassImpl.hpp`` is considered "main" (in addition to
   /// ``Class.c``, ``Class.cc``, ``Class.cpp`` and so on) and "main
   /// include file" logic will be executed (with *IncludeIsMainRegex* setting
   /// also being respected in later phase). Without this option set,
   /// ``ClassImpl.hpp`` would not have the main include file put on top
   /// before any other include.
-  /// \version 7
+  /// \version 10
   std::string IncludeIsMainSourceRegex;
 };
 
 } // namespace tooling
 } // namespace clang
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::tooling::IncludeStyle::IncludeCategory)