Fix PR18792 - Bad diagnostic messages for std::enable_if_t uses

[stephant]

Summary

Fix PR18792 - Bad diagnostic messages for std::enable_if_t uses

This patch improves the diagnostic messages for overloads disabled with
enable_if, in particular those where the failing typename enable_if<...>::type
lookup happens during the instantiation of an alias template like
std::enable_if_t.

Previously the diagnostic note for an overload disabled with std::enable_if_t
(or a similar alias template) only contained the location of the typename
enable_if<...>::type lookup and did not contain the location of the disabled
function overload, which could be quite annoying when you had many overloads.

This patch makes clang generate a note with the name and location of the
outermost alias template in the SFINAE context in which the enable_if<...>::type
lookup failed. Typically this location will be inside the source range for the
function template declaration, i.e. exactly where we want it. In the rare
circumstances where this is not the case, see e.g. the new test case with the
FIXME in overload-candidates.cpp, the implementation makes sure that the
diagnostic is placed at the disabled overload.

I'm not certain whether using the "disabled by %0" message even for template
aliases whose names don't start with "enable" or "disable" is optimal, but I'm
pretty sure that in the vast majority of cases the generated message should
be quite understandable and certainly better than the one generated when
not using the enable_if logic. Though, if someone has a good idea for the
wording, it would be easy to use a different message for such aliases.

This patch also improves the source range highlighting for regular enable_if
uses and always prints out the fully qualified name of the enable_if template
(as was requested by a FIXME in SemaOverload.cpp).

[rsmith]

include/clang/Basic/SourceLocation.h

217–218

Rather than essentially duplicating the implementation in the body, how about an English description, "Indicates whether another source range is the same as, or contained within, this range."

Also, the implementation doesn't appear to be correct; < on SourceLocations does not in general give source order (though it happens to if the locations are within the same FileID). Use SourceManager::isBeforeInTranslationUnit for this check (and it shouldn't be a member of SourceRange to avoid layering problems).

Maybe this should be a SourceManager member function?

include/clang/Sema/Sema.h

6055–6056

This seems a bit arbitrary. Could you add a TemplateArgumentListInfo * instead? (Maybe make TemplateArgs above a PointerUnion?)

lib/Sema/SemaOverload.cpp

8905–8918

I don't like inspecting the source ranges on a PartialDiagnostic -- they're not part of the numbered argument set for the diagnostic, so someone emitting the diagnostic is within their rights to change the set of ranges they provide. More generally, I'm not really a fan of digging into the implementation of the PartialDiagnostic to find its arguments.

Instead, how about switching the diagnostic ID from err_typename_nested_not_found_enable_if to note_ovl_candidate_disabled_by_enable_if (with comments in the .td file saying that they're required to take the same arguments)?

Instead of using the Range, below, to determine the location for the diagnostic, you could use something like TemplDecl->getSourceRange().contains(PDiag->first) ? PDiag->first : Templated->getLocation().

lib/Sema/SemaTemplate.cpp

7887–7919

Having reflected on this a bit more, I think we should *only* do this if the context surrounding the enable_if is an alias template named enable_if_t (and we should only walk through one such alias template). If we walk too far away from the enable_if expression itself, it will no longer be obvious what we're complaining about.

7918

Please also change the literal 'enable_if' in err_typename_nested_not_found_enable_if to a %1.

[stephant]

Thanks for the review!

include/clang/Basic/SourceLocation.h

217–218

I used the short technical definition in the description because I wasn't sure how to describe the behaviour verbally in a terse and accurate way.

I didn't use isBeforeInTranslationUnit for the implementation because I wanted to test whether one source range is visually contained by the other in the original source file. However, I just tested the behaviour for macro expansions and noticed that clang does print both the spelling and the expansion location for macros, so using isBeforeInTranslationUnit indeed seems preferable here.

Do you maybe have a suggestion for the name of the new method in SourceManager? Maybe rangeContains?

include/clang/Sema/Sema.h

6055–6056

Using the InstantiationRange for storing the source range seemed like the minimally invasive way to make the source information for the enable_if diagnostic available.

I could store a TemplateArgumentListInfo pointer instead, but that would also require a new InstantiatingTemplate constructor.

lib/Sema/SemaOverload.cpp

8905–8918

In my view a PartialDiagnostic (or Diagnostic) is not just the input to some formatting routine but a strongly typed container of an error id and additional pieces of information about the error. So, accessing the arguments to the diagnostic through a proper API (introduced by D3060) in order to generate a better error message doesn't seem that objectionable to me. Also, I interpreted your FIXME as a request to do exactly this.

I used a second source range and the err_typename_nested_not_found_enable_if id because I assumed that in Sema::CheckTypenameType we should always generate an error that would be appropriate if the error message is not suppressed by the SFINAE logic. If this is not the case, it might be cleaner to always prepare the enable_if diagnostic in CheckTypenameType and then just reemit it in DiagnoseBadDeduction (adding the missing TemplateArgString).

If you'd like this code to not fail in the hypothetical case where someone generates a err_typename_nested_not_found_enable_if diagnostic with unexpected contents, I could replace the assert with some always-on fallback logic.

lib/Sema/SemaTemplate.cpp

7887–7919

If we don't walk up all alias template instantiations in the current SFINAE context on the instantiation stack, the SFINAE diagnostic will only state no type named 'type' in 'enable_if<false>' or disabled by 'enable_if' without any indication which alias template instantiation caused this error, since the SFINAE diagnostic doesn't contain the stack of instantiated alias templates for the suppressed error. (Would it maybe be an alternative to store and print this stack when we don't have a straightforward enable_if case?)

In my opinion such a diagnostic is significantly worse than a diagnostic that states something like e.g. disabled by 'enable_if_is_callback' or disabled by an error during the substitution of the alias template 'enable_if_is_callback' and that points to the source location of the enable_if_is_callback instantiation in the function declaration triggering the error.

Could you maybe give an example for a situation where you'd find the proposed diagnostic confusing? Would rewording the diagnostic in that situation be an alternative to falling back to the basic SFINAE diagnostic?

[rsmith]

include/clang/Basic/SourceLocation.h

217–218

How about SourceManager::isWithinInTranslationUnit(SourceRange, SourceLocation)?

lib/Sema/SemaOverload.cpp

8905–8918

I don't think a PartialDiagnostic is even notionally strongly typed (you can use the same diagnostic with a string or a Decl for the same argument, for instance, and we do that sort of thing in some cases). The approach you're taking is fragile in the presence of refactoring or people reusing the same diagnostic message in other circumstances (where they may not provide the same SourceRanges). I'm also not particularly enthusiastic about a fallback codepath -- I'd much rather have a clean way to pass the necessary information through. I'm not yet sure what that mechanism is, though.

(Yes, the diagnostic produced in CheckTypenameType should be appropriate in the case where we're not in a SFINAE condition.)

lib/Sema/SemaTemplate.cpp

7887–7919

Hmm, suppose I have:

template<typename T> void f(Iterator<T> iter);

with Iterator an alias template. If substitution fails for any reason within Iterator<T>, I don't want to be told disabled by 'Iterator'. I think in this case I actually want to produce two notes for the substitution failure: one indicating that the candidate was ignored due to a substitution failure (pointing at the candidate), and another pointing at the location within the alias template where we hit the problem.

I think we can do this without any alias template special-casing: when we come to emit a delayed 'substitution failure' diagnostic, check whether the location of the diagnostic is within the source range of the declaration of the candidate. If so, do what we do today, and if not, produce two notes (one pointing at the candidate and the other pointing at the location where we hit the error.

[stephant]

lib/Sema/SemaOverload.cpp

8905–8918

What I meant with strongly typed is that you can access the diagnostic arguments in a type safe way, as the types of the arguments are recorded and can be queried. Documenting the extra arguments in the diagnostic .td file should minimize any fragility.

If I want to pass on additional information about an error, putting it into the diagnostic data structure still seems rather natural to me. In this case the only alternative I can think of is to put this as an additional field into the TemplateDeductionInfo, but I don't think that would be cleaner.

lib/Sema/SemaTemplate.cpp

7887–7919

It would be really nice if we could tell the user that the substitution failure occurred within Iterator<T>. In this case there is no other possible place, but in more complicated situations it would make the error easier to understand, especially if the error occurred not directly within the Iterator<T> declaration but inside a nested alias template use. When you work with with an IDE that highlights the source ranges in an editor, this can be a real improvement. (And, of course, we can use a different wording than "disabled by xxx" for this and similar cases.)

Without any alias template special-casing the location of the original diagnostic for an error inside an alias template instantiation will never be within the source range of the declaration of the candidate and enable_if_t uses will generate arguably worse error messages than enable_if uses.

include/clang/Basic/DiagnosticSemaKinds.td

def note_ovl_candidate_instantiation_depth : Note<
     "candidate template ignored: substitution exceeded maximum template "
     "instantiation depth">;
 def note_ovl_candidate_underqualified : Note<
     "candidate template ignored: can't deduce a type for %0 which would "
     "make %2 equal %1">;
 def note_ovl_candidate_substitution_failure : Note<
     "candidate template ignored: substitution failure%0%1">;
 def note_ovl_candidate_disabled_by_enable_if : Note<
-    "candidate template ignored: disabled by %0%1">;
+    "candidate template ignored: disabled by %q0%1">;
 def note_ovl_candidate_disabled_by_enable_if_attr : Note<
     "candidate disabled: %0">;
 def note_ovl_candidate_failed_overload_resolution : Note<
     "candidate template ignored: couldn't resolve reference to overloaded "
     "function %0">;
 def note_ovl_candidate_non_deduced_mismatch : Note<
     "candidate template ignored: could not match %diff{$ against $|types}0,1">;
 // This note is needed because the above note would sometimes print two

include/clang/Basic/SourceLocation.h

public:
 
   bool operator==(const SourceRange &X) const {
     return B == X.B && E == X.E;
   }
 
   bool operator!=(const SourceRange &X) const {
     return B != X.B || E != X.E;
   }
+
+  /// \brief Indicates whether
+  /// `getBegin() <= other.getBegin() && other.getEnd() <= getEnd()`.
+  bool contains(SourceRange other) const {
+    return !(other.B < B || E < other.E);
+  }
 };
   
 /// \brief Represents a character-granular source range.
 ///
 /// The underlying SourceRange can either specify the starting/ending character
 /// of the range, or it can specify the start of the range and the start of the
 /// last token of the range (a "token range").  In the token range case, the
 /// size of the last token must be measured to determine the actual end of the

include/clang/Sema/Sema.h

struct ActiveTemplateInstantiation {
 
     /// \brief The template deduction info object associated with the
     /// substitution or checking of explicit or deduced template arguments.
     sema::TemplateDeductionInfo *DeductionInfo;
 
     /// \brief The source range that covers the construct that cause
     /// the instantiation, e.g., the template-id that causes a class
     /// template instantiation.
+    ///
+    /// For alias template instantiations this member is used to store the
+    /// source range of the first template argument.
     SourceRange InstantiationRange;
 
     ActiveTemplateInstantiation()
       : Kind(TemplateInstantiation), Template(0), Entity(0), TemplateArgs(0),
         NumTemplateArgs(0), DeductionInfo(0) {}
 
     /// \brief Determines whether this template is an actual instantiation
     /// that should be counted toward the maximum instantiation depth.

lib/Sema/SemaOverload.cpp

case Sema::TDK_InstantiationDepth:
     S.Diag(Templated->getLocation(),
            diag::note_ovl_candidate_instantiation_depth);
     MaybeEmitInheritedConstructorNote(S, Templated);
     return;
 
   case Sema::TDK_SubstitutionFailure: {
     // Format the template argument list into the argument string.
     SmallString<128> TemplateArgString;
+    TemplateDecl *TemplDecl = getDescribedTemplate(Templated);
     if (TemplateArgumentList *Args =
             DeductionFailure.getTemplateArgumentList()) {
       TemplateArgString = " ";
       TemplateArgString += S.getTemplateArgumentBindingsText(
-          getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
+          TemplDecl->getTemplateParameters(), *Args);
     }
 
     // If this candidate was disabled by enable_if, say so.
     PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
     if (PDiag && PDiag->second.getDiagID() ==
           diag::err_typename_nested_not_found_enable_if) {
-      // FIXME: Use the source range of the condition, and the fully-qualified
-      //        name of the enable_if template. These are both present in PDiag.
-      S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
-        << "'enable_if'" << TemplateArgString;
+      PartialDiagnostic &PD = PDiag->second;
+      ArrayRef<CharSourceRange> PDRanges = PD.getRanges();
+      // We expect the PartialDiagnostic in the form it is generated by the
+      // isEnableIf case in Sema::CheckTypenameType.
+      // The first argument should always be the DeclContext of the enable_if
+      // specialization for which the 'type' lookup failed.
+      // The first range should always be the source range for the first
+      // argument in the `typename enable_if<arg1, ...>::type` expression.
+      // If the failed enable_if lookup occurred within an alias template
+      // instantiation, the PartialDiagnostic should additionally contain a
+      // pointer to the TypeAliasTemplateDecl and a source range that marks
+      // a relevant part of the alias template instantiation.
+      assert(PD.getNumArgs() >= 1 && PDRanges.size() >= 1 &&
+             PD.getArgKind(0) == DiagnosticsEngine::ak_declcontext &&
+             (PD.getNumArgs() == 1 ||
+              (PD.getArgKind(1) == DiagnosticsEngine::ak_nameddecl &&
+               PDRanges.size() >= 2)) &&
+             "an err_typename_nested_not_found_enable_if diagnostic does"
+             " not contain the expected arguments and source ranges");
+      const bool IsAlias = PDRanges.size() > 1;
+      const NamedDecl *EnableIfOrAliasDecl =
+          IsAlias ? reinterpret_cast<NamedDecl *>(PD.getRawArg(1))
+                  : cast<ClassTemplateSpecializationDecl>(
+                        reinterpret_cast<DeclContext *>(PD.getRawArg(0)))
+                        ->getSpecializedTemplate();
+      SourceRange Range = PDRanges[IsAlias ? 1 : 0].getAsRange();
+      // If an alias template that contains an enable_if type lookup is
+      // instantiated with a dependent type, the failing type lookup
+      // may occur when the alias template is no longer on the instantiation
+      // stack and we may end up with a source range that is far away from
+      // the disabled overload. To make sure that the diagnostic always
+      // contains the location of the disabled overload, we check whether the
+      // range is contained in the source range of the template declaration.
+      S.Diag(TemplDecl->getSourceRange().contains(Range)
+                 ? Range.getBegin()
+                 : Templated->getLocation(),
+             diag::note_ovl_candidate_disabled_by_enable_if)
+          << EnableIfOrAliasDecl << TemplateArgString << Range;
       return;
     }
 
     // Format the SFINAE diagnostic into the argument string.
     // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
     //        formatted message in another diagnostic.
     SmallString<128> SFINAEArgString;
     SourceRange R;

lib/Sema/SemaTemplate.cpp

QualType Sema::CheckTemplateIdType(TemplateName Name,
   bool InstantiationDependent = false;
   if (TypeAliasTemplateDecl *AliasTemplate =
           dyn_cast<TypeAliasTemplateDecl>(Template)) {
     // Find the canonical type for this type alias template specialization.
     TypeAliasDecl *Pattern = AliasTemplate->getTemplatedDecl();
     if (Pattern->isInvalidDecl())
       return QualType();
 
+    // We use this range for improving the diagnostic messages for enable_if
+    // SFINAE errors.
+    SourceRange Arg0Range = TemplateArgs.size()
+                                ? TemplateArgs[0].getSourceRange()
+                                : SourceRange(TemplateLoc);
+
     TemplateArgumentList TemplateArgs(TemplateArgumentList::OnStack,
                                       Converted.data(), Converted.size());
 
     // Only substitute for the innermost template argument list.
     MultiLevelTemplateArgumentList TemplateArgLists;
     TemplateArgLists.addOuterTemplateArguments(&TemplateArgs);
     unsigned Depth = AliasTemplate->getTemplateParameters()->getDepth();
     for (unsigned I = 0; I < Depth; ++I)
       TemplateArgLists.addOuterTemplateArguments(None);
 
     LocalInstantiationScope Scope(*this);
-    InstantiatingTemplate Inst(*this, TemplateLoc, Template);
+    InstantiatingTemplate Inst(*this, TemplateLoc, AliasTemplate, Arg0Range);
     if (Inst.isInvalid())
       return QualType();
 
     CanonType = SubstType(Pattern->getUnderlyingType(),
                           TemplateArgLists, AliasTemplate->getLocation(),
                           AliasTemplate->getDeclName());
     if (CanonType.isNull())
       return QualType();
static bool isEnableIf(NestedNameSpecifierLoc NNS, const IdentifierInfo &II,
   // ... which names a complete class template declaration...
   const TemplateDecl *EnableIfDecl =
     EnableIfTST->getTemplateName().getAsTemplateDecl();
   if (!EnableIfDecl || EnableIfTST->isIncompleteType())
     return false;
 
   // ... called "enable_if".
   const IdentifierInfo *EnableIfII =
       EnableIfDecl->getDeclName().getAsIdentifierInfo();
   if (!EnableIfII || !EnableIfII->isStr("enable_if"))
     return false;
 
   // Assume the first template argument is the condition.
   CondRange = EnableIfTSTLoc.getArgLoc(0).getSourceRange();
   return true;
 }
 
+/// \brief Returns a pointer to the ActiveTemplateInstantiation record for the
+/// outermost type alias instantiation in the current SFINAE context, or null
+/// if there is no such instantiation.
+static const Sema::ActiveTemplateInstantiation *
+findOutermostAliasTemplateInstantiationInSFINAEContext(const Sema &S) {
+  if (S.InNonInstantiationSFINAEContext)
+    return nullptr;
+  const Sema::ActiveTemplateInstantiation *ATI = nullptr;
+  // See the comments in Sema::isSFINAEContext.
+  for (auto A = S.ActiveTemplateInstantiations.rbegin(),
+            E = S.ActiveTemplateInstantiations.rend();
+       A != E; ++A) {
+    switch (A->Kind) {
+    case Sema::ActiveTemplateInstantiation::TemplateInstantiation:
+      if (isa<TypeAliasTemplateDecl>(A->Entity)) {
+        ATI = &*A;
+        continue;
+      }
+    // Fall through.
+    case Sema::ActiveTemplateInstantiation::DefaultFunctionArgumentInstantiation:
+    case Sema::ActiveTemplateInstantiation::ExceptionSpecInstantiation:
+      return nullptr; // No SFINAE.
+
+    case Sema::ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation:
+    case Sema::ActiveTemplateInstantiation::PriorTemplateArgumentSubstitution:
+    case Sema::ActiveTemplateInstantiation::DefaultTemplateArgumentChecking:
+      continue; // Look further up the stack.
+
+    case Sema::ActiveTemplateInstantiation::ExplicitTemplateArgumentSubstitution:
+    case Sema::ActiveTemplateInstantiation::DeducedTemplateArgumentSubstitution:
+      return ATI;
+    }
+  }
+  return nullptr;
+}
+
 /// \brief Build the type that describes a C++ typename specifier,
 /// e.g., "typename T::type".
 QualType
 Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, 
                         SourceLocation KeywordLoc,
                         NestedNameSpecifierLoc QualifierLoc, 
                         const IdentifierInfo &II,
                         SourceLocation IILoc) {
Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword,
   unsigned DiagID = 0;
   Decl *Referenced = 0;
   switch (Result.getResultKind()) {
   case LookupResult::NotFound: {
     // If we're looking up 'type' within a template named 'enable_if', produce
     // a more specific diagnostic.
     SourceRange CondRange;
     if (isEnableIf(QualifierLoc, II, CondRange)) {
-      Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if)
+      auto D = Diag(CondRange.getBegin(),
+                    diag::err_typename_nested_not_found_enable_if)
                << Ctx << CondRange;
+      if (const Sema::ActiveTemplateInstantiation *ATI =
+              findOutermostAliasTemplateInstantiationInSFINAEContext(*this)) {
+        // For a failed enable_if lookup within an alias template instantiation
+        // we also store the source range of the instantiation and a pointer to
+        // the TypeAliasTemplateDecl in the PartialDiagnostic.
+        // This allows us is Sema::DiagnoseBadDeduction to highlight a source
+        // range that is actually *within* the declaration of the disabled
+        // overload (and not in the declaration of the alias template).
+        // We don't restrict this handling to alias templates named enable_if_t
+        // because if a failed 'typename enable_if<...>::type' lookup occurs
+        // within an alias template instantiation in a SFINAE context, it is
+        // highly likely that the alias is used similarly to std::enable_if_t.
+        auto *AliasDecl = cast<TypeAliasTemplateDecl>(ATI->Entity);
+        // Sema::CheckTemplateIdType stores the source range for the first
+        // template argument in ATI->InstantiationRange.
+        SourceRange Arg0Range = ATI->InstantiationRange;
+        auto *EnableIfII = AliasDecl->getDeclName().getAsIdentifierInfo();
+        TemplateParameterList *TPL = AliasDecl->getTemplateParameters();
+        if (Arg0Range.isInvalid() || TPL->size() == 0)
+          CondRange = ATI->PointOfInstantiation;
+        else if (TPL->size() == 1 || EnableIfII->isStr("enable_if_t"))
+          CondRange = Arg0Range;
+        else {
+          // If the alias template has more than one parameter and is not
+          // called enable_if_t, we can't be sure that the first argument is
+          // actually the one that caused the error. So instead of underlining
+          // the full argument, we only point to the beginning of it, which
+          // should avoid misunderstandings while still pointing (close) to the
+          // origin of the error.
+          CondRange = Arg0Range.getBegin();
+        }
+        D << AliasDecl << CondRange;
+      }
       return QualType();
     }
 
     DiagID = diag::err_typename_nested_not_found;
     break;
   }
 
   case LookupResult::FoundUnresolvedValue: {

lib/Sema/SemaTemplateInstantiate.cpp

case ActiveTemplateInstantiation::TemplateInstantiation: {
       } else if (EnumDecl *ED = dyn_cast<EnumDecl>(D)) {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_template_enum_def_here)
           << ED
           << Active->InstantiationRange;
       } else {
         Diags.Report(Active->PointOfInstantiation,
                      diag::note_template_type_alias_instantiation_here)
-          << cast<TypeAliasTemplateDecl>(D)
-          << Active->InstantiationRange;
+          << cast<TypeAliasTemplateDecl>(D);
+        // For an alias template Active->InstantiationRange is used
+        // to store the source range of the first template argument.
       }
       break;
     }
 
     case ActiveTemplateInstantiation::DefaultTemplateArgumentInstantiation: {
       TemplateDecl *Template = cast<TemplateDecl>(Active->Entity);
       SmallVector<char, 128> TemplateArgsStr;
       llvm::raw_svector_ostream OS(TemplateArgsStr);

test/SemaTemplate/constexpr-instantiate.cpp

namespace PR13423 {
     template<bool, typename> struct enable_if {};
     template<typename T> struct enable_if<true, T> { using type = T; };
 
     template<typename T> struct F {
       template<typename U>
       static constexpr bool f() { return sizeof(T) < U::size; }
 
       template<typename U>
-      static typename enable_if<f<U>(), void>::type g() {} // expected-note {{disabled by 'enable_if'}}
+      static typename enable_if<f<U>(), void>::type g() {}
+      // expected-note@-1 {{disabled by 'Unevaluated::PR13423::enable_if'}}
     };
 
     struct U { static constexpr int size = 2; };
 
     void h() { F<char>::g<U>(); }
     void i() { F<int>::g<U>(); } // expected-error {{no matching function}}
   }
 

test/SemaTemplate/overload-candidates.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
 
 template<typename T>
 const T& min(const T&, const T&); // expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'long')}}
 
 void test_min() {
   (void)min(1, 2l); // expected-error{{no matching function for call to 'min'}}
 }
 

 void test_X_min(X x) {
   (void)x.min(1, 2l); // expected-error{{no matching member function for call to 'min'}}
 }
 
 namespace boost {
   template<bool, typename = void> struct enable_if {};
   template<typename T> struct enable_if<true, T> { typedef T type; };
 }
-template<typename T> typename boost::enable_if<sizeof(T) == 4, int>::type if_size_4(); // expected-note{{candidate template ignored: disabled by 'enable_if' [with T = char]}}
+template<typename T> typename boost::enable_if<sizeof(T) == 4, int>::type if_size_4(); // expected-note{{candidate template ignored: disabled by 'boost::enable_if' [with T = char]}}
 int k = if_size_4<char>(); // expected-error{{no matching function}}
 
 namespace llvm {
   template<typename Cond, typename T = void> struct enable_if : boost::enable_if<Cond::value, T> {};
 }
 template<typename T> struct is_int { enum { value = false }; };
 template<> struct is_int<int> { enum { value = true }; };
-template<typename T> typename llvm::enable_if<is_int<T> >::type if_int(); // expected-note{{candidate template ignored: disabled by 'enable_if' [with T = char]}}
+template<typename T> typename llvm::enable_if<is_int<T> >::type if_int(); // expected-note{{candidate template ignored: disabled by 'llvm::enable_if' [with T = char]}}
 void test_if_int() {
   if_int<char>(); // expected-error{{no matching function}}
 }
 
 template<typename T> struct NonTemplateFunction {
   typename boost::enable_if<sizeof(T) == 4, int>::type f(); // expected-error{{no type named 'type' in 'boost::enable_if<false, int>'; 'enable_if' cannot be used to disable this declaration}}
 };
 NonTemplateFunction<char> NTFC; // expected-note{{here}}

 void test() {
   foo(NS1::array<int>()); // expected-error{{no matching function for call to 'foo'}}
 }
 
 namespace std {
   template<bool, typename = void> struct enable_if {};
   template<typename T> struct enable_if<true, T> { typedef T type; };
 
+  template <bool b, typename T = void>
+  using enable_if_t = typename enable_if<b, T>::type;
+
   template<typename T, T V> struct integral_constant { static const T value = V; };
   typedef integral_constant<bool, false> false_type;
   typedef integral_constant<bool, true> true_type;
 };
 
 namespace PR15673 {
   template<typename T>
   struct a_trait : std::false_type {};
 
   template<typename T,
-           typename Requires = typename std::enable_if<a_trait<T>::value>::type> // expected-warning {{C++11 extension}}
-  // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
+           typename Requires = typename std::enable_if<a_trait<T>::value>::type>
+  // expected-note@-1 {{candidate template ignored: disabled by 'std::enable_if' [with T = int]}}
   void foo() {}
   void bar() { foo<int>(); } // expected-error {{no matching function for call to 'foo'}}
 
 
   template<typename T>
   struct some_trait : std::false_type {};
 
   // FIXME: It would be nice to tunnel the 'disabled by enable_if' diagnostic through here.
   template<typename T>
   struct a_pony : std::enable_if<some_trait<T>::value> {};
 
   template<typename T,
-           typename Requires = typename a_pony<T>::type> // expected-warning {{C++11 extension}}
+           typename Requires = typename a_pony<T>::type>
   // FIXME: The source location here is poor.
   void baz() { } // expected-note {{candidate template ignored: substitution failure [with T = int]: no type named 'type' in 'PR15673::a_pony<int>'}}
   void quux() { baz<int>(); } // expected-error {{no matching function for call to 'baz'}}
 
 
-  // FIXME: This note doesn't make it clear which candidate we rejected.
   template <typename T>
-  using unicorns = typename std::enable_if<some_trait<T>::value>::type; // expected-warning {{C++11 extension}}
-  // expected-note@-1 {{candidate template ignored: disabled by 'enable_if' [with T = int]}}
+  using unicorns = typename std::enable_if<some_trait<T>::value>::type;
 
   template<typename T,
-           typename Requires = unicorns<T> > // expected-warning {{C++11 extension}}
+           typename Requires = unicorns<T> > // expected-note {{candidate template ignored: disabled by 'PR15673::unicorns' [with T = int]}}
   void wibble() {}
   void wobble() { wibble<int>(); } // expected-error {{no matching function for call to 'wibble'}}
 }
+
+template <typename T,
+          std::enable_if_t<sizeof(T) == 1, int> = 0> // expected-note {{candidate template ignored: disabled by 'std::enable_if_t' [with T = int]}}
+void test1() {}
+
+template <typename T> 
+auto test2() 
+-> std::enable_if_t<sizeof(T) == 1> // expected-note {{candidate template ignored: disabled by 'std::enable_if_t' [with T = int]}}
+{} 
+
+template <bool b>
+using enable_if_t2 = std::enable_if_t<b>;
+
+template <typename T,
+          typename = enable_if_t2<sizeof(T) == 1>> // expected-note {{candidate template ignored: disabled by 'enable_if_t2' [with T = int]}}
+void test3() {}
+
+template <bool b, typename T = enable_if_t2<b>>
+using enable_if_t3 = T;
+
+template <typename T,
+          typename = enable_if_t3<sizeof(T) == 1>>
+                // FIXME: This note should mention enable_if_t3.
+void test4() {} // expected-note {{candidate template ignored: disabled by 'enable_if_t2' [with T = int]}}
+
+template <bool b>
+using AnotherEnableIf =
+  typename std::enable_if<b, int>::type; 
+// expected-error@-1 {{no type named 'type' in 'std::enable_if<false, int>'; 'enable_if' cannot be used to disable this declaration}}
+
+template <bool b>
+struct BrokenEnableIf {
+  typedef AnotherEnableIf<b> type;
+// expected-note@-1 {{in instantiation of template type alias 'AnotherEnableIf' requested here}}
+};
+
+template <typename T,
+          typename BrokenEnableIf<sizeof(T) == 1>::type = 0>
+          // expected-note@-1 {{in instantiation of template class 'BrokenEnableIf<false>'}}
+void test5() {} // expected-note {{candidate template ignored: substitution failure [with T = int]}}
+// expected-note@-1 {{while substituting prior template arguments into non-type template parameter [with T = int]}}
+
+void tests() {
+  test1<int>(); // expected-error {{no matching function for call to 'test1'}}
+  test2<int>(); // expected-error {{no matching function for call to 'test2'}}
+  test3<int>(); // expected-error {{no matching function for call to 'test3'}} 
+  test4<int>(); // expected-error {{no matching function for call to 'test4'}}
+  test5<int>(); // expected-error {{no matching function for call to 'test5'}}
+// expected-note@-1 {{while substituting deduced template arguments into function template 'test5'}}
+}