-frewrite-includes: Fix support for __has_include_next

[davve]

Summary

-frewrite-includes: Fix support for __has_include_next

__has_include_next handling inside -frewrite-includes had two
issues. First the Lookup parameter passed to HandleHasInclude was
unused and second, the Lookup paramenter pass was always nullptr and
thus never incremented as intended for __has_include_next
functionality to work.

-frewrite-includes works in two stages. The first stage runs the
preprocessor on the entire file and through callbacks records included
files. The second stage steps through the file again using the raw
lexer and replaces include directives with the recorded includes from
stage one. However in the second stage, the current directory lookup
is not maintained inside PP and PP.GetCurDirLookup() would always
return nullptr.

Instead of relying on PP.GetCurDirLookup(), use HeaderSearch to find
the lookup for the current file and move past it. Update the testsuite
to depend on the new behaviour instead of the old.

Fixes PR26828.

[davve]

Eugene Velesevich noted in the bug that the patch is broken for multiple levels of headers:

Patch seems work only for first header with same name. I.e. code below finds first header even clang parses second or third ones. Thus __has_include_next is always true if there are two or more headers with same name.

Code below being the extra added LookupFile call.

lib/Frontend/Rewrite/InclusionRewriter.cpp

   void CommentOutDirective(Lexer &DirectivesLex, const Token &StartToken,
                            const MemoryBuffer &FromFile, StringRef EOL,
                            unsigned &NextToWrite, int &Lines);
+  enum HasIncludeKind { HasIncludeNormal, HasIncludeNext };
   bool HandleHasInclude(FileID FileId, Lexer &RawLex,
-                        const DirectoryLookup *Lookup, Token &Tok,
+                        HasIncludeKind HasIncludeVariant, Token &Tok,
                         bool &FileExists);
   const IncludedFile *FindIncludeAtLocation(SourceLocation Loc) const;
   const Module *FindModuleAtLocation(SourceLocation Loc) const;

 // Expand __has_include and __has_include_next if possible. If there's no
 // definitive answer return false.
 bool InclusionRewriter::HandleHasInclude(
-    FileID FileId, Lexer &RawLex, const DirectoryLookup *Lookup, Token &Tok,
+    FileID FileId, Lexer &RawLex, HasIncludeKind HasIncludeVariant, Token &Tok,
     bool &FileExists) {
   // Lex the opening paren.
   RawLex.LexFromRawLexer(Tok);

   // Now ask HeaderInfo if it knows about the header.
   // FIXME: Subframeworks aren't handled here. Do we care?
   bool isAngled = PP.GetIncludeFilenameSpelling(Tok.getLocation(), Filename);
-  const DirectoryLookup *CurDir;
   const FileEntry *FileEnt = PP.getSourceManager().getFileEntryForID(FileId);
   SmallVector<std::pair<const FileEntry *, const DirectoryEntry *>, 1>
       Includers;
   Includers.push_back(std::make_pair(FileEnt, FileEnt->getDir()));
+  const DirectoryLookup *Lookup = nullptr;
+
+  if (HasIncludeVariant == HasIncludeNext) {
+    // Find lookup for file and move past it.
+    PP.getHeaderSearchInfo().LookupFile(Filename, SourceLocation(), isAngled,
+                                        nullptr, Lookup, Includers, nullptr,
+                                        nullptr, nullptr, nullptr, false);
+    if (Lookup)
+      Lookup++;
+  }
+
+  const DirectoryLookup *CurDir;
   // FIXME: Why don't we call PP.LookupFile here?
   const FileEntry *File = PP.getHeaderSearchInfo().LookupFile(
-      Filename, SourceLocation(), isAngled, nullptr, CurDir, Includers, nullptr,
+      Filename, SourceLocation(), isAngled, Lookup, CurDir, Includers, nullptr,
       nullptr, nullptr, nullptr, false);
 
   FileExists = File != nullptr;

 
                 // Rewrite __has_include(x)
                 if (RawToken.getIdentifierInfo()->isStr("__has_include")) {
-                  if (!HandleHasInclude(FileId, RawLex, nullptr, RawToken,
+                  if (!HandleHasInclude(FileId, RawLex, HasIncludeNormal, RawToken,
                                         HasFile))
                     continue;
                   // Rewrite __has_include_next(x)
                 } else if (RawToken.getIdentifierInfo()->isStr(
                                "__has_include_next")) {
-                  const DirectoryLookup *Lookup = PP.GetCurDirLookup();
-                  if (Lookup)
-                    ++Lookup;
-
-                  if (!HandleHasInclude(FileId, RawLex, Lookup, RawToken,
+                  if (!HandleHasInclude(FileId, RawLex, HasIncludeNext, RawToken,
                                         HasFile))
                     continue;
                 } else {

test/Frontend/rewrite-includes.c

 // CHECK-NEXT: {{^}}#endif /* expanded by -frewrite-includes */{{$}}
 // CHECK-NEXT: {{^}}# 22 "{{.*}}rewrite-includes.c"{{$}}
 // CHECK-NEXT: {{^}}# 1 "{{.*[/\\]Inputs(/|\\\\)}}rewrite-includes8.h" 1{{$}}
-// CHECK-NEXT: {{^}}#if (1)/*__has_include_next(<rewrite-includes8.h>)*/{{$}}
+// CHECK-NEXT: {{^}}#if (0)/*__has_include_next(<rewrite-includes8.h>)*/{{$}}
 // CHECK-NEXT: {{^}}#elif (0)/*__has_include(<rewrite-includes8.hfail>)*/{{$}}
 // CHECK-NEXT: {{^}}# 3 "{{.*[/\\]Inputs(/|\\\\)}}rewrite-includes8.h"{{$}}
 // CHECK-NEXT: {{^}}#endif{{$}}

 // CHECKNL-NEXT: {{^}}#if 0 /* expanded by -frewrite-includes */{{$}}
 // CHECKNL-NEXT: {{^}}#include "rewrite-includes8.h"{{$}}
 // CHECKNL-NEXT: {{^}}#endif /* expanded by -frewrite-includes */{{$}}
-// CHECKNL-NEXT: {{^}}#if (1)/*__has_include_next(<rewrite-includes8.h>)*/{{$}}
+// CHECKNL-NEXT: {{^}}#if (0)/*__has_include_next(<rewrite-includes8.h>)*/{{$}}
 // CHECKNL-NEXT: {{^}}#elif (0)/*__has_include(<rewrite-includes8.hfail>)*/{{$}}
 // CHECKNL-NEXT: {{^}}#endif{{$}}
 // CHECKNL-NEXT: {{^}}#if !(1)/*__has_include("rewrite-includes8.h")*/{{$}}