Do not print certain warnings when input is a header.

[erikjv]

Summary

When generating pre-compiled headers, or when opening a header file with
libclang, suppress the warnings "#pragma once in main file" and
"#include_next in primary source file".

Fixes PR16686 and PR24390.

[mehdi_amini]

include/clang/Basic/SourceManager.h

660

Document?

764

Variable should start with a capital

include/clang/Frontend/FrontendOptions.h

91

Document

[erikjv]

ping?

[aaron.ballman]

include/clang/Basic/LangOptions.h

131 ↗

(On Diff #60023)

Should move the initializer to the constructor (not certain that MSVC 2013 supports this construct, but it's also more consistent).

[mehdi_amini]

include/clang/Basic/LangOptions.h

131 ↗

(On Diff #60023)

Interestingly I prefer to have them on the fields themselves (when writing new struct/classes), but I agree that consistency takes precedence when adding a field to an existing class.

include/clang/Basic/SourceManager.h

class SourceManager : public RefCountedBase<SourceManager> {
   mutable FileID LastLineNoFileIDQuery;
   mutable SrcMgr::ContentCache *LastLineNoContentCache;
   mutable unsigned LastLineNoFilePos;
   mutable unsigned LastLineNoResult;
 
   /// \brief The file ID for the main source file of the translation unit.
   FileID MainFileID;
 
+  bool MainFileIsHeader = false;
+
   /// \brief The file ID for the precompiled preamble there is one.
   FileID PreambleFileID;
 
   // Statistics for -print-stats.
   mutable unsigned NumLinearScans, NumBinaryProbes;
 
   /// \brief Associates a FileID with its "included/expanded in" decomposed
   /// location.
public:
   /// \brief Returns the FileID of the main source file.
   FileID getMainFileID() const { return MainFileID; }
 
   /// \brief Set the file ID for the main source file.
   void setMainFileID(FileID FID) {
     MainFileID = FID;
   }
 
+  void setMainFileHeader(bool mainFileIsHeader) {
+    MainFileIsHeader = mainFileIsHeader;
+  }
+
+  bool isMainFileHeader() const {
+    return MainFileIsHeader;
+  }
+
   /// \brief Set the file ID for the precompiled preamble.
   void setPreambleFileID(FileID Preamble) {
     assert(PreambleFileID.isInvalid() && "PreambleFileID already set!");
     PreambleFileID = Preamble;
   }
 
   /// \brief Get the file ID for the precompiled preamble if there is one.
   FileID getPreambleFileID() const { return PreambleFileID; }

include/clang/Frontend/FrontendOptions.h

class FrontendInputFile {
   /// \brief The file name, or "-" to read from standard input.
   std::string File;
 
   llvm::MemoryBuffer *Buffer;
 
   /// \brief The kind of input, e.g., C source, AST file, LLVM IR.
   InputKind Kind;
 
+  bool IsHeader;
+
   /// \brief Whether we're dealing with a 'system' input (vs. a 'user' input).
   bool IsSystem;
 
 public:
   FrontendInputFile() : Buffer(nullptr), Kind(IK_None), IsSystem(false) { }
-  FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
-    : File(File.str()), Buffer(nullptr), Kind(Kind), IsSystem(IsSystem) { }
-  FrontendInputFile(llvm::MemoryBuffer *buffer, InputKind Kind,
+  FrontendInputFile(StringRef File, InputKind Kind, bool IsHeader = false,
                     bool IsSystem = false)
-    : Buffer(buffer), Kind(Kind), IsSystem(IsSystem) { }
+    : File(File.str()), Buffer(nullptr), Kind(Kind), IsHeader(IsHeader)
+    , IsSystem(IsSystem) { }
+  FrontendInputFile(llvm::MemoryBuffer *buffer, InputKind Kind,
+                    bool IsHeader = false, bool IsSystem = false)
+    : Buffer(buffer), Kind(Kind), IsHeader(IsHeader), IsSystem(IsSystem) { }
 
   InputKind getKind() const { return Kind; }
+  bool isHeader() const { return IsHeader; }
   bool isSystem() const { return IsSystem; }
 
   bool isEmpty() const { return File.empty() && Buffer == nullptr; }
   bool isFile() const { return !isBuffer(); }
   bool isBuffer() const { return Buffer != nullptr; }
 
   StringRef getFile() const {
     assert(isFile());

lib/Frontend/CompilerInstance.cpp

 
 bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
                                                DiagnosticsEngine &Diags,
                                                FileManager &FileMgr,
                                                SourceManager &SourceMgr,
                                                const FrontendOptions &Opts) {
   SrcMgr::CharacteristicKind
     Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
+  SourceMgr.setMainFileHeader(Input.isHeader());
 
   if (Input.isBuffer()) {
     SourceMgr.setMainFileID(SourceMgr.createFileID(
         std::unique_ptr<llvm::MemoryBuffer>(Input.getBuffer()), Kind));
     assert(SourceMgr.getMainFileID().isValid() &&
            "Couldn't establish MainFileID!");
     return true;
   }

lib/Frontend/CompilerInvocation.cpp

static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
 
   if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
       Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
     Diags.Report(diag::err_drv_argument_not_allowed_with)
       << "ARC migration" << "ObjC migration";
   }
 
   InputKind DashX = IK_None;
+  bool IsHeader = false;
   if (const Arg *A = Args.getLastArg(OPT_x)) {
     DashX = llvm::StringSwitch<InputKind>(A->getValue())
       .Case("c", IK_C)
       .Case("cl", IK_OpenCL)
       .Case("cuda", IK_CUDA)
       .Case("c++", IK_CXX)
       .Case("objective-c", IK_ObjC)
       .Case("objective-c++", IK_ObjCXX)
DashX = llvm::StringSwitch<InputKind>(A->getValue())
       .Case("c++-header", IK_CXX)
       .Case("objective-c++-header", IK_ObjCXX)
       .Cases("ast", "pcm", IK_AST)
       .Case("ir", IK_LLVM_IR)
       .Default(IK_None);
     if (DashX == IK_None)
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << A->getValue();
+    IsHeader = llvm::StringSwitch<bool>(A->getValue())
+        .Case("c-header", true)
+        .Case("cl-header", true)
+        .Case("objective-c-header", true)
+        .Case("c++-header", true)
+        .Case("objective-c++-header", true)
+        .Default(false);
   }
 
   // '-' is the default input if none is given.
   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
   Opts.Inputs.clear();
   if (Inputs.empty())
     Inputs.push_back("-");
   for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
     InputKind IK = DashX;
     if (IK == IK_None) {
       IK = FrontendOptions::getInputKindForExtension(
         StringRef(Inputs[i]).rsplit('.').second);
       // FIXME: Remove this hack.
       if (i == 0)
         DashX = IK;
     }
-    Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
+    Opts.Inputs.emplace_back(std::move(Inputs[i]), IK, IsHeader);
   }
 
   return DashX;
 }
 
 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
                                                  void *MainAddr) {
   std::string ClangExecutable =

lib/Frontend/FrontendActions.cpp

bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI,
   // be resolved relative to the build directory of the module map file.
   CI.getPreprocessor().setMainFileDir(Module->Directory);
 
   std::unique_ptr<llvm::MemoryBuffer> InputBuffer =
       llvm::MemoryBuffer::getMemBufferCopy(HeaderContents,
                                            Module::getModuleInputBufferName());
   // Ownership of InputBuffer will be transferred to the SourceManager.
   setCurrentInput(FrontendInputFile(InputBuffer.release(), getCurrentFileKind(),
-                                    Module->IsSystem));
+                                    false, Module->IsSystem));
   return true;
 }
 
 raw_pwrite_stream *GenerateModuleAction::ComputeASTConsumerArguments(
     CompilerInstance &CI, StringRef InFile, std::string &Sysroot,
     std::string &OutputFile) {
   // If no output file was provided, figure out where this module would go
   // in the module cache.

lib/Lex/PPDirectives.cpp

void Preprocessor::HandleIncludeNextDirective(SourceLocation HashLoc,
                                               Token &IncludeNextTok) {
   Diag(IncludeNextTok, diag::ext_pp_include_next_directive);
 
   // #include_next is like #include, except that we start searching after
   // the current found directory.  If we can't do this, issue a
   // diagnostic.
   const DirectoryLookup *Lookup = CurDirLookup;
   const FileEntry *LookupFromFile = nullptr;
-  if (isInPrimaryFile()) {
+  if (isInPrimaryFile() && SourceMgr.isMainFileHeader()) {
+    // If the main file is a header, then it's either for PCH/AST generation,
+    // or libclang opened it. Either way, handle it as a normal include below.
+  } else if (isInPrimaryFile()) {
     Lookup = nullptr;
     Diag(IncludeNextTok, diag::pp_include_next_in_primary);
   } else if (CurSubmodule) {
     // Start looking up in the directory *after* the one in which the current
     // file would be found, if any.
     assert(CurPPLexer && "#include_next directive in macro?");
     LookupFromFile = CurPPLexer->getFileEntry();
     Lookup = nullptr;

lib/Lex/PPMacroExpansion.cpp

static bool EvaluateHasIncludeNext(Token &Tok,
                                    IdentifierInfo *II, Preprocessor &PP) {
   // __has_include_next is like __has_include, except that we start
   // searching after the current found directory.  If we can't do this,
   // issue a diagnostic.
   // FIXME: Factor out duplication with 
   // Preprocessor::HandleIncludeNextDirective.
   const DirectoryLookup *Lookup = PP.GetCurDirLookup();
   const FileEntry *LookupFromFile = nullptr;
-  if (PP.isInPrimaryFile()) {
+  if (PP.isInPrimaryFile() && PP.getSourceManager().isMainFileHeader()) {
+    // If the main file is a header, then it's either for PCH/AST generation,
+    // or libclang opened it. Either way, handle it as a normal include below.
+  } else if (PP.isInPrimaryFile()) {
     Lookup = nullptr;
     PP.Diag(Tok, diag::pp_include_next_in_primary);
   } else if (PP.getCurrentSubmodule()) {
     // Start looking up in the directory *after* the one in which the current
     // file would be found, if any.
     assert(PP.getCurrentLexer() && "#include_next directive in macro?");
     LookupFromFile = PP.getCurrentLexer()->getFileEntry();
     Lookup = nullptr;

lib/Lex/Pragma.cpp

void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
 
   // Finally, return whatever came after the pragma directive.
   return Lex(Tok);
 }
 
 /// HandlePragmaOnce - Handle \#pragma once.  OnceTok is the 'once'.
 ///
 void Preprocessor::HandlePragmaOnce(Token &OnceTok) {
-  if (isInPrimaryFile()) {
+  // If the main file is a header, then it's either for PCH/AST generation,
+  // or libclang opened it. Allow #pragma once either way.
+  if (isInPrimaryFile() && !SourceMgr.isMainFileHeader()) {
     Diag(OnceTok, diag::pp_pragma_once_in_main_file);
     return;
   }
 
   // Get the current file lexer we're looking at.  Ignore _Pragma 'files' etc.
   // Mark the file as a once-only file now.
   HeaderInfo.MarkFileIncludeOnce(getCurrentFileLexer()->getFileEntry());
 }

test/Preprocessor/header_is_main_file.c

+// RUN: %clang_cc1 -x c-header -ffreestanding -Eonly -verify %s
+// expected-no-diagnostics
+
+#pragma once
+#include_next "stdint.h"
+#if !__has_include_next("stdint.h")
+#error "__has_include_next failed"
+#endif