[clang-format] Rename case sorting

[HazardyKnusperkeks]

Summary

As discussed in D95017 the names case sensitive and insensitive should be switched.

[curdeius]

LGTM. It's indeed more logical this way.
Hopefully the original author will confirm.

[PragmaNull]

Thank you!

[HazardyKnusperkeks]

In D97927#2603089, @curdeius wrote:

LGTM. It's indeed more logical this way.
Hopefully the original author will confirm.

I'll give him one week, if he or nobody else comes along to object I'll push it.

[kentsommer]

LGTM

Sorry for the slow response!

[HazardyKnusperkeks]

In D97927#2605914, @kentsommer wrote:

LGTM

Sorry for the slow response!

No problem, we all have some phases where we don't have or find the time.

clang/docs/ClangFormatStyleOptions.rst

* ``SI_Never`` (in configuration: ``Never``)
     .. code-block:: c++
 
        #include "B/A.h"
        #include "A/B.h"
        #include "a/b.h"
        #include "A/b.h"
        #include "B/a.h"
 
-  * ``SI_CaseInsensitive`` (in configuration: ``CaseInsensitive``)
-    Includes are sorted in an ASCIIbetical or case insensitive fashion.
+  * ``SI_CaseSensitive`` (in configuration: ``CaseSensitive``)
+    Includes are sorted in an ASCIIbetical or case sensitive fashion.
 
     .. code-block:: c++
 
        #include "A/B.h"
        #include "A/b.h"
        #include "B/A.h"
        #include "B/a.h"
        #include "a/b.h"
 
-  * ``SI_CaseSensitive`` (in configuration: ``CaseSensitive``)
-    Includes are sorted in an alphabetical or case sensitive fashion.
+  * ``SI_CaseInsensitive`` (in configuration: ``CaseInsensitive``)
+    Includes are sorted in an alphabetical or case insensitive fashion.
 
     .. code-block:: c++
 
        #include "A/B.h"
        #include "A/b.h"
        #include "a/b.h"
        #include "B/A.h"
        #include "B/a.h"

clang/docs/ReleaseNotes.rst

 clang-format
 ------------
 
 - Option ``SpacesInLineCommentPrefix`` has been added to control the
   number of spaces in a line comments prefix.
 
 - Option ``SortIncludes`` has been updated from a ``bool`` to an
   ``enum`` with backwards compatibility. In addition to the previous
-  ``true``/``false`` states (now ``CaseInsensitive``/``Never``), a third
-  state has been added (``CaseSensitive``) which causes an alphabetical sort
+  ``true``/``false`` states (now ``CaseSensitive``/``Never``), a third
+  state has been added (``CaseInsensitive``) which causes an alphabetical sort
   with case used as a tie-breaker.
 
   .. code-block:: c++
 
     // Never (previously false)
     #include "B/A.h"
     #include "A/B.h"
     #include "a/b.h"
     #include "A/b.h"
     #include "B/a.h"
 
-    // CaseInsensitive (previously true)
+    // CaseSensitive (previously true)
     #include "A/B.h"
     #include "A/b.h"
     #include "B/A.h"
     #include "B/a.h"
     #include "a/b.h"
 
-    // CaseSensitive
+    // CaseInsensitive
     #include "A/B.h"
     #include "A/b.h"
     #include "a/b.h"
     #include "B/A.h"
     #include "B/a.h"
 
 - ``BasedOnStyle: InheritParentConfig`` allows to use the ``.clang-format`` of
   the parent directories to overwrite only parts of it.

clang/include/clang/Format/Format.h

enum SortIncludesOptions : unsigned char {
     /// \code
     ///    #include "B/A.h"
     ///    #include "A/B.h"
     ///    #include "a/b.h"
     ///    #include "A/b.h"
     ///    #include "B/a.h"
     /// \endcode
     SI_Never,
-    /// Includes are sorted in an ASCIIbetical or case insensitive fashion.
+    /// Includes are sorted in an ASCIIbetical or case sensitive fashion.
     /// \code
     ///    #include "A/B.h"
     ///    #include "A/b.h"
     ///    #include "B/A.h"
     ///    #include "B/a.h"
     ///    #include "a/b.h"
     /// \endcode
-    SI_CaseInsensitive,
-    /// Includes are sorted in an alphabetical or case sensitive fashion.
+    SI_CaseSensitive,
+    /// Includes are sorted in an alphabetical or case insensitive fashion.
     /// \code
     ///    #include "A/B.h"
     ///    #include "A/b.h"
     ///    #include "a/b.h"
     ///    #include "B/A.h"
     ///    #include "B/a.h"
     /// \endcode
-    SI_CaseSensitive,
+    SI_CaseInsensitive,
   };
 
   /// Controls if and how clang-format will sort ``#includes``.
   /// If ``Never``, includes are never sorted.
   /// If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
   /// insensitive fashion.
   /// If ``CaseSensitive``, includes are sorted in an alphabetical or case
   /// sensitive fashion.

clang/lib/Format/Format.cpp

 template <> struct ScalarEnumerationTraits<FormatStyle::SortIncludesOptions> {
   static void enumeration(IO &IO, FormatStyle::SortIncludesOptions &Value) {
     IO.enumCase(Value, "Never", FormatStyle::SI_Never);
     IO.enumCase(Value, "CaseInsensitive", FormatStyle::SI_CaseInsensitive);
     IO.enumCase(Value, "CaseSensitive", FormatStyle::SI_CaseSensitive);
 
     // For backward compatibility.
     IO.enumCase(Value, "false", FormatStyle::SI_Never);
-    IO.enumCase(Value, "true", FormatStyle::SI_CaseInsensitive);
+    IO.enumCase(Value, "true", FormatStyle::SI_CaseSensitive);
   }
 };
 
 template <>
 struct ScalarEnumerationTraits<FormatStyle::SortJavaStaticImportOptions> {
   static void enumeration(IO &IO,
                           FormatStyle::SortJavaStaticImportOptions &Value) {
     IO.enumCase(Value, "Before", FormatStyle::SJSIO_Before);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.PenaltyBreakString = 1000;
   LLVMStyle.PenaltyExcessCharacter = 1000000;
   LLVMStyle.PenaltyReturnTypeOnItsOwnLine = 60;
   LLVMStyle.PenaltyBreakBeforeFirstCallParameter = 19;
   LLVMStyle.PenaltyBreakTemplateDeclaration = prec::Relational;
   LLVMStyle.PenaltyIndentedWhitespace = 0;
 
   LLVMStyle.DisableFormat = false;
-  LLVMStyle.SortIncludes = FormatStyle::SI_CaseInsensitive;
+  LLVMStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
   LLVMStyle.SortJavaStaticImport = FormatStyle::SJSIO_Before;
   LLVMStyle.SortUsingDeclarations = true;
   LLVMStyle.StatementAttributeLikeMacros.push_back("Q_EMIT");
   LLVMStyle.StatementMacros.push_back("Q_UNUSED");
   LLVMStyle.StatementMacros.push_back("QT_REQUIRE_VERSION");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("STRINGIZE");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("PP_STRINGIZE");
   LLVMStyle.WhitespaceSensitiveMacros.push_back("BOOST_PP_STRINGIZE");
ChromiumStyle.JavaImportGroups = {
         "dalvik",
         "junit",
         "org",
         "com.google.android.apps.chrome",
         "org.chromium",
         "java",
         "javax",
     };
-    ChromiumStyle.SortIncludes = FormatStyle::SI_CaseInsensitive;
+    ChromiumStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
   } else if (Language == FormatStyle::LK_JavaScript) {
     ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
   } else {
     ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
     ChromiumStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
     ChromiumStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
     ChromiumStyle.AllowShortLoopsOnASingleLine = false;
static void sortCppIncludes(const FormatStyle &Style,
   unsigned IncludesBlockSize = IncludesEndOffset - IncludesBeginOffset;
   if (!affectsRange(Ranges, IncludesBeginOffset, IncludesEndOffset))
     return;
   SmallVector<unsigned, 16> Indices;
   for (unsigned i = 0, e = Includes.size(); i != e; ++i) {
     Indices.push_back(i);
   }
 
-  if (Style.SortIncludes == FormatStyle::SI_CaseSensitive) {
+  if (Style.SortIncludes == FormatStyle::SI_CaseInsensitive) {
     llvm::stable_sort(Indices, [&](unsigned LHSI, unsigned RHSI) {
       const auto LHSFilenameLower = Includes[LHSI].Filename.lower();
       const auto RHSFilenameLower = Includes[RHSI].Filename.lower();
       return std::tie(Includes[LHSI].Priority, LHSFilenameLower,
                       Includes[LHSI].Filename) <
              std::tie(Includes[RHSI].Priority, RHSFilenameLower,
                       Includes[RHSI].Filename);
     });

clang/tools/clang-format/ClangFormat.cpp

llvm::Expected<FormatStyle> FormatStyle =
                nullptr, WNoErrorList.isSet(WNoError::Unknown));
   if (!FormatStyle) {
     llvm::errs() << llvm::toString(FormatStyle.takeError()) << "\n";
     return true;
   }
 
   if (SortIncludes.getNumOccurrences() != 0) {
     if (SortIncludes)
-      FormatStyle->SortIncludes = FormatStyle::SI_CaseInsensitive;
+      FormatStyle->SortIncludes = FormatStyle::SI_CaseSensitive;
     else
       FormatStyle->SortIncludes = FormatStyle::SI_Never;
   }
   unsigned CursorPosition = Cursor;
   Replacements Replaces = sortIncludes(*FormatStyle, Code->getBuffer(), Ranges,
                                        AssumedFileName, &CursorPosition);
   auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(), Replaces);
   if (!ChangedCode) {

clang/unittests/Format/FormatTest.cpp

CHECK_PARSE("IncludeCategories:\n"
               IncludeStyle.IncludeCategories, ExpectedCategories);
   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
               "abc$");
   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
 
   Style.SortIncludes = FormatStyle::SI_Never;
   CHECK_PARSE("SortIncludes: true", SortIncludes,
-              FormatStyle::SI_CaseInsensitive);
+              FormatStyle::SI_CaseSensitive);
   CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
   CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
               FormatStyle::SI_CaseInsensitive);
   CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
               FormatStyle::SI_CaseSensitive);
   CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
 
   Style.RawStringFormats.clear();
std::string Expected = "#include \"a.h\"\n"
                          "  return 0;\n"
                          "}";
   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
   tooling::Replacements Replaces = toReplacements(
       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
                             "#include \"b.h\"\n")});
 
   format::FormatStyle Style = format::getLLVMStyle();
-  Style.SortIncludes = FormatStyle::SI_CaseInsensitive;
+  Style.SortIncludes = FormatStyle::SI_CaseSensitive;
   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
       << llvm::toString(FormattedReplaces.takeError()) << "\n";
   auto Result = applyAllReplacements(Code, *FormattedReplaces);
   EXPECT_TRUE(static_cast<bool>(Result));
   EXPECT_EQ(Expected, *Result);
 }
 

clang/unittests/Format/SortIncludesTest.cpp

EXPECT_EQ("#include \"a.h\"\n"
             sort("#include \"b.h\"\n"
                  "\n"
                  "#include \"a.h\"\n"
                  "#include \"c.h\"\n",
                  "a.cc"));
 }
 
 TEST_F(SortIncludesTest, SupportOptionalCaseSensitiveSorting) {
-  EXPECT_FALSE(FmtStyle.SortIncludes == FormatStyle::SI_CaseSensitive);
+  EXPECT_FALSE(FmtStyle.SortIncludes == FormatStyle::SI_CaseInsensitive);
 
-  FmtStyle.SortIncludes = FormatStyle::SI_CaseSensitive;
+  FmtStyle.SortIncludes = FormatStyle::SI_CaseInsensitive;
 
   EXPECT_EQ("#include \"A/B.h\"\n"
             "#include \"A/b.h\"\n"
             "#include \"a/b.h\"\n"
             "#include \"B/A.h\"\n"
             "#include \"B/a.h\"\n",
             sort("#include \"B/a.h\"\n"
                  "#include \"B/A.h\"\n"