[clang][Interp] Evaluate Base when discarding a MemberExpr

[tbaeder]

Summary

The Base expression might cause side-effects, so we still have to
evaluate it.

[aaron.ballman]

LGTM

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (Kind == UETT_AlignOf || Kind == UETT_PreferredAlignOf) {
     return this->emitConst(Size.getQuantity(), E);
   }
 
   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 (DiscardResult)
+    return this->discard(Base);
 
   if (!this->visit(Base))
     return false;
 
   // Base above gives us a pointer on the stack.
   // TODO: Implement non-FieldDecl members.
+  const ValueDecl *Member = E->getMemberDecl();
   if (const auto *FD = dyn_cast<FieldDecl>(Member)) {
     const RecordDecl *RD = FD->getParent();
     const Record *R = getRecord(RD);
     const Record::Field *F = R->getField(FD);
     // Leave a pointer to the field on the stack.
     if (F->Decl->getType()->isReferenceType())
       return this->emitGetFieldPop(PT_Ptr, F->Offset, E);
     return this->emitGetPtrField(F->Offset, E);

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, "");
 
-struct A{};
+struct A{ int a; };
 constexpr int ignoredExprs() {
   (void)(1 / 2);
   A a;
   a; // expected-warning {{unused}} \
      // ref-warning {{unused}}
   (void)a;
   (a); // expected-warning {{unused}} \
        // ref-warning {{unused}}
constexpr int Comma(int 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}}
+  return i;
+}
+static_assert(ignoredMemberExpr() == 1, "");
 #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++)