[clang][Interp] Fix tests for ignored expressions

[tbaeder]

Summary

We didn't call the function explicitly in a static_assert() statement
and the checkPotentialConstantExpression() invocation quietly aborted
early because of the missing initializer for A::a.

Fix this by calling ignoredExprs() explicitly.

[tbaeder]

@aaron.ballman This is where the sizeof/alignof tests were actually broken.

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

533–534

For my own understanding -- why do we not need to call discard() on the operand expression?

clang/test/AST/Interp/literals.cpp

204–205

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

533–534

Is it ever legal to have an argument expr with side effects (in cases the constant expression interpreter needs to handle)? That's really the only reason I did it this way.

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.cpp

533–534

Ah, I see! No, I don't think it's possible to have an expression argument with side effects that's valid in a constant expression for these operators.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitCastExpr(const CastExpr *CE) {
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
   case CK_BitCast:
+    if (DiscardResult)
+      return this->discard(SubExpr);
     return this->visit(SubExpr);
 
   case CK_IntegralToBoolean:
   case CK_IntegralCast: {
     std::optional<PrimType> FromT = classify(SubExpr->getType());
     std::optional<PrimType> ToT = classify(CE->getType());
     if (!FromT || !ToT)
       return false;
if (ArgType->isVoidType() || ArgType->isFunctionType())
       Size = CharUnits::One();
     else {
       if (ArgType->isDependentType() || !ArgType->isConstantSizeType())
         return false;
 
       Size = ASTCtx.getTypeSizeInChars(ArgType);
     }
 
+    if (DiscardResult)
+      return true;
+
     return this->emitConst(Size.getQuantity(), E);
   }
 
   if (Kind == UETT_AlignOf || Kind == UETT_PreferredAlignOf) {
     CharUnits Size;
 
     if (E->isArgumentType()) {
       QualType ArgType = E->getTypeOfArgument();
if (E->isArgumentType()) {
                                    /*RefAsPointee*/ true);
       else if (const auto *ME = dyn_cast<MemberExpr>(Arg))
         Size = ASTCtx.getDeclAlign(ME->getMemberDecl(),
                                    /*RefAsPointee*/ true);
       else
         Size = AlignOfType(Arg->getType(), ASTCtx, Kind);
     }
 
+    if (DiscardResult)
+      return true;
+
     return this->emitConst(Size.getQuantity(), E);
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {

clang/test/AST/Interp/literals.cpp

namespace SizeOf {
 
 
   void func() {
     int n = 12;
     constexpr int oofda = sizeof(int[n++]); // expected-error {{must be initialized by a constant expression}} \
                                             // ref-error {{must be initialized by a constant expression}}
   }
 
+#if __cplusplus >= 201402L
+  constexpr int IgnoredRejected() { // ref-error {{never produces a constant expression}}
+    int n = 0;
+    sizeof(int[n++]); // expected-warning {{expression result unused}} \
+                      // ref-warning {{expression result unused}} \
+                      // ref-note 2{{subexpression not valid in a constant expression}}
+    return n;
+  }
+  /// FIXME: This is rejected because the parameter so sizeof() is not constant.
+  ///   produce a proper diagnostic.
+  static_assert(IgnoredRejected() == 0, ""); // expected-error {{not an integral constant expression}} \
+                                             // ref-error {{not an integral constant expression}} \
+                                             // ref-note {{in call to 'IgnoredRejected()'}}
+#endif
+
 
 #if __cplusplus >= 202002L
   /// FIXME: The following code should be accepted.
   consteval int foo(int n) { // ref-error {{consteval function never produces a constant expression}}
     return sizeof(int[n]); // ref-note 3{{not valid in a constant expression}} \
                            // expected-note {{not valid in a constant expression}}
   }
   constinit int var = foo(5); // ref-error {{not a constant expression}} \

 
 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 a{12};
     a;
     (void)a;
     (a);
 
     /// Ignored MaterializeTemporaryExpr.
     struct B{ const int &a; };
     (void)B{12};
 
     (void)5, (void)6;
 
     1 ? 0 : 1;
     __is_trivial(int);
 
     (int){1};
     (int[]){1,2,3};
     int arr[] = {1,2,3};
     arr[0];
     "a";
     'b';
+    sizeof(int);
+    alignof(int);
 
     return 0;
   }
+  static_assert(ignoredExprs() == 0, "");
 
   constexpr int oh_my(int x) {
     (int){ x++ };
     return x;
   }
   static_assert(oh_my(0) == 1, "");
 
   constexpr int oh_my2(int x) {