From 2b4cad5e471c60edae528979fa5f3edde844ac34 Mon Sep 17 00:00:00 2001 From: Arthur O'Dwyer Date: Wed, 8 Sep 2021 09:07:34 -0400 Subject: [PATCH] [clang] Enable the special enable_if_t diagnostics for libc++'s __enable_if_t as well. This comes from lengthy discussion between Quuxplusone and ldionne over on D108216. Right now, libc++ uses a "SCARY metaprogramming" version of _EnableIf that bypasses all of Clang's clever diagnostic stuff and thus produces bad diagnostics. My recent benchmarks ( https://quuxplusone.github.io/blog/2021/09/04/enable-if-benchmark/ ) have determined that the SCARYness is not buying us any speedup; therefore we are happy to drop it and go back to using the standard std::enable_if for all our SFINAE needs. However, we don't want to type out typename std::enable_if::type all over the library; we want to use an alias template. And we can't use std::enable_if_t because we need a solution that works in C++11, and we do not provide std::enable_if_t in C++11. Therefore, D109435 switches us from SCARY `_EnableIf` to a normal `__enable_if_t` (at least in C++11 mode, and possibly everywhere for consistency). Simultaneously, this Clang patch enables the good diagnostics for `__enable_if_t`. We don't need to enable good diagnostics for `_EnableIf` because the name `_EnableIf` has only ever been used for the SCARY version where the good diagnostics don't trigger anyway. (Btw, this existing code is all sorts of broken, theoretically speaking. I filed https://bugs.llvm.org/show_bug.cgi?id=51696 about it last week. So if someone wants to use this PR as an excuse to go down the rabbit hole and fix it for real, that would be cool too.) Differential Revision: https://reviews.llvm.org/D109411 --- clang/lib/Sema/SemaTemplate.cpp | 4 +- clang/test/SemaTemplate/diagnose-enable-if-t.cpp | 96 ++++++++++++++++++++++++ 2 files changed, 99 insertions(+), 1 deletion(-) create mode 100644 clang/test/SemaTemplate/diagnose-enable-if-t.cpp diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 6682b17..bfe69a4 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -3511,8 +3511,10 @@ checkBuiltinTemplateIdType(Sema &SemaRef, BuiltinTemplateDecl *BTD, } /// Determine whether this alias template is "enable_if_t". +/// libc++ >=14 uses "__enable_if_t" in C++11 mode. static bool isEnableIfAliasTemplate(TypeAliasTemplateDecl *AliasTemplate) { - return AliasTemplate->getName().equals("enable_if_t"); + return AliasTemplate->getName().equals("enable_if_t") || + AliasTemplate->getName().equals("__enable_if_t"); } /// Collect all of the separable terms in the given condition, which diff --git a/clang/test/SemaTemplate/diagnose-enable-if-t.cpp b/clang/test/SemaTemplate/diagnose-enable-if-t.cpp new file mode 100644 index 0000000..3cf1429 --- /dev/null +++ b/clang/test/SemaTemplate/diagnose-enable-if-t.cpp @@ -0,0 +1,96 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++17 %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s + +namespace std { + inline namespace __1 { + template struct enable_if {}; + template struct enable_if { using type = T; }; + template using enable_if_t = typename enable_if::type; + } +} + +namespace similar_to_user_code { + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template> + void f(T, short); + + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template* = nullptr> + void f(T, int); + + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template + std::enable_if_t f(T, long); + + void test() { + f('x', 0); // expected-error{{no matching function}} + } +} + +namespace similar_to_libcxx_version_14 { + template struct enable_if {}; + template struct enable_if { using type = T; }; + template using __enable_if_t = typename enable_if::type; + + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template> + void f(T, short); + + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template* = nullptr> + void f(T, int); + + // expected-note@+2 {{candidate template ignored: requirement 'sizeof(char) != 1' was not satisfied [with T = char]}} + template + __enable_if_t f(T, long); + + void test() { + f('x', 0); // expected-error{{no matching function}} + } +} + +namespace similar_to_libcxx_version_13 { + template struct _MetaBase {}; + template<> struct _MetaBase { template using _EnableIfImpl = R; }; + template using _EnableIf = typename _MetaBase::template _EnableIfImpl; + + // expected-note@+2 {{no member named '_EnableIfImpl'}} + template> + void f(T, short); + + // expected-note@+2 {{no member named '_EnableIfImpl'}} + template* = nullptr> + void f(T, int); + + // expected-note@+2 {{no member named '_EnableIfImpl'}} + template + _EnableIf f(T, long); + + void test() { + f('x', 0); // expected-error{{no matching function}} + } +} + +namespace not_all_names_are_magic { + template struct enable_if {}; + template struct enable_if { using type = T; }; + template using a_pony = typename enable_if::type; + + // expected-note@-2 {{candidate template ignored: disabled by 'enable_if' [with T = char]}} + template> + void f(T, short); + + // expected-note@-6 {{candidate template ignored: disabled by 'enable_if' [with T = char]}} + template* = nullptr> + void f(T, int); + + // expected-note@-10 {{candidate template ignored: disabled by 'enable_if' [with T = char]}} + template + a_pony f(T, long); + + void test() { + f('x', 0); // expected-error{{no matching function}} + } +} -- 2.7.4