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

[kuzkry]

Summary

Introduced by 23a5090c6, some style option markers indicated
'clang-format 11', 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:

AllowShortBlocksOnASingleLine - introduced by 17605d396118f3066a0bd4dfd128b7a8893f8b94
DeriveLineEnding - introduced by 358eaa3dcea1dee6350c2cbf80aab3c25db4d4d9
SpaceBeforeSquareBrackets - introduced by a4a7c1259e8a8f2d11fa29686a6c2834948c1358
SpaceInEmptyBlock - introduced by db4ad3603ac9bc2f118aa5f176dc04979f836c25
SpacesInConditionalStatement - introduced by 26748a321e20a7aa952ce8daa4f030c384ae7032
UseCRLF - introduced by 358eaa3dcea1dee6350c2cbf80aab3c25db4d4d9

[kuzkry]

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

[kuzkry]

Hi. Could you deliver this, please?

[kuzkry]

Kind reminder, please deliver this revision. I don't have write access.

[HazardyKnusperkeks]

In D122064#3430644, @kuzkry wrote:

Kind reminder, please deliver this revision. I don't have write access.

It's not forgotten, at least by me, but I currently have no time to update my LLVM, so I could push anything.
You just could ask for push rights, especially if you want to change something more in the future.

[kuzkry]

@owenpan, thank you for delivery.

You just could ask for push rights, especially if you want to change something more in the future.

I will request it then. Hopefully I get accepted as apparently they check for a good "record of submitting high quality patches" (from https://llvm.org/docs/DeveloperPolicy.html#obtaining-commit-access).

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
 
     false:
     void myFunction(int a,
                     int b,
                     int c,
                     int d,
                     int e);
 
-**AllowShortBlocksOnASingleLine** (``ShortBlockStyle``) :versionbadge:`clang-format 11`
+**AllowShortBlocksOnASingleLine** (``ShortBlockStyle``) :versionbadge:`clang-format 3.5`
   Dependent on the value, ``while (true) { continue; }`` can be put on a
   single line.
 
   Possible values:
 
   * ``SBS_Never`` (in configuration: ``Never``)
     Never merge blocks into a single line.
 
**BraceWrapping** (``BraceWrappingFlags``) :versionbadge:`clang-format 3.8`
   * ``bool SplitEmptyFunction`` If ``false``, empty function body can be put on a single line.
     This option is used only if the opening brace of the function has
     already been wrapped, i.e. the `AfterFunction` brace wrapping mode is
     set, and the function could/should not be put on a single line (as per
     `AllowShortFunctionsOnASingleLine` and constructor formatting options).
 
     .. code-block:: c++
 
+      false:          true:
       int f()   vs.   int f()
       {}              {
                       }
 
   * ``bool SplitEmptyRecord`` If ``false``, empty record (e.g. class, struct or union) body
     can be put on a single line. This option is used only if the opening
     brace of the record has already been wrapped, i.e. the `AfterClass`
     (for classes) brace wrapping mode is set.
 
     .. code-block:: c++
 
+      false:           true:
       class Foo   vs.  class Foo
       {}               {
                        }
 
   * ``bool SplitEmptyNamespace`` If ``false``, empty namespace body can be put on a single line.
     This option is used only if the opening brace of the namespace has
     already been wrapped, i.e. the `AfterNamespace` brace wrapping mode is
     set.
 
     .. code-block:: c++
 
+      false:               true:
       namespace Foo   vs.  namespace Foo
       {}                   {
                            }
 
 
 **BreakAfterJavaFieldAnnotations** (``Boolean``) :versionbadge:`clang-format 3.8`
   Break after each annotation on a field in Java files.
 
**Cpp11BracedListStyle** (``Boolean``) :versionbadge:`clang-format 3.4`
   .. code-block:: c++
 
      true:                                  false:
      vector<int> x{1, 2, 3, 4};     vs.     vector<int> x{ 1, 2, 3, 4 };
      vector<T> x{{}, {}, {}, {}};           vector<T> x{ {}, {}, {}, {} };
      f(MyMap[{composite, key}]);            f(MyMap[{ composite, key }]);
      new int[3]{1, 2, 3};                   new int[3]{ 1, 2, 3 };
 
-**DeriveLineEnding** (``Boolean``) :versionbadge:`clang-format 11`
+**DeriveLineEnding** (``Boolean``) :versionbadge:`clang-format 10`
   Analyze the formatted file for the most used line ending (``\r\n``
   or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
 
 **DerivePointerAlignment** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, analyze the formatted file for the most common
   alignment of ``&`` and ``*``.
   Pointer and reference alignment styles are going to be updated according
   to the preferences found in the file.
**SpaceBeforeRangeBasedForLoopColon** (``Boolean``) :versionbadge:`clang-format 7`
   If ``false``, spaces will be removed before range-based for loop
   colon.
 
   .. code-block:: c++
 
      true:                                  false:
      for (auto v : values) {}       vs.     for(auto v: values) {}
 
-**SpaceBeforeSquareBrackets** (``Boolean``) :versionbadge:`clang-format 11`
+**SpaceBeforeSquareBrackets** (``Boolean``) :versionbadge:`clang-format 10`
   If ``true``, spaces will be before  ``[``.
   Lambdas will not be affected. Only the first ``[`` will get a space added.
 
   .. code-block:: c++
 
      true:                                  false:
      int a [5];                    vs.      int a[5];
      int a [5][5];                 vs.      int a[5][5];
 
-**SpaceInEmptyBlock** (``Boolean``) :versionbadge:`clang-format 11`
+**SpaceInEmptyBlock** (``Boolean``) :versionbadge:`clang-format 10`
   If ``true``, spaces will be inserted into ``{}``.
 
   .. code-block:: c++
 
      true:                                false:
      void f() { }                   vs.   void f() {}
      while (true) { }                     while (true) {}
 

 **SpacesInCStyleCastParentheses** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces may be inserted into C style casts.
 
   .. code-block:: c++
 
      true:                                  false:
      x = ( int32 )y                 vs.     x = (int32)y
 
-**SpacesInConditionalStatement** (``Boolean``) :versionbadge:`clang-format 11`
+**SpacesInConditionalStatement** (``Boolean``) :versionbadge:`clang-format 10`
   If ``true``, spaces will be inserted around if/for/switch/while
   conditions.
 
   .. code-block:: c++
 
      true:                                  false:
      if ( a )  { ... }              vs.     if (a) { ... }
      while ( i < 5 )  { ... }               while (i < 5) { ... }
**TypenameMacros** (``List of Strings``) :versionbadge:`clang-format 9`
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     TypenameMacros: ['STACK_OF', 'LIST']
 
   For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
 
-**UseCRLF** (``Boolean``) :versionbadge:`clang-format 11`
+**UseCRLF** (``Boolean``) :versionbadge:`clang-format 10`
   Use ``\r\n`` instead of ``\n`` for line breaks.
   Also used as fallback if ``DeriveLineEnding`` is true.
 
 **UseTab** (``UseTabStyle``) :versionbadge:`clang-format 3.7`
   The way to use tab characters in the resulting file.
 
   Possible values:
 

clang/include/clang/Format/Format.h

enum ShortBlockStyle : int8_t {
     ///   while (true) {}
     ///   while (true) { continue; }
     /// \endcode
     SBS_Always,
   };
 
   /// Dependent on the value, ``while (true) { continue; }`` can be put on a
   /// single line.
-  /// \version 11
+  /// \version 3.5
   ShortBlockStyle AllowShortBlocksOnASingleLine;
 
   /// If ``true``, short case labels will be contracted to a single line.
   /// \code
   ///   true:                                   false:
   ///   switch (a) {                    vs.     switch (a) {
   ///   case 1: x = 1; break;                   case 1:
   ///   case 2: return;                           x = 1;

   ///    f(MyMap[{composite, key}]);            f(MyMap[{ composite, key }]);
   ///    new int[3]{1, 2, 3};                   new int[3]{ 1, 2, 3 };
   /// \endcode
   /// \version 3.4
   bool Cpp11BracedListStyle;
 
   /// \brief Analyze the formatted file for the most used line ending (``\r\n``
   /// or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
-  /// \version 11
+  /// \version 10
   bool DeriveLineEnding;
 
   /// If ``true``, analyze the formatted file for the most common
   /// alignment of ``&`` and ``*``.
   /// Pointer and reference alignment styles are going to be updated according
   /// to the preferences found in the file.
   /// ``PointerAlignment`` is then used only as fallback.
   /// \version 3.7
///    NS_TABLE_.*_END$"
   bool SpaceBeforeRangeBasedForLoopColon;
 
   /// If ``true``, spaces will be inserted into ``{}``.
   /// \code
   ///    true:                                false:
   ///    void f() { }                   vs.   void f() {}
   ///    while (true) { }                     while (true) {}
   /// \endcode
-  /// \version 11
+  /// \version 10
   bool SpaceInEmptyBlock;
 
   /// If ``true``, spaces may be inserted into ``()``.
   /// \code
   ///    true:                                false:
   ///    void f( ) {                    vs.   void f() {
   ///      int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
   ///      if (true) {                          if (true) {
///    NS_TABLE_.*_END$"
 
   /// If ``true``, spaces will be inserted around if/for/switch/while
   /// conditions.
   /// \code
   ///    true:                                  false:
   ///    if ( a )  { ... }              vs.     if (a) { ... }
   ///    while ( i < 5 )  { ... }               while (i < 5) { ... }
   /// \endcode
-  /// \version 11
+  /// \version 10
   bool SpacesInConditionalStatement;
 
   /// If ``true``, spaces are inserted inside container literals (e.g.
   /// ObjC and Javascript array and dict literals).
   /// \code{.js}
   ///    true:                                  false:
   ///    var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
   ///    f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});

 
   /// If ``true``, spaces will be before  ``[``.
   /// Lambdas will not be affected. Only the first ``[`` will get a space added.
   /// \code
   ///    true:                                  false:
   ///    int a [5];                    vs.      int a[5];
   ///    int a [5][5];                 vs.      int a[5][5];
   /// \endcode
-  /// \version 11
+  /// \version 10
   bool SpaceBeforeSquareBrackets;
 
   /// Styles for adding spacing around ``:`` in bitfield definitions.
   enum BitFieldColonSpacingStyle : int8_t {
     /// Add one space on each side of the ``:``
     /// \code
     ///   unsigned bf : 2;
     /// \endcode
enum UseTabStyle : int8_t {
     UT_AlignWithSpaces,
     /// Use tabs whenever we need to fill whitespace that spans at least from
     /// one tab stop to the next one.
     UT_Always
   };
 
   /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
   /// Also used as fallback if ``DeriveLineEnding`` is true.
-  /// \version 11
+  /// \version 10
   bool UseCRLF;
 
   /// The way to use tab characters in the resulting file.
   /// \version 3.7
   UseTabStyle UseTab;
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&