[ASTContext] Fix part of DR224 for nontype template arguments

[mgehre]

Summary

Look through expressions to determine if a nontype template argument has been given the value of the template parameter.

[aaron.ballman]

Generally LGTM with a small nit.

lib/AST/ASTContext.cpp

4456

const auto * (and propagate it to other declarations)?

[mgehre]

lib/AST/ASTContext.cpp

4456

Unfortunately, the TemplateArgument constructor in

return TemplateArgument(DeclRef);

takes a Expr* (and not a const Expr*).

[mgehre]

ping

[rsmith]

Discussion on the core reflector suggests that we should use odr-style equivalence when identifying the current instantiation, and not look through static const member initializers as the example in the standard suggests. Let's hold off on this until CWG has a chance to discuss it in person.

[mgehre]

I'm sorry if this sounds dumb, but is there a way for me to follow that particular discussion?

[mgehre]

Ping

[rsmith]

In D22587#551647, @mgehre wrote:

I'm sorry if this sounds dumb, but is there a way for me to follow that particular discussion?

Only if you have access to the C++ committee's internal reflectors. Sadly this is not on the issues list yet either (it only lists issues reported up to the end of June 2016, and this was filed in July). The suggestion from the end of the discussion thread was that the right rule for recognising an injected-class-name is that the template argument must be equivalent to the template parameter for the primary template / template argument for a partial specialization, using the rules in [temp.over.link] to determine equivalence. (Thus not even parentheses surrounding a non-type template argument are permitted.) There seems to be consensus that dr224 was a mistake.

lib/AST/ASTContext.cpp

 }
 
 TemplateArgument
 ASTContext::getCanonicalTemplateArgument(const TemplateArgument &Arg) const {
   switch (Arg.getKind()) {
     case TemplateArgument::Null:
       return Arg;
 
-    case TemplateArgument::Expression:
+    case TemplateArgument::Expression: {
+      // Look through variable declarations that have been initialized to a non-type template
+      // parameter, see 14.6.2.1 [temp.dep.type]:
+      // [...], the argument must have been given the value of
+      // the template parameter and not an expression involving the template parameter.
+      auto *E = Arg.getAsExpr()->IgnoreImpCasts();
+      while(auto *DeclRef = dyn_cast_or_null<DeclRefExpr>(E)) {
+        auto *D = DeclRef->getDecl();
+        if (isa<NonTypeTemplateParmDecl>(D))
+          return TemplateArgument(DeclRef);
+
+        auto *VD = dyn_cast<VarDecl>(D);
+        if (!VD)
+          break;
+        E = VD->getInit();
+        if (E)
+          E = E->IgnoreImpCasts();
+      }
       return Arg;
+    }
 
     case TemplateArgument::Declaration: {
       ValueDecl *D = cast<ValueDecl>(Arg.getAsDecl()->getCanonicalDecl());
       return TemplateArgument(D, Arg.getParamTypeForDecl());
     }
 
     case TemplateArgument::NullPtr:
       return TemplateArgument(getCanonicalType(Arg.getNullPtrType()),

test/CXX/drs/dr2xx.cpp

template <class T1, class T2, int I> struct B {
       typedef int type;
       B<T1, T2, I>::type b1;
       B<T2, T1, I>::type b2; // expected-error {{missing 'typename'}}
 
       typedef T1 my_T1;
       static const int my_I = I;
       static const int my_I2 = I+0;
       static const int my_I3 = my_I;
-      B<my_T1, T2, my_I>::type b3; // FIXME: expected-error {{missing 'typename'}}
+      B<my_T1, T2, my_I>::type b3;
       B<my_T1, T2, my_I2>::type b4; // expected-error {{missing 'typename'}}
-      B<my_T1, T2, my_I3>::type b5; // FIXME: expected-error {{missing 'typename'}}
+      B<my_T1, T2, my_I3>::type b5;
     };
   }
 
   namespace example2 {
     template <int, typename T> struct X { typedef T type; };
     template <class T> class A {
       static const int i = 5;
       X<i, int>::type w; // FIXME: expected-error {{missing 'typename'}}