[clang-tidy] Make clang-format and include-order-check coherent again

[njames93]

Summary

After D91602 gmock support was added to include-order check. However that support puts gmock and gtest headers in the same category as system headers.
ClangFormat on the other hand for LLVMStyle appears to put system headers after these 2 special cases.

This patch synchronizes the behaviour and fixes more false tidy-warnings

[kadircet]

i thought clang-format was also putting angled includes and "OtherHeaders" into same category, by looking at:

LLVMStyle.IncludeStyle.IncludeCategories = {
      {"^\"(llvm|llvm-c|clang|clang-c)/", 2, 0, false},
      {"^(<|\"(gtest|gmock|isl|json)/)", 3, 0, false},      // Starts with `<` or gtest/gmock...
      {".*", 1, 0, false}};

not sure why it is done so (stylistic preferences i suppose ...). it definitely makes sense for me to separate them into 2 different categories, but i wouldn't dare make that decision :D maybe ask on cfe-dev first to get some consensus.
but it would make sense to include isl and json in this list for now, i forgot to do that in the initial patch :(

clang-tools-extra/clang-tidy/llvm/IncludeOrderCheck.cpp

 //===--- IncludeOrderCheck.cpp - clang-tidy -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "IncludeOrderCheck.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
+#include "llvm/ADT/STLExtras.h"
 
 #include <map>
 
 namespace clang {
 namespace tidy {
 namespace llvm_check {
 
 namespace {
void IncludeOrderCheck::registerPPCallbacks(const SourceManager &SM,
   PP->addPPCallbacks(::std::make_unique<IncludeOrderPPCallbacks>(*this, SM));
 }
 
 static int getPriority(StringRef Filename, bool IsAngled, bool IsMainModule) {
   // We leave the main module header at the top.
   if (IsMainModule)
     return 0;
 
-  // LLVM and clang headers are in the penultimate position.
-  if (Filename.startswith("llvm/") || Filename.startswith("llvm-c/") ||
-      Filename.startswith("clang/") || Filename.startswith("clang-c/"))
+  auto FilenameStartsWith = [&](StringRef Search) {
+    return Filename.startswith(Search);
+  };
+
+  constexpr StringRef LLVMClangHeaders[] = {"llvm/", "llvm-c/", "clang/",
+                                            "clang-c/"};
+  constexpr StringRef OtherHeaders[] = {"gtest/", "gmock/", "isl/", "json/"};
+
+  if (llvm::any_of(LLVMClangHeaders, FilenameStartsWith))
     return 2;
 
-  // System headers are sorted to the end.
-  if (IsAngled || Filename.startswith("gtest/") ||
-      Filename.startswith("gmock/"))
+  if (llvm::any_of(OtherHeaders, FilenameStartsWith))
     return 3;
 
+  // System headers are sorted to the end.
+  if (IsAngled)
+    return 4;
+
   // Other headers are inserted between the main module header and LLVM headers.
   return 1;
 }
 
 void IncludeOrderPPCallbacks::InclusionDirective(
     SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName,
     bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File,
     StringRef SearchPath, StringRef RelativePath, const Module *Imported,

clang-tools-extra/test/clang-tidy/checkers/llvm-include-order.cpp

 // RUN: %check_clang_tidy %s llvm-include-order %t -- -- -isystem %S/Inputs/Headers
 
 // CHECK-MESSAGES: [[@LINE+2]]:1: warning: #includes are not sorted properly
 #include "j.h"
 #include "gtest/foo.h"
 #include "gmock/foo.h"
 #include "i.h"
 #include <s.h>
+#include <a.h>
 #include "llvm/a.h"
 #include "clang/b.h"
 #include "clang-c/c.h" // hi
 #include "llvm-c/d.h" // -c
 
 // CHECK-FIXES: #include "j.h"
 // CHECK-FIXES-NEXT: #include "i.h"
 // CHECK-FIXES-NEXT: #include "clang-c/c.h" // hi
 // CHECK-FIXES-NEXT: #include "clang/b.h"
 // CHECK-FIXES-NEXT: #include "llvm-c/d.h" // -c
 // CHECK-FIXES-NEXT: #include "llvm/a.h"
 // CHECK-FIXES-NEXT: #include "gmock/foo.h"
 // CHECK-FIXES-NEXT: #include "gtest/foo.h"
+// CHECK-FIXES-NEXT: #include <a.h>
 // CHECK-FIXES-NEXT: #include <s.h>
 
 #include "b.h"
 #ifdef FOO
 #include "a.h"
 #endif
 
 // CHECK-FIXES: #include "b.h"