[clang][Interp] Handle DeclRefExpr of reference types

[tbaeder]

Summary

And add a couple of tests for it.

Notably, this is missing MaterializeTemporaryExpr and ExprWithCleanups, but the basic support seems to work.

[shafik]

I think like @aaron.ballman was saying in another PR you should aim for as complete set of tests as possible even if you have to comment one that can't work yet. For example cases that would involve MemberExpr or UsingShadow for example as well as the cases you mentioned not implemented in your description.

[tbaeder]

In D132997#3763094, @shafik wrote:

I think like @aaron.ballman was saying in another PR you should aim for as complete set of tests as possible even if you have to comment one that can't work yet. For example cases that would involve MemberExpr or UsingShadow for example as well as the cases you mentioned not implemented in your description.

I get it for the MaterializeTemporaryExprs, but I don't understand why I would add tests using MemberExpr now and not when I work on record types (and references have already landed).

[aaron.ballman]

In D132997#3763367, @tbaeder wrote:

In D132997#3763094, @shafik wrote:

I think like @aaron.ballman was saying in another PR you should aim for as complete set of tests as possible even if you have to comment one that can't work yet. For example cases that would involve MemberExpr or UsingShadow for example as well as the cases you mentioned not implemented in your description.

I get it for the MaterializeTemporaryExprs, but I don't understand why I would add tests using MemberExpr now and not when I work on record types (and references have already landed).

The test case I was thinking of for that is:

struct S {
  int i, j;
};

constexpr int test() {
  S s{1, 2};

  int &j = s.i;
  j += 10;

  return j;
}

static_assert(test() == 11, "");

where the reference is a DeclRefExpr. Even if structures don't work yet, capturing it as a test case now means we don't have to remember to think about "what if there's a reference to this member" when structures are implemented.

clang/test/AST/Interp/references.cpp

14

[aaron.ballman]

LGTM aside from a request for a comment in the test, thanks!

clang/test/AST/Interp/references.cpp

92

[vitalybuka]

It breaks the bot https://lab.llvm.org/buildbot/#/builders/5/builds/27410

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitUnaryOperator(const UnaryOperator *E) {
   }
 
   return false;
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitDeclRefExpr(const DeclRefExpr *E) {
   const auto *Decl = E->getDecl();
+  bool IsReference = Decl->getType()->isReferenceType();
+  bool FoundDecl = false;
 
   if (auto It = Locals.find(Decl); It != Locals.end()) {
     const unsigned Offset = It->second.Offset;
-    return this->emitGetPtrLocal(Offset, E);
+    if (!this->emitGetPtrLocal(Offset, E))
+      return false;
+
+    FoundDecl = true;
   } else if (auto GlobalIndex = P.getGlobal(Decl)) {
-    return this->emitGetPtrGlobal(*GlobalIndex, E);
+    if (!this->emitGetPtrGlobal(*GlobalIndex, E))
+      return false;
+
+    FoundDecl = true;
   } else if (const auto *PVD = dyn_cast<ParmVarDecl>(Decl)) {
-    if (auto It = this->Params.find(PVD); It != this->Params.end())
-      return this->emitGetPtrParam(It->second, E);
+    if (auto It = this->Params.find(PVD); It != this->Params.end()) {
+      if (!this->emitGetPtrParam(It->second, E))
+        return false;
+
+      FoundDecl = true;
+    }
+  }
+
+  // References are implemented using pointers, so when we get here,
+  // we have a pointer to a pointer, which we need to de-reference once.
+  if (FoundDecl) {
+    if (IsReference) {
+      if (!this->emitLoadPopPtr(E))
+        return false;
+    }
+
+    return true;
   }
 
   return false;
 }
 
 template <class Emitter>
 void ByteCodeExprGen<Emitter>::emitCleanup() {
   for (VariableScope<Emitter> *C = VarScope; C; C = C->getParent())

clang/test/AST/Interp/arrays.cpp

 
 template<typename T>
 constexpr T getElementOf(T* array, int i) {
   return array[i];
 }
 static_assert(getElementOf(foo[0], 1) == &m, "");
 
 
+template <typename T, int N>
+constexpr T& getElementOfArray(T (&array)[N], int I) {
+  return array[I];
+}
+static_assert(getElementOfArray(foo[2], 3) == &m, "");
+
+
 constexpr int data[] = {5, 4, 3, 2, 1};
 static_assert(data[0] == 4, ""); // expected-error{{failed}} \
                                  // expected-note{{5 == 4}} \
                                  // ref-error{{failed}} \
                                  // ref-note{{5 == 4}}
 
 
 constexpr int dynamic[] = {

clang/test/AST/Interp/references.cpp

+// RUN: %clang_cc1 -fexperimental-new-constant-interpreter -verify %s
+// RUN: %clang_cc1 -verify=ref %s
+
+
+// ref-no-diagnostics
+
+constexpr int a = 10;
+constexpr const int &b = a;
+static_assert(a == b, "");
+
+constexpr int assignToReference() {
+  int a = 20;
+  int &b = a;
+
+  b = 100;
+  return a;
+}
+static_assert(assignToReference() == 100, "");
+
+
+constexpr void setValue(int &dest, int val) {
+  dest = val;
+}
+
+constexpr int checkSetValue() {
+  int l = 100;
+  setValue(l, 200);
+  return l;
+}
+static_assert(checkSetValue() == 200, "");
+
+constexpr int readLocalRef() {
+  int a = 20;
+  int &b = a;
+  return b;
+}
+static_assert(readLocalRef() == 20, "");
+
+constexpr int incRef() {
+  int a = 0;
+  int &b = a;
+
+  b = b + 1;
+
+  return a;
+}
+static_assert(incRef() == 1, "");
+
+
+template<const int &V>
+constexpr void Plus3(int &A) {
+  A = V + 3;
+}
+constexpr int foo = 4;
+
+constexpr int callTemplate() {
+  int a = 3;
+  Plus3<foo>(a);
+  return a;
+}
+static_assert(callTemplate() == 7, "");
+
+
+constexpr int& getValue(int *array, int index) {
+  return array[index];
+}
+constexpr int testGetValue() {
+  int values[] = {1, 2, 3, 4};
+  getValue(values, 2) = 30;
+  return values[2];
+}
+static_assert(testGetValue() == 30, "");
+
+// FIXME: ExprWithCleanups + MaterializeTemporaryExpr not implemented
+constexpr const int &MCE = 1; // expected-error{{must be initialized by a constant expression}}
+
+
+struct S {
+  int i, j;
+};
+
+constexpr int RefToMemberExpr() {
+  S s{1, 2};
+
+  int &j = s.i;
+  j += 10;
+
+  return j;
+}
+// FIXME: Should be accepted.
+static_assert(RefToMemberExpr() == 11, ""); // expected-error{{not an integral constant expression}}