[clang][Interp] Fix ignoring SubstNonTypeTemplateParmExpr

[tbaeder]

Summary

Ignore the expressions and re-do the tests without all the "result
ignored" expected warnings. Those are expected, given the nature of the
tests.

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!this->visit(Init))
       return false;
   }
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitSubstNonTypeTemplateParmExpr(
     const SubstNonTypeTemplateParmExpr *E) {
+  if (DiscardResult)
+    return this->discard(E->getReplacement());
   return this->visit(E->getReplacement());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitConstantExpr(const ConstantExpr *E) {
   // TODO: Check if the ConstantExpr already has a value set and if so,
   //   use that instead of evaluating it again.
   return this->visit(E->getSubExpr());

clang/test/AST/Interp/literals.cpp

constexpr int ignoredDecls() {
   enum E { b };
   using A = int;
   typedef int Z;
 
   return F{12}.a;
 }
 static_assert(ignoredDecls() == 12, "");
 
+namespace DiscardExprs {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunused-value"
+
   struct A{ int a; };
   constexpr int ignoredExprs() {
     (void)(1 / 2);
     A a;
-  a; // expected-warning {{unused}} \
-     // ref-warning {{unused}}
+    a;
     (void)a;
-  (a); // expected-warning {{unused}} \
-       // ref-warning {{unused}}
-
-  (void)5, (void)6;
+    (a);
 
-  1 ? 0 : 1; // expected-warning {{unused}} \
-             // ref-warning {{unused}}
     /// Ignored MaterializeTemporaryExpr.
     struct B{ const int &a; };
     (void)B{12};
+
+    (void)5, (void)6;
+
+    1 ? 0 : 1;
     return 0;
   }
 
   /// Ignored comma expressions still have their
   /// expressions evaluated.
   constexpr int Comma(int start) {
       int i = start;
 
       (void)i++;
       (void)i++,(void)i++;
       return i;
   }
   constexpr int Value = Comma(5);
   static_assert(Value == 8, "");
 
   /// Ignored MemberExprs need to still evaluate the Base
   /// expr.
   constexpr A callme(int &i) {
     ++i;
     return A{};
   }
   constexpr int ignoredMemberExpr() {
     int i = 0;
-  callme(i).a; // ref-warning {{result unused}} \
-               // expected-warning {{result unused}}
+    callme(i).a;
     return i;
   }
   static_assert(ignoredMemberExpr() == 1, "");
+
+  template <int I>
+  constexpr int foo() {
+    I;
+    return I;
+  }
+  static_assert(foo<3>() == 3, "");
+
+#pragma clang diagnostic pop
+}
 #endif
 
 namespace PredefinedExprs {
 #if __cplusplus >= 201402L
   template<typename CharT>
   constexpr bool strings_match(const CharT *str1, const CharT *str2) {
     while (*str1 && *str2) {
       if (*str1++ != *str2++)