[clang][Interp] Implement C++ Range-for loops

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

404–409

Under what circumstances is there not a condition for a range-based for loop?

418–419

Under what circumstances is there not an increment?

clang/test/AST/Interp/loops.cpp

274

You should also add failure tests where the range-based for loop is not valid in a constant expression. Especially interesting cases would be ones involving lifetime problems, such as: https://godbolt.org/z/3EE7f8rdE

[tbaeder]

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

418–419

The answer to both is that I looked at the code for regular for loops and assumed that the restrictions are the same.

But looks like there aren't and even isBody() always returns non-null.

[tbaeder]

clang/test/AST/Interp/loops.cpp

274

Oof, that reproducer doesn't work right now for several reasons :/ Can you come up with something simpler?

[aaron.ballman]

clang/test/AST/Interp/loops.cpp

274

Not trivially, no. Also, that case is now fixed by https://wg21.link/p2644r0 for C++23 due to lifetime extension that we probably don't model yet.

[tbaeder]

Ping

[aaron.ballman]

LGTM; I suspect there's still lifetime issues we are not catching here, but this is incrementally forward progress and we can test the lifetime issues once we have more of the interpreter implemented.

clang/lib/AST/Interp/ByteCodeStmtGen.h

private:
   bool visitStmt(const Stmt *S);
   bool visitCompoundStmt(const CompoundStmt *S);
   bool visitDeclStmt(const DeclStmt *DS);
   bool visitReturnStmt(const ReturnStmt *RS);
   bool visitIfStmt(const IfStmt *IS);
   bool visitWhileStmt(const WhileStmt *S);
   bool visitDoStmt(const DoStmt *S);
   bool visitForStmt(const ForStmt *S);
+  bool visitCXXForRangeStmt(const CXXForRangeStmt *S);
   bool visitBreakStmt(const BreakStmt *S);
   bool visitContinueStmt(const ContinueStmt *S);
   bool visitSwitchStmt(const SwitchStmt *S);
   bool visitCaseStmt(const CaseStmt *S);
   bool visitDefaultStmt(const DefaultStmt *S);
 
   /// Type of the expression returned by the function.
   std::optional<PrimType> ReturnType;

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::visitStmt(const Stmt *S) {
   case Stmt::IfStmtClass:
     return visitIfStmt(cast<IfStmt>(S));
   case Stmt::WhileStmtClass:
     return visitWhileStmt(cast<WhileStmt>(S));
   case Stmt::DoStmtClass:
     return visitDoStmt(cast<DoStmt>(S));
   case Stmt::ForStmtClass:
     return visitForStmt(cast<ForStmt>(S));
+  case Stmt::CXXForRangeStmtClass:
+    return visitCXXForRangeStmt(cast<CXXForRangeStmt>(S));
   case Stmt::BreakStmtClass:
     return visitBreakStmt(cast<BreakStmt>(S));
   case Stmt::ContinueStmtClass:
     return visitContinueStmt(cast<ContinueStmt>(S));
   case Stmt::SwitchStmtClass:
     return visitSwitchStmt(cast<SwitchStmt>(S));
   case Stmt::CaseStmtClass:
     return visitCaseStmt(cast<CaseStmt>(S));
if (Inc && !this->discard(Inc))
     return false;
   if (!this->jump(CondLabel))
     return false;
   this->emitLabel(EndLabel);
   return true;
 }
 
 template <class Emitter>
+bool ByteCodeStmtGen<Emitter>::visitCXXForRangeStmt(const CXXForRangeStmt *S) {
+  const Stmt *Init = S->getInit();
+  const Expr *Cond = S->getCond();
+  const Expr *Inc = S->getInc();
+  const Stmt *Body = S->getBody();
+  const Stmt *BeginStmt = S->getBeginStmt();
+  const Stmt *RangeStmt = S->getRangeStmt();
+  const Stmt *EndStmt = S->getEndStmt();
+  const VarDecl *LoopVar = S->getLoopVariable();
+
+  LabelTy EndLabel = this->getLabel();
+  LabelTy CondLabel = this->getLabel();
+  LabelTy IncLabel = this->getLabel();
+  ExprScope<Emitter> ES(this);
+  LoopScope<Emitter> LS(this, EndLabel, IncLabel);
+
+  // Emit declarations needed in the loop.
+  if (Init && !this->visitStmt(Init))
+    return false;
+  if (!this->visitStmt(RangeStmt))
+    return false;
+  if (!this->visitStmt(BeginStmt))
+    return false;
+  if (!this->visitStmt(EndStmt))
+    return false;
+
+  // Now the condition as well as the loop variable assignment.
+  this->emitLabel(CondLabel);
+  if (!this->visitBool(Cond))
+    return false;
+  if (!this->jumpFalse(EndLabel))
+    return false;
+
+  if (!this->visitVarDecl(LoopVar))
+    return false;
+
+  // Body.
+  if (!this->visitStmt(Body))
+    return false;
+  this->emitLabel(IncLabel);
+  if (!this->discard(Inc))
+    return false;
+  if (!this->jump(CondLabel))
+    return false;
+
+  this->emitLabel(EndLabel);
+  return true;
+}
+
+template <class Emitter>
 bool ByteCodeStmtGen<Emitter>::visitBreakStmt(const BreakStmt *S) {
   if (!BreakLabel)
     return false;
 
   return this->jump(*BreakLabel);
 }
 
 template <class Emitter>

clang/test/AST/Interp/loops.cpp

 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++14 -verify %s
 // RUN: %clang_cc1 -std=c++14 -verify=ref %s
 // RUN: %clang_cc1 -fexperimental-new-constant-interpreter -std=c++20 -verify=expected-cpp20 %s
 // RUN: %clang_cc1 -std=c++20 -verify=ref %s
 
-// ref-no-diagnostics
-// expected-no-diagnostics
-// expected-cpp20-no-diagnostics
-
 namespace WhileLoop {
   constexpr int f() {
     int i = 0;
     while(false) {
       i = i + 1;
     }
     return i;
   }
#if 0
   /// FIXME: This is an infinite loop, which should
   ///   be rejected.
   constexpr int f6() {
     for(;;);
   }
 #endif
 
 };
+
+namespace RangeForLoop {
+  constexpr int localArray() {
+    int a[] = {1,2,3,4};
+    int s = 0;
+    for(int i : a) {
+      s += i;
+    }
+    return s;
+  }
+  static_assert(localArray() == 10, "");
+
+  constexpr int localArray2() {
+    int a[] = {1,2,3,4};
+    int s = 0;
+    for(const int &i : a) {
+      s += i;
+    }
+    return s;
+  }
+  static_assert(localArray2() == 10, "");
+
+  constexpr int nested() {
+    int s = 0;
+    for (const int i : (int[]){1,2,3,4}) {
+      int a[] = {i, i};
+      for(int m : a) {
+        s += m;
+      }
+    }
+    return s;
+  }
+  static_assert(nested() == 20, "");
+
+  constexpr int withBreak() {
+    int s = 0;
+    for (const int &i: (bool[]){false, true}) {
+      if (i)
+        break;
+      s++;
+    }
+    return s;
+  }
+  static_assert(withBreak() == 1, "");
+
+  constexpr void NoBody() {
+    for (const int &i: (bool[]){false, true}); // expected-warning {{empty body}} \
+                                               // expected-note {{semicolon on a separate line}} \
+                                               // expected-cpp20-warning {{empty body}} \
+                                               // expected-cpp20-note {{semicolon on a separate line}} \
+                                               // ref-warning {{empty body}} \
+                                               // ref-note {{semicolon on a separate line}}
+  }
+}