Add the diagnose_if attribute to clang.

[george.burgess.iv]

Summary

This patch adds the diagnose_if attribute to clang.

diagnose_if is meant to be a less powerful version of enable_if: it doesn't interact with overload resolution at all, and if the condition in the diagnose_if attribute can't be evaluated, compilation proceeds as though said diagnose_if attribute was not present. It can be used to emit either errors or warnings, like so:

void foo(int a) __attribute__((diagnose_if(a > 10, "a is too large!", "error")));
void bar(int a) __attribute__((diagnose_if(a > 10, "this takes a long time if a is larger than 10.", "warning")));
void baz(int a) __attribute__((diagnose_if(1, "don't use me anymore", "warning")));

void run(int a) {
  foo(10);
  foo(11); // error: a is too large
  foo(a);
  bar(10);
  bar(11); // warning: this takes a long time if a is larger than 10.
  bar(a);

  void (*b)(int) = baz; // warning: don't use me anymore.
}

Under the hood, we have two kinds of diagnose_if attributes: ones that are dependent on the value of arguments (which are handled a lot like enable_if), and ones that aren't (which are treated like unavailable/deprecated attributes). This split made this attribute *substantially* less complex to implement, since it lets us reuse existing code

[EricWF]

Awesome, this is exactly what I was hoping for! Thanks for working on this!

I'm a bit surprised that the attribute fails to evaluate the condition as a constant expression during the evaluation of constexpr functions.
Ex:

#define DIAG(...) __attribute__((diagnose_if(__VA_ARGS__, "message", "error")))
constexpr bool foo(int x) DIAG(x == 0) // fails to evaluate this
{ 
  // assert(x != 0); <-- ironically a simple assert would catch this
  return x == 0;
}  
constexpr bool bar(int x) { return foo(x); }
static_assert(bar(0), "");

Clearly the compiler can evaluate x == 0 as a constant expression, but the attribute fails to see this. If the condition could be evaluated as-if it were part of the function body (during constexpr evaluation) that would be incredibly powerful. Especially within the STL where everything is constexpr.

The second thing that would be amazing if this attribute was late parsed so it the ability to reference this when applied to member functions.
For example:

struct Foo {
  bool is_good;
  constexpr bool good() const { return is_good; }
  constexpr bool foo() const _diagnose_if(!good(), "message", "error")
  {return true; }
};
constexpr Foo f{false};
static_assert(f.foo(), "");

Thanks again for working on this! I'm very excited to get to use it!

[george.burgess.iv]

Glad you like it!

The second thing that would be amazing if this attribute was late parsed so it the ability to reference this when applied to member functions

That seems like a good idea; I'll look into what that would take. (In the meantime, reviews would be appreciated. :) )

If the condition could be evaluated as-if it were part of the function body (during constexpr evaluation) that would be incredibly powerful. Especially within the STL where everything is constexpr.

Honestly, if we could take this attribute and turn it into a full-fledged precondition attribute (that optionally acts as if it's a part of the function, optionally emits dynamic checks, ...), I'd be thrilled. If the community thinks that'd be a good idea, I'm happy to poke at it + incrementally build off of this in order to make that*. That said, I think all of that is going to require a fair bit more code and design thought to get right, and diagnose_if is useful enough as-is to stand on its own IMO.

IOW, we need to start somewhere, and this is a minimial-ish feature set that I think would be useful.

∗ - We can do this in a non-breaking way by either introducing an independent precondition attribute that heavily piggybacks off of diagnose_if, or we can add diagnostic modes + flags to diagnose_if (e.g. can have warning, error, static-precondition, dynamic-precondition, ...).

[ahatanak]

include/clang/Sema/Overload.h

754

I guess you could use "void *" instead of ImplicitConversionSequence for the alignment to make it clear that this has the alignment of a pointer type (or the larger of alignof(ImplicitConversionSequence) and alignof(DiagnoseIfAttr *))?

[george.burgess.iv]

Addressed alignment comment. Thanks! (Late parsing is still to-be-done)

[aaron.ballman]

I really like this attribute, thank you for working on it!

include/clang/Basic/Attr.td

1584

I think this should also have a C++ spelling under the clang namespace.

include/clang/Basic/AttrDocs.td

359

Capitalize the B in because.

include/clang/Basic/DiagnosticCommonKinds.td

164

If we do add the clang namespaced spelling, we should have a test to ensure that this diagnostic is not triggered when the attribute is spelled [[clang::diagnose_if(...)]].

include/clang/Basic/DiagnosticSemaKinds.td

2136

Diagnostics don't have full stops, so I think a better way to write this is: invalid diagnostic type for 'diagnose_if'; use \"error\" or \"warning\" instead.

3352–3354

Space before the colon.

4371

Please single quote the use of diagnose_if.

include/clang/Sema/Overload.h

664

an -> a

include/clang/Sema/Sema.h

2623

Can this (and the other new functions) accept the FunctionDecl as a const FunctionDecl * instead?

lib/Sema/SemaDeclAttr.cpp

857

This should accept FD as a const pointer.

lib/Sema/SemaExpr.cpp

368

const DiagnoseIfAttr *?

388

const auto *?

5186

const auto *?

lib/Sema/SemaOverload.cpp

821–823

DiagnoseIfAttrs aren't the only thing allocated with the slab allocator though, right? Since this is being generalized, I wonder if asserting somewhere that the slab allocator only deals with pointers would make sense?

6151

Please spell out the type instead of using auto, since the type isn't spelled in the initialization.

6178–6179

Instead of doing this, you can use specific_attrs<DiagnoseIfAttr>()

9009

Can you run into a situation with stacked diagnose_if errors, so that there's > 1?

9101

Can use const auto * here.

12667

Can use const auto * here.

lib/Sema/SemaTemplateInstantiateDecl.cpp

193

You shouldn't have to use getSpelling() here; I believe the diagnostics engine has an overload to properly handle Attr * objects.

194

const auto &

[george.burgess.iv]

Addressed all feedback + made diagnose_if late-parsed.

[george.burgess.iv]

Do we have a page that details when we should/shouldn't use auto? I was under the impression that it was preferred only in cases where the type's spelled out (e.g. cast<Foo>, ...). (To be clear, I'm happy to use it in loops, too; I'd just like to know if we have guidelines about it. :) )

include/clang/Basic/Attr.td

1584

Agreed. Though, it looks like that would requires us teaching the parser how to late-parse c++11 attrs if we wanted to do it properly. Given the size of this patch, I think that can be done as a follow-up.

include/clang/Basic/DiagnosticCommonKinds.td

164

Added a disabled test for this.

include/clang/Sema/Sema.h

2623

Not easily, unless you'd prefer to see const here and a const_cast or two in checkArgDependentDiagnoseIf over what we have now. I have no preference, so if you would prefer to see that, I'm happy to do it.

If ExprResult and initialization routines like Sema::PerformCopyInitialization were happy to take a const Expr *, this would be a different story :)

lib/Sema/SemaOverload.cpp

821–823

It also allocates ImplicitConversionSequences, but those are properly cleaned up by destroyCandidates. Added another static_assert to slabAllocate to hopefully catch errors if others try to use this.

9009

Not at the moment (we stop evaluating diagnose_if attrs as soon as we find one that's an error), though you're right that this could be more robust.

[aaron.ballman]

In D27424#636496, @george.burgess.iv wrote:

Do we have a page that details when we should/shouldn't use auto? I was under the impression that it was preferred only in cases where the type's spelled out (e.g. cast<Foo>, ...). (To be clear, I'm happy to use it in loops, too; I'd just like to know if we have guidelines about it. :) )

We do: http://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

Btw, there's a question in there about late parsing that Phab won't let me delete, feel free to ignore it. ;-)

include/clang/Basic/Attr.td

1584

That seems reasonable to me.

include/clang/Sema/Sema.h

2623

That sounds like more churn than it's worth, to me. It'd be nice if we were better about const-correctness, but that's not this patch's problem to solve. ;-)

lib/AST/ExprConstant.cpp

10371 ↗

(On Diff #83188)

I think the message means to say "Don't provide 'this' for static methods."

lib/Parse/ParseDecl.cpp

371–372

In the last patch, this code was checking for enable_if or diagnose_if, but now only checks for enable_if. Do you not need this for diagnose_if because it's now late parsed?

lib/Sema/SemaDeclAttr.cpp

864

const auto *

[george.burgess.iv]

Addressed feedback. Thanks!

[george.burgess.iv]

We do: http://llvm.org/docs/CodingStandards.html#use-auto-type-deduction-to-make-code-more-readable

Awesome. Thanks!

Btw, there's a question in there about late parsing that Phab won't let me delete, feel free to ignore it. ;-)

OK. The answer is "yes" anyway. :)

[aaron.ballman]

LGTM, but please point this out in the release notes as well.

[EricWF]

Awesome! I'm so excited for this!

[george.burgess.iv]

Thanks for the review! :)

include/clang/Basic/Attr.td

class Argument<string name, bit optional, bit fake = 0> {
   string Name = name;
   bit Optional = optional;
 
   /// A fake argument is used to store and serialize additional information
   /// in an attribute without actually changing its parsing or pretty-printing.
   bit Fake = fake;
 }
 
-class BoolArgument<string name, bit opt = 0> : Argument<name, opt>;
+class BoolArgument<string name, bit opt = 0, bit fake = 0> : Argument<name, opt,
+                                                                      fake>;
 class IdentifierArgument<string name, bit opt = 0> : Argument<name, opt>;
 class IntArgument<string name, bit opt = 0> : Argument<name, opt>;
 class StringArgument<string name, bit opt = 0> : Argument<name, opt>;
 class ExprArgument<string name, bit opt = 0> : Argument<name, opt>;
-class FunctionArgument<string name, bit opt = 0> : Argument<name, opt>;
+class FunctionArgument<string name, bit opt = 0, bit fake = 0> : Argument<name,
+                                                                          opt,
+                                                                          fake>;
 class TypeArgument<string name, bit opt = 0> : Argument<name, opt>;
 class UnsignedArgument<string name, bit opt = 0> : Argument<name, opt>;
 class VariadicUnsignedArgument<string name> : Argument<name, 1>;
 class VariadicExprArgument<string name> : Argument<name, 1>;
 class VariadicStringArgument<string name> : Argument<name, 1>;
 
 // A version of the form major.minor[.subminor].
 class VersionArgument<string name, bit opt = 0> : Argument<name, opt>;
let Args = [StringArgument<"Message", 1>,
                  "IR_ARCForbiddenType",
                  "IR_ForbiddenWeak",
                  "IR_ARCForbiddenConversion",
                  "IR_ARCInitReturnsUnrelated",
                  "IR_ARCFieldWithOwnership"], 1, /*fake*/ 1>];
   let Documentation = [Undocumented];
 }
 
+def DiagnoseIf : InheritableAttr {
+  let Spellings = [GNU<"diagnose_if">];
+  let Subjects = SubjectList<[Function]>;
+  let Args = [ExprArgument<"Cond">, StringArgument<"Message">,
+              EnumArgument<"DiagnosticType",
+                           "DiagnosticType",
+                           ["error", "warning"],
+                           ["DT_Error", "DT_Warning"]>,
+              BoolArgument<"ArgDependent", 0, /*fake*/ 1>,
+              FunctionArgument<"Parent", 0, /*fake*/ 1>];
+  let DuplicatesAllowedWhileMerging = 1;
+  let AdditionalMembers = [{
+    bool isError() const { return diagnosticType == DT_Error; }
+    bool isWarning() const { return diagnosticType == DT_Warning; }
+  }];
+  let TemplateDependent = 1;
+  let Documentation = [DiagnoseIfDocs];
+}
+
 def ArcWeakrefUnavailable : InheritableAttr {
   let Spellings = [GNU<"objc_arc_weak_reference_unavailable">];
   let Subjects = SubjectList<[ObjCInterface], ErrorDiag>;
   let Documentation = [Undocumented];
 }
 
 def ObjCGC : TypeAttr {
   let Spellings = [GNU<"objc_gc">];

include/clang/Basic/AttrDocs.td

 
 This is because, in ``bar``, ``foo`` is resolved prior to template
 instantiation, so the value for ``I`` isn't known (thus, both ``enable_if``
 conditions for ``foo`` fail). However, in ``baz``, ``foo`` is resolved during
 template instantiation, so the value for ``T::number`` is known.
   }];
 }
 
+def DiagnoseIfDocs : Documentation {
+  let Category = DocCatFunction;
+  let Content = [{
+The ``diagnose_if`` attribute can be placed on function declarations to emit
+warnings or errors at compile-time if calls to the attributed function meet
+certain user-defined criteria. For example:
+
+.. code-block:: c
+  void abs(int a)
+    __attribute__((diagnose_if(a >= 0, "Redundant abs call", "warning")));
+  void must_abs(int a)
+    __attribute__((diagnose_if(a >= 0, "Redundant abs call", "error")));
+
+  int val = abs(1); // warning: Redundant abs call
+  int val2 = must_abs(1); // error: Redundant abs call
+  int val3 = abs(val);
+  int val4 = must_abs(val); // because run-time checks are not emitted for
+                            // diagnose_if attributes, this executes without
+                            // issue.
+
+
+``diagnose_if`` is closely related to ``enable_if``, with a few key differences:
+
+* Overload resolution is not aware of ``diagnose_if`` attributes: they're
+  considered only after we select the best candidate from a given candidate set.
+* Function declarations that differ only in their ``diagnose_if`` attributes are
+  considered to be redeclarations of the same function (not overloads).
+* If the condition provided to ``diagnose_if`` cannot be evaluated, no
+  diagnostic will be emitted.
+
+Otherwise, ``diagnose_if`` is essentially the logical negation of ``enable_if``.
+
+As a result of bullet number two, ``diagnose_if`` attributes will stack on the
+same function. For example:
+
+.. code-block:: c
+
+  int foo() __attribute__((diagnose_if(1, "diag1", "warning")));
+  int foo() __attribute__((diagnose_if(1, "diag2", "warning")));
+
+  int bar = foo(); // warning: diag1
+                   // warning: diag2
+  int (*fooptr)(void) = foo; // warning: diag1
+                             // warning: diag2
+
+  constexpr int supportsAPILevel(int N) { return N < 5; }
+  int baz(int a)
+    __attribute__((diagnose_if(!supportsAPILevel(10),
+                               "Upgrade to API level 10 to use baz", "error")));
+  int baz(int a)
+    __attribute__((diagnose_if(!a, "0 is not recommended.", "warning")));
+
+  int (*bazptr)(int) = baz; // error: Upgrade to API level 10 to use baz
+  int v = baz(0); // error: Upgrade to API level 10 to use baz
+
+Query for this feature with ``__has_attribute(diagnose_if)``.
+  }];
+}
+
 def PassObjectSizeDocs : Documentation {
   let Category = DocCatVariable; // Technically it's a parameter doc, but eh.
   let Content = [{
 .. Note:: The mangling of functions with parameters that are annotated with
   ``pass_object_size`` is subject to change. You can get around this by
   using ``__asm__("foo")`` to explicitly name your functions, thus preserving
   your ABI; also, non-overloadable C functions with ``pass_object_size`` are
   not mangled.

include/clang/Basic/DiagnosticCommonKinds.td

 def ext_old_implicitly_unsigned_long_cxx : ExtWarn<
   "integer literal is too large to be represented in type 'long' and is "
   "subject to undefined behavior under C++98, interpreting as 'unsigned long'; "
   "this literal will %select{have type 'long long'|be ill-formed}0 "
   "in C++11 onwards">,
   InGroup<CXX11Compat>;
 def ext_clang_enable_if : Extension<"'enable_if' is a clang extension">,
                           InGroup<GccCompat>;
+def ext_clang_diagnose_if : Extension<"'diagnose_if' is a clang extension">,
+                            InGroup<GccCompat>;
 
 // SEH
 def err_seh_expected_handler : Error<
   "expected '__except' or '__finally' block">;
 def err_seh___except_block : Error<
   "%0 only allowed in __except block or filter expression">;
 def err_seh___except_filter : Error<
   "%0 only allowed in __except filter expression">;

include/clang/Basic/DiagnosticGroups.td

 def UnusedConstVariable : DiagGroup<"unused-const-variable">;
 def UnusedVariable : DiagGroup<"unused-variable",
                                [UnusedConstVariable]>;
 def UnusedLocalTypedef : DiagGroup<"unused-local-typedef">;
 def UnusedPropertyIvar :  DiagGroup<"unused-property-ivar">;
 def UnusedGetterReturnValue : DiagGroup<"unused-getter-return-value">;
 def UsedButMarkedUnused : DiagGroup<"used-but-marked-unused">;
 def UserDefinedLiterals : DiagGroup<"user-defined-literals">;
+def UserDefinedWarnings : DiagGroup<"user-defined-warnings">;
 def Reorder : DiagGroup<"reorder">;
 def UndeclaredSelector : DiagGroup<"undeclared-selector">;
 def ImplicitAtomic : DiagGroup<"implicit-atomic-properties">;
 def CustomAtomic : DiagGroup<"custom-atomic-properties">;
 def AtomicProperties : DiagGroup<"atomic-properties",
                                  [ImplicitAtomic, CustomAtomic]>;
 def ARCUnsafeRetainedAssign : DiagGroup<"arc-unsafe-retained-assign">;
 def ARCRetainCycles : DiagGroup<"arc-retain-cycles">;
def Most : DiagGroup<"most", [
     UnknownPragmas,
     Unused,
     VolatileRegisterVar,
     ObjCMissingSuperCalls,
     ObjCDesignatedInit,
     OverloadedVirtual,
     PrivateExtern,
     SelTypeCast,
-    ExternCCompat
+    ExternCCompat,
+    UserDefinedWarnings
  ]>;
 
 // Thread Safety warnings 
 def ThreadSafetyAttributes : DiagGroup<"thread-safety-attributes">;
 def ThreadSafetyAnalysis   : DiagGroup<"thread-safety-analysis">;
 def ThreadSafetyPrecise    : DiagGroup<"thread-safety-precise">;
 def ThreadSafetyReference  : DiagGroup<"thread-safety-reference">;
 def ThreadSafetyNegative   : DiagGroup<"thread-safety-negative">;

include/clang/Basic/DiagnosticSemaKinds.td

def err_constexpr_local_var_non_literal_type : Error<
   "variable of non-literal type %1 cannot be defined in a constexpr "
   "%select{function|constructor}0">;
 def err_constexpr_local_var_no_init : Error<
   "variables defined in a constexpr %select{function|constructor}0 must be "
   "initialized">;
 def ext_constexpr_function_never_constant_expr : ExtWarn<
   "constexpr %select{function|constructor}0 never produces a "
   "constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError;
-def err_enable_if_never_constant_expr : Error<
-  "'enable_if' attribute expression never produces a constant expression">;
+def err_attr_cond_never_constant_expr : Error<
+  "%0 attribute expression never produces a constant expression">;
+def err_diagnose_if_invalid_diagnostic_type : Error<
+  "invalid diagnostic type for diagnose_if. Try 'error' or 'warning'.">;
 def err_constexpr_body_no_return : Error<
   "no return statement in constexpr function">;
 def err_constexpr_return_missing_expr : Error<
   "non-void constexpr function %0 should return a value">;
 def warn_cxx11_compat_constexpr_body_no_return : Warning<
   "constexpr function with no return statements is incompatible with C++ "
   "standards before C++14">, InGroup<CXXPre14Compat>, DefaultIgnore;
 def ext_constexpr_body_multiple_return : ExtWarn<
def note_ovl_candidate_underqualified : Note<
     "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">;
 def note_ovl_candidate_has_pass_object_size_params: Note<
     "candidate address cannot be taken because parameter %0 has "
     "pass_object_size attribute">;
-def note_ovl_candidate_disabled_by_enable_if_attr : Note<
+def err_diagnose_if_succeeded: Error<"%0">;
+def warn_diagnose_if_succeeded : Warning<"%0">, InGroup<UserDefinedWarnings>;
+def note_ovl_candidate_disabled_by_function_cond_attr : Note<
     "candidate disabled: %0">;
 def err_addrof_function_disabled_by_enable_if_attr : Error<
     "cannot take address of function %0 becuase it has one or more "
     "non-tautological enable_if conditions">;
 def note_addrof_ovl_candidate_disabled_by_enable_if_attr : Note<
     "candidate function made ineligible by enable_if">;
 def note_ovl_candidate_failed_overload_resolution : Note<
     "candidate template ignored: couldn't resolve reference to overloaded "
def note_dependent_var_use : Note<"must qualify identifier to find this "
     "declaration in dependent base class">;
 def err_not_found_by_two_phase_lookup : Error<"call to function %0 that is neither "
     "visible in the template definition nor found by argument-dependent lookup">;
 def note_not_found_by_two_phase_lookup : Note<"%0 should be declared prior to the "
     "call site%select{| or in %2| or in an associated namespace of one of its arguments}1">;
 def err_undeclared_use : Error<"use of undeclared %0">;
 def warn_deprecated : Warning<"%0 is deprecated">,
     InGroup<DeprecatedDeclarations>;
+def note_from_diagnose_if : Note<"from diagnose_if attribute on %0:">;
 def warn_property_method_deprecated :
     Warning<"property access is using %0 method which is deprecated">,
     InGroup<DeprecatedDeclarations>;
 def warn_deprecated_message : Warning<"%0 is deprecated: %1">,
     InGroup<DeprecatedDeclarations>;
 def warn_deprecated_anonymous_namespace : Warning<
   "'deprecated' attribute on anonymous namespace ignored">,
   InGroup<IgnoredAttributes>;

include/clang/Sema/Overload.h

struct OverloadCandidate {
     /// FailureKind - The reason why this candidate is not viable.
     /// Actually an OverloadFailureKind.
     unsigned char FailureKind;
 
     /// \brief The number of call arguments that were explicitly provided,
     /// to be used while performing partial ordering of function templates.
     unsigned ExplicitCallArguments;
 
+    /// The number of diagnose_if attributes that this overload triggered.
+    /// If any of the triggered attributes are errors, this won't count
+    /// diagnose_if warnings.
+    unsigned NumTriggeredDiagnoseIfs = 0;
+
+    /// Basically an TinyPtrVector<DiagnoseIfAttr *> that doesn't own the
+    /// vector: If NumTriggeredDiagnoseIfs is 0 or 1, this is a DiagnoseIfAttr
+    /// *, otherwise it's a pointer to an array of `NumTriggeredDiagnoseIfs`
+    /// DiagnoseIfAttr *s.
+    llvm::PointerUnion<DiagnoseIfAttr *, DiagnoseIfAttr **> DiagnoseIfInfo;
+
+    /// Gets an ArrayRef for the data at DiagnoseIfInfo. Note that this may give
+    /// you a pointer into DiagnoseIfInfo.
+    ArrayRef<DiagnoseIfAttr *> getDiagnoseIfInfo() const {
+      auto *Ptr = NumTriggeredDiagnoseIfs <= 1
+                      ? DiagnoseIfInfo.getAddrOfPtr1()
+                      : DiagnoseIfInfo.get<DiagnoseIfAttr **>();
+      return {Ptr, NumTriggeredDiagnoseIfs};
+    }
+
     union {
       DeductionFailureInfo DeductionFailure;
       
       /// FinalConversion - For a conversion function (where Function is
       /// a CXXConversionDecl), the standard conversion that occurs
       /// after the call to the overload candidate to convert the result
       /// of calling the conversion function to the required type.
       StandardConversionSequence FinalConversion;
enum CandidateSetKind {
       /// argument is of the same enum type.
       CSK_Operator
     };
 
   private:
     SmallVector<OverloadCandidate, 16> Candidates;
     llvm::SmallPtrSet<Decl *, 16> Functions;
 
-    // Allocator for OverloadCandidate::Conversions. We store the first few
-    // elements inline to avoid allocation for small sets.
-    llvm::BumpPtrAllocator ConversionSequenceAllocator;
+    // Allocator for OverloadCandidate::Conversions and DiagnoseIfAttr* arrays.
+    // We store the first few of each of these inline to avoid allocation for
+    // small sets.
+    llvm::BumpPtrAllocator SlabAllocator;
 
     SourceLocation Loc;
     CandidateSetKind Kind;
 
-    unsigned NumInlineSequences;
-    llvm::AlignedCharArray<alignof(ImplicitConversionSequence),
-                           16 * sizeof(ImplicitConversionSequence)>
+    constexpr static unsigned NumInlineBytes =
+        24 * sizeof(ImplicitConversionSequence);
+    unsigned NumInlineBytesUsed;
+    llvm::AlignedCharArray<alignof(ImplicitConversionSequence), NumInlineBytes>
         InlineSpace;
 
+    /// If we have space, allocates from inline storage. Otherwise, allocates
+    /// from the slab allocator.
+    /// FIXME: It would probably be nice to have a SmallBumpPtrAllocator instead.
+    template <typename T>
+    T *slabAllocate(unsigned N) {
+      // It's simpler if this doesn't need to consider alignment.
+      static_assert(alignof(T) == alignof(void *),
+                    "Only works for pointer-aligned types.");
+
+      unsigned NBytes = sizeof(T) * N;
+      if (NBytes > NumInlineBytes - NumInlineBytesUsed)
+        return SlabAllocator.Allocate<T>(N);
+      char *FreeSpaceStart = InlineSpace.buffer + NumInlineBytesUsed;
+      assert(uintptr_t(FreeSpaceStart) % alignof(void *) == 0 &&
+             "Misaligned storage!");
+
+      NumInlineBytesUsed += NBytes;
+      return reinterpret_cast<T *>(FreeSpaceStart);
+    }
+
     OverloadCandidateSet(const OverloadCandidateSet &) = delete;
     void operator=(const OverloadCandidateSet &) = delete;
 
     void destroyCandidates();
 
   public:
     OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
-        : Loc(Loc), Kind(CSK), NumInlineSequences(0) {}
+        : Loc(Loc), Kind(CSK), NumInlineBytesUsed(0) {}
     ~OverloadCandidateSet() { destroyCandidates(); }
 
     SourceLocation getLocation() const { return Loc; }
     CandidateSetKind getKind() const { return Kind; }
 
+    /// Make a DiagnoseIfAttr* array in a block of memory that will live for
+    /// as long as this OverloadCandidateSet. Returns a pointer to the start
+    /// of that array.
+    DiagnoseIfAttr **addDiagnoseIfComplaints(ArrayRef<DiagnoseIfAttr *> CA);
+
     /// \brief Determine when this overload candidate will be new to the
     /// overload set.
     bool isNewCandidate(Decl *F) {
       return Functions.insert(F->getCanonicalDecl()).second;
     }
 
     /// \brief Clear out all of the candidates.
     void clear();
 
     typedef SmallVectorImpl<OverloadCandidate>::iterator iterator;
     iterator begin() { return Candidates.begin(); }
     iterator end() { return Candidates.end(); }
 
     size_t size() const { return Candidates.size(); }
     bool empty() const { return Candidates.empty(); }
 
     /// \brief Add a new candidate with NumConversions conversion sequence slots
     /// to the overload set.
     OverloadCandidate &addCandidate(unsigned NumConversions = 0) {
       Candidates.push_back(OverloadCandidate());
       OverloadCandidate &C = Candidates.back();
 
-      // Assign space from the inline array if there are enough free slots
-      // available.
-      if (NumConversions + NumInlineSequences <= 16) {
-        ImplicitConversionSequence *I =
-            (ImplicitConversionSequence *)InlineSpace.buffer;
-        C.Conversions = &I[NumInlineSequences];
-        NumInlineSequences += NumConversions;
-      } else {
-        // Otherwise get memory from the allocator.
-        C.Conversions = ConversionSequenceAllocator
-                          .Allocate<ImplicitConversionSequence>(NumConversions);
-      }
-
+      C.Conversions = slabAllocate<ImplicitConversionSequence>(NumConversions);
       // Construct the new objects.
       for (unsigned i = 0; i != NumConversions; ++i)
         new (&C.Conversions[i]) ImplicitConversionSequence();
 
       C.NumConversions = NumConversions;
       return C;
     }
 

include/clang/Sema/Sema.h

public:
   void NoteAllOverloadCandidates(Expr *E, QualType DestType = QualType(),
                                  bool TakingAddress = false);
 
   /// Check the enable_if expressions on the given function. Returns the first
   /// failing attribute, or NULL if they were all successful.
   EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
                               bool MissingImplicitThis = false);
 
+  /// Check the diagnose_if attributes on the given function. Returns the
+  /// first succesful fatal attribute, or null if calling Function(Args) isn't
+  /// an error.
+  ///
+  /// This only considers ArgDependent DiagnoseIfAttrs.
+  ///
+  /// This will populate Nonfatal with all non-error DiagnoseIfAttrs that
+  /// succeed. If this function returns non-null, the contents of Nonfatal are
+  /// unspecified.
+  DiagnoseIfAttr *
+  checkArgDependentDiagnoseIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
+                              SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal,
+                              bool MissingImplicitThis = false);
+
+  /// Check the diagnose_if expressions on the given function. Returns the
+  /// first succesful fatal attribute, or null if using Function isn't
+  /// an error.
+  ///
+  /// This ignores all ArgDependent DiagnoseIfAttrs.
+  ///
+  /// This will populate Nonfatal with all non-error DiagnoseIfAttrs that
+  /// succeed. If this function returns non-null, the contents of Nonfatal are
+  /// unspecified.
+  DiagnoseIfAttr *
+  checkArgIndependentDiagnoseIf(FunctionDecl *Function,
+                                SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal);
+
+  /// Emits the diagnostic contained in the given DiagnoseIfAttr at Loc. Also
+  /// emits a note about the location of said attribute.
+  void emitDiagnoseIfDiagnostic(SourceLocation Loc, const DiagnoseIfAttr *DIA);
+
   /// Returns whether the given function's address can be taken or not,
   /// optionally emitting a diagnostic if the address can't be taken.
   ///
   /// Returns false if taking the address of the function is illegal.
   bool checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
                                          bool Complain = false,
                                          SourceLocation Loc = SourceLocation());
 

lib/Parse/ParseDecl.cpp

unsigned Parser::ParseAttributeArgsCommon(
   }
 
   if (EndLoc)
     *EndLoc = RParen;
 
   return static_cast<unsigned>(ArgExprs.size());
 }
 
+static bool attrMayReferToFunctionParams(StringRef Name) {
+  StringRef NormalizedName = normalizeAttrName(Name);
+  return NormalizedName == "enable_if" || NormalizedName == "diagnose_if";
+}
+
 /// Parse the arguments to a parameterized GNU attribute or
 /// a C++11 attribute in "gnu" namespace.
 void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
                                    SourceLocation AttrNameLoc,
                                    ParsedAttributes &Attrs,
                                    SourceLocation *EndLoc,
                                    IdentifierInfo *ScopeName,
                                    SourceLocation ScopeLoc,
void Parser::ParseGNUAttributeArgs(IdentifierInfo *AttrName,
   } else if (AttrKind == AttributeList::AT_TypeTagForDatatype) {
     ParseTypeTagForDatatypeAttribute(*AttrName, AttrNameLoc, Attrs, EndLoc,
                                      ScopeName, ScopeLoc, Syntax);
     return;
   } else if (attributeIsTypeArgAttr(*AttrName)) {
     ParseAttributeWithTypeArg(*AttrName, AttrNameLoc, Attrs, EndLoc, ScopeName,
                               ScopeLoc, Syntax);
     return;
   }
 
   // These may refer to the function arguments, but need to be parsed early to
   // participate in determining whether it's a redeclaration.
   llvm::Optional<ParseScope> PrototypeScope;
-  if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
-      D && D->isFunctionDeclarator()) {
+  if (D && D->isFunctionDeclarator() &&
+      attrMayReferToFunctionParams(AttrName->getName())) {
     DeclaratorChunk::FunctionTypeInfo FTI = D->getFunctionTypeInfo();
     PrototypeScope.emplace(this, Scope::FunctionPrototypeScope |
                                      Scope::FunctionDeclarationScope |
                                      Scope::DeclScope);
     for (unsigned i = 0; i != FTI.NumParams; ++i) {
       ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
       Actions.ActOnReenterCXXMethodParameter(getCurScope(), Param);
     }

lib/Sema/SemaDeclAttr.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaInternal.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace clang;
 using namespace sema;
 
 namespace AttributeLangSupport {
   enum LANG {
if (Size == 0)
     return;
   Expr **StartArg = &Args[0];
 
   D->addAttr(::new (S.Context)
              LocksExcludedAttr(Attr.getRange(), S.Context, StartArg, Size,
                                Attr.getAttributeSpellingListIndex()));
 }
 
-static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
-  S.Diag(Attr.getLoc(), diag::ext_clang_enable_if);
-
-  Expr *Cond = Attr.getArgAsExpr(0);
+static bool checkFunctionConditionAttr(Sema &S, Decl *D,
+                                       const AttributeList &Attr,
+                                       Expr *&Cond, StringRef &Msg) {
+  Cond = Attr.getArgAsExpr(0);
   if (!Cond->isTypeDependent()) {
     ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
     if (Converted.isInvalid())
-      return;
+      return false;
     Cond = Converted.get();
   }
 
-  StringRef Msg;
   if (!S.checkStringLiteralArgumentAttr(Attr, 1, Msg))
-    return;
+    return false;
+
+  if (Msg.empty())
+    Msg = "<no message provided>";
 
   SmallVector<PartialDiagnosticAt, 8> Diags;
   if (!Cond->isValueDependent() &&
       !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(D),
                                                 Diags)) {
-    S.Diag(Attr.getLoc(), diag::err_enable_if_never_constant_expr);
+    S.Diag(Attr.getLoc(), diag::err_attr_cond_never_constant_expr)
+        << Attr.getName();
     for (const PartialDiagnosticAt &PDiag : Diags)
       S.Diag(PDiag.first, PDiag.second);
-    return;
-  }
+    return false;
+  }
+  return true;
 
+static void handleEnableIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
+  S.Diag(Attr.getLoc(), diag::ext_clang_enable_if);
+
+  Expr *Cond;
+  StringRef Msg;
+  if (checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
     D->addAttr(::new (S.Context)
                    EnableIfAttr(Attr.getRange(), S.Context, Cond, Msg,
                                 Attr.getAttributeSpellingListIndex()));
 }
 
+namespace {
+/// Determines if a given Expr references any of the given ParmVarDecls.
+class ParmVarDeclChecker : public RecursiveASTVisitor<ParmVarDeclChecker> {
+  llvm::SmallPtrSet<const ParmVarDecl *, 16> Parms;
+  bool Result;
+
+public:
+  ParmVarDeclChecker(FunctionDecl *FD) {
+    Parms.insert(FD->param_begin(), FD->param_end());
+  }
+
+  bool referencesParmVars(Expr *E) {
+    Result = false;
+    TraverseStmt(E);
+    return Result;
+  }
+
+  bool VisitDeclRefExpr(DeclRefExpr *DRE) {
+    if (auto *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl()))
+      if (Parms.count(PVD)) {
+        Result = true;
+        return false;
+      }
+    return true;
+  }
+};
+}
+
+static void handleDiagnoseIfAttr(Sema &S, Decl *D, const AttributeList &Attr) {
+  S.Diag(Attr.getLoc(), diag::ext_clang_diagnose_if);
+
+  Expr *Cond;
+  StringRef Msg;
+  if (!checkFunctionConditionAttr(S, D, Attr, Cond, Msg))
+    return;
+
+  StringRef DiagTypeStr;
+  if (!S.checkStringLiteralArgumentAttr(Attr, 2, DiagTypeStr))
+    return;
+
+  DiagnoseIfAttr::DiagnosticType DiagType;
+  if (!DiagnoseIfAttr::ConvertStrToDiagnosticType(DiagTypeStr, DiagType)) {
+    S.Diag(Attr.getArgAsExpr(2)->getLocStart(),
+           diag::err_diagnose_if_invalid_diagnostic_type);
+    return;
+  }
+
+  auto *FD = cast<FunctionDecl>(D);
+  bool ArgDependent = ParmVarDeclChecker(FD).referencesParmVars(Cond);
+  D->addAttr(::new (S.Context) DiagnoseIfAttr(
+      Attr.getRange(), S.Context, Cond, Msg, DiagType, ArgDependent, FD,
+      Attr.getAttributeSpellingListIndex()));
+}
+
 static void handlePassObjectSizeAttr(Sema &S, Decl *D,
                                      const AttributeList &Attr) {
   if (D->hasAttr<PassObjectSizeAttr>()) {
     S.Diag(D->getLocStart(), diag::err_attribute_only_once_per_parameter)
         << Attr.getName();
     return;
   }
 
case AttributeList::AT_Deprecated:
     handleDeprecatedAttr(S, D, Attr);
     break;
   case AttributeList::AT_Destructor:
     handleDestructorAttr(S, D, Attr);
     break;
   case AttributeList::AT_EnableIf:
     handleEnableIfAttr(S, D, Attr);
     break;
+  case AttributeList::AT_DiagnoseIf:
+    handleDiagnoseIfAttr(S, D, Attr);
+    break;
   case AttributeList::AT_ExtVectorType:
     handleExtVectorTypeAttr(S, scope, D, Attr);
     break;
   case AttributeList::AT_MinSize:
     handleMinSizeAttr(S, D, Attr);
     break;
   case AttributeList::AT_OptimizeNone:
     handleOptimizeNoneAttr(S, D, Attr);

lib/Sema/SemaExpr.cpp

if (isa<BindingDecl>(D)) {
 
       Diag(Loc, diag::err_auto_variable_cannot_appear_in_own_initializer)
         << D->getDeclName() << (unsigned)AT->getKeyword();
     }
     return true;
   }
 
   // See if this is a deleted function.
+  SmallVector<DiagnoseIfAttr *, 4> DiagnoseIfWarnings;
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     if (FD->isDeleted()) {
       auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
       if (Ctor && Ctor->isInheritingConstructor())
         Diag(Loc, diag::err_deleted_inherited_ctor_use)
             << Ctor->getParent()
             << Ctor->getInheritedConstructor().getConstructor()->getParent();
       else 
         Diag(Loc, diag::err_deleted_function_use);
       NoteDeletedFunction(FD);
       return true;
     }
 
     // If the function has a deduced return type, and we can't deduce it,
     // then we can't use it either.
     if (getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
         DeduceReturnType(FD, Loc))
       return true;
 
     if (getLangOpts().CUDA && !CheckCUDACall(Loc, FD))
       return true;
+
+    if (DiagnoseIfAttr *A =
+            checkArgIndependentDiagnoseIf(FD, DiagnoseIfWarnings)) {
+      emitDiagnoseIfDiagnostic(Loc, A);
+      return true;
+    }
   }
 
   // [OpenMP 4.0], 2.15 declare reduction Directive, Restrictions
   // Only the variables omp_in and omp_out are allowed in the combiner.
   // Only the variables omp_priv and omp_orig are allowed in the
   // initializer-clause.
   auto *DRD = dyn_cast<OMPDeclareReductionDecl>(CurContext);
   if (LangOpts.OpenMP && DRD && !CurContext->containsDecl(D) &&
       isa<VarDecl>(D)) {
     Diag(Loc, diag::err_omp_wrong_var_in_declare_reduction)
         << getCurFunction()->HasOMPDeclareReductionCombiner;
     Diag(D->getLocation(), diag::note_entity_declared_at) << D;
     return true;
   }
+
+  for (DiagnoseIfAttr *W : DiagnoseIfWarnings)
+    emitDiagnoseIfDiagnostic(Loc, W);
+
   DiagnoseAvailabilityOfDecl(*this, D, Loc, UnknownObjCClass,
                              ObjCPropertyAccess);
 
   DiagnoseUnusedOfDecl(*this, D, Loc);
 
   diagnoseUseOfInternalDeclInInlineFunction(*this, D, Loc);
 
   return false;
ParmVarDecl *Parm =
                                 /*TInfo=*/nullptr, SC_None, nullptr);
     Parm->setScopeInfo(0, i);
     Params.push_back(Parm);
   }
   OverloadDecl->setParams(Params);
   return OverloadDecl;
 }
 
-static bool isNumberOfArgsValidForCall(Sema &S, const FunctionDecl *Callee,
-                                       std::size_t NumArgs) {
-  if (S.TooManyArguments(Callee->getNumParams(), NumArgs,
-                         /*PartialOverloading=*/false))
-    return Callee->isVariadic();
-  return Callee->getMinRequiredArguments() <= NumArgs;
+static void checkDirectCallValidity(Sema &S, const Expr *Fn,
+                                    FunctionDecl *Callee,
+                                    MultiExprArg ArgExprs) {
+  // `Callee` (when called with ArgExprs) may be ill-formed. enable_if (and
+  // similar attributes) really don't like it when functions are called with an
+  // invalid number of args.
+  if (S.TooManyArguments(Callee->getNumParams(), ArgExprs.size(),
+                         /*PartialOverloading=*/false) &&
+      !Callee->isVariadic())
+    return;
+  if (Callee->getMinRequiredArguments() > ArgExprs.size())
+    return;
+
+  if (const EnableIfAttr *Attr = S.CheckEnableIf(Callee, ArgExprs, true)) {
+    S.Diag(Fn->getLocStart(),
+           isa<CXXMethodDecl>(Callee)
+               ? diag::err_ovl_no_viable_member_function_in_call
+               : diag::err_ovl_no_viable_function_in_call)
+        << Callee << Callee->getSourceRange();
+    S.Diag(Callee->getLocation(),
+           diag::note_ovl_candidate_disabled_by_function_cond_attr)
+        << Attr->getCond()->getSourceRange() << Attr->getMessage();
+    return;
+  }
+
+  SmallVector<DiagnoseIfAttr *, 4> Nonfatal;
+  if (const DiagnoseIfAttr *Attr = S.checkArgDependentDiagnoseIf(
+          Callee, ArgExprs, Nonfatal, /*MissingImplicitThis=*/true)) {
+    S.emitDiagnoseIfDiagnostic(Fn->getLocStart(), Attr);
+    return;
+  }
+
+  for (DiagnoseIfAttr *Attr : Nonfatal)
+    S.emitDiagnoseIfDiagnostic(Fn->getLocStart(), Attr);
 }
 
 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
 /// This provides the location of the left/right parens and a list of comma
 /// locations.
 ExprResult Sema::ActOnCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
                                Expr *ExecConfig, bool IsExecConfig) {
if (isa<DeclRefExpr>(NakedFn)) {
     NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
 
   if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(NDecl)) {
     if (CallingNDeclIndirectly &&
         !checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
                                            Fn->getLocStart()))
       return ExprError();
 
-    // CheckEnableIf assumes that the we're passing in a sane number of args for
-    // FD, but that doesn't always hold true here. This is because, in some
-    // cases, we'll emit a diag about an ill-formed function call, but then
-    // we'll continue on as if the function call wasn't ill-formed. So, if the
-    // number of args looks incorrect, don't do enable_if checks; we should've
-    // already emitted an error about the bad call.
-    if (FD->hasAttr<EnableIfAttr>() &&
-        isNumberOfArgsValidForCall(*this, FD, ArgExprs.size())) {
-      if (const EnableIfAttr *Attr = CheckEnableIf(FD, ArgExprs, true)) {
-        Diag(Fn->getLocStart(),
-             isa<CXXMethodDecl>(FD)
-                 ? diag::err_ovl_no_viable_member_function_in_call
-                 : diag::err_ovl_no_viable_function_in_call)
-            << FD << FD->getSourceRange();
-        Diag(FD->getLocation(),
-             diag::note_ovl_candidate_disabled_by_enable_if_attr)
-            << Attr->getCond()->getSourceRange() << Attr->getMessage();
-      }
-    }
+    checkDirectCallValidity(*this, Fn, FD, ArgExprs);
   }
 
   return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
                                ExecConfig, IsExecConfig);
 }
 
 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
 ///

lib/Sema/SemaOverload.cpp

 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/SemaInternal.h"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateDeduction.h"
 #include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include <algorithm>
 #include <cstdlib>
 
 using namespace clang;
 using namespace sema;
for (unsigned ii = 0, ie = i->NumConversions; ii != ie; ++ii)
       i->Conversions[ii].~ImplicitConversionSequence();
     if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
       i->DeductionFailure.Destroy();
   }
 }
 
 void OverloadCandidateSet::clear() {
   destroyCandidates();
-  ConversionSequenceAllocator.Reset();
-  NumInlineSequences = 0;
+  // DiagnoseIfAttrs are just pointers, so we don't need to destroy them.
+  SlabAllocator.Reset();
+  NumInlineBytesUsed = 0;
   Candidates.clear();
   Functions.clear();
 }
 
+DiagnoseIfAttr **
+OverloadCandidateSet::addDiagnoseIfComplaints(ArrayRef<DiagnoseIfAttr *> CA) {
+  auto *DIA = slabAllocate<DiagnoseIfAttr *>(CA.size());
+  std::uninitialized_copy(CA.begin(), CA.end(), DIA);
+  return DIA;
+}
+
 namespace {
   class UnbridgedCastsSet {
     struct Entry {
       Expr **Addr;
       Expr *Saved;
     };
     SmallVector<Entry, 2> Entries;
     
if (!T2.isNull() && T2->isEnumeralType()) {
     QualType ArgType = Proto->getParamType(1).getNonReferenceType();
     if (Context.hasSameUnqualifiedType(T2, ArgType))
       return true;
   }
 
   return false;
 }
 
+static void initDiagnoseIfComplaint(Sema &S, OverloadCandidateSet &CandidateSet,
+                                    OverloadCandidate &Candidate,
+                                    FunctionDecl *Function,
+                                    ArrayRef<Expr *> Args,
+                                    bool MissingImplicitThis = false) {
+  SmallVector<DiagnoseIfAttr *, 8> Results;
+  if (DiagnoseIfAttr *DIA = S.checkArgDependentDiagnoseIf(
+          Function, Args, Results, MissingImplicitThis)) {
+    Results.clear();
+    Results.push_back(DIA);
+  }
+
+  Candidate.NumTriggeredDiagnoseIfs = Results.size();
+  if (Results.empty())
+    Candidate.DiagnoseIfInfo = nullptr;
+  else if (Results.size() == 1)
+    Candidate.DiagnoseIfInfo = Results[0];
+  else
+    Candidate.DiagnoseIfInfo = CandidateSet.addDiagnoseIfComplaints(Results);
+}
+
 /// AddOverloadCandidate - Adds the given function to the set of
 /// candidate functions, using the given function call arguments.  If
 /// @p SuppressUserConversions, then don't allow user-defined
 /// conversions via constructors or conversion operators.
 ///
 /// \param PartialOverloading true if we are performing "partial" overloading
 /// based on an incomplete set of function arguments. This feature is used by
 /// code completion.
Sema::AddOverloadCandidate(FunctionDecl *Function,
   }
 
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
+
+  initDiagnoseIfComplaint(*this, CandidateSet, Candidate, Function, Args);
 }
 
 ObjCMethodDecl *
 Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
                        SmallVectorImpl<ObjCMethodDecl *> &Methods) {
   if (Methods.size() <= 1)
     return nullptr;
 
getOrderedEnableIfAttrs(const FunctionDecl *Function) {
   for (Attr *Attr : FuncAttrs)
     if (auto *EnableIf = dyn_cast<EnableIfAttr>(Attr))
       Result.push_back(EnableIf);
 
   std::reverse(Result.begin(), Result.end());
   return Result;
 }
 
-EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
-                                  bool MissingImplicitThis) {
-  auto EnableIfAttrs = getOrderedEnableIfAttrs(Function);
-  if (EnableIfAttrs.empty())
-    return nullptr;
-
-  SFINAETrap Trap(*this);
-  SmallVector<Expr *, 16> ConvertedArgs;
-  bool InitializationFailed = false;
-
+static bool convertArgsForAvailabilityChecks(
+    Sema &S, FunctionDecl *Function, ArrayRef<Expr *> Args,
+    bool MissingImplicitThis, Sema::SFINAETrap &Trap,
+    SmallVectorImpl<Expr *> &ConvertedArgs) {
   // Ignore any variadic arguments. Converting them is pointless, since the
   // user can't refer to them in the enable_if condition.
   unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
 
   // Convert the arguments.
   for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
     ExprResult R;
     if (I == 0 && !MissingImplicitThis && isa<CXXMethodDecl>(Function) &&
         !cast<CXXMethodDecl>(Function)->isStatic() &&
         !isa<CXXConstructorDecl>(Function)) {
       CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
-      R = PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
+      R = S.PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
                                                 Method, Method);
     } else {
-      R = PerformCopyInitialization(InitializedEntity::InitializeParameter(
-                                        Context, Function->getParamDecl(I)),
+      R = S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                          S.Context, Function->getParamDecl(I)),
                                       SourceLocation(), Args[I]);
     }
 
-    if (R.isInvalid()) {
-      InitializationFailed = true;
-      break;
-    }
+    if (R.isInvalid())
+      return false;
 
     ConvertedArgs.push_back(R.get());
   }
 
-  if (InitializationFailed || Trap.hasErrorOccurred())
-    return EnableIfAttrs[0];
+  if (Trap.hasErrorOccurred())
+    return false;
 
   // Push default arguments if needed.
   if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
     for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
       ParmVarDecl *P = Function->getParamDecl(i);
-      ExprResult R = PerformCopyInitialization(
-          InitializedEntity::InitializeParameter(Context,
+      ExprResult R = S.PerformCopyInitialization(
+          InitializedEntity::InitializeParameter(S.Context,
                                                  Function->getParamDecl(i)),
           SourceLocation(),
           P->hasUninstantiatedDefaultArg() ? P->getUninstantiatedDefaultArg()
                                            : P->getDefaultArg());
-      if (R.isInvalid()) {
-        InitializationFailed = true;
-        break;
-      }
+      if (R.isInvalid())
+        return false;
       ConvertedArgs.push_back(R.get());
     }
 
-    if (InitializationFailed || Trap.hasErrorOccurred())
-      return EnableIfAttrs[0];
+    if (Trap.hasErrorOccurred())
+      return false;
   }
+  return true;
+}
+
+EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
+                                  bool MissingImplicitThis) {
+  auto EnableIfAttrs = getOrderedEnableIfAttrs(Function);
+  if (EnableIfAttrs.empty())
+    return nullptr;
+
+  SFINAETrap Trap(*this);
+  SmallVector<Expr *, 16> ConvertedArgs;
+  if (!convertArgsForAvailabilityChecks(
+          *this, Function, Args, MissingImplicitThis, Trap, ConvertedArgs))
+    return EnableIfAttrs[0];
 
   for (auto *EIA : EnableIfAttrs) {
     APValue Result;
     // FIXME: This doesn't consider value-dependent cases, because doing so is
     // very difficult. Ideally, we should handle them more gracefully.
     if (!EIA->getCond()->EvaluateWithSubstitution(
             Result, Context, Function, llvm::makeArrayRef(ConvertedArgs)))
       return EIA;
 
     if (!Result.isInt() || !Result.getInt().getBoolValue())
       return EIA;
   }
   return nullptr;
 }
 
+static bool gatherDiagnoseIfAttrs(FunctionDecl *Function, bool ArgDependent,
+                                  SmallVectorImpl<DiagnoseIfAttr *> &Errors,
+                                  SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal) {
+  for (Attr *A : Function->attrs())
+    if (auto *DIA = dyn_cast<DiagnoseIfAttr>(A))
+      if (ArgDependent == DIA->getArgDependent()) {
+        if (DIA->isError())
+          Errors.push_back(DIA);
+        else
+          Nonfatal.push_back(DIA);
+      }
+
+  return !Errors.empty() || !Nonfatal.empty();
+}
+
+template <typename CheckFn>
+static DiagnoseIfAttr *
+checkDiagnoseIfAttrsWith(const SmallVectorImpl<DiagnoseIfAttr *> &Errors,
+                         SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal,
+                         CheckFn &&IsSuccessful) {
+  // attrs() iterates through attributes in reverse, and we want to traverse
+  // through diagnose_if attributes in top-to-bottom order. So, we need to
+  // reverse them.
+  auto ErrAttr = llvm::find_if(llvm::reverse(Errors), IsSuccessful);
+  if (ErrAttr != Errors.rend())
+    return *ErrAttr;
+
+  auto NewEnd = llvm::remove_if(
+      Nonfatal, [&](DiagnoseIfAttr *A) { return !IsSuccessful(A); });
+  Nonfatal.erase(NewEnd, Nonfatal.end());
+
+  // Again, these things are stored in reverse order, and we care about having
+  // them in the correct order.
+  std::reverse(Nonfatal.begin(), Nonfatal.end());
+  return nullptr;
+}
+
+DiagnoseIfAttr *
+Sema::checkArgDependentDiagnoseIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
+                                  SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal,
+                                  bool MissingImplicitThis) {
+  SmallVector<DiagnoseIfAttr *, 4> Errors;
+  if (!gatherDiagnoseIfAttrs(Function, /*ArgDependent=*/true, Errors, Nonfatal))
+    return nullptr;
+
+  SFINAETrap Trap(*this);
+  SmallVector<Expr *, 16> ConvertedArgs;
+  if (!convertArgsForAvailabilityChecks(
+          *this, Function, Args, MissingImplicitThis, Trap, ConvertedArgs))
+    return nullptr;
+
+  return checkDiagnoseIfAttrsWith(Errors, Nonfatal, [&](DiagnoseIfAttr *DIA) {
+    APValue Result;
+    // It's sane to use the same ConvertedArgs for any redecl of this function,
+    // since EvaluateWithSubstitution only cares about the position of each
+    // argument in the arg list, not the ParmVarDecl* it maps to.
+    if (!DIA->getCond()->EvaluateWithSubstitution(
+            Result, Context, DIA->getParent(), ConvertedArgs))
+      return false;
+    return Result.isInt() && Result.getInt().getBoolValue();
+  });
+}
+
+DiagnoseIfAttr *Sema::checkArgIndependentDiagnoseIf(
+    FunctionDecl *Function, SmallVectorImpl<DiagnoseIfAttr *> &Nonfatal) {
+  SmallVector<DiagnoseIfAttr *, 4> Errors;
+  if (!gatherDiagnoseIfAttrs(Function, /*ArgDependent=*/false, Errors,
+                             Nonfatal))
+    return nullptr;
+
+  return checkDiagnoseIfAttrsWith(Errors, Nonfatal, [&](DiagnoseIfAttr *DIA) {
+    bool Result;
+    return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
+           Result;
+  });
+}
+
+void Sema::emitDiagnoseIfDiagnostic(SourceLocation Loc,
+                                    const DiagnoseIfAttr *DIA) {
+  auto Code = DIA->isError() ? diag::err_diagnose_if_succeeded
+                             : diag::warn_diagnose_if_succeeded;
+  Diag(Loc, Code) << DIA->getMessage();
+  Diag(DIA->getLocation(), diag::note_from_diagnose_if)
+      << DIA->getParent() << DIA->getCond()->getSourceRange();
+}
+
 /// \brief Add all of the function declarations in the given function set to
 /// the overload candidate set.
 void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
                                  ArrayRef<Expr *> Args,
                                  OverloadCandidateSet& CandidateSet,
                                  TemplateArgumentListInfo *ExplicitTemplateArgs,
                                  bool SuppressUserConversions,
                                  bool PartialOverloading) {
Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
   }
 
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Method, Args, true)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
+
+  initDiagnoseIfComplaint(*this, CandidateSet, Candidate, Method, Args, true);
 }
 
 /// \brief Add a C++ member function template as a candidate to the candidate
 /// set, using template argument deduction to produce an appropriate member
 /// function template specialization.
 void
 Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
                                  DeclAccessPair FoundDecl,
Sema::AddConversionCandidate(CXXConversionDecl *Conversion,
   }
 
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
+
+  initDiagnoseIfComplaint(*this, CandidateSet, Candidate, Conversion, None);
 }
 
 /// \brief Adds a conversion function template specialization
 /// candidate to the overload set, using template argument deduction
 /// to deduce the template arguments of the conversion function
 /// template from the type that we are converting to (C++
 /// [temp.deduct.conv]).
 void
void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
   }
 
   if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
     Candidate.DeductionFailure.Data = FailedAttr;
     return;
   }
+
+  initDiagnoseIfComplaint(*this, CandidateSet, Candidate, Conversion, None);
 }
 
 /// \brief Add overload candidates for overloaded operators that are
 /// member functions.
 ///
 /// Add the overloaded operator candidates that are member functions
 /// for the operator Op that was used in an operator expression such
 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
void Sema::diagnoseEquivalentInternalLinkageDeclarations(
 
   for (auto *E : Equiv) {
     Module *M = getOwningModule(const_cast<NamedDecl*>(E));
     Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
         << !M << (M ? M->getFullModuleName() : "");
   }
 }
 
+static bool isCandidateUnavailableDueToDiagnoseIf(const OverloadCandidate &OC) {
+  return OC.NumTriggeredDiagnoseIfs == 1 &&
+         OC.DiagnoseIfInfo.get<DiagnoseIfAttr *>()->isError();
+}
+
 /// \brief Computes the best viable function (C++ 13.3.3)
 /// within an overload candidate set.
 ///
 /// \param Loc The location of the function name (or operator symbol) for
 /// which overload resolution occurs.
 ///
 /// \param Best If overload resolution was successful or found a deleted
 /// function, \p Best points to the candidate function found.
if (Cand->Viable &&
       Best = end();
       return OR_Ambiguous;
     }
   }
 
   // Best is the best viable function.
   if (Best->Function &&
       (Best->Function->isDeleted() ||
-       S.isFunctionConsideredUnavailable(Best->Function)))
+       S.isFunctionConsideredUnavailable(Best->Function) ||
+       isCandidateUnavailableDueToDiagnoseIf(*Best)))
     return OR_Deleted;
 
   if (!EquivalentCands.empty())
     S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
                                                     EquivalentCands);
 
+  for (DiagnoseIfAttr *W : Best->getDiagnoseIfInfo()) {
+    assert(W->isWarning() && "Errors should've been caught earlier!");
+    S.emitDiagnoseIfDiagnostic(Loc, W);
+  }
+
   return OR_Success;
 }
 
 namespace {
 
 enum OverloadCandidateKind {
   oc_function,
   oc_method,
static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
   }
 }
 
 static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
   FunctionDecl *Callee = Cand->Function;
   EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
 
   S.Diag(Callee->getLocation(),
-         diag::note_ovl_candidate_disabled_by_enable_if_attr)
+         diag::note_ovl_candidate_disabled_by_function_cond_attr)
       << Attr->getCond()->getSourceRange() << Attr->getMessage();
 }
 
 /// Generates a 'note' diagnostic for an overload candidate.  We've
 /// already generated a primary error at the call site.
 ///
 /// It really does need to be a single diagnostic with its caret
 /// pointed at the candidate declaration.  Yes, this creates some
 /// major challenges of technical writing.  Yes, this makes pointing
 /// out problems with specific arguments quite awkward.  It's still
 /// better than generating twenty screens of text for every failed
 /// overload.
 ///
 /// It would be great to be able to express per-candidate problems
 /// more richly for those diagnostic clients that cared, but we'd
 /// still have to be just as careful with the default diagnostics.
 static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
                                   unsigned NumArgs,
                                   bool TakingCandidateAddress) {
   FunctionDecl *Fn = Cand->Function;
 
   // Note deleted candidates, but only if they're viable.
-  if (Cand->Viable && (Fn->isDeleted() ||
-      S.isFunctionConsideredUnavailable(Fn))) {
+  if (Cand->Viable) {
+    if (Fn->isDeleted() || S.isFunctionConsideredUnavailable(Fn)) {
       std::string FnDesc;
       OverloadCandidateKind FnKind =
         ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, FnDesc);
 
       S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
         << FnKind << FnDesc
         << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
       MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
       return;
     }
+    if (isCandidateUnavailableDueToDiagnoseIf(*Cand)) {
+      auto *A = Cand->DiagnoseIfInfo.get<DiagnoseIfAttr *>();
+      assert(A->isError() && "Non-error diagnose_if disables a candidate?");
+      S.Diag(Cand->Function->getLocation(),
+             diag::note_ovl_candidate_disabled_by_function_cond_attr)
+          << A->getCond()->getSourceRange() << A->getMessage();
+      return;
+    }
 
     // We don't really have anything else to say about viable candidates.
-  if (Cand->Viable) {
     S.NoteOverloadCandidate(Cand->FoundDecl, Fn);
     return;
   }
 
   switch (Cand->FailureKind) {
   case ovl_fail_too_many_arguments:
   case ovl_fail_too_few_arguments:
     return DiagnoseArityMismatch(S, Cand, NumArgs);
Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
   // resolution process, we still need to handle the enable_if attribute. Do
   // that here, so it will not hide previous -- and more relevant -- errors.
   if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
     if (const EnableIfAttr *Attr = CheckEnableIf(Method, Args, true)) {
       Diag(MemE->getMemberLoc(),
            diag::err_ovl_no_viable_member_function_in_call)
           << Method << Method->getSourceRange();
       Diag(Method->getLocation(),
-           diag::note_ovl_candidate_disabled_by_enable_if_attr)
+           diag::note_ovl_candidate_disabled_by_function_cond_attr)
           << Attr->getCond()->getSourceRange() << Attr->getMessage();
       return ExprError();
     }
+
+    SmallVector<DiagnoseIfAttr *, 4> Nonfatal;
+    if (const DiagnoseIfAttr *Attr = checkArgDependentDiagnoseIf(
+            Method, Args, Nonfatal, /*MissingImplicitThis=*/true)) {
+      emitDiagnoseIfDiagnostic(MemE->getMemberLoc(), Attr);
+      return ExprError();
+    }
+
+    for (DiagnoseIfAttr *Attr : Nonfatal)
+      emitDiagnoseIfDiagnostic(MemE->getMemberLoc(), Attr);
   }
 
   if ((isa<CXXConstructorDecl>(CurContext) || 
        isa<CXXDestructorDecl>(CurContext)) && 
       TheCall->getMethodDecl()->isPure()) {
     const CXXMethodDecl *MD = TheCall->getMethodDecl();
 
     if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&

lib/Sema/SemaTemplateInstantiateDecl.cpp

static void instantiateDependentAlignValueAttr(
   // The alignment expression is a constant expression.
   EnterExpressionEvaluationContext Unevaluated(S, Sema::ConstantEvaluated);
   ExprResult Result = S.SubstExpr(Aligned->getAlignment(), TemplateArgs);
   if (!Result.isInvalid())
     S.AddAlignValueAttr(Aligned->getLocation(), New, Result.getAs<Expr>(),
                         Aligned->getSpellingListIndex());
 }
 
-static void instantiateDependentEnableIfAttr(
+static Expr *instantiateDependentFunctionAttrCondition(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
-    const EnableIfAttr *A, const Decl *Tmpl, Decl *New) {
+    const Attr *A, Expr *OldCond, const Decl *Tmpl, FunctionDecl *New) {
   Expr *Cond = nullptr;
   {
     EnterExpressionEvaluationContext Unevaluated(S, Sema::Unevaluated);
-    ExprResult Result = S.SubstExpr(A->getCond(), TemplateArgs);
+    ExprResult Result = S.SubstExpr(OldCond, TemplateArgs);
     if (Result.isInvalid())
-      return;
+      return nullptr;
     Cond = Result.getAs<Expr>();
   }
   if (!Cond->isTypeDependent()) {
     ExprResult Converted = S.PerformContextuallyConvertToBool(Cond);
     if (Converted.isInvalid())
-      return;
+      return nullptr;
     Cond = Converted.get();
   }
 
   SmallVector<PartialDiagnosticAt, 8> Diags;
-  if (A->getCond()->isValueDependent() && !Cond->isValueDependent() &&
-      !Expr::isPotentialConstantExprUnevaluated(Cond, cast<FunctionDecl>(New),
-                                                Diags)) {
-    S.Diag(A->getLocation(), diag::err_enable_if_never_constant_expr);
-    for (int I = 0, N = Diags.size(); I != N; ++I)
-      S.Diag(Diags[I].first, Diags[I].second);
-    return;
-  }
+  if (OldCond->isValueDependent() && !Cond->isValueDependent() &&
+      !Expr::isPotentialConstantExprUnevaluated(Cond, New, Diags)) {
+    S.Diag(A->getLocation(), diag::err_attr_cond_never_constant_expr)
+        << A->getSpelling();
+    for (const PartialDiagnosticAt &P : Diags)
+      S.Diag(P.first, P.second);
+    return nullptr;
+  }
+  return Cond;
 
-  EnableIfAttr *EIA = new (S.getASTContext())
-                        EnableIfAttr(A->getLocation(), S.getASTContext(), Cond,
-                                     A->getMessage(),
-                                     A->getSpellingListIndex());
-  New->addAttr(EIA);
+static void instantiateDependentEnableIfAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const EnableIfAttr *EIA, const Decl *Tmpl, FunctionDecl *New) {
+  Expr *Cond = instantiateDependentFunctionAttrCondition(
+      S, TemplateArgs, EIA, EIA->getCond(), Tmpl, New);
+
+  if (Cond)
+    New->addAttr(new (S.getASTContext()) EnableIfAttr(
+        EIA->getLocation(), S.getASTContext(), Cond, EIA->getMessage(),
+        EIA->getSpellingListIndex()));
+}
+
+static void instantiateDependentDiagnoseIfAttr(
+    Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
+    const DiagnoseIfAttr *DIA, const Decl *Tmpl, FunctionDecl *New) {
+  Expr *Cond = instantiateDependentFunctionAttrCondition(
+      S, TemplateArgs, DIA, DIA->getCond(), Tmpl, New);
+
+  if (Cond)
+    New->addAttr(new (S.getASTContext()) DiagnoseIfAttr(
+        DIA->getLocation(), S.getASTContext(), Cond, DIA->getMessage(),
+        DIA->getDiagnosticType(), DIA->getArgDependent(), New,
+        DIA->getSpellingListIndex()));
 }
 
 // Constructs and adds to New a new instance of CUDALaunchBoundsAttr using
 // template A as the base and arguments from TemplateArgs.
 static void instantiateDependentCUDALaunchBoundsAttr(
     Sema &S, const MultiLevelTemplateArgumentList &TemplateArgs,
     const CUDALaunchBoundsAttr &Attr, Decl *New) {
   // The alignment expression is a constant expression.
for (const auto *TmplAttr : Tmpl->attrs()) {
     const AlignValueAttr *AlignValue = dyn_cast<AlignValueAttr>(TmplAttr);
     if (AlignValue) {
       instantiateDependentAlignValueAttr(*this, TemplateArgs, AlignValue, New);
       continue;
     }
 
     if (const auto *EnableIf = dyn_cast<EnableIfAttr>(TmplAttr)) {
       instantiateDependentEnableIfAttr(*this, TemplateArgs, EnableIf, Tmpl,
-                                       New);
+                                       cast<FunctionDecl>(New));
+      continue;
+    }
+
+    if (const auto *DiagnoseIf = dyn_cast<DiagnoseIfAttr>(TmplAttr)) {
+      instantiateDependentDiagnoseIfAttr(*this, TemplateArgs, DiagnoseIf, Tmpl,
+                                         cast<FunctionDecl>(New));
       continue;
     }
 
     if (const CUDALaunchBoundsAttr *CUDALaunchBounds =
             dyn_cast<CUDALaunchBoundsAttr>(TmplAttr)) {
       instantiateDependentCUDALaunchBoundsAttr(*this, TemplateArgs,
                                                *CUDALaunchBounds, New);
       continue;

test/Sema/diagnose_if.c

+// RUN: %clang_cc1 %s -verify -fno-builtin
+
+#define _diagnose_if(...) __attribute__((diagnose_if(__VA_ARGS__)))
+
+void failure() _diagnose_if(); // expected-error{{exactly 3 arguments}}
+void failure() _diagnose_if(0); // expected-error{{exactly 3 arguments}}
+void failure() _diagnose_if(0, ""); // expected-error{{exactly 3 arguments}}
+void failure() _diagnose_if(0, "", "error", 1); // expected-error{{exactly 3 arguments}}
+void failure() _diagnose_if(0, 0, "error"); // expected-error{{requires a string}}
+void failure() _diagnose_if(0, "", "invalid"); // expected-error{{invalid diagnostic type}}
+void failure() _diagnose_if(0, "", "ERROR"); // expected-error{{invalid diagnostic type}}
+void failure(int a) _diagnose_if(a, "", ""); // expected-error{{invalid diagnostic type}}
+void failure() _diagnose_if(a, "", ""); // expected-error{{undeclared identifier 'a'}}
+
+int globalVar;
+void never_constant() _diagnose_if(globalVar, "", "error"); // expected-error{{'diagnose_if' attribute expression never produces a constant expression}} expected-note{{subexpression not valid}}
+void never_constant() _diagnose_if(globalVar, "", "warning"); // expected-error{{'diagnose_if' attribute expression never produces a constant expression}} expected-note{{subexpression not valid}}
+
+int alwaysok(int q) _diagnose_if(0, "", "error");
+int neverok(int q) _diagnose_if(1, "oh no", "error"); // expected-note 5{{from diagnose_if attribute on 'neverok'}}
+int alwayswarn(int q) _diagnose_if(1, "oh no", "warning"); // expected-note 5{{from diagnose_if attribute}}
+int neverwarn(int q) _diagnose_if(0, "", "warning");
+
+void runConstant() {
+  int m;
+  alwaysok(0);
+  alwaysok(1);
+  alwaysok(m);
+
+  {
+    int (*pok)(int) = alwaysok;
+    pok = &alwaysok;
+  }
+
+  neverok(0); // expected-error{{oh no}}
+  neverok(1); // expected-error{{oh no}}
+  neverok(m); // expected-error{{oh no}}
+  {
+    int (*pok)(int) = neverok; // expected-error{{oh no}}
+    pok = &neverok; // expected-error{{oh no}}
+  }
+
+  alwayswarn(0); // expected-warning{{oh no}}
+  alwayswarn(1); // expected-warning{{oh no}}
+  alwayswarn(m); // expected-warning{{oh no}}
+  {
+    int (*pok)(int) = alwayswarn; // expected-warning{{oh no}}
+    pok = &alwayswarn; // expected-warning{{oh no}}
+  }
+
+  neverwarn(0);
+  neverwarn(1);
+  neverwarn(m);
+  {
+    int (*pok)(int) = neverwarn;
+    pok = &neverwarn;
+  }
+}
+
+int abs(int q) _diagnose_if(q >= 0, "redundant abs call", "error"); //expected-note{{from diagnose_if}}
+void runVariable() {
+  int m;
+  abs(-1);
+  abs(1); // expected-error{{redundant abs call}}
+  abs(m);
+
+  int (*pabs)(int) = abs;
+  pabs = &abs;
+}
+
+#define _overloadable __attribute__((overloadable))
+
+int ovl1(const char *n) _overloadable _diagnose_if(n, "oh no", "error"); // expected-note{{oh no}}
+int ovl1(void *m) _overloadable; // expected-note{{candidate function}}
+
+int ovl2(const char *n) _overloadable _diagnose_if(n, "oh no", "error"); // expected-note{{candidate function}}
+int ovl2(char *m) _overloadable; // expected-note{{candidate function}}
+void overloadsYay() {
+  ovl1((void *)0);
+  ovl1(""); // expected-error{{call to unavailable function}}
+
+  ovl2((void *)0); // expected-error{{ambiguous}}
+}
+
+void errorWarnDiagnose1() _diagnose_if(1, "oh no", "error") // expected-note{{from diagnose_if}}
+  _diagnose_if(1, "nop", "warning");
+void errorWarnDiagnose2() _diagnose_if(1, "oh no", "error") // expected-note{{from diagnose_if}}
+  _diagnose_if(1, "nop", "error");
+void errorWarnDiagnose3() _diagnose_if(1, "nop", "warning")
+  _diagnose_if(1, "oh no", "error"); // expected-note{{from diagnose_if}}
+
+void errorWarnDiagnoseArg1(int a) _diagnose_if(a == 1, "oh no", "error") // expected-note{{from diagnose_if}}
+  _diagnose_if(a == 1, "nop", "warning");
+void errorWarnDiagnoseArg2(int a) _diagnose_if(a == 1, "oh no", "error") // expected-note{{from diagnose_if}}
+  _diagnose_if(a == 1, "nop", "error");
+void errorWarnDiagnoseArg3(int a) _diagnose_if(a == 1, "nop", "warning")
+  _diagnose_if(a == 1, "oh no", "error"); // expected-note{{from diagnose_if}}
+
+void runErrorWarnDiagnose() {
+  errorWarnDiagnose1(); // expected-error{{oh no}}
+  errorWarnDiagnose2(); // expected-error{{oh no}}
+  errorWarnDiagnose3(); // expected-error{{oh no}}
+
+  errorWarnDiagnoseArg1(1); // expected-error{{oh no}}
+  errorWarnDiagnoseArg2(1); // expected-error{{oh no}}
+  errorWarnDiagnoseArg3(1); // expected-error{{oh no}}
+}
+
+void warnWarnDiagnose() _diagnose_if(1, "oh no!", "warning") _diagnose_if(1, "foo", "warning"); // expected-note 2{{from diagnose_if}}
+void runWarnWarnDiagnose() {
+  warnWarnDiagnose(); // expected-warning{{oh no!}} expected-warning{{foo}}
+}
+
+void declsStackErr1(int a) _diagnose_if(a & 1, "decl1", "error"); // expected-note 2{{from diagnose_if}}
+void declsStackErr1(int a) _diagnose_if(a & 2, "decl2", "error"); // expected-note{{from diagnose_if}}
+void declsStackErr2();
+void declsStackErr2() _diagnose_if(1, "complaint", "error"); // expected-note{{from diagnose_if}}
+void declsStackErr3() _diagnose_if(1, "complaint", "error"); // expected-note{{from diagnose_if}}
+void declsStackErr3();
+void runDeclsStackErr() {
+  declsStackErr1(0);
+  declsStackErr1(1); // expected-error{{decl1}}
+  declsStackErr1(2); // expected-error{{decl2}}
+  declsStackErr1(3); // expected-error{{decl1}}
+  declsStackErr2(); // expected-error{{complaint}}
+  declsStackErr3(); // expected-error{{complaint}}
+}
+
+void declsStackWarn1(int a) _diagnose_if(a & 1, "decl1", "warning"); // expected-note 2{{from diagnose_if}}
+void declsStackWarn1(int a) _diagnose_if(a & 2, "decl2", "warning"); // expected-note 2{{from diagnose_if}}
+void declsStackWarn2();
+void declsStackWarn2() _diagnose_if(1, "complaint", "warning"); // expected-note{{from diagnose_if}}
+void declsStackWarn3() _diagnose_if(1, "complaint", "warning"); // expected-note{{from diagnose_if}}
+void declsStackWarn3();
+void runDeclsStackWarn() {
+  declsStackWarn1(0);
+  declsStackWarn1(1); // expected-warning{{decl1}}
+  declsStackWarn1(2); // expected-warning{{decl2}}
+  declsStackWarn1(3); // expected-warning{{decl1}} expected-warning{{decl2}}
+  declsStackWarn2(); // expected-warning{{complaint}}
+  declsStackWarn3(); // expected-warning{{complaint}}
+}
+
+void noMsg(int n) _diagnose_if(n, "", "warning"); // expected-note{{from diagnose_if}}
+void runNoMsg() {
+  noMsg(1); // expected-warning{{<no message provided>}}
+}
+
+void alwaysWarnWithArg(int a) _diagnose_if(1 || a, "alwaysWarn", "warning"); // expected-note{{from diagnose_if}}
+void runAlwaysWarnWithArg(int a) {
+  alwaysWarnWithArg(a); // expected-warning{{alwaysWarn}}
+}

test/SemaCXX/diagnose_if.cpp

+// RUN: %clang_cc1 %s -verify -fno-builtin -std=c++11
+
+#define _diagnose_if(...) __attribute__((diagnose_if(__VA_ARGS__)))
+
+namespace type_dependent {
+template <typename T>
+void neverok() _diagnose_if(!T(), "oh no", "error") {} // expected-note 4{{from diagnose_if}}
+
+template <typename T>
+void alwaysok() _diagnose_if(T(), "oh no", "error") {}
+
+template <typename T>
+void alwayswarn() _diagnose_if(!T(), "oh no", "warning") {} // expected-note 4{{from diagnose_if}}
+
+template <typename T>
+void neverwarn() _diagnose_if(T(), "oh no", "warning") {}
+
+void runAll() {
+  alwaysok<int>();
+  alwaysok<int>();
+
+  {
+    void (*pok)() = alwaysok<int>;
+    pok = &alwaysok<int>;
+  }
+
+  neverok<int>(); // expected-error{{oh no}}
+  neverok<short>(); // expected-error{{oh no}}
+
+  {
+    void (*pok)() = neverok<int>; // expected-error{{oh no}}
+  }
+  {
+    void (*pok)();
+    pok = &neverok<int>; // expected-error{{oh no}}
+  }
+
+  alwayswarn<int>(); // expected-warning{{oh no}}
+  alwayswarn<short>(); // expected-warning{{oh no}}
+  {
+    void (*pok)() = alwayswarn<int>; // expected-warning{{oh no}}
+    pok = &alwayswarn<int>; // expected-warning{{oh no}}
+  }
+
+  neverwarn<int>();
+  neverwarn<short>();
+  {
+    void (*pok)() = neverwarn<int>;
+    pok = &neverwarn<int>;
+  }
+}
+
+template <typename T>
+void errorIf(T a) _diagnose_if(T() != a, "oh no", "error") {} // expected-note {{candidate disabled: oh no}}
+
+template <typename T>
+void warnIf(T a) _diagnose_if(T() != a, "oh no", "warning") {} // expected-note {{from diagnose_if}}
+
+void runIf() {
+  errorIf(0);
+  errorIf(1); // expected-error{{call to unavailable function}}
+
+  warnIf(0);
+  warnIf(1); // expected-warning{{oh no}}
+}
+}
+
+namespace value_dependent {
+template <int N>
+void neverok() _diagnose_if(N == 0 || N != 0, "oh no", "error") {} // expected-note 4{{from diagnose_if}}
+
+template <int N>
+void alwaysok() _diagnose_if(N == 0 && N != 0, "oh no", "error") {}
+
+template <int N>
+void alwayswarn() _diagnose_if(N == 0 || N != 0, "oh no", "warning") {} // expected-note 4{{from diagnose_if}}
+
+template <int N>
+void neverwarn() _diagnose_if(N == 0 && N != 0, "oh no", "warning") {}
+
+void runAll() {
+  alwaysok<0>();
+  alwaysok<1>();
+
+  {
+    void (*pok)() = alwaysok<0>;
+    pok = &alwaysok<0>;
+  }
+
+  neverok<0>(); // expected-error{{oh no}}
+  neverok<1>(); // expected-error{{oh no}}
+
+  {
+    void (*pok)() = neverok<0>; // expected-error{{oh no}}
+  }
+  {
+    void (*pok)();
+    pok = &neverok<0>; // expected-error{{oh no}}
+  }
+
+  alwayswarn<0>(); // expected-warning{{oh no}}
+  alwayswarn<1>(); // expected-warning{{oh no}}
+  {
+    void (*pok)() = alwayswarn<0>; // expected-warning{{oh no}}
+    pok = &alwayswarn<0>; // expected-warning{{oh no}}
+  }
+
+  neverwarn<0>();
+  neverwarn<1>();
+  {
+    void (*pok)() = neverwarn<0>;
+    pok = &neverwarn<0>;
+  }
+}
+
+template <int N>
+void errorIf(int a) _diagnose_if(N != a, "oh no", "error") {} // expected-note {{candidate disabled: oh no}}
+
+template <int N>
+void warnIf(int a) _diagnose_if(N != a, "oh no", "warning") {} // expected-note {{from diagnose_if}}
+
+void runIf() {
+  errorIf<0>(0);
+  errorIf<0>(1); // expected-error{{call to unavailable function}}
+
+  warnIf<0>(0);
+  warnIf<0>(1); // expected-warning{{oh no}}
+}
+}
+
+namespace no_overload_interaction {
+void foo(int) _diagnose_if(1, "oh no", "error"); // expected-note{{from diagnose_if}}
+void foo(short);
+
+void bar(int);
+void bar(short) _diagnose_if(1, "oh no", "error");
+
+void fooArg(int a) _diagnose_if(a, "oh no", "error"); // expected-note{{candidate disabled: oh no}}
+void fooArg(short); // expected-note{{candidate function}}
+
+void barArg(int);
+void barArg(short a) _diagnose_if(a, "oh no", "error");
+
+void runAll() {
+  foo(1); // expected-error{{oh no}}
+  bar(1);
+
+  fooArg(1); // expected-error{{call to unavailable function}}
+  barArg(1);
+
+  auto p = foo; // expected-error{{incompatible initializer of type '<overloaded function type>'}}
+}
+}
+
+// We have some inline space craziness going on. This is meant to go over that
+// in hopes of hitting some edge cases. At the time of writing, our inline
+// buffer can support 16 DiagnoseIfAttr*s. If a function only has one attr, no
+// allocation is done.
+namespace overloading_multiple_coverage {
+#define _diagnose_thirteen_times \
+  _diagnose_if(a <= 1, "oh no", "warning") \
+  _diagnose_if(a <= 2, "oh no", "warning") \
+  _diagnose_if(a <= 3, "oh no", "warning") \
+  _diagnose_if(a <= 4, "oh no", "warning") \
+  _diagnose_if(a <= 5, "oh no", "warning") \
+  _diagnose_if(a <= 6, "oh no", "warning") \
+  _diagnose_if(a <= 7, "oh no", "warning") \
+  _diagnose_if(a <= 8, "oh no", "warning") \
+  _diagnose_if(a <= 9, "oh no", "warning") \
+  _diagnose_if(a <= 10, "oh no", "warning") \
+  _diagnose_if(a <= 11, "oh no", "warning") \
+  _diagnose_if(a <= 12, "oh no", "warning") \
+  _diagnose_if(a <= 13, "oh no", "warning")
+
+void foo(short a) _diagnose_thirteen_times; // expected-note 25{{from diagnose_if}}
+void foo(unsigned short a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning");
+void foo(long a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning");
+void foo(unsigned long a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning");
+void foo(int a) _diagnose_if(a <= 1, "oh no", "warning"); // expected-note{{from diagnose_if}}
+
+void runFoo() {
+  foo(int(1)); // expected-warning{{oh no}}
+  foo(short(1)); // expected-warning 13{{oh no}}
+
+  foo(int(2));
+  foo(short(2)); // expected-warning 12{{oh no}}
+}
+
+void bar(short a) _diagnose_thirteen_times; // expected-note 25{{from diagnose_if}}
+void bar(unsigned short a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning")
+  _diagnose_if(a <= 3, "oh no", "warning");
+void bar(long a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning");
+void bar(unsigned long a) _diagnose_if(a <= 1, "oh no", "warning")
+  _diagnose_if(a <= 2, "oh no", "warning");
+void bar(int a) _diagnose_if(a <= 1, "oh no", "warning"); // expected-note{{from diagnose_if}}
+
+void runBar() {
+  bar(int(1)); // expected-warning{{oh no}}
+  bar(short(1)); // expected-warning 13{{oh no}}
+
+  bar(int(2));
+  bar(short(2)); // expected-warning 12{{oh no}}
+}
+#undef _diagnose_thirteen_times
+}
+
+namespace with_default_args {
+void foo(int a = 0) _diagnose_if(a, "oh no", "warning"); // expected-note 1{{from diagnose_if}}
+void bar(int a = 1) _diagnose_if(a, "oh no", "warning"); // expected-note 2{{from diagnose_if}}
+
+void runAll() {
+  foo();
+  foo(0);
+  foo(1); // expected-warning{{oh no}}
+
+  bar(); // expected-warning{{oh no}}
+  bar(0);
+  bar(1); // expected-warning{{oh no}}
+}
+}
+
+namespace naked_mem_expr {
+struct Foo {
+  void foo(int a) _diagnose_if(a, "should warn", "warning"); // expected-note{{from diagnose_if}}
+  void bar(int a) _diagnose_if(a, "oh no", "error"); // expected-note{{from diagnose_if}}
+};
+
+void runFoo() {
+  Foo().foo(0);
+  Foo().foo(1); // expected-warning{{should warn}}
+
+  Foo().bar(0);
+  Foo().bar(1); // expected-error{{oh no}}
+}
+}
+
+namespace class_template {
+template <typename T>
+struct Errors {
+  void foo(int i) _diagnose_if(i, "bad i", "error"); // expected-note{{from diagnose_if}}
+  void bar(int i) _diagnose_if(i != T(), "bad i", "error"); // expected-note{{from diagnose_if}}
+
+  void fooOvl(int i) _diagnose_if(i, "int bad i", "error"); // expected-note 2{{int bad i}}
+  void fooOvl(short i) _diagnose_if(i, "short bad i", "error"); // expected-note 2{{short bad i}}
+
+  void barOvl(int i) _diagnose_if(i != T(), "int bad i", "error"); // expected-note 2{{int bad i}}
+  void barOvl(short i) _diagnose_if(i != T(), "short bad i", "error"); // expected-note 2{{short bad i}}
+};
+
+void runErrors() {
+  Errors<int>().foo(0);
+  Errors<int>().foo(1); // expected-error{{bad i}}
+
+  Errors<int>().bar(0);
+  Errors<int>().bar(1); // expected-error{{bad i}}
+
+  Errors<int>().fooOvl(0);
+  Errors<int>().fooOvl(1); // expected-error{{call to unavailable}}
+  Errors<int>().fooOvl(short(0));
+  Errors<int>().fooOvl(short(1)); // expected-error{{call to unavailable}}
+
+  Errors<int>().barOvl(0);
+  Errors<int>().barOvl(1); // expected-error{{call to unavailable}}
+  Errors<int>().barOvl(short(0));
+  Errors<int>().barOvl(short(1)); // expected-error{{call to unavailable}}
+}
+
+template <typename T>
+struct Warnings {
+  void foo(int i) _diagnose_if(i, "bad i", "warning"); // expected-note{{from diagnose_if}}
+  void bar(int i) _diagnose_if(i != T(), "bad i", "warning"); // expected-note{{from diagnose_if}}
+
+  void fooOvl(int i) _diagnose_if(i, "int bad i", "warning"); // expected-note{{from diagnose_if}}
+  void fooOvl(short i) _diagnose_if(i, "short bad i", "warning"); // expected-note{{from diagnose_if}}
+
+  void barOvl(int i) _diagnose_if(i != T(), "int bad i", "warning"); // expected-note{{from diagnose_if}}
+  void barOvl(short i) _diagnose_if(i != T(), "short bad i", "warning"); // expected-note{{from diagnose_if}}
+};
+
+void runWarnings() {
+  Warnings<int>().foo(0);
+  Warnings<int>().foo(1); // expected-warning{{bad i}}
+
+  Warnings<int>().bar(0);
+  Warnings<int>().bar(1); // expected-warning{{bad i}}
+
+  Warnings<int>().fooOvl(0);
+  Warnings<int>().fooOvl(1); // expected-warning{{int bad i}}
+  Warnings<int>().fooOvl(short(0));
+  Warnings<int>().fooOvl(short(1)); // expected-warning{{short bad i}}
+
+  Warnings<int>().barOvl(0);
+  Warnings<int>().barOvl(1); // expected-warning{{int bad i}}
+  Warnings<int>().barOvl(short(0));
+  Warnings<int>().barOvl(short(1)); // expected-warning{{short bad i}}
+}
+}
+
+namespace template_specialization {
+template <typename T>
+struct Foo {
+  void foo() _diagnose_if(1, "override me", "error"); // expected-note{{from diagnose_if}}
+  void bar(int i) _diagnose_if(i, "bad i", "error"); // expected-note{{from diagnose_if}}
+  void baz(int i);
+};
+
+template <>
+struct Foo<int> {
+  void foo();
+  void bar(int i);
+  void baz(int i) _diagnose_if(i, "bad i", "error"); // expected-note{{from diagnose_if}}
+};
+
+void runAll() {
+  Foo<double>().foo(); // expected-error{{override me}}
+  Foo<int>().foo();
+
+  Foo<double>().bar(1); // expected-error{{bad i}}
+  Foo<int>().bar(1);
+
+  Foo<double>().baz(1);
+  Foo<int>().baz(1); // expected-error{{bad i}}
+}
+}
+
+namespace late_constexpr {
+constexpr int foo();
+constexpr int foo(int a);
+
+void bar() _diagnose_if(foo(), "bad foo", "error"); // expected-note{{from diagnose_if}} expected-note{{not viable: requires 0 arguments}}
+void bar(int a) _diagnose_if(foo(a), "bad foo", "error"); // expected-note{{bad foo}}
+
+void early() {
+  bar();
+  bar(0);
+  bar(1);
+}
+
+constexpr int foo() { return 1; }
+constexpr int foo(int a) { return a; }
+
+void late() {
+  bar(); // expected-error{{bad foo}}
+  bar(0);
+  bar(1); // expected-error{{call to unavailable function}}
+}
+}