[Polly] Use isl C++ foreach implementation

[grosser]

Summary

This commit switches Polly over to the isl::Obj::foreach_* implementation,
which is part of the new isl bindings and follows the foreach pattern
established in Polly by Michael Kruse.

The original isl C function:

isl_stat isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
    isl_stat (*fn)(__isl_take isl_set *set, void *user), void *user);

which required the user to define a static callback function to which all
interesting parameters are passed via a 'void *' user-pointer, is on the
C++ side available as a function that takes a std::function<>, which can
carry any additional arguments without the need for a user pointer:

stat UnionSet::foreach_set(std::function<stat(set)> &&fn) const;

The following code illustrates the use of the new C++ interface:

auto Lambda = [=, &Result](isl::set Set) -> isl::stat {
  auto Shifted = shiftDimension(Set, Pos, Amount);
  Result = Result.add(Shifted);
  return isl::stat::ok;
}

UnionSet.foreach_set(Lambda);

Polly had some specialized foreach functions which did not require the lambdas
to return a status flag. We remove these functions in this commit to move
Polly completely over to the new isl interface. We may in the future discuss
if functors without return values can be supported easily.

[Meinersbur]

I'd prefer having an iterator implementation for the C++ bindings instead of a callback one. Since it requires support for isl, we previously decided to delay it to keep the bindings simple until the bindings are committed.

[grosser]

Michael, this is a very good point. I wrote this to make sure we have a minimal and complete implementation of these bindings to show that the _base_ we propose for inclusion is mature enough to handle foreach generation. I agree that an iterator interface would be preferable, but is likely more difficult to implement. I agree with you that it would be preferable to leave this out from the initial bindings and have afterwards a dedicated discussion which focused on the iterator interface. I will leave this out in the first proposal.

[grosser]

Hi Michael,

it seems Sven feels strongly about also providing a foreach based interface. As such an interface will be anyhow part of the isl C++ bindings, I wonder if it makes sense to commit this patch for now and then later move to the iterator based interface, when available? Or would you like me to abondon this commit and wait for your proposal of an iterator based interface? I am fine with any of the two.

[Meinersbur]

Whatever you think makes more sense is also ok for me.

lib/Support/GICHelper.cpp

std::string polly::getIslCompatibleName(const std::string &Prefix,
   std::string ValStr;
   raw_string_ostream OS(ValStr);
   Val->printAsOperand(OS, false);
   ValStr = OS.str();
   // Remove the leading %
   ValStr.erase(0, 1);
   return getIslCompatibleName(Prefix, ValStr, Suffix);
 }
-
-void polly::foreachElt(const isl::map &Map,
-                       const std::function<void(isl::basic_map)> &F) {
-  isl_map_foreach_basic_map(
-      Map.keep(),
-      [](__isl_take isl_basic_map *BMap, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<void(isl::basic_map)> *>(User);
-        F(give(BMap));
-        return isl_stat_ok;
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-void polly::foreachElt(const isl::set &Set,
-                       const std::function<void(isl::basic_set)> &F) {
-  isl_set_foreach_basic_set(
-      Set.keep(),
-      [](__isl_take isl_basic_set *BSet, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<void(isl::basic_set)> *>(User);
-        F(give(BSet));
-        return isl_stat_ok;
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-void polly::foreachElt(const isl::union_map &UMap,
-                       const std::function<void(isl::map Map)> &F) {
-  isl_union_map_foreach_map(
-      UMap.keep(),
-      [](__isl_take isl_map *Map, void *User) -> isl_stat {
-        auto &F = *static_cast<const std::function<void(isl::map)> *>(User);
-        F(give(Map));
-        return isl_stat_ok;
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-void polly::foreachElt(const isl::union_set &USet,
-                       const std::function<void(isl::set Set)> &F) {
-  isl_union_set_foreach_set(
-      USet.keep(),
-      [](__isl_take isl_set *Set, void *User) -> isl_stat {
-        auto &F = *static_cast<const std::function<void(isl::set)> *>(User);
-        F(give(Set));
-        return isl_stat_ok;
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-void polly::foreachElt(const isl::union_pw_aff &UPwAff,
-                       const std::function<void(isl::pw_aff)> &F) {
-  isl_union_pw_aff_foreach_pw_aff(
-      UPwAff.keep(),
-      [](__isl_take isl_pw_aff *PwAff, void *User) -> isl_stat {
-        auto &F = *static_cast<const std::function<void(isl::pw_aff)> *>(User);
-        F(give(PwAff));
-        return isl_stat_ok;
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-isl_stat
-polly::foreachEltWithBreak(const isl::map &Map,
-                           const std::function<isl_stat(isl::basic_map)> &F) {
-  return isl_map_foreach_basic_map(
-      Map.keep(),
-      [](__isl_take isl_basic_map *BMap, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<isl_stat(isl::basic_map)> *>(User);
-        return F(give(BMap));
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-isl_stat
-polly::foreachEltWithBreak(const isl::union_map &UMap,
-                           const std::function<isl_stat(isl::map Map)> &F) {
-  return isl_union_map_foreach_map(
-      UMap.keep(),
-      [](__isl_take isl_map *Map, void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<isl_stat(isl::map Map)> *>(User);
-        return F(give(Map));
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}
-
-isl_stat polly::foreachPieceWithBreak(
-    const isl::pw_aff &PwAff,
-    const std::function<isl_stat(isl::set, isl::aff)> &F) {
-  return isl_pw_aff_foreach_piece(
-      PwAff.keep(),
-      [](__isl_take isl_set *Domain, __isl_take isl_aff *Aff,
-         void *User) -> isl_stat {
-        auto &F =
-            *static_cast<const std::function<isl_stat(isl::set, isl::aff)> *>(
-                User);
-        return F(give(Domain), give(Aff));
-      },
-      const_cast<void *>(static_cast<const void *>(&F)));
-}

lib/Support/ISLTools.cpp

isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
   auto ScatterRel = give(Strict ? isl_map_lex_gt(RangeSpace.take())
                                 : isl_map_lex_ge(RangeSpace.take()));
   return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
 }
 
 isl::union_map polly::beforeScatter(isl::union_map UMap, bool Strict) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](isl::map Map) {
+  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
     auto After = beforeScatter(Map, Strict);
     Result = give(isl_union_map_add_map(Result.take(), After.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::afterScatter(isl::map Map, bool Strict) {
   auto RangeSpace = give(isl_space_range(isl_map_get_space(Map.keep())));
   auto ScatterRel = give(Strict ? isl_map_lex_lt(RangeSpace.take())
                                 : isl_map_lex_le(RangeSpace.take()));
   return give(isl_map_apply_range(Map.take(), ScatterRel.take()));
 }
 
 isl::union_map polly::afterScatter(const isl::union_map &UMap, bool Strict) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](isl::map Map) {
+  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
     auto After = afterScatter(Map, Strict);
     Result = give(isl_union_map_add_map(Result.take(), After.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
                                bool InclTo) {
   auto AfterFrom = afterScatter(From, !InclFrom);
   auto BeforeTo = beforeScatter(To, !InclTo);
isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
   assert(!Result || isl_space_has_equal_tuples(
                         give(isl_set_get_space(Result.keep())).keep(),
                         ExpectedSpace.keep()) == isl_bool_true);
   return Result;
 }
 
 unsigned polly::getNumScatterDims(const isl::union_map &Schedule) {
   unsigned Dims = 0;
-  foreachElt(Schedule, [&Dims](isl::map Map) {
+  Schedule.foreach_map([&Dims](isl::map Map) -> isl::stat {
     Dims = std::max(Dims, isl_map_dim(Map.keep(), isl_dim_out));
+    return isl::stat::ok;
   });
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (!Schedule)
     return nullptr;
   auto Dims = getNumScatterDims(Schedule);
   auto ScatterSpace =
       give(isl_space_set_from_params(isl_union_map_get_space(Schedule.keep())));
   return give(isl_space_add_dims(ScatterSpace.take(), isl_dim_set, Dims));
 }
 
 isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
                                       bool RestrictDomain) {
   auto Result = give(isl_union_map_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](isl::set Set) {
+  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
     auto IdentityMap = give(isl_map_identity(
         isl_space_map_from_set(isl_set_get_space(Set.keep()))));
     if (RestrictDomain)
       IdentityMap =
           give(isl_map_intersect_domain(IdentityMap.take(), Set.take()));
     Result = give(isl_union_map_add_map(Result.take(), IdentityMap.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::map polly::reverseDomain(isl::map Map) {
   auto DomSpace =
       give(isl_space_unwrap(isl_space_domain(isl_map_get_space(Map.keep()))));
   auto Space1 = give(isl_space_domain(DomSpace.copy()));
   auto Space2 = give(isl_space_range(DomSpace.take()));
   auto Swap = makeTupleSwapMap(std::move(Space1), std::move(Space2));
   return give(isl_map_apply_domain(Map.take(), Swap.take()));
 }
 
 isl::union_map polly::reverseDomain(const isl::union_map &UMap) {
   auto Result = give(isl_union_map_empty(isl_union_map_get_space(UMap.keep())));
-  foreachElt(UMap, [=, &Result](isl::map Map) {
+  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
     auto Reversed = reverseDomain(std::move(Map));
     Result = give(isl_union_map_add_map(Result.take(), Reversed.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 isl::set polly::shiftDim(isl::set Set, int Pos, int Amount) {
   int NumDims = isl_set_dim(Set.keep(), isl_dim_set);
   if (Pos < 0)
     Pos = NumDims + Pos;
   assert(Pos < NumDims && "Dimension index must be in range");
   auto Space = give(isl_set_get_space(Set.keep()));
   Space = give(isl_space_map_from_domain_and_range(Space.copy(), Space.copy()));
   auto Translator = makeShiftDimAff(std::move(Space), Pos, Amount);
   auto TranslatorMap = give(isl_map_from_multi_aff(Translator.take()));
   return give(isl_set_apply(Set.take(), TranslatorMap.take()));
 }
 
 isl::union_set polly::shiftDim(isl::union_set USet, int Pos, int Amount) {
   auto Result = give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](isl::set Set) {
+  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
     auto Shifted = shiftDim(Set, Pos, Amount);
     Result = give(isl_union_set_add_set(Result.take(), Shifted.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 void polly::simplify(isl::set &Set) {
   Set = give(isl_set_compute_divs(Set.take()));
   Set = give(isl_set_detect_equalities(Set.take()));
   Set = give(isl_set_coalesce(Set.take()));

lib/Transform/DeLICM.cpp

void computeCommon() {
     }
 
     // { DomainWrite[] -> Element[] }
     auto AllWrites =
         give(isl_union_map_union(AllMustWrites.copy(), AllMayWrites.copy()));
 
     // { Element[] }
     AllElements = makeEmptyUnionSet();
-    foreachElt(AllWrites, [this](isl::map Write) {
+    AllWrites.foreach_map([this](isl::map Write) -> isl::stat {
       auto Space = give(isl_map_get_space(Write.keep()));
       auto EltSpace = give(isl_space_range(Space.take()));
       auto EltUniv = give(isl_set_universe(EltSpace.take()));
       AllElements =
           give(isl_union_set_add_set(AllElements.take(), EltUniv.take()));
+      return isl::stat::ok;
     });
   }
 
   /// Print the current state of all MemoryAccesses to @p.
   void printAccesses(llvm::raw_ostream &OS, int Indent = 0) const {
     OS.indent(Indent) << "After accesses {\n";
     for (auto &Stmt : *S) {
       OS.indent(Indent + 4) << Stmt.getBaseName() << "\n";

lib/Transform/FlattenAlgo.cpp

 /// Whether BMap's first out-dimension is not a constant.
 bool isVariableDim(const isl::basic_map &BMap) {
   auto FixedVal = BMap.plain_get_val_if_fixed(isl::dim::out, 0);
   return !FixedVal || FixedVal.is_nan();
 }
 
 /// Whether Map's first out dimension is no constant nor piecewise constant.
 bool isVariableDim(const isl::map &Map) {
-  return foreachEltWithBreak(Map, [](isl::basic_map BMap) -> isl_stat {
+  return Map.foreach_basic_map([](isl::basic_map BMap) -> isl::stat {
     if (isVariableDim(BMap))
-      return isl_stat_error;
-    return isl_stat_ok;
-  });
+      return isl::stat::error;
+    return isl::stat::ok;
+  }) == isl::stat::ok;
 }
 
 /// Whether UMap's first out dimension is no (piecewise) constant.
 bool isVariableDim(const isl::union_map &UMap) {
-  return foreachEltWithBreak(UMap, [](isl::map Map) -> isl_stat {
+  return UMap.foreach_map([](isl::map Map) -> isl::stat {
     if (isVariableDim(Map))
-      return isl_stat_error;
-    return isl_stat_ok;
-  });
+      return isl::stat::error;
+    return isl::stat::ok;
+  }) == isl::stat::ok;
 }
 
 /// If @p PwAff maps to a constant, return said constant. If @p Max/@p Min, it
 /// can also be a piecewise constant and it would return the minimum/maximum
 /// value. Otherwise, return NaN.
 isl::val getConstant(isl::pw_aff PwAff, bool Max, bool Min) {
   assert(!Max || !Min);
   isl::val Result;
-  foreachPieceWithBreak(PwAff, [=, &Result](isl::set Set, isl::aff Aff) {
+  PwAff.foreach_piece([=, &Result](isl::set Set, isl::aff Aff) -> isl::stat {
     if (Result && Result.is_nan())
-      return isl_stat_ok;
+      return isl::stat::ok;
 
     // TODO: If Min/Max, we can also determine a minimum/maximum value if
     // Set is constant-bounded.
     if (!Aff.is_cst()) {
       Result = isl::val::nan(Aff.get_ctx());
-      return isl_stat_error;
+      return isl::stat::ok;
     }
 
     auto ThisVal = Aff.get_constant_val();
     if (!Result) {
       Result = ThisVal;
-      return isl_stat_ok;
+      return isl::stat::ok;
     }
 
     if (Result.eq(ThisVal))
-      return isl_stat_ok;
+      return isl::stat::ok;
 
     if (Max && ThisVal.gt(Result)) {
       Result = ThisVal;
-      return isl_stat_ok;
+      return isl::stat::ok;
     }
 
     if (Min && ThisVal.lt(Result)) {
       Result = ThisVal;
-      return isl_stat_ok;
+      return isl::stat::ok;
     }
 
     // Not compatible
     Result = isl::val::nan(Aff.get_ctx());
-    return isl_stat_error;
+    return isl::stat::error;
   });
   return Result;
 }
 
 /// Compute @p UPwAff - @p Val.
 isl::union_pw_aff subtract(isl::union_pw_aff UPwAff, isl::val Val) {
   if (Val.is_zero())
     return UPwAff;
 
   auto Result = isl::union_pw_aff::empty(UPwAff.get_space());
-  foreachElt(UPwAff, [=, &Result](isl::pw_aff PwAff) {
+  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) -> isl::stat {
     auto ValAff =
         isl::pw_aff(isl::set::universe(PwAff.get_space().domain()), Val);
     auto Subtracted = PwAff.sub(ValAff);
     Result = Result.union_add(isl::union_pw_aff(Subtracted));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 /// Compute @UPwAff * @p Val.
 isl::union_pw_aff multiply(isl::union_pw_aff UPwAff, isl::val Val) {
   if (Val.is_one())
     return UPwAff;
 
   auto Result = isl::union_pw_aff::empty(UPwAff.get_space());
-  foreachElt(UPwAff, [=, &Result](isl::pw_aff PwAff) {
+  UPwAff.foreach_pw_aff([=, &Result](isl::pw_aff PwAff) -> isl::stat {
     auto ValAff =
         isl::pw_aff(isl::set::universe(PwAff.get_space().domain()), Val);
     auto Multiplied = PwAff.mul(ValAff);
     Result = Result.union_add(Multiplied);
+    return isl::stat::ok;
   });
   return Result;
 }
 
 /// Remove @p n dimensions from @p UMap's range, starting at @p first.
 ///
 /// It is assumed that all maps in the maps have at least the necessary number
 /// of out dimensions.
 isl::union_map scheduleProjectOut(const isl::union_map &UMap, unsigned first,
                                   unsigned n) {
   if (n == 0)
     return UMap; /* isl_map_project_out would also reset the tuple, which should
                     have no effect on schedule ranges */
 
   auto Result = isl::union_map::empty(UMap.get_space());
-  foreachElt(UMap, [=, &Result](isl::map Map) {
+  UMap.foreach_map([=, &Result](isl::map Map) -> isl::stat {
     auto Outprojected = Map.project_out(isl::dim::out, first, n);
     Result = Result.add_map(Outprojected);
+    return isl::stat::ok;
   });
   return Result;
 }
 
 /// Return the number of dimensions in the input map's range.
 ///
 /// Because this function takes an isl_union_map, the out dimensions could be
 /// different. We return the maximum number in this case. However, a different
 /// number of dimensions is not supported by the other code in this file.
 size_t scheduleScatterDims(const isl::union_map &Schedule) {
   unsigned Dims = 0;
-  foreachElt(Schedule, [&Dims](isl::map Map) {
+  Schedule.foreach_map([&Dims](isl::map Map) -> isl::stat {
     Dims = std::max(Dims, Map.dim(isl::dim::out));
+    return isl::stat::ok;
   });
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
 isl::union_pw_aff scheduleExtractDimAff(isl::union_map UMap, unsigned pos) {
   auto SingleUMap = isl::union_map::empty(UMap.get_space());
-  foreachElt(UMap, [=, &SingleUMap](isl::map Map) {
+  UMap.foreach_map([=, &SingleUMap](isl::map Map) -> isl::stat {
     auto MapDims = Map.dim(isl::dim::out);
     auto SingleMap = Map.project_out(isl::dim::out, 0, pos);
     SingleMap = SingleMap.project_out(isl::dim::out, 1, MapDims - pos - 1);
     SingleUMap = SingleUMap.add_map(SingleMap);
+    return isl::stat::ok;
   });
 
   auto UAff = isl::union_pw_multi_aff(SingleUMap);
   auto FirstMAff = isl::multi_union_pw_aff(UAff);
   return FirstMAff.get_union_pw_aff(0);
 }
 
 /// Flatten a sequence-like first dimension.

lib/Transform/FlattenSchedule.cpp

 
 namespace {
 
 /// Print a schedule to @p OS.
 ///
 /// Prints the schedule for each statements on a new line.
 void printSchedule(raw_ostream &OS, const isl::union_map &Schedule,
                    int indent) {
-  foreachElt(Schedule,
-             [&OS, indent](isl::map Map) { OS.indent(indent) << Map << "\n"; });
+  Schedule.foreach_map([&OS, indent](isl::map Map) -> isl::stat {
+    OS.indent(indent) << Map << "\n";
+    return isl::stat::ok;
+  });
 }
 
 /// Flatten the schedule stored in an polly::Scop.
 class FlattenSchedule : public ScopPass {
 private:
   FlattenSchedule(const FlattenSchedule &) = delete;
   const FlattenSchedule &operator=(const FlattenSchedule &) = delete;
 

unittests/DeLICM/DeLICMTest.cpp

 using namespace llvm;
 using namespace polly;
 
 namespace {
 
 /// Get the universes of all spaces in @p USet.
 isl::union_set unionSpace(const isl::union_set &USet) {
   auto Result = give(isl_union_set_empty(isl_union_set_get_space(USet.keep())));
-  foreachElt(USet, [=, &Result](isl::set Set) {
+  USet.foreach_set([=, &Result](isl::set Set) -> isl::stat {
     auto Space = give(isl_set_get_space(Set.keep()));
     auto Universe = give(isl_set_universe(Space.take()));
     Result = give(isl_union_set_add_set(Result.take(), Universe.take()));
+    return isl::stat::ok;
   });
   return Result;
 }
 
 void completeLifetime(isl::union_set Universe, isl::union_set &Unknown,
                       isl::union_set &Undef) {
   if (!Unknown) {
     assert(Undef);

unittests/Isl/IslTest.cpp

TEST(Isl, Foreach) {
 
   auto SetSpace = isl::space(Ctx.get(), 0, 1);
   isl::basic_set TestBSet = isl::point(SetSpace);
   isl::set TestSet = TestBSet;
   isl::union_set TestUSet = TestSet;
 
   {
     auto NumBMaps = 0;
-    foreachElt(TestMap, [&](isl::basic_map BMap) {
+    TestMap.foreach_basic_map([&](isl::basic_map BMap) -> isl::stat {
       EXPECT_EQ(BMap, TestBMap);
       NumBMaps++;
+      return isl::stat::ok;
     });
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumBSets = 0;
-    foreachElt(TestSet, [&](isl::basic_set BSet) {
+    TestSet.foreach_basic_set([&](isl::basic_set BSet) -> isl::stat {
       EXPECT_EQ(BSet, TestBSet);
       NumBSets++;
+      return isl::stat::ok;
     });
     EXPECT_EQ(1, NumBSets);
   }
 
   {
     auto NumMaps = 0;
-    foreachElt(TestUMap, [&](isl::map Map) {
+    TestUMap.foreach_map([&](isl::map Map) -> isl::stat {
       EXPECT_EQ(Map, TestMap);
       NumMaps++;
+      return isl::stat::ok;
     });
     EXPECT_EQ(1, NumMaps);
   }
 
   {
     auto NumSets = 0;
-    foreachElt(TestUSet, [&](isl::set Set) {
+    TestUSet.foreach_set([&](isl::set Set) -> isl::stat {
       EXPECT_EQ(Set, TestSet);
       NumSets++;
+      return isl::stat::ok;
     });
     EXPECT_EQ(1, NumSets);
   }
 
   {
     auto UPwAff = isl::union_pw_aff(TestUSet, isl::val::zero(Ctx.get()));
     auto NumPwAffs = 0;
-    foreachElt(UPwAff, [&](isl::pw_aff PwAff) {
+    UPwAff.foreach_pw_aff([&](isl::pw_aff PwAff) -> isl::stat {
       EXPECT_TRUE(PwAff.is_cst());
       NumPwAffs++;
+      return isl::stat::ok;
     });
     EXPECT_EQ(1, NumPwAffs);
   }
 
   {
     auto NumBMaps = 0;
-    EXPECT_EQ(
-        isl_stat_error,
-        foreachEltWithBreak(TestMap, [&](isl::basic_map BMap) -> isl_stat {
+    EXPECT_EQ(isl::stat::error,
+              TestMap.foreach_basic_map([&](isl::basic_map BMap) -> isl::stat {
                 EXPECT_EQ(BMap, TestBMap);
                 NumBMaps++;
-          return isl_stat_error;
+                return isl::stat::error;
               }));
     EXPECT_EQ(1, NumBMaps);
   }
 
   {
     auto NumMaps = 0;
-    EXPECT_EQ(isl_stat_error,
-              foreachEltWithBreak(TestUMap, [&](isl::map Map) -> isl_stat {
+    EXPECT_EQ(isl::stat::error,
+              TestUMap.foreach_map([&](isl::map Map) -> isl::stat {
                 EXPECT_EQ(Map, TestMap);
                 NumMaps++;
-                return isl_stat_error;
+                return isl::stat::error;
               }));
     EXPECT_EQ(1, NumMaps);
   }
 
   {
     auto TestPwAff = isl::pw_aff(TestSet, isl::val::zero(Ctx.get()));
     auto NumPieces = 0;
-    foreachPieceWithBreak(TestPwAff,
-                          [&](isl::set Domain, isl::aff Aff) -> isl_stat {
-                            EXPECT_EQ(Domain, TestSet);
-                            EXPECT_TRUE(Aff.is_cst());
-                            NumPieces++;
-                            return isl_stat_error;
-                          });
+    TestPwAff.foreach_piece([&](isl::set Domain, isl::aff Aff) -> isl::stat {
+      return isl::stat::error;
     EXPECT_EQ(1, NumPieces);
   }
 }
 
 TEST(ISLTools, beforeScatter) {
   std::unique_ptr<isl_ctx, decltype(&isl_ctx_free)> Ctx(isl_ctx_alloc(),
                                                         &isl_ctx_free);