[Lex] Allow to set missing include error to not fatal

[yvvan]

Summary

For IDE it's a nice feature to not get a fatal error and continue preprocessing even if the file is missing.
This allows include further files and get more relevant information about the current translation unit.

[yvvan]

I've tested it with libclang. If something else is needed for proper clangd args forwarding - let me know.

[yvvan]

It's probably not needed because I don't see a path which checked for the fatal errors in 8.0. So i will probably abandon this one or update if it does not cover the case I need.

include/clang/Basic/Diagnostic.h

public:
   /// When set to true, any error reported is made a fatal error.
   void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; }
   bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; }
 
   /// When set to true (the default), suppress further diagnostics after
   /// a fatal error.
   void setSuppressAfterFatalError(bool Val) { SuppressAfterFatalError = Val; }
 
+  bool getSuppressAfterFatalError() { return SuppressAfterFatalError; }
+
   /// When set to true mask warnings that come from system headers.
   void setSuppressSystemWarnings(bool Val) {
     GetCurDiagState()->SuppressSystemWarnings = Val;
   }
   bool getSuppressSystemWarnings() const {
     return GetCurDiagState()->SuppressSystemWarnings;
   }
 

include/clang/Basic/DiagnosticLexKinds.td

 
 def err_pp_opencl_variadic_macros :
   Error<"variadic macros not supported in OpenCL">;
 
 def err_pp_invalid_directive : Error<"invalid preprocessing directive">;
 def err_pp_directive_required : Error<
   "%0 must be used within a preprocessing directive">;
 def err_pp_file_not_found : Error<"'%0' file not found">, DefaultFatal;
+def err_pp_file_not_found_keep_going : Error<"'%0' file not found">;
 def err_pp_through_header_not_found : Error<
   "'%0' required for precompiled header not found">, DefaultFatal;
 def err_pp_through_header_not_seen : Error<
   "#include of '%0' not seen while attempting to "
   "%select{create|use}1 precompiled header">, DefaultFatal;
 def err_pp_pragma_hdrstop_not_seen : Error<
   "#pragma hdrstop not seen while attempting to use precompiled header">,
   DefaultFatal;

include/clang/Lex/PreprocessorOptions.h

public:
   /// Whether the compiler instance should retain (i.e., not free)
   /// the buffers associated with remapped files.
   ///
   /// This flag defaults to false; it can be set true only through direct
   /// manipulation of the compiler invocation object, in cases where the
   /// compiler invocation and its buffers will be reused.
   bool RetainRemappedFileBuffers = false;
 
+  /// Whether to emit normal error instead of fatal in case the include is
+  /// missing. This should help to provide more meaningful information for the
+  /// code that uses data from the following headers which are ignored
+  /// otherwise.
+  bool KeepGoingAfterMissingInclude = false;
+
   /// The Objective-C++ ARC standard library that we should support,
   /// by providing appropriate definitions to retrofit the standard library
   /// with support for lifetime-qualified pointers.
   ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
 
   /// Records the set of modules
   class FailedModulesSet {
     llvm::StringSet<> Failed;

lib/Frontend/ASTUnit.cpp

ASTUnit *ASTUnit::LoadFromCommandLine(
   for (const auto &RemappedFile : RemappedFiles) {
     CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
                                               RemappedFile.second);
   }
   PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
   PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName;
   PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors;
   PPOpts.SingleFileParseMode = SingleFileParse;
+  PPOpts.KeepGoingAfterMissingInclude = !Diags->getSuppressAfterFatalError();
 
   // Override the resources path.
   CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 
   CI->getFrontendOpts().SkipFunctionBodies =
       SkipFunctionBodies == SkipFunctionBodiesScope::PreambleAndMainFile;
 
   if (ModuleFormat)

lib/Lex/PPDirectives.cpp

#endif
           // We found the file, so set the Filename to the name after typo
           // correction.
           Filename = TypoCorrectionName;
         }
       }
 
       // If the file is still not found, just go with the vanilla diagnostic
       if (!File) {
-        Diag(FilenameTok, diag::err_pp_file_not_found) << OriginalFilename
-                                                       << FilenameRange;
+        Diag(FilenameTok, PPOpts->KeepGoingAfterMissingInclude
+                              ? diag::err_pp_file_not_found_keep_going
+                              : diag::err_pp_file_not_found)
+            << OriginalFilename << FilenameRange;
         if (IsFrameworkFound) {
           size_t SlashPos = OriginalFilename.find('/');
           assert(SlashPos != StringRef::npos &&
                  "Include with framework name should have '/' in the filename");
           StringRef FrameworkName = OriginalFilename.substr(0, SlashPos);
           FrameworkCacheEntry &CacheEntry =
               HeaderInfo.LookupFrameworkCache(FrameworkName);
           assert(CacheEntry.Directory && "Found framework should be in cache");

lib/Lex/Pragma.cpp

 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/LexDiagnostic.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Lex/MacroInfo.h"
 #include "clang/Lex/ModuleLoader.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Lex/PreprocessorLexer.h"
 #include "clang/Lex/Token.h"
 #include "clang/Lex/TokenLexer.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
if (Filename.empty())
     return;
 
   // Search include directories for this file.
   const DirectoryLookup *CurDir;
   const FileEntry *File =
       LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
                  nullptr, CurDir, nullptr, nullptr, nullptr, nullptr, nullptr);
   if (!File) {
-    if (!SuppressIncludeNotFoundError)
-      Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
+    if (!SuppressIncludeNotFoundError) {
+      Diag(FilenameTok, PPOpts->KeepGoingAfterMissingInclude
+                            ? diag::err_pp_file_not_found_keep_going
+                            : diag::err_pp_file_not_found)
+          << Filename;
+    }
     return;
   }
 
   const FileEntry *CurFile = getCurrentFileLexer()->getFileEntry();
 
   // If this file is older than the file it depends on, emit a diagnostic.
   if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
     // Lex tokens at the end of the message and include them in the message.