Support ObjC in IncludeInserter

[compositeprimes]

Summary

Update IncludeSorter/IncludeInserter to support objective-c google style (part 1):

1. Correctly consider .mm/.m extensions
2. Correctly categorize category headers.
3. Add support for generated files to go in a separate section of imports

[compositeprimes]

clang-format is complaining about my ordering of headers in my test case in IncludeInserterTest (but that's correct objc formatting). Not sure if there's a way to disable that on those lines

[alexfh]

LG

clang-tools-extra/clang-tidy/utils/IncludeSorter.h

public:
   enum IncludeStyle { IS_LLVM = 0, IS_Google = 1, IS_Google_ObjC };
 
   /// The classifications of inclusions, in the order they should be sorted.
   enum IncludeKinds {
     IK_MainTUInclude = 0,    ///< e.g. ``#include "foo.h"`` when editing foo.cc
     IK_CSystemInclude = 1,   ///< e.g. ``#include <stdio.h>``
     IK_CXXSystemInclude = 2, ///< e.g. ``#include <vector>``
     IK_NonSystemInclude = 3, ///< e.g. ``#include "bar.h"``
-    IK_InvalidInclude = 4    ///< total number of valid ``IncludeKind``s
+    IK_GeneratedInclude = 4, ///< e.g. ``#include "bar.proto.h"``
+    IK_InvalidInclude = 5    ///< total number of valid ``IncludeKind``s
   };
 
   /// ``IncludeSorter`` constructor; takes the FileID and name of the file to be
   /// processed by the sorter.
   IncludeSorter(const SourceManager *SourceMgr, const FileID FileID,
                 StringRef FileName, IncludeStyle Style);
 
   /// Adds the given include directive to the sorter.

clang-tools-extra/clang-tidy/utils/IncludeSorter.cpp

std::string ProtoCanonicalInclude =
         Parts.first.str() + "/proto/" + Parts.second.str();
 
     // Determine the kind of this inclusion.
     if (CanonicalFile.equals(AltCanonicalInclude) ||
         CanonicalFile.equals(ProtoCanonicalInclude)) {
       return IncludeSorter::IK_MainTUInclude;
     }
   }
+  if (Style == IncludeSorter::IS_Google_ObjC) {
+    if (IncludeFile.endswith(".generated.h") ||
+        IncludeFile.endswith(".proto.h") || IncludeFile.endswith(".pbobjc.h")) {
+      return IncludeSorter::IK_GeneratedInclude;
+    }
+  }
   return IncludeSorter::IK_NonSystemInclude;
 }
 
 
 int CompareHeaders(StringRef LHS, StringRef RHS,
                    IncludeSorter::IncludeStyle Style) {
   if (Style == IncludeSorter::IncludeStyle::IS_Google_ObjC) {
     const std::pair<const char *, const char *> &mismatch =

clang-tools-extra/unittests/clang-tidy/IncludeInserterTest.cpp

ObjCCategoryHeaderInserterCheck(StringRef CheckName,
       : IncludeInserterCheckBase(CheckName, Context,
                                  utils::IncludeSorter::IS_Google_ObjC) {}
 
   std::vector<StringRef> headersToInclude() const override {
     return {"clang_tidy/tests/insert_includes_test_header+foo.h"};
   }
 };
 
+class ObjCGeneratedHeaderInserterCheck : public IncludeInserterCheckBase {
+public:
+  ObjCGeneratedHeaderInserterCheck(StringRef CheckName,
+                                         ClangTidyContext *Context)
+      : IncludeInserterCheckBase(CheckName, Context,
+                                 utils::IncludeSorter::IS_Google_ObjC) {}
+
+  std::vector<StringRef> headersToInclude() const override {
+    return {"clang_tidy/tests/generated_file.proto.h"};
+  }
+};
+
 template <typename Check>
 std::string runCheckOnCode(StringRef Code, StringRef Filename) {
   std::vector<ClangTidyError> Errors;
   return test::runCheckOnCode<Check>(Code, &Errors, Filename, None,
                                      ClangTidyOptions(),
                                      {// Main file include
                                       {"clang_tidy/tests/"
                                        "insert_includes_test_header.h",
                                        "\n"},
                                       // ObjC category.
                                       {"clang_tidy/tests/"
                                        "insert_includes_test_header+foo.h",
                                        "\n"},
                                       // Non system headers
                                       {"a/header.h", "\n"},
                                       {"path/to/a/header.h", "\n"},
                                       {"path/to/z/header.h", "\n"},
                                       {"path/to/header.h", "\n"},
                                       {"path/to/header2.h", "\n"},
+                                      // Generated headers
+                                      {"clang_tidy/tests/"
+                                       "generated_file.proto.h", "\n"},
                                       // Fake system headers.
                                       {"stdlib.h", "\n"},
                                       {"unistd.h", "\n"},
                                       {"list", "\n"},
                                       {"map", "\n"},
                                       {"set", "\n"},
                                       {"vector", "\n"}});
 }
void foo() {
   int a = 0;
 })";
 
   EXPECT_EQ(PostCode, runCheckOnCode<ObjCCategoryHeaderInserterCheck>(
                           PreCode, "devtools/cymbal/clang_tidy/tests/"
                                    "insert_includes_test_header.mm"));
 }
 
+TEST(IncludeInserterTest, InsertGeneratedHeaderObjectiveC) {
+  const char *PreCode = R"(
+#import "clang_tidy/tests/insert_includes_test_header.h"
+
+#include <list>
+#include <map>
+
+#include "path/to/a/header.h"
+
+void foo() {
+  int a = 0;
+})";
+  const char *PostCode = R"(
+#import "clang_tidy/tests/insert_includes_test_header.h"
+
+#include <list>
+#include <map>
+
+#include "path/to/a/header.h"
+
+#import "clang_tidy/tests/generated_file.proto.h"
+
+void foo() {
+  int a = 0;
+})";
+
+  EXPECT_EQ(PostCode, runCheckOnCode<ObjCGeneratedHeaderInserterCheck>(
+                          PreCode, "devtools/cymbal/clang_tidy/tests/"
+                                   "insert_includes_test_header.mm"));
+}
+
 } // anonymous namespace
 } // namespace tidy
 } // namespace clang
 
 #endif