[Sema] Make enable_if act correctly with value dependent conditions/arguments

[george.burgess.iv]

Summary

Test case:

int foo(int A) __attribute__((enable_if(A == 0, "")));
template <int A> int bar() { return foo(A); }

int G = bar<1>(); // calls foo(1), which should be a compile-time error, but isn't.

We get around this by making CheckEnableIf fail all value dependent enable_if conditions, and report whether the condition may have failed due to a dependent value. If we fail for this reason during overload resolution, we hand back an unresolved, type-dependent call expression, because the following code is perfectly legal:

int ThisIsABadIdea(int A) __attribute__((enable_if(A == 1, "")));
double ThisIsABadIdea(int A) __attribute__((enable_if(A == 2, "")));

...But if we're not in overload resolution, we can get away with just marking the expression as value dependent, because we know our target. :)

[george.burgess.iv]

Ping ;)

[rsmith]

include/clang/Sema/Sema.h

2491

I'd just call this Dependent -- that is, "here is a dependent enable_if attribute, so I couldn't tell whether this is enabled". The details of why it's dependent shouldn't be relevant to the caller.

lib/Sema/SemaExpr.cpp

5047–5098

You don't seem to make use of this refactoring in the functional change below. Either revert or commit separately, please (and if you commit it, fix the comment in Sema.h to reflect what this is used for).

5091–5106

Can you delete this FIXME? I'm pretty sure we've got that right for years :)

5218–5221

Does this need to be value-dependent? The only possible outcomes here are either that we call the designated function or that instantiation fails, which seems like instantiation-dependence is enough. (In practice, the setValueDependent call will be a no-op, because the only way the flag gets set is if one of the ArgExprs is value-dependent, which results in the call being value-dependent regardless, so there should be no functional change in removing the setValueDependent call.)

lib/Sema/SemaOverload.cpp

5879

I'm nervous about setting Viable to false for a function that *might be* viable; I expect a lot of code to "misinterpret" that. If we go ahead with this direction, I'd prefer for the Viable flag to become an enum of NonViable, Viable, Dependent, have overload resolution treat dependently-viable functions like viable functions, and add an OverloadingResult of OR_Dependent for the case where there was a unique best result that was dependently viable. All 31 callers of BestViableFunction would then need to check for and handle the new case, and build a dependent call expression in that case.

However, this seems like a lot of complexity to deal with this case. Let's talk offline and see if we can come up with something better.

[george.burgess.iv]

Addressed most feedback; see comments. :)

lib/Sema/SemaExpr.cpp

5047–5098

SG; will just revert.

5091–5106

r265341

5218–5221

If instantiation dependence is enough to be sure that we re-evaluate the enable_if condition(s) when we have all of the values we need, then not marking this as value-dependent seems like a better approach, yeah. :)

In practice, the setValueDependent call will be a no-op, because the only way the flag gets set is if one of the ArgExprs is value-dependent, which results in the call being value-dependent regardless, so there should be no functional change in removing the setValueDependent call

Given that we no longer care about value-dependence, it doesn't matter, but will this also happen when the enable_if condition itself is value-dependent?

lib/Sema/SemaOverload.cpp

5879

Works for me; will come bug you soonish.

[rsmith]

lib/Sema/SemaExpr.cpp

5218–5221

Hmm, good point, you might see a change in a contrived case like this:

constexpr bool g() __attribute__((enable_if(true, ""))) { return false; }
template<bool B> void f() {
  constexpr bool g() __attribute__((enable_if(B, "")));
  static_assert(g());
}

... where we can diagnose the static_assert failure at template definition time if the call is not value-dependent.

[george.burgess.iv]

Abandoning this; D20130 is our new approach.

include/clang/Sema/Sema.h

 
   // Emit as a series of 'note's all template and non-templates identified by
   // the expression Expr
   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.
+  ///
+  /// If `Dependent` is non-NULL, this function will set it to true if the
+  /// attribute it's handing back couldn't be evaluated properly due to a
+  /// value-dependent expression.
   EnableIfAttr *CheckEnableIf(FunctionDecl *Function, ArrayRef<Expr *> Args,
-                              bool MissingImplicitThis = false);
+                              bool MissingImplicitThis = false,
+                              bool *Dependent = nullptr);
 
   /// 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/Sema/SemaExpr.cpp

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;
 }
 
 /// 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 *S, Expr *Fn, SourceLocation LParenLoc,
                     MultiExprArg ArgExprs, SourceLocation RParenLoc,
                     Expr *ExecConfig, bool IsExecConfig) {
   // Since this might be a postfix expression, get rid of ParenListExprs.
   ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn);
   if (Result.isInvalid()) return ExprError();
   Fn = Result.get();
 
   if (checkArgsForPlaceholders(*this, ArgExprs))
     return ExprError();
 
   if (getLangOpts().CPlusPlus) {
     // If this is a pseudo-destructor expression, build the call immediately.
     if (isa<CXXPseudoDestructorExpr>(Fn)) {
       if (!ArgExprs.empty()) {
         // Pseudo-destructor calls should not have any arguments.
         Diag(Fn->getLocStart(), diag::err_pseudo_dtor_call_with_args)
           << FixItHint::CreateRemoval(
                                     SourceRange(ArgExprs.front()->getLocStart(),
                                                 ArgExprs.back()->getLocEnd()));
       }
 
       return new (Context)
           CallExpr(Context, Fn, None, Context.VoidTy, VK_RValue, RParenLoc);
     }
     if (Fn->getType() == Context.PseudoObjectTy) {
       ExprResult result = CheckPlaceholderExpr(Fn);
       if (result.isInvalid()) return ExprError();
       Fn = result.get();
     }
 
     // Determine whether this is a dependent call inside a C++ template,
     // in which case we won't do any semantic analysis now.
-    // FIXME: Will need to cache the results of name lookup (including ADL) in
-    // Fn.
     bool Dependent = false;
     if (Fn->isTypeDependent())
       Dependent = true;
     else if (Expr::hasAnyTypeDependentArguments(ArgExprs))
       Dependent = true;
 
     if (Dependent) {
       if (ExecConfig) {
         return new (Context) CUDAKernelCallExpr(
             Context, Fn, cast<CallExpr>(ExecConfig), ArgExprs,
             Context.DependentTy, VK_RValue, RParenLoc);
       } else {
         return new (Context) CallExpr(
             Context, Fn, ArgExprs, Context.DependentTy, VK_RValue, RParenLoc);
       }
     }
 
     // Determine whether this is a call to an object (C++ [over.call.object]).
     if (Fn->getType()->isRecordType())
       return BuildCallToObjectOfClassType(S, Fn, LParenLoc, ArgExprs,
                                           RParenLoc);
 
     if (Fn->getType() == Context.UnknownAnyTy) {
if (FDecl && FDecl->getBuiltinID()) {
                            SourceLocation(), FDecl, false,
                            SourceLocation(), FDecl->getType(),
                            Fn->getValueKind(), FDecl);
       }
     }
   } else if (isa<MemberExpr>(NakedFn))
     NDecl = cast<MemberExpr>(NakedFn)->getMemberDecl();
 
+  bool MakeCallInstantiationDependent = false;
   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)) {
+      bool DependentExpr;
+      if (const EnableIfAttr *Attr =
+              CheckEnableIf(FD, ArgExprs, true, &DependentExpr)) {
+        if (DependentExpr) {
+          // We can build this as usual, but we need to check the enable_if
+          // condition when we have all of the necessary values, so we need to
+          // ensure the resultant function is properly marked as instantiation
+          // dependent.
+          MakeCallInstantiationDependent = true;
+        } else {
           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();
         }
       }
     }
+  }
+
+  ExprResult BuiltCall = BuildResolvedCallExpr(
+      Fn, NDecl, LParenLoc, ArgExprs, RParenLoc, ExecConfig, IsExecConfig);
 
-  return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
-                               ExecConfig, IsExecConfig);
+  if (MakeCallInstantiationDependent)
+    BuiltCall.get()->setInstantiationDependent(true);
+  return BuiltCall;
 }
 
 /// ActOnAsTypeExpr - create a new asType (bitcast) from the arguments.
 ///
 /// __builtin_astype( value, dst type )
 ///
 ExprResult Sema::ActOnAsTypeExpr(Expr *E, ParsedType ParsedDestTy,
                                  SourceLocation BuiltinLoc,

lib/Sema/SemaOverload.cpp

if (!T2.isNull() && T2->isEnumeralType()) {
     QualType ArgType = Proto->getParamType(1).getNonReferenceType();
     if (Context.hasSameUnqualifiedType(T2, ArgType))
       return true;
   }
 
   return false;
 }
 
+namespace {
+/// In overload resolution, we need to know if any enable_if candidates couldn't
+/// be evaluated due to value-dependent values. So, we pack that into the
+/// FailedAttr pointer, rather than recomputing it.
+struct EnableIfFailureResults {
+  EnableIfAttr *FailedAttr;
+  bool ValueDependent;
+};
+}
+
+static EnableIfFailureResults unpackEnableIfFailure(void *Opaque) {
+  llvm::PointerIntPair<EnableIfAttr*, 1> Pair;
+  Pair.setFromOpaqueValue(Opaque);
+  return {Pair.getPointer(), bool(Pair.getInt())};
+}
+
+static void *packedCheckEnableIf(Sema &S, FunctionDecl *Fn,
+                                 ArrayRef<Expr *> Args,
+                                 bool MissingImplicitThis = false) {
+  bool ValDep = false;
+  EnableIfAttr *EIA = S.CheckEnableIf(Fn, Args, MissingImplicitThis, &ValDep);
+  // ValDep is meaningless if we didn't fail.
+  if (!EIA)
+    return nullptr;
+  return llvm::PointerIntPair<EnableIfAttr *, 1>(EIA, ValDep).getOpaqueValue();
+}
+
 /// 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.
for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
     } else {
       // (C++ 13.3.2p2): For the purposes of overload resolution, any
       // argument for which there is no corresponding parameter is
       // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
       Candidate.Conversions[ArgIdx].setEllipsis();
     }
   }
 
-  if (EnableIfAttr *FailedAttr = CheckEnableIf(Function, Args)) {
+  if (void *Failed = packedCheckEnableIf(*this, Function, Args)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
-    Candidate.DeductionFailure.Data = FailedAttr;
+    Candidate.DeductionFailure.Data = Failed;
     return;
   }
 }
 
 ObjCMethodDecl *Sema::SelectBestMethod(Selector Sel, MultiExprArg Args,
                                        bool IsInstance) {
   SmallVector<ObjCMethodDecl*, 4> Methods;
   if (!CollectMultipleMethodsInGlobalPool(Sel, Methods, IsInstance))
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) {
+                                  bool MissingImplicitThis, bool *Dependent) {
+  if (Dependent)
+    *Dependent = false;
+
   auto EnableIfAttrs = getOrderedEnableIfAttrs(Function);
   if (EnableIfAttrs.empty())
     return nullptr;
 
   SFINAETrap Trap(*this);
   SmallVector<Expr *, 16> ConvertedArgs;
   bool InitializationFailed = false;
   bool ContainsValueDependentExpr = false;
if (I == 0 && !MissingImplicitThis && isa<CXXMethodDecl>(Function) &&
                                     SourceLocation(), Args[I]);
     }
 
     if (R.isInvalid()) {
       InitializationFailed = true;
       break;
     }
 
+    // Some args may be ignored by enable_if conditions, so we shouldn't
+    // immediately fail when we see a value-dependent argument.
     ContainsValueDependentExpr |= R.get()->isValueDependent();
     ConvertedArgs.push_back(R.get());
   }
 
   if (InitializationFailed || Trap.hasErrorOccurred())
     return EnableIfAttrs[0];
 
   // Push default arguments if needed.
if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
 
     if (InitializationFailed || Trap.hasErrorOccurred())
       return EnableIfAttrs[0];
   }
 
   for (auto *EIA : EnableIfAttrs) {
     APValue Result;
     if (EIA->getCond()->isValueDependent()) {
-      // Don't even try now, we'll examine it after instantiation.
-      continue;
+      if (Dependent)
+        *Dependent = true;
+      return EIA;
     }
 
     if (!EIA->getCond()->EvaluateWithSubstitution(
             Result, Context, Function, llvm::makeArrayRef(ConvertedArgs))) {
-      if (!ContainsValueDependentExpr)
-        return EIA;
-    } else if (!Result.isInt() || !Result.getInt().getBoolValue()) {
+      // Dependent is a best effort check that notes that we *may* have failed
+      // due to a value dependent expression. There's no cheap way to figure out
+      // if this is true, so set it in all cases where it may apply. If we're
+      // wrong, we'll find that out after instantiation.
+      if (Dependent)
+        *Dependent = ContainsValueDependentExpr;
       return EIA;
     }
+
+    if (!Result.isInt() || !Result.getInt().getBoolValue())
+      return EIA;
   }
   return nullptr;
 }
 
 /// \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,
for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
     } else {
       // (C++ 13.3.2p2): For the purposes of overload resolution, any
       // argument for which there is no corresponding parameter is
       // considered to "match the ellipsis" (C+ 13.3.3.1.3).
       Candidate.Conversions[ArgIdx + 1].setEllipsis();
     }
   }
 
-  if (EnableIfAttr *FailedAttr = CheckEnableIf(Method, Args, true)) {
+  if (void *Failed = packedCheckEnableIf(*this, Method, Args, true)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
-    Candidate.DeductionFailure.Data = FailedAttr;
+    Candidate.DeductionFailure.Data = Failed;
     return;
   }
 }
 
 /// \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
case ImplicitConversionSequence::BadConversion:
     Candidate.FailureKind = ovl_fail_bad_final_conversion;
     return;
 
   default:
     llvm_unreachable(
            "Can only end up with a standard conversion sequence or failure");
   }
 
-  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
+  if (void *Failed = packedCheckEnableIf(*this, Conversion, None)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
-    Candidate.DeductionFailure.Data = FailedAttr;
+    Candidate.DeductionFailure.Data = Failed;
     return;
   }
 }
 
 /// \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++
for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
     } else {
       // (C++ 13.3.2p2): For the purposes of overload resolution, any
       // argument for which there is no corresponding parameter is
       // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
       Candidate.Conversions[ArgIdx + 1].setEllipsis();
     }
   }
 
-  if (EnableIfAttr *FailedAttr = CheckEnableIf(Conversion, None)) {
+  if (void *Failed = packedCheckEnableIf(*this, Conversion, None)) {
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_enable_if;
-    Candidate.DeductionFailure.Data = FailedAttr;
+    Candidate.DeductionFailure.Data = Failed;
     return;
   }
 }
 
 /// \brief Add overload candidates for overloaded operators that are
 /// member functions.
 ///
 /// Add the overloaded operator candidates that are member functions
if (Meth != nullptr && Meth->isImplicit()) {
     S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
                                               /* ConstRHS */ ConstRHS,
                                               /* Diagnose */ true);
   }
 }
 
 static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
   FunctionDecl *Callee = Cand->Function;
-  EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
+  void *PackedFailure = Cand->DeductionFailure.Data;
+  EnableIfAttr *Attr = unpackEnableIfFailure(PackedFailure).FailedAttr;
 
   S.Diag(Callee->getLocation(),
          diag::note_ovl_candidate_disabled_by_enable_if_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.
ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
   OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
                                     OverloadCandidateSet::CSK_Normal);
   ExprResult result;
 
   if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
                              &result))
     return result;
 
+  // If we had any enable_if attributes fail because they were value dependent,
+  // then we can't accurately resolve the overload now. Defer it until later.
+  if (getLangOpts().CPlusPlus)
+    for (auto I = CandidateSet.begin(), E = CandidateSet.end(); I != E; ++I)
+      if (!I->Viable && I->FailureKind == ovl_fail_enable_if &&
+          unpackEnableIfFailure(I->DeductionFailure.Data).ValueDependent) {
+        // The overload we select may change depending on the value the failing
+        // enable_if is dependent upon. So, the type of the function we're
+        // using is both type dependent and value dependent.
+        CallExpr *CE;
+        if (ExecConfig)
+          CE = new (Context)
+              CUDAKernelCallExpr(Context, Fn, cast<CallExpr>(ExecConfig), Args,
+                                 Context.DependentTy, VK_RValue, RParenLoc);
+        else
+          CE = new (Context) CallExpr(Context, Fn, Args, Context.DependentTy,
+                                      VK_RValue, RParenLoc);
+
+        CE->setInstantiationDependent(true);
+        CE->setValueDependent(true);
+        CE->setTypeDependent(true);
+        return CE;
+      }
+
   // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
-  // functions that aren't addressible are considered unviable.
+  // functions that aren't addressable are considered unviable.
   if (CalleesAddressIsTaken)
     markUnaddressableCandidatesUnviable(*this, CandidateSet);
 
   OverloadCandidateSet::iterator Best;
   OverloadingResult OverloadResult =
       CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best);
 
   return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args,

test/SemaCXX/enable_if.cpp

 
 void test4() {
   Y<int> y;
 
   int t0 = y.h(0);
   int t1 = y.h(1, 2);  // expected-error{{no matching member function for call to 'h'}}
 }
 
-// FIXME: issue an error (without instantiation) because ::h(T()) is not
-// convertible to bool, because return types aren't overloadable.
+void ovlH(int);
+int ovlH(double);
 void h(int);
-template <typename T> void outer() {
-  void local_function() __attribute__((enable_if(::h(T()), "")));
+template <typename T> int outer() {
+  void local_function() __attribute__((enable_if(::h(T()), ""))); // expected-error{{value of type 'void' is not contextually convertible to 'bool'}}
+  void local_function2() __attribute__((enable_if(::ovlH(T()), ""))); // expected-error{{value of type 'void' is not contextually convertible to 'bool'}}
   local_function();
-};
+  local_function2();
+  return 0;
+}
+
+int runOuter = outer<int>(); // expected-note{{in instantiation of function template specialization 'outer<int>'}}
 
 namespace PR20988 {
   struct Integer {
     Integer(int);
   };
 
   int fn1(const Integer &) __attribute__((enable_if(true, "")));
   template <class T> void test1() {
void test2() {
     int (*a)(int);
     a = ovlBar;
     a = &ovlBar;
   }
 
   int ovlConflict(int m) __attribute__((enable_if(true, "")));
   int ovlConflict(int m) __attribute__((enable_if(1, "")));
   void test3() {
-    int (*p)(int) = ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-    int (*p2)(int) = &ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
+    int (*p)(int) = ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@196{{candidate function}} expected-note@197{{candidate function}}
+    int (*p2)(int) = &ovlConflict; // expected-error{{address of overloaded function 'ovlConflict' is ambiguous}} expected-note@196{{candidate function}} expected-note@197{{candidate function}}
     int (*a)(int);
-    a = ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
-    a = &ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@191{{candidate function}} expected-note@192{{candidate function}}
+    a = ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@196{{candidate function}} expected-note@197{{candidate function}}
+    a = &ovlConflict; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@196{{candidate function}} expected-note@197{{candidate function}}
   }
 
   template <typename T>
   T templated(T m) __attribute__((enable_if(true, ""))) { return T(); }
   template <typename T>
   T templated(T m) __attribute__((enable_if(false, ""))) { return T(); }
   void test4() {
     int (*p)(int) = templated<int>;
     int (*p2)(int) = &templated<int>;
     int (*a)(int);
     a = templated<int>;
     a = &templated<int>;
   }
 
   template <typename T>
   T templatedBar(T m) __attribute__((enable_if(m > 0, ""))) { return T(); }
   void test5() {
-    int (*p)(int) = templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@214{{candidate function made ineligible by enable_if}}
-    int (*p2)(int) = &templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@214{{candidate function made ineligible by enable_if}}
+    int (*p)(int) = templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@219{{candidate function made ineligible by enable_if}}
+    int (*p2)(int) = &templatedBar<int>; // expected-error{{address of overloaded function 'templatedBar' does not match required type 'int (int)'}} expected-note@219{{candidate function made ineligible by enable_if}}
     int (*a)(int);
-    a = templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@214{{candidate function made ineligible by enable_if}}
-    a = &templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@214{{candidate function made ineligible by enable_if}}
+    a = templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@219{{candidate function made ineligible by enable_if}}
+    a = &templatedBar<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@219{{candidate function made ineligible by enable_if}}
   }
 
   template <typename T>
   T templatedConflict(T m) __attribute__((enable_if(false, ""))) { return T(); }
   template <typename T>
   T templatedConflict(T m) __attribute__((enable_if(true, ""))) { return T(); }
   template <typename T>
   T templatedConflict(T m) __attribute__((enable_if(1, ""))) { return T(); }
   void test6() {
-    int (*p)(int) = templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@224{{candidate function made ineligible by enable_if}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-    int (*p0)(int) = &templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@224{{candidate function made ineligible by enable_if}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
+    int (*p)(int) = templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@229{{candidate function made ineligible by enable_if}} expected-note@231{{candidate function}} expected-note@233{{candidate function}}
+    int (*p0)(int) = &templatedConflict<int>; // expected-error{{address of overloaded function 'templatedConflict' is ambiguous}} expected-note@229{{candidate function made ineligible by enable_if}} expected-note@231{{candidate function}} expected-note@233{{candidate function}}
     int (*a)(int);
-    a = templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
-    a = &templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@226{{candidate function}} expected-note@228{{candidate function}}
+    a = templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@231{{candidate function}} expected-note@233{{candidate function}}
+    a = &templatedConflict<int>; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@231{{candidate function}} expected-note@233{{candidate function}}
   }
 
   int ovlNoCandidate(int m) __attribute__((enable_if(false, "")));
   int ovlNoCandidate(int m) __attribute__((enable_if(0, "")));
   void test7() {
-    int (*p)(int) = ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-    int (*p2)(int) = &ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
+    int (*p)(int) = ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@242{{made ineligible by enable_if}} expected-note@243{{made ineligible by enable_if}}
+    int (*p2)(int) = &ovlNoCandidate; // expected-error{{address of overloaded function 'ovlNoCandidate' does not match required type}} expected-note@242{{made ineligible by enable_if}} expected-note@243{{made ineligible by enable_if}}
     int (*a)(int);
-    a = ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
-    a = &ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@237{{made ineligible by enable_if}} expected-note@238{{made ineligible by enable_if}}
+    a = ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@242{{made ineligible by enable_if}} expected-note@243{{made ineligible by enable_if}}
+    a = &ovlNoCandidate; // expected-error{{assigning to 'int (*)(int)' from incompatible type '<overloaded function type>'}} expected-note@242{{made ineligible by enable_if}} expected-note@243{{made ineligible by enable_if}}
   }
 
   int noOvlNoCandidate(int m) __attribute__((enable_if(false, "")));
   void test8() {
     int (*p)(int) = noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' becuase it has one or more non-tautological enable_if conditions}}
     int (*p2)(int) = &noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' becuase it has one or more non-tautological enable_if conditions}}
     int (*a)(int);
     a = noOvlNoCandidate; // expected-error{{cannot take address of function 'noOvlNoCandidate' becuase it has one or more non-tautological enable_if conditions}}

 };
 
 void runFoo() {
   Foo f;
   f.bar(); // expected-error{{too few arguments}}
   f.bar(1, 2); // expected-error{{too many arguments}}
 }
 }
+
+namespace value_dependent {
+// Ensure that enable_if works well with dependent expressions...
+
+constexpr int noOverload(int N) __attribute__((enable_if(!N, ""))) { return 0; } //expected-note 2 {{candidate disabled}}
+
+template <int N> constexpr int callNoOverload() { return noOverload(N); }
+
+static_assert(callNoOverload<0>() == 0, "");
+constexpr int Fail = callNoOverload<1>(); // expected-error@-3{{no matching function for call to 'noOverload'}} expected-error{{constexpr variable 'Fail' must be initialized by a constant expression}} expected-note{{in instantiation of function}}
+
+// Prefixing noOverload with its namespace means we get to skip ADL, so we won't
+// go into overload resolution for this.
+template <int N> constexpr int directCallNoOverload() {
+  return ::value_dependent::noOverload(N);
+}
+
+static_assert(directCallNoOverload<0>() == 0, "");
+constexpr int FailAgain = directCallNoOverload<1>(); // expected-error@-4{{no matching function for call to 'noOverload'}} expected-note{{in instantiation of function}}
+
+constexpr int overloaded(int N) __attribute__((enable_if(N == 0, ""))) {
+  return 1;
+}
+
+constexpr int overloaded(int N) __attribute__((enable_if(N == 1, ""))) {
+  return 2;
+}
+
+constexpr int overloaded(int N) { return 4; }
+
+template <int N> constexpr int callIt() { return overloaded(N); }
+
+static_assert(callIt<0>() == 1, "");
+static_assert(callIt<1>() == 2, "");
+static_assert(callIt<2>() == 4, "");
+
+template <int N>
+constexpr int directlyDepends() __attribute__((enable_if(N, ""))) {
+  return N;
+}
+
+static_assert(directlyDepends<1>() == 1, "");
+constexpr int FailYetAgain = directlyDepends<0>(); // expected-error{{no matching function for call to 'directlyDepends'}} expected-note@-5{{candidate disabled}}
+}