[clang][Interp] Fix ignoring expression return values

[tbaeder]

Summary

Randomly noticed this. We need to honor DiscardResult here.

[aaron.ballman]

clang/test/AST/Interp/records.cpp

208

Hmmm, this feels related to the discarded value results changes, but it might be a test case for a different scenario as well, so take this or leave it:

struct S {
  int &Ref;
  constexpr S(int &R) : Ref(R) { Ref = 0; }
  constexpr ~S() { Ref = 12; }
};

constexpr S get_s(int &i) { return S{i}; }

constexpr int func() {
  int i = 1;
  {
    get_s(i);
  }
  return i;
}

static_assert(func() == 12);

The idea behind the test is -- we construct the S object but discard its results in the compound block, but the dtor still runs as expected.

[tbaeder]

clang/test/AST/Interp/records.cpp

208

I think this would trigger the TODO I added, since this is a RVO function but we have nowhere to write the return value.

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (E->getKind() == UETT_SizeOf) {
     return this->emitConst(E, Size.getQuantity());
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitMemberExpr(const MemberExpr *E) {
+  if (DiscardResult)
+    return true;
+
   // 'Base.Member'
   const Expr *Base = E->getBase();
   const ValueDecl *Member = E->getMemberDecl();
 
   if (!this->visit(Base))
     return false;
 
   // Base above gives us a pointer on the stack.
if (const auto *FuncDecl = dyn_cast_or_null<FunctionDecl>(Callee)) {
     for (const auto *Arg : E->arguments()) {
       if (!this->visit(Arg))
         return false;
     }
 
     // In any case call the function. The return value will end up on the stack and
     // if the function has RVO, we already have the pointer on the stack to write
     // the result into.
-    return this->emitCall(Func, E);
+    if (!this->emitCall(Func, E))
+      return false;
+
+    QualType ReturnType = E->getCallReturnType(Ctx.getASTContext());
+    if (DiscardResult && !ReturnType->isVoidType()) {
+      Optional<PrimType> T = classify(ReturnType);
+      if (T)
+        return this->emitPop(*T, E);
+      // TODO: This is a RVO function and we need to ignore the return value.
+    }
+
+    return true;
   } else {
     assert(false && "We don't support non-FunctionDecl callees right now.");
   }
 
   return false;
 }
 
 template <class Emitter>
bool ByteCodeExprGen<Emitter>::VisitCXXNullPtrLiteralExpr(
   if (DiscardResult)
     return true;
 
   return this->emitNullPtr(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXThisExpr(const CXXThisExpr *E) {
+  if (DiscardResult)
+    return true;
   return this->emitThis(E);
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
+  if (DiscardResult)
+    return true;
+
   const Expr *SubExpr = E->getSubExpr();
 
   switch (E->getOpcode()) {
   case UO_PostInc: // x++
   case UO_PostDec: // x--
   case UO_PreInc:  // --x
   case UO_PreDec:  // ++x
     return false;

clang/test/AST/Interp/literals.cpp

namespace bitOr {
   static_assert((10 | 1) == 11, "");
   static_assert((10 | 10) == 10, "");
 
   static_assert((1337 | -1) == -1, "");
   static_assert((0 | gimme(12)) == 12, "");
   static_assert((12 | true) == 13, "");
 };
 
+#if __cplusplus >= 201402L
+constexpr bool IgnoredUnary() {
+  bool bo = true;
+  !bo; // expected-warning {{expression result unused}} \
+       // ref-warning {{expression result unused}}
+  return bo;
+}
+static_assert(IgnoredUnary(), "");
+#endif
+
 namespace strings {
   constexpr const char *S = "abc";
   static_assert(S[0] == 97, "");
   static_assert(S[1] == 98, "");
   static_assert(S[2] == 99, "");
   static_assert(S[3] == 0, "");
 
   static_assert("foobar"[2] == 'o', "");

clang/test/AST/Interp/records.cpp

 static_assert(a.i == 100, "");
 constexpr A a2{12};
 static_assert(a2.i == 12, "");
 static_assert(a2.i == 200, ""); // ref-error {{static assertion failed}} \
                                 // ref-note {{evaluates to '12 == 200'}} \
                                 // expected-error {{static assertion failed}} \
                                 // expected-note {{evaluates to '12 == 200'}}
 
+
+struct S {
+  int a = 0;
+  constexpr int get5() const { return 5; }
+  constexpr void fo() const {
+    this; // expected-warning {{expression result unused}} \
+          // ref-warning {{expression result unused}}
+    this->a; // expected-warning {{expression result unused}} \
+             // ref-warning {{expression result unused}}
+    get5();
+  }
+
+  constexpr int m() const {
+    fo();
+    return 1;
+  }
+};
+constexpr S s;
+static_assert(s.m() == 1, "");
+
 namespace MI {
   class A {
   public:
     int a;
     constexpr A(int a) : a(a) {}
   };
 
   class B {