[clang][Interp] Fix ignoring CompoundLiteralExprs

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

477

Obviously, this patch also fixes ignoring InitListExprs.

[aaron.ballman]

clang/test/AST/Interp/literals.cpp

900

Can you also add a test like:

constexpr int oh_my(int x) {
  (int){ x++ };
  return x;
}
static_assert(oh_my(0) == 1);

and

constexpr int oh_my(int x) {
  int y{x++};
  return x;
}

static_assert(oh_my(0) == 1);

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (DiscardResult)
     return this->emitPopPtr(E);
 
   return true;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitInitListExpr(const InitListExpr *E) {
   for (const Expr *Init : E->inits()) {
+    if (DiscardResult) {
+      if (!this->discard(Init))
+        return false;
+    } else {
       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());
if (std::optional<unsigned> GlobalIndex = P.createGlobal(E)) {
         return false;
       return this->visitInitializer(Init);
     }
   }
 
   // Otherwise, use a local variable.
   if (T) {
     // For primitive types, we just visit the initializer.
-    return this->visit(Init);
+    return DiscardResult ? this->discard(Init) : this->visit(Init);
   } else {
     if (std::optional<unsigned> LocalIndex = allocateLocal(Init)) {
       if (!this->emitGetPtrLocal(*LocalIndex, E))
         return false;
-      return this->visitInitializer(Init);
+      if (!this->visitInitializer(Init))
+        return false;
+      if (DiscardResult)
+        return this->emitPopPtr(E);
+      return true;
     }
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitTypeTraitExpr(const TypeTraitExpr *E) {

clang/test/AST/Interp/literals.cpp

constexpr int ignoredExprs() {
     struct B{ const int &a; };
     (void)B{12};
 
     (void)5, (void)6;
 
     1 ? 0 : 1;
     __is_trivial(int);
 
+    (int){1};
+    (int[]){1,2,3};
+
     return 0;
   }
 
+  constexpr int oh_my(int x) {
+    (int){ x++ };
+    return x;
+  }
+  static_assert(oh_my(0) == 1, "");
+
+  constexpr int oh_my2(int x) {
+    int y{x++};
+    return x;
+  }
+
+  static_assert(oh_my2(0) == 1, "");
+
+
   /// Ignored comma expressions still have their
   /// expressions evaluated.
   constexpr int Comma(int start) {
       int i = start;
 
       (void)i++;
       (void)i++,(void)i++;
       return i;