[clang][deps] Teach dep directive scanner about #pragma clang system_header

[benlangmuir]

Summary

This ensures we get the correct FileCharacteristic during scanning. In a
yet-to-be-upstreamed branch this fixes observable failures, but it's
also good to handle this on principle: the FileCharacteristic is a
property of the file that is observable in the scanner, so there is
nothing preventing us from depending on it.

rdar://108627403

clang/include/clang/Lex/DependencyDirectivesScanner.h

enum DirectiveKind : uint8_t {
   pp_define,
   pp_undef,
   pp_import,
   pp_pragma_import,
   pp_pragma_once,
   pp_pragma_push_macro,
   pp_pragma_pop_macro,
   pp_pragma_include_alias,
+  pp_pragma_system_header,
   pp_include_next,
   pp_if,
   pp_ifdef,
   pp_ifndef,
   pp_elif,
   pp_elifdef,
   pp_elifndef,
   pp_else,

clang/lib/Lex/DependencyDirectivesScanner.cpp

if (Kind != pp_none) {
     return false;
   }
 
   if (Id != "clang") {
     skipLine(First, End);
     return false;
   }
 
-  // #pragma clang.
-  if (!isNextIdentifierOrSkipLine("module", First, End))
+  FoundId = tryLexIdentifierOrSkipLine(First, End);
+  if (!FoundId)
     return false;
+  Id = *FoundId;
+
+  // #pragma clang system_header
+  if (Id == "system_header") {
+    lexPPDirectiveBody(First, End);
+    pushDirective(pp_pragma_system_header);
+    return false;
+  }
+
+  if (Id != "module") {
+    skipLine(First, End);
+    return false;
+  }
 
   // #pragma clang module.
   if (!isNextIdentifierOrSkipLine("import", First, End))
     return false;
 
   // #pragma clang module import.
   lexPPDirectiveBody(First, End);
   pushDirective(pp_pragma_import);

clang/lib/Lex/Lexer.cpp

do {
     case pp_define:
     case pp_undef:
     case pp_import:
     case pp_pragma_import:
     case pp_pragma_once:
     case pp_pragma_push_macro:
     case pp_pragma_pop_macro:
     case pp_pragma_include_alias:
+    case pp_pragma_system_header:
     case pp_include_next:
     case decl_at_import:
     case cxx_module_decl:
     case cxx_import_decl:
     case cxx_export_module_decl:
     case cxx_export_import_decl:
     case tokens_present_before_eof:
       break;

clang/unittests/Lex/DependencyDirectivesScannerTest.cpp

ASSERT_FALSE(
                                            "#__include_macros <A>\n"
                                            "#import <A>\n"
                                            "@import A;\n"
                                            "#pragma clang module import A\n"
                                            "#pragma push_macro(A)\n"
                                            "#pragma pop_macro(A)\n"
                                            "#pragma include_alias(<A>, <B>)\n"
                                            "export module m;\n"
-                                           "import m;\n",
+                                           "import m;\n"
+                                           "#pragma clang system_header\n",
                                            Out, Tokens, Directives));
   EXPECT_EQ(pp_define, Directives[0].Kind);
   EXPECT_EQ(pp_undef, Directives[1].Kind);
   EXPECT_EQ(pp_endif, Directives[2].Kind);
   EXPECT_EQ(pp_if, Directives[3].Kind);
   EXPECT_EQ(pp_ifdef, Directives[4].Kind);
   EXPECT_EQ(pp_ifndef, Directives[5].Kind);
   EXPECT_EQ(pp_elifdef, Directives[6].Kind);
   EXPECT_EQ(pp_elifndef, Directives[7].Kind);
   EXPECT_EQ(pp_elif, Directives[8].Kind);
   EXPECT_EQ(pp_else, Directives[9].Kind);
   EXPECT_EQ(pp_include, Directives[10].Kind);
   EXPECT_EQ(pp_include_next, Directives[11].Kind);
   EXPECT_EQ(pp___include_macros, Directives[12].Kind);
   EXPECT_EQ(pp_import, Directives[13].Kind);
   EXPECT_EQ(decl_at_import, Directives[14].Kind);
   EXPECT_EQ(pp_pragma_import, Directives[15].Kind);
   EXPECT_EQ(pp_pragma_push_macro, Directives[16].Kind);
   EXPECT_EQ(pp_pragma_pop_macro, Directives[17].Kind);
   EXPECT_EQ(pp_pragma_include_alias, Directives[18].Kind);
   EXPECT_EQ(cxx_export_module_decl, Directives[19].Kind);
   EXPECT_EQ(cxx_import_decl, Directives[20].Kind);
-  EXPECT_EQ(pp_eof, Directives[21].Kind);
+  EXPECT_EQ(pp_pragma_system_header, Directives[21].Kind);
+  EXPECT_EQ(pp_eof, Directives[22].Kind);
 }
 
 TEST(MinimizeSourceToDependencyDirectivesTest, EmptyHash) {
   SmallVector<char, 128> Out;
 
   ASSERT_FALSE(
       minimizeSourceToDependencyDirectives("#\n#define MACRO a\n", Out));
   EXPECT_STREQ("#define MACRO a\n", Out.data());