Fix assertion failure on MaybeODRUseExprs.

[manmanren]

Summary

In VisitNonTypeTemplateParamDecl, before SubstExpr with the default argument,
we should create a ConstantEvaluated ExpressionEvaluationContext. Without this,
it is possible to use a PotentiallyEvaluated ExpressionEvaluationContext; and
MaybeODRUseExprs will not be cleared when popping the context, causing
assertion failure.

This is similar to how we handle the context before SubstExpr with the
default argument, in SubstDefaultTemplateArgument.

Part of PR13986.
rdar://24480205

[faisalv]

lib/Sema/SemaTemplateInstantiateDecl.cpp

2114 ↗

(On Diff #48963)

Looks reasonable to me - since it is consistent with the other changes I had made. But somewhat orthogonal to your fix, I wouldn't mind Richard commenting on why constant expression evaluation does not have IsPotentiallyEvaluatedContext return false (and avoid adding an entry to MaybeODRUse)
Also, just as SubstituteDefaultTemplateArgument does, Perhaps we should add an InstantiatingTemplate on the stack that marks this as a substitution into default arguments. It would be nice if we could refactor both into a call to the same function (i.e SubstittueDefaultTempalteArgument) - but looking at the code for it, that would be a little tricky.
My 2 cents.

[rsmith]

lib/Sema/SemaTemplateInstantiateDecl.cpp

2114 ↗

(On Diff #48963)

"Potentially evaluated" is a term defined in the standard; it would be confusing for us to use it to mean something else. Constant expressions *are* evaluated (typically only during compilation), and they can result in odr-use. The cases where they don't do so are somewhat specialized.

I don't think we need or want a separate entry on the instantiation stack, as we're still instantiating pieces of the same entity, with the same instantiation semantics.

cfe/trunk/lib/Sema/SemaTemplateInstantiateDecl.cpp

Param = NonTypeTemplateParmDecl::Create(SemaRef.Context, Owner,
                                             D->getIdentifier(), T,
                                             D->isParameterPack(), DI);
 
   Param->setAccess(AS_public);
   if (Invalid)
     Param->setInvalidDecl();
 
   if (D->hasDefaultArgument() && !D->defaultArgumentWasInherited()) {
+    EnterExpressionEvaluationContext ConstantEvaluated(SemaRef,
+                                                       Sema::ConstantEvaluated);
     ExprResult Value = SemaRef.SubstExpr(D->getDefaultArgument(), TemplateArgs);
     if (!Value.isInvalid())
       Param->setDefaultArgument(Value.get());
   }
 
   // Introduce this template parameter's instantiation into the instantiation
   // scope.
   SemaRef.CurrentInstantiationScope->InstantiatedLocal(D, Param);

cfe/trunk/test/SemaTemplate/default-arguments-cxx0x.cpp

template<typename T> int f(T t) {
     return 0;
   }
   template<typename T> int g(int a = f([] {}));
   void test() {
     g<int>();
     g<int>();
   }
 }
+
+// rdar://problem/24480205
+namespace PR13986 {
+  constexpr unsigned Dynamic = 0;
+  template <unsigned> class A { template <unsigned = Dynamic> void m_fn1(); };
+  class Test {
+    ~Test() {}
+    A<1> m_target;
+  };
+}