[Lexer] Make __has_extension ignore -pedantic-errors inside system headers

[EricWF]

Summary

Libc++ needs to be able to detect and use certain language extensions inside the STL headers. However __has_extension currently return 0 when -pedantic-errors is specified. However libc++ can still safely use these extensions since -pedantic-errors is ignored within system headers.

This patch make __has_extension ignore -pedantic-errors when the expansion occurs in a system header.

docs/LanguageExtensions.rst

.. code-block:: c++
   #endif
 
   #if __has_extension(cxx_rvalue_references)
   // This code will be compiled with the -std=c++11, -std=gnu++11, -std=c++98
   // and -std=gnu++98 options, because rvalue references are supported as a
   // language extension in C++98.
   #endif
 
+Note that Clang may need to change the language extensions it offers, including
+removing extensions completely.
+
 .. _langext-has-feature-back-compat:
 
 For backward compatibility, ``__has_feature`` can also be used to test
 for support for non-standardized features, i.e. features not prefixed ``c_``,
 ``cxx_`` or ``objc_``.
 
 Another use of ``__has_feature`` is to check for compiler features not related
 to the language standard, such as e.g. :doc:`AddressSanitizer
 <AddressSanitizer>`.
 
 If the ``-pedantic-errors`` option is given, ``__has_extension`` is equivalent
-to ``__has_feature``.
+to ``__has_feature`` unless the expansion is within a system header in which
+case ``-pedantic-errors`` has no effect.
 
 The feature tag is described along with the language feature below.
 
 The feature name or extension name can also be specified with a preceding and
 following ``__`` (double underscore) to avoid interference from a macro with
 the same name.  For instance, ``__cxx_rvalue_references__`` can be used instead
 of ``cxx_rvalue_references``.
 

lib/Lex/PPMacroExpansion.cpp

       .Case("tls", PP.getTargetInfo().isTLSSupported())
       .Case("underlying_type", LangOpts.CPlusPlus)
       .Default(false);
 }
 
 /// HasExtension - Return true if we recognize and implement the feature
 /// specified by the identifier, either as an extension or a standard language
 /// feature.
-static bool HasExtension(const Preprocessor &PP, StringRef Extension) {
+static bool HasExtension(const Preprocessor &PP, StringRef Extension,
+                         bool IsInSystemHeader) {
   if (HasFeature(PP, Extension))
     return true;
 
   // If the use of an extension results in an error diagnostic, extensions are
   // effectively unavailable, so just return false here.
   if (PP.getDiagnostics().getExtensionHandlingBehavior() >=
-      diag::Severity::Error)
+      diag::Severity::Error && !IsInSystemHeader)
     return false;
 
   const LangOptions &LangOpts = PP.getLangOpts();
 
   // Normalize the extension name, __foo__ becomes foo.
   if (Extension.startswith("__") && Extension.endswith("__") &&
       Extension.size() >= 4)
     Extension = Extension.substr(2, Extension.size() - 4);

                                            diag::err_feature_check_malformed);
         return II && HasFeature(*this, II->getName());
       });
   } else if (II == Ident__has_extension) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
-        return II && HasExtension(*this, II->getName());
+        if (!II) return false;
+        bool IsInSystemHeader = SourceMgr.isInSystemHeader(Tok.getLocation());
+        return HasExtension(*this, II->getName(), IsInSystemHeader);
       });
   } else if (II == Ident__has_builtin) {
     EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this,
       [this](Token &Tok, bool &HasLexedNextToken) -> int {
         IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                            diag::err_feature_check_malformed);
         if (!II)
           return false;

test/Lexer/has_extension_system_header.h

+#pragma once
+
+static_assert(__has_extension(cxx_init_captures) == !Pedantic, "");
+static_assert(MY_HAS_EXT(cxx_init_captures) == !Pedantic, "");
+
+#pragma clang system_header
+
+// Test expansions from macros defined in system headers and used elsewhere.
+#define SYSTEM_HAS_EXT(ID) __has_extension(ID)
+
+static_assert(__has_extension(cxx_init_captures), "");
+static_assert(SYSTEM_HAS_EXT(cxx_init_captures), "");
+static_assert(MY_HAS_EXT(cxx_init_captures), "");

test/Lexer/has_extension_system_header.cpp

+// RUN: %clang_cc1 -std=c++11 -fsyntax-only  %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -pedantic-errors -DIS_PEDANTIC %s
+
+#ifdef IS_PEDANTIC
+constexpr bool Pedantic = true;
+#else
+constexpr bool Pedantic = false;
+#endif
+
+// Test expansions from macros defined outside of system headers
+#define MY_HAS_EXT(ID) __has_extension(ID)
+
+#include "has_extension_system_header.h"
+
+static_assert(__has_extension(cxx_init_captures) == !Pedantic, "");
+static_assert(SYSTEM_HAS_EXT(cxx_init_captures) == !Pedantic, "");
+static_assert(MY_HAS_EXT(cxx_init_captures) == !Pedantic, "");