Support C++1z features in `__has_extension`

[EricWF]

Summary

This patch updates __has_extension to report the C++1z extensions Clang offers

[EricWF]

• Improve documentation

[EricWF]

• Correctly report that structured bindings, inline variables, and fold expressions are available in C++03.

[EricWF]

@rsmith ping. I need this for http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2017/p0607r0.html

[filcab]

Hi Eric,

I know this is old, but are you interested in reviving this patch? I don't know enough about clang's extensions to LGTM such a patch (updated for the current code), but would really like to have a way to know if extensions are supported.
We just now had people ask how to detect if if constexpr is available, and not having a feature check makes it much harder to figure out (and makes our test based on current clang behaviour).

Thank you,
Filipe

[EricWF]

I don't mind picking it up again, but it won't be until next week.

docs/LanguageExtensions.rst

 
 C++14 variable templates
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 Use ``__has_feature(cxx_variable_templates)`` or
 ``__has_extension(cxx_variable_templates)`` to determine if support for
 templated variable declarations is enabled.
 
+C++1z
+-----
+
+C++1z fold expressions
+^^^^^^^^^^^^^^^^^^^^^^
+
+Use ``__has_feature(cxx_fold_expressions)`` or
+``__has_extension(cxx_fold_expressions)`` to determine if support for
+fold expressions is enabled. For instance:
+
+.. code-block:: c++
+
+  template <class ...Bools>
+  bool variadic_and(Bools... b) { return (b && ...); }
+
+C++1z if constexpr
+^^^^^^^^^^^^^^^^^^
+
+Use ``__has_feature(cxx_if_constexpr)`` or
+``__has_extension(cxx_if_constexpr)`` to determine if support for
+``if constexpr`` is enabled.
+
+C++1z inline variables
+^^^^^^^^^^^^^^^^^^^^^^
+
+Use ``__has_feature(cxx_inline_variables)`` or
+``__has_extension(cxx_inline_variables)`` to determine if support for
+inline variables is enabled. (For instance, ``inline int x = 42;``)
+
+C++1z structured bindings
+^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Use ``__has_feature(cxx_structured_bindings)`` or
+``__has_extension(cxx_structured_bindings)`` to determine if support for
+structured bindings is enabled. (For instance,
+``auto [a, b, c] = std::make_tuple(1, 2, 3);``)
+
+C++1z variadic using
+^^^^^^^^^^^^^^^^^^^^
+
+Use ``__has_feature(cxx_variadic_using)`` or
+``__has_extension(cxx_variadic_using)`` to determine if support for
+pack expansions of using-declarations is enabled. For instance:
+
+.. code-block:: c++
+
+  template <class ...Bases> struct T : Bases... {
+    using Bases::operator()...;
+  }
+
+
 C11
 ---
 
 The features listed below are part of the C11 standard.  As a result, all these
 features are enabled with the ``-std=c11`` or ``-std=gnu11`` option when
 compiling C code.  Additionally, because these features are all
 backward-compatible, they are available as extensions in all language modes.
 

lib/Lex/PPMacroExpansion.cpp

       .Case("cxx_binary_literals", LangOpts.CPlusPlus14)
       .Case("cxx_contextual_conversions", LangOpts.CPlusPlus14)
       .Case("cxx_decltype_auto", LangOpts.CPlusPlus14)
       .Case("cxx_generic_lambdas", LangOpts.CPlusPlus14)
       .Case("cxx_init_captures", LangOpts.CPlusPlus14)
       .Case("cxx_relaxed_constexpr", LangOpts.CPlusPlus14)
       .Case("cxx_return_type_deduction", LangOpts.CPlusPlus14)
       .Case("cxx_variable_templates", LangOpts.CPlusPlus14)
+      // C++17 features
+      .Case("cxx_fold_expressions", LangOpts.CPlusPlus1z)
+      .Case("cxx_if_constexpr", LangOpts.CPlusPlus1z)
+      .Case("cxx_inline_variables", LangOpts.CPlusPlus1z)
+      .Case("cxx_structured_bindings", LangOpts.CPlusPlus1z)
+      .Case("cxx_variadic_using", LangOpts.CPlusPlus1z)
       // NOTE: For features covered by SD-6, it is preferable to provide *only*
-      // the SD-6 macro and not a __has_feature check.
+      // the SD-6 macro and not a __has_feature check unless the feature is
+      // also provided as an extension in older dialects.
 
       // C++ TSes
       //.Case("cxx_runtime_arrays", LangOpts.CPlusPlusTSArrays)
       //.Case("cxx_concepts", LangOpts.CPlusPlusTSConcepts)
       // FIXME: Should this be __has_feature or __has_extension?
       //.Case("raw_invocation_type", LangOpts.CPlusPlus)
       // Type traits
       // N.B. Additional type traits should not be added to the following list.

            .Case("cxx_range_for", LangOpts.CPlusPlus)
            .Case("cxx_reference_qualified_functions", LangOpts.CPlusPlus)
            .Case("cxx_rvalue_references", LangOpts.CPlusPlus)
            .Case("cxx_variadic_templates", LangOpts.CPlusPlus)
            // C++14 features supported by other languages as extensions.
            .Case("cxx_binary_literals", true)
            .Case("cxx_init_captures", LangOpts.CPlusPlus11)
            .Case("cxx_variable_templates", LangOpts.CPlusPlus)
+           // C++17 features supported by other languages as extensions.
+           .Case("cxx_fold_expressions", LangOpts.CPlusPlus)
+           .Case("cxx_if_constexpr", LangOpts.CPlusPlus11)
+           .Case("cxx_inline_variables", LangOpts.CPlusPlus)
+           .Case("cxx_structured_bindings", LangOpts.CPlusPlus)
+           .Case("cxx_variadic_using", LangOpts.CPlusPlus11)
            .Default(false);
 }
 
 /// EvaluateHasIncludeCommon - Process a '__has_include("path")'
 /// or '__has_include_next("path")' expression.
 /// Returns true if successful.
 static bool EvaluateHasIncludeCommon(Token &Tok,
                                      IdentifierInfo *II, Preprocessor &PP,

test/Lexer/has_extension_cxx.cpp

 int has_variable_templates();
 #endif
 
 // CHECK-NOT: has_init_captures
 // CHECK11: has_init_captures
 #if __has_extension(cxx_init_captures)
 int has_init_captures();
 #endif
+
+// CHECK: has_fold_expressions
+// CHECK11: has_fold_expressions
+#if __has_extension(cxx_fold_expressions)
+int has_fold_expressions();
+#endif
+
+// CHECK-NOT: has_if_constexpr
+// CHECK11: has_if_constexpr
+#if __has_extension(cxx_if_constexpr)
+int has_if_constexpr();
+#endif
+
+// CHECK: has_inline_variables
+// CHECK11: has_inline_variables
+#if __has_extension(cxx_inline_variables)
+int has_inline_variables();
+#endif
+
+// CHECK: has_structured_bindings
+// CHECK11: has_structured_bindings
+#if __has_extension(cxx_structured_bindings)
+int has_structured_bindings();
+#endif
+
+// CHECK-NOT: has_variadic_using
+// CHECK11: has_variadic_using
+#if __has_extension(cxx_variadic_using)
+int has_variadic_using();
+#endif

test/Lexer/has_feature_cxx0x.cpp

 #else
 int no_generic_lambdas();
 #endif
 
 // CHECK-1Z: has_generic_lambdas
 // CHECK-14: has_generic_lambdas
 // CHECK-11: no_generic_lambdas
 // CHECK-NO-11: no_generic_lambdas
+
+#if __has_feature(cxx_fold_expressions)
+int has_fold_expressions();
+#else
+int no_fold_expressions();
+#endif
+// CHECK-1Z: has_fold_expressions
+// CHECK-14: no_fold_expressions
+// CHECK-11: no_fold_expressions
+// CHECK-NO-11: no_fold_expressions
+
+
+#if __has_feature(cxx_if_constexpr)
+int has_if_constexpr();
+#else
+int no_if_constexpr();
+#endif
+// CHECK-1Z: has_if_constexpr
+// CHECK-14: no_if_constexpr
+// CHECK-11: no_if_constexpr
+// CHECK-NO-11: no_if_constexpr
+
+
+#if __has_feature(cxx_inline_variables)
+int has_inline_variables();
+#else
+int no_inline_variables();
+#endif
+// CHECK-1Z: has_inline_variables
+// CHECK-14: no_inline_variables
+// CHECK-11: no_inline_variables
+// CHECK-NO-11: no_inline_variables
+
+
+#if __has_feature(cxx_structured_bindings)
+int has_structured_bindings();
+#else
+int no_structured_bindings();
+#endif
+// CHECK-1Z: has_structured_bindings
+// CHECK-14: no_structured_bindings
+// CHECK-11: no_structured_bindings
+// CHECK-NO-11: no_structured_bindings
+
+
+#if __has_feature(cxx_variadic_using)
+int has_variadic_using();
+#else
+int no_variadic_using();
+#endif
+// CHECK-1Z: has_variadic_using
+// CHECK-14: no_variadic_using
+// CHECK-11: no_variadic_using
+// CHECK-NO-11: no_variadic_using

test/SemaCXX/cxx1z-extensions.cpp

+// RUN: %clang_cc1 -std=c++03  -Wno-c++11-extensions -Wno-c++14-extensions \
+// RUN:                        -Wno-c++1z-extensions -verify %s
+// RUN: %clang_cc1 -std=c++11 -Wno-c++14-extensions -Wno-c++1z-extensions  -verify %s
+
+// expected-no-diagnostics
+
+// Fold Expressions //
+_Static_assert(__has_extension(cxx_fold_expressions), "");
+template <class ...Bools>
+bool test_fold_expressions(Bools ...b) {
+  return (b && ...);
+}
+static bool test_fold_expressions_result = test_fold_expressions(true, true, true);
+
+#if __cplusplus >= 201103L
+// If Constexpr //
+_Static_assert(__has_extension(cxx_if_constexpr), "");
+template <bool Pred>
+constexpr bool test_if_constexpr() {
+  if constexpr (Pred) {
+    _Static_assert(Pred, "");
+    return true;
+  } else {
+    _Static_assert(!Pred, "");
+    return false;
+  }
+}
+_Static_assert(test_if_constexpr<true>(), "");
+_Static_assert(!test_if_constexpr<false>(), "");
+#endif
+
+// Inline Variables //
+_Static_assert(__has_extension(cxx_inline_variables), "");
+inline int test_inline_variables = 42;
+
+// Structured Bindings //
+_Static_assert(__has_extension(cxx_structured_bindings), "");
+struct Tuple {
+  int a, b, c;
+};
+bool test_bindings() {
+  Tuple t = {42, 101, -1};
+  auto [a, b, c] = t;
+  return a == 42 && b == 101 && c == -1;
+}
+
+#if __cplusplus >= 201103L
+// Variadic Using //
+_Static_assert(__has_extension(cxx_variadic_using), "");
+struct A { constexpr bool operator()() const { return true; } };
+struct B { constexpr bool operator()(int) const { return false; } };
+template <class ...Args> struct TestVariadicUsing : Args... {
+  using Args::operator()...;
+};
+_Static_assert(TestVariadicUsing<A, B>{}(), "");
+_Static_assert(!TestVariadicUsing<A, B>{}(42), "");
+#endif