[Polly][Isl] Removing explicit operator bool() from isl C++ bindings. NFC.

[patacca]

Summary

This is part of an effort to reduce the differences between the custom C++ bindings used right now by polly in lib/External/isl/include/isl/isl-noxceptions.h and the official isl C++ interface.

Changes made:

• Removing explicit operator bool() from all the classes in the isl C++ bindings.
• Replace each call to operator bool() to method is_null().
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/27396daac5a5ee8228d25511a12f4a814c92ba8f

[Meinersbur]

LGTM

polly/include/polly/ScopInfo.h

public:
 
   /// Return the context where execution behavior is defined. Might return
   /// nullptr.
   isl::set getDefinedBehaviorContext() const { return DefinedBehaviorContext; }
 
   /// Return the define behavior context, or if not available, its approximation
   /// from all other contexts.
   isl::set getBestKnownDefinedBehaviorContext() const {
-    if (DefinedBehaviorContext)
+    if (!DefinedBehaviorContext.is_null())
       return DefinedBehaviorContext;
 
     return Context.intersect_params(AssumedContext).subtract(InvalidContext);
   }
 
   /// Return space of isl context parameters.
   ///
   /// Returns the set of context parameters that are currently constrained. In

polly/lib/Analysis/DependenceInfo.cpp

for (ScopStmt &Stmt : S) {
     auto Lookup = NewSchedule.find(&Stmt);
     if (Lookup == NewSchedule.end())
       StmtScat = Stmt.getSchedule();
     else
       StmtScat = Lookup->second;
     assert(!StmtScat.is_null() &&
            "Schedules that contain extension nodes require special handling.");
 
-    if (!ScheduleSpace)
+    if (ScheduleSpace.is_null())
       ScheduleSpace = StmtScat.get_space().range();
 
     Schedule = Schedule.add_map(StmtScat);
   }
 
   Dependences = Dependences.apply_domain(Schedule);
   Dependences = Dependences.apply_range(Schedule);
 

polly/lib/Analysis/ScopBuilder.cpp

if (RN->isSubRegion()) {
         if (!propagateDomainConstraints(SubRegion, InvalidDomainMap))
           return false;
         continue;
       }
     }
 
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
     isl::set &Domain = scop->getOrInitEmptyDomain(BB);
-    assert(Domain);
+    assert(!Domain.is_null());
 
     // Under the union of all predecessor conditions we can reach this block.
     isl::set PredDom = getPredecessorDomainConstraints(BB, Domain);
     Domain = Domain.intersect(PredDom).coalesce();
     Domain = Domain.align_params(scop->getParamSpace());
 
     Loop *BBLoop = getRegionNodeLoop(RN, LI);
     if (BBLoop && BBLoop->getHeader() == BB && scop->contains(BBLoop))
while (L && scop->contains(L)) {
     BBLoop->getLoopLatches(LatchBBs);
     for (auto *LatchBB : LatchBBs)
       if (BB != LatchBB && BBReg->contains(LatchBB))
         return;
     L = L->getParentLoop();
   }
 
   isl::set Domain = scop->getOrInitEmptyDomain(BB);
-  assert(Domain && "Cannot propagate a nullptr");
+  assert(!Domain.is_null() && "Cannot propagate a nullptr");
 
   Loop *ExitBBLoop = getFirstNonBoxedLoopFor(ExitBB, LI, scop->getBoxedLoops());
 
   // Since the dimensions of @p BB and @p ExitBB might be different we have to
   // adjust the domain before we can propagate it.
   isl::set AdjustedDomain = adjustDomainDimensions(Domain, BBLoop, ExitBBLoop);
   isl::set &ExitDomain = scop->getOrInitEmptyDomain(ExitBB);
 
   // If the exit domain is not yet created we set it otherwise we "add" the
   // current domain.
-  ExitDomain = ExitDomain ? AdjustedDomain.unite(ExitDomain) : AdjustedDomain;
+  ExitDomain =
+      !ExitDomain.is_null() ? AdjustedDomain.unite(ExitDomain) : AdjustedDomain;
 
   // Initialize the invalid domain.
   InvalidDomainMap[ExitBB] = ExitDomain.empty(ExitDomain.get_space());
 
   FinishedExitBlocks.insert(ExitBB);
 }
 
 isl::set ScopBuilder::getPredecessorDomainConstraints(BasicBlock *BB,
for (unsigned u = 0, e = ConditionSets.size(); u < e; u++) {
 
       CondSet = adjustDomainDimensions(CondSet, BBLoop, SuccBBLoop);
 
       // Set the domain for the successor or merge it with an existing domain in
       // case there are multiple paths (without loop back edges) to the
       // successor block.
       isl::set &SuccDomain = scop->getOrInitEmptyDomain(SuccBB);
 
-      if (SuccDomain) {
+      if (!SuccDomain.is_null()) {
         SuccDomain = SuccDomain.unite(CondSet).coalesce();
       } else {
         // Initialize the invalid domain.
         InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
         SuccDomain = CondSet;
       }
 
       SuccDomain = SuccDomain.detect_equalities();
if (RN->isSubRegion()) {
         propagateInvalidStmtDomains(SubRegion, InvalidDomainMap);
         continue;
       }
     }
 
     bool ContainsErrorBlock = containsErrorBlock(RN, scop->getRegion(), LI, DT);
     BasicBlock *BB = getRegionNodeBasicBlock(RN);
     isl::set &Domain = scop->getOrInitEmptyDomain(BB);
-    assert(Domain && "Cannot propagate a nullptr");
+    assert(!Domain.is_null() && "Cannot propagate a nullptr");
 
     isl::set InvalidDomain = InvalidDomainMap[BB];
 
     bool IsInvalidBlock = ContainsErrorBlock || Domain.is_subset(InvalidDomain);
 
     if (!IsInvalidBlock) {
       InvalidDomain = InvalidDomain.intersect(Domain);
     } else {
void ScopBuilder::buildScalarDependences(ScopStmt *UserStmt,
   for (Use &Op : Inst->operands())
     ensureValueRead(Op.get(), UserStmt);
 }
 
 // Create a sequence of two schedules. Either argument may be null and is
 // interpreted as the empty schedule. Can also return null if both schedules are
 // empty.
 static isl::schedule combineInSequence(isl::schedule Prev, isl::schedule Succ) {
-  if (!Prev)
+  if (Prev.is_null())
     return Succ;
-  if (!Succ)
+  if (Succ.is_null())
     return Prev;
 
   return Prev.sequence(Succ);
 }
 
 // Create an isl_multi_union_aff that defines an identity mapping from the
 // elements of USet to their N-th dimension.
 //
 // # Example:
 //
 //            Domain: { A[i,j]; B[i,j,k] }
 //                 N: 1
 //
 // Resulting Mapping: { {A[i,j] -> [(j)]; B[i,j,k] -> [(j)] }
 //
 // @param USet   A union set describing the elements for which to generate a
 //               mapping.
 // @param N      The dimension to map to.
 // @returns      A mapping from USet to its N-th dimension.
 static isl::multi_union_pw_aff mapToDimension(isl::union_set USet, int N) {
   assert(N >= 0);
-  assert(USet);
+  assert(!USet.is_null());
   assert(!USet.is_empty());
 
   auto Result = isl::union_pw_multi_aff::empty(USet.get_space());
 
   for (isl::set S : USet.get_set_list()) {
     int Dim = S.dim(isl::dim::set);
     auto PMA = isl::pw_multi_aff::project_out_map(S.get_space(), isl::dim::set,
                                                   N, Dim - N);
while (LoopData->L &&
     isl::schedule Schedule = LoopData->Schedule;
     auto NumBlocksProcessed = LoopData->NumBlocksProcessed;
 
     assert(std::next(LoopData) != LoopStack.rend());
     Loop *L = LoopData->L;
     ++LoopData;
     --Dimension;
 
-    if (Schedule) {
+    if (!Schedule.is_null()) {
       isl::union_set Domain = Schedule.get_domain();
       isl::multi_union_pw_aff MUPA = mapToDimension(Domain, Dimension);
       Schedule = Schedule.insert_partial_schedule(MUPA);
 
       if (hasDisableAllTransformsHint(L)) {
         /// If any of the loops has a disable_nonforced heuristic, mark the
         /// entire SCoP as such. The ISL rescheduler can only reschedule the
         /// SCoP in its entirety.
         /// TODO: ScopDetection could avoid including such loops or warp them as
         /// boxed loop. It still needs to pass-through loop with user-defined
         /// metadata.
         scop->markDisableHeuristics();
       }
 
       // It is easier to insert the marks here that do it retroactively.
       isl::id IslLoopId = createIslLoopAttr(scop->getIslCtx(), L);
-      if (IslLoopId)
+      if (!IslLoopId.is_null())
         Schedule = Schedule.get_root()
                        .get_child(0)
                        .insert_mark(IslLoopId)
                        .get_schedule();
 
       LoopData->Schedule = combineInSequence(LoopData->Schedule, Schedule);
     }
 

 void ScopBuilder::hoistInvariantLoads() {
   if (!PollyInvariantLoadHoisting)
     return;
 
   isl::union_map Writes = scop->getWrites();
   for (ScopStmt &Stmt : *scop) {
     InvariantAccessesTy InvariantAccesses;
 
-    for (MemoryAccess *Access : Stmt)
-      if (isl::set NHCtx = getNonHoistableCtx(Access, Writes))
+    for (MemoryAccess *Access : Stmt) {
+      isl::set NHCtx = getNonHoistableCtx(Access, Writes);
+      if (!NHCtx.is_null())
         InvariantAccesses.push_back({Access, NHCtx});
+    }
 
     // Transfer the memory access from the statement to the SCoP.
     for (auto InvMA : InvariantAccesses)
       Stmt.removeMemoryAccess(InvMA.MA);
     addInvariantLoads(Stmt, InvariantAccesses);
   }
 }
 
for (auto &InvMA : InvMAs) {
     if (SE.isSCEVable(AccInst->getType())) {
       SetVector<Value *> Values;
       for (const SCEV *Parameter : scop->parameters()) {
         Values.clear();
         findValues(Parameter, SE, Values);
         if (!Values.count(AccInst))
           continue;
 
-        if (isl::id ParamId = scop->getIdForParam(Parameter)) {
+        isl::id ParamId = scop->getIdForParam(Parameter);
+        if (!ParamId.is_null()) {
           int Dim = DomainCtx.find_dim_by_id(isl::dim::param, ParamId);
           if (Dim >= 0)
             DomainCtx = DomainCtx.eliminate(isl::dim::param, Dim, 1);
         }
       }
     }
   }
 
for (auto &IAClass : scop->invariantEquivClasses()) {
 
       // Add MA to the list of accesses that are in this class.
       MAs.push_front(MA);
 
       Consolidated = true;
 
       // Unify the execution context of the class and this statement.
       isl::set IAClassDomainCtx = IAClass.ExecutionContext;
-      if (IAClassDomainCtx)
+      if (!IAClassDomainCtx.is_null())
         IAClassDomainCtx = IAClassDomainCtx.unite(MACtx).coalesce();
       else
         IAClassDomainCtx = MACtx;
       IAClass.ExecutionContext = IAClassDomainCtx;
       break;
     }
 
     if (Consolidated)
static bool buildMinMaxAccess(isl::set Set,
 
   MinPMA = MinPMA.coalesce();
   MaxPMA = MaxPMA.coalesce();
 
   // Adjust the last dimension of the maximal access by one as we want to
   // enclose the accessed memory region by MinPMA and MaxPMA. The pointer
   // we test during code generation might now point after the end of the
   // allocated array but we will never dereference it anyway.
-  assert((!MaxPMA || MaxPMA.dim(isl::dim::out)) &&
+  assert((MaxPMA.is_null() || MaxPMA.dim(isl::dim::out)) &&
          "Assumed at least one output dimension");
 
   Pos = MaxPMA.dim(isl::dim::out) - 1;
   LastDimAff = MaxPMA.get_pw_aff(Pos);
   OneAff = isl::aff(isl::local_space(LastDimAff.get_domain_space()));
   OneAff = OneAff.add_constant_si(1);
   LastDimAff = LastDimAff.add(OneAff);
   MaxPMA = MaxPMA.set_pw_aff(Pos, LastDimAff);
 
-  if (!MinPMA || !MaxPMA)
+  if (MinPMA.is_null() || MaxPMA.is_null())
     return false;
 
   MinMaxAccesses.push_back(std::make_pair(MinPMA, MaxPMA));
 
   return true;
 }
 
 /// Wrapper function to calculate minimal/maximal accesses to each array.

polly/lib/Analysis/ScopInfo.cpp

 void ScopArrayInfo::applyAndSetFAD(Value *FAD) {
   assert(FAD && "got invalid Fortran array descriptor");
   if (this->FAD) {
     assert(this->FAD == FAD &&
            "receiving different array descriptors for same array");
     return;
   }
 
-  assert(DimensionSizesPw.size() > 0 && !DimensionSizesPw[0]);
+  assert(DimensionSizesPw.size() > 0 && DimensionSizesPw[0].is_null());
   assert(!this->FAD);
   this->FAD = FAD;
 
   isl::space Space(S.getIslCtx(), 1, 0);
 
   std::string param_name = getName();
   param_name += "_fortranarr_size";
   isl::id IdPwAff = isl::id::alloc(S.getIslCtx(), param_name, this);
bool MemoryAccess::isStrideOne(isl::map Schedule) const {
   return isStrideX(Schedule, 1);
 }
 
 void MemoryAccess::setAccessRelation(isl::map NewAccess) {
   AccessRelation = NewAccess;
 }
 
 void MemoryAccess::setNewAccessRelation(isl::map NewAccess) {
-  assert(NewAccess);
+  assert(!NewAccess.is_null());
 
 #ifndef NDEBUG
   // Check domain space compatibility.
   isl::space NewSpace = NewAccess.get_space();
   isl::space NewDomainSpace = NewSpace.domain();
   isl::space OriginalDomainSpace = getStatement()->getDomainSpace();
   assert(OriginalDomainSpace.has_equal_tuples(NewDomainSpace));
 

 
 //===----------------------------------------------------------------------===//
 
 isl::map ScopStmt::getSchedule() const {
   isl::set Domain = getDomain();
   if (Domain.is_empty())
     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
   auto Schedule = getParent()->getSchedule();
-  if (!Schedule)
+  if (Schedule.is_null())
     return {};
   Schedule = Schedule.intersect_domain(isl::union_set(Domain));
   if (Schedule.is_empty())
     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
   isl::map M = M.from_union_map(Schedule);
   M = M.coalesce();
   M = M.gist_domain(Domain);
   M = M.coalesce();
void ScopStmt::printInstructions(raw_ostream &OS) const {
 
   OS.indent(12) << "}\n";
 }
 
 void ScopStmt::print(raw_ostream &OS, bool PrintInstructions) const {
   OS << "\t" << getBaseName() << "\n";
   OS.indent(12) << "Domain :=\n";
 
-  if (Domain) {
+  if (!Domain.is_null()) {
     OS.indent(16) << getDomainStr() << ";\n";
   } else
     OS.indent(16) << "n/a\n";
 
   OS.indent(12) << "Schedule :=\n";
 
-  if (Domain) {
+  if (!Domain.is_null()) {
     OS.indent(16) << getScheduleStr() << ";\n";
   } else
     OS.indent(16) << "n/a\n";
 
   for (MemoryAccess *Access : MemAccs)
     Access->print(OS);
 
   if (PrintInstructions)
static std::vector<isl::id> getFortranArrayIds(Scop::array_range Arrays) {
   std::vector<isl::id> OutermostSizeIds;
   for (auto Array : Arrays) {
     // To check if an array is a Fortran array, we check if it has a isl_pw_aff
     // for its outermost dimension. Fortran arrays will have this since the
     // outermost dimension size can be picked up from their runtime description.
     // TODO: actually need to check if it has a FAD, but for now this works.
     if (Array->getNumberOfDimensions() > 0) {
       isl::pw_aff PwAff = Array->getDimensionSizePw(0);
-      if (!PwAff)
+      if (PwAff.is_null())
         continue;
 
       isl::id Id = PwAff.get_dim_id(isl::dim::param, 0);
       assert(!Id.is_null() &&
              "Invalid Id for PwAff expression in Fortran array");
       OutermostSizeIds.push_back(Id);
     }
   }
for (auto StmtIt = Stmts.begin(), StmtEnd = Stmts.end(); StmtIt != StmtEnd;) {
     removeFromStmtMap(*StmtIt);
     StmtIt = Stmts.erase(StmtIt);
   }
 }
 
 void Scop::removeStmtNotInDomainMap() {
   removeStmts([this](ScopStmt &Stmt) -> bool {
     isl::set Domain = DomainMap.lookup(Stmt.getEntryBlock());
-    if (!Domain)
+    if (Domain.is_null())
       return true;
     return Domain.is_empty();
   });
 }
 
 void Scop::simplifySCoP(bool AfterHoisting) {
   removeStmts(
       [AfterHoisting](ScopStmt &Stmt) -> bool {
ScopArrayInfo *Scop::getScopArrayInfo(Value *BasePtr, MemoryKind Kind) {
   auto *SAI = getScopArrayInfoOrNull(BasePtr, Kind);
   assert(SAI && "No ScopArrayInfo available for this base pointer");
   return SAI;
 }
 
 std::string Scop::getContextStr() const { return getContext().to_str(); }
 
 std::string Scop::getAssumedContextStr() const {
-  assert(AssumedContext && "Assumed context not yet built");
+  assert(!AssumedContext.is_null() && "Assumed context not yet built");
   return AssumedContext.to_str();
 }
 
 std::string Scop::getInvalidContextStr() const {
   return InvalidContext.to_str();
 }
 
 std::string Scop::getNameStr() const {
isl::space Scop::getFullParamSpace() const {
 
   for (isl::id Id : FortranIDs)
     Space = Space.set_dim_id(isl::dim::param, PDim++, Id);
 
   return Space;
 }
 
 isl::set Scop::getAssumedContext() const {
-  assert(AssumedContext && "Assumed context not yet built");
+  assert(!AssumedContext.is_null() && "Assumed context not yet built");
   return AssumedContext;
 }
 
 bool Scop::isProfitable(bool ScalarsAreUnprofitable) const {
   if (PollyProcessUnprofitable)
     return true;
 
   if (isEmpty())
void Scop::addAssumption(AssumptionKind Kind, isl::set Set, DebugLoc Loc,
 
   if (Sign == AS_ASSUMPTION)
     AssumedContext = AssumedContext.intersect(Set).coalesce();
   else
     InvalidContext = InvalidContext.unite(Set).coalesce();
 }
 
 void Scop::intersectDefinedBehavior(isl::set Set, AssumptionSign Sign) {
-  if (!DefinedBehaviorContext)
+  if (DefinedBehaviorContext.is_null())
     return;
 
   if (Sign == AS_ASSUMPTION)
     DefinedBehaviorContext = DefinedBehaviorContext.intersect(Set);
   else
     DefinedBehaviorContext = DefinedBehaviorContext.subtract(Set);
 
   // Limit the complexity of the context. If complexity is exceeded, simplify
void Scop::printContext(raw_ostream &OS) const {
 
   OS.indent(4) << "Assumed Context:\n";
   OS.indent(4) << AssumedContext << "\n";
 
   OS.indent(4) << "Invalid Context:\n";
   OS.indent(4) << InvalidContext << "\n";
 
   OS.indent(4) << "Defined Behavior Context:\n";
-  if (DefinedBehaviorContext)
+  if (!DefinedBehaviorContext.is_null())
     OS.indent(4) << DefinedBehaviorContext << "\n";
   else
     OS.indent(4) << "<unavailable>\n";
 
   unsigned Dim = 0;
   for (const SCEV *Parameter : Parameters)
     OS.indent(4) << "p" << Dim++ << ": " << *Parameter << "\n";
 }
__isl_give PWACtx Scop::getPwAff(const SCEV *E, BasicBlock *BB,
                                  bool NonNegative,
                                  RecordedAssumptionsTy *RecordedAssumptions) {
   // First try to use the SCEVAffinator to generate a piecewise defined
   // affine function from @p E in the context of @p BB. If that tasks becomes to
   // complex the affinator might return a nullptr. In such a case we invalidate
   // the SCoP and return a dummy value. This way we do not need to add error
   // handling code to all users of this function.
   auto PWAC = Affinator.getPwAff(E, BB, RecordedAssumptions);
-  if (PWAC.first) {
+  if (!PWAC.first.is_null()) {
     // TODO: We could use a heuristic and either use:
     //         SCEVAffinator::takeNonNegativeAssumption
     //       or
     //         SCEVAffinator::interpretAsUnsigned
     //       to deal with unsigned or "NonNegative" SCEVs.
     if (NonNegative)
       Affinator.takeNonNegativeAssumption(PWAC, RecordedAssumptions);
     return PWAC;

polly/lib/CodeGen/IslAst.cpp

 isl::ast_node IslAst::getAst() { return Root; }
 isl::ast_expr IslAst::getRunCondition() { return RunCondition; }
 
 isl::ast_node IslAstInfo::getAst() { return Ast.getAst(); }
 isl::ast_expr IslAstInfo::getRunCondition() { return Ast.getRunCondition(); }
 
 IslAstUserPayload *IslAstInfo::getNodePayload(const isl::ast_node &Node) {
   isl::id Id = Node.get_annotation();
-  if (!Id)
+  if (Id.is_null())
     return nullptr;
   IslAstUserPayload *Payload = (IslAstUserPayload *)Id.get_user();
   return Payload;
 }
 
 bool IslAstInfo::isInnermost(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsInnermost;

polly/lib/CodeGen/PPCGCodeGeneration.cpp

for (isl::id &ToKillId : KillMemIds) {
     // 3. Create the kill schedule of the form:
     //     "[param] -> { Stmt_phantom[] }"
     // Then add this to Info.KillsSchedule.
     isl::space KillStmtSpace = ParamSpace;
     KillStmtSpace = KillStmtSpace.set_tuple_id(isl::dim::set, KillStmtId);
     isl::union_set KillStmtDomain = isl::set::universe(KillStmtSpace);
 
     isl::schedule KillSchedule = isl::schedule::from_domain(KillStmtDomain);
-    if (Info.KillsSchedule)
+    if (!Info.KillsSchedule.is_null())
       Info.KillsSchedule = isl::manage(
           isl_schedule_set(Info.KillsSchedule.release(), KillSchedule.copy()));
     else
       Info.KillsSchedule = KillSchedule;
   }
 
   return Info;
 }
void getAnalysisUsage(AnalysisUsage &AU) const override {
     // FIXME: We do not yet add regions for the newly generated code to the
     //        region tree.
   }
 };
 } // namespace
 
 char PPCGCodeGeneration::ID = 1;
 
 Pass *polly::createPPCGCodeGenerationPass(GPUArch Arch, GPURuntime Runtime) {
   PPCGCodeGeneration *generator = new PPCGCodeGeneration();
   generator->Runtime = Runtime;
   generator->Architecture = Arch;
   return generator;
 }
 
 INITIALIZE_PASS_BEGIN(PPCGCodeGeneration, "polly-codegen-ppcg",
                       "Polly - Apply PPCG translation to SCOP", false, false)
 INITIALIZE_PASS_DEPENDENCY(DependenceInfo);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScopDetectionWrapperPass);
 INITIALIZE_PASS_END(PPCGCodeGeneration, "polly-codegen-ppcg",
                     "Polly - Apply PPCG translation to SCOP", false, false)

polly/lib/Exchange/JSONExporter.cpp

if (!JScop.get("context")) {
     errs() << "JScop file has no key named 'context'.\n";
     return false;
   }
 
   isl::set NewContext = isl::set{S.getIslCtx().get(),
                                  JScop.getString("context").getValue().str()};
 
   // Check whether the context was parsed successfully.
-  if (!NewContext) {
+  if (NewContext.is_null()) {
     errs() << "The context was not parsed successfully by ISL.\n";
     return false;
   }
 
   // Check if the isl_set is a parameter set.
   if (!NewContext.is_params()) {
     errs() << "The isl_set is not a parameter set.\n";
     return false;

polly/lib/External/isl/include/isl/isl-noexceptions.h

public:
   inline explicit aff(local_space ls);
   inline aff &operator=(aff obj);
   inline ~aff();
   inline __isl_give isl_aff *copy() const &;
   inline __isl_give isl_aff *copy() && = delete;
   inline __isl_keep isl_aff *get() const;
   inline __isl_give isl_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline aff add(aff aff2) const;
   inline aff add_coefficient_si(isl::dim type, int pos, int v) const;
   inline aff add_coefficient_val(isl::dim type, int pos, val v) const;
   inline aff add_constant(val v) const;
public:
   inline /* implicit */ aff_list(const aff_list &obj);
   inline aff_list &operator=(aff_list obj);
   inline ~aff_list();
   inline __isl_give isl_aff_list *copy() const &;
   inline __isl_give isl_aff_list *copy() && = delete;
   inline __isl_keep isl_aff_list *get() const;
   inline __isl_give isl_aff_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline aff_list add(aff el) const;
   static inline aff_list alloc(ctx ctx, int n);
   inline aff_list clear() const;
   inline aff_list concat(aff_list list2) const;
public:
   inline explicit ast_build(ctx ctx);
   inline ast_build &operator=(ast_build obj);
   inline ~ast_build();
   inline __isl_give isl_ast_build *copy() const &;
   inline __isl_give isl_ast_build *copy() && = delete;
   inline __isl_keep isl_ast_build *get() const;
   inline __isl_give isl_ast_build *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
 
   inline ast_expr access_from(multi_pw_aff mpa) const;
   inline ast_expr access_from(pw_multi_aff pma) const;
   inline ast_node ast_from_schedule(union_map schedule) const;
   inline ast_expr call_from(multi_pw_aff mpa) const;
   inline ast_expr call_from(pw_multi_aff pma) const;
   inline ast_expr expr_from(pw_aff pa) const;
public:
   inline /* implicit */ ast_expr(const ast_expr &obj);
   inline ast_expr &operator=(ast_expr obj);
   inline ~ast_expr();
   inline __isl_give isl_ast_expr *copy() const &;
   inline __isl_give isl_ast_expr *copy() && = delete;
   inline __isl_keep isl_ast_expr *get() const;
   inline __isl_give isl_ast_expr *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_expr access(ast_expr_list indices) const;
   inline ast_expr add(ast_expr expr2) const;
   inline ast_expr address_of() const;
   inline ast_expr call(ast_expr_list arguments) const;
public:
   inline /* implicit */ ast_expr_list(const ast_expr_list &obj);
   inline ast_expr_list &operator=(ast_expr_list obj);
   inline ~ast_expr_list();
   inline __isl_give isl_ast_expr_list *copy() const &;
   inline __isl_give isl_ast_expr_list *copy() && = delete;
   inline __isl_keep isl_ast_expr_list *get() const;
   inline __isl_give isl_ast_expr_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_expr_list add(ast_expr el) const;
   static inline ast_expr_list alloc(ctx ctx, int n);
   inline ast_expr_list clear() const;
   inline ast_expr_list concat(ast_expr_list list2) const;
public:
   inline /* implicit */ ast_node(const ast_node &obj);
   inline ast_node &operator=(ast_node obj);
   inline ~ast_node();
   inline __isl_give isl_ast_node *copy() const &;
   inline __isl_give isl_ast_node *copy() && = delete;
   inline __isl_keep isl_ast_node *get() const;
   inline __isl_give isl_ast_node *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   static inline ast_node alloc_user(ast_expr expr);
   inline ast_node_list block_get_children() const;
   inline ast_node for_get_body() const;
   inline ast_expr for_get_cond() const;
public:
   inline /* implicit */ ast_node_list(const ast_node_list &obj);
   inline ast_node_list &operator=(ast_node_list obj);
   inline ~ast_node_list();
   inline __isl_give isl_ast_node_list *copy() const &;
   inline __isl_give isl_ast_node_list *copy() && = delete;
   inline __isl_keep isl_ast_node_list *get() const;
   inline __isl_give isl_ast_node_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline ast_node_list add(ast_node el) const;
   static inline ast_node_list alloc(ctx ctx, int n);
   inline ast_node_list clear() const;
   inline ast_node_list concat(ast_node_list list2) const;
public:
   inline explicit basic_map(ctx ctx, const std::string &str);
   inline basic_map &operator=(basic_map obj);
   inline ~basic_map();
   inline __isl_give isl_basic_map *copy() const &;
   inline __isl_give isl_basic_map *copy() && = delete;
   inline __isl_keep isl_basic_map *get() const;
   inline __isl_give isl_basic_map *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_map add_constraint(constraint constraint) const;
   inline basic_map add_dims(isl::dim type, unsigned int n) const;
   inline basic_map affine_hull() const;
   inline basic_map align_params(space model) const;
public:
   inline /* implicit */ basic_map_list(const basic_map_list &obj);
   inline basic_map_list &operator=(basic_map_list obj);
   inline ~basic_map_list();
   inline __isl_give isl_basic_map_list *copy() const &;
   inline __isl_give isl_basic_map_list *copy() && = delete;
   inline __isl_keep isl_basic_map_list *get() const;
   inline __isl_give isl_basic_map_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_map_list add(basic_map el) const;
   static inline basic_map_list alloc(ctx ctx, int n);
   inline basic_map_list clear() const;
   inline basic_map_list concat(basic_map_list list2) const;
public:
   inline explicit basic_set(ctx ctx, const std::string &str);
   inline basic_set &operator=(basic_set obj);
   inline ~basic_set();
   inline __isl_give isl_basic_set *copy() const &;
   inline __isl_give isl_basic_set *copy() && = delete;
   inline __isl_keep isl_basic_set *get() const;
   inline __isl_give isl_basic_set *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_set affine_hull() const;
   inline basic_set align_params(space model) const;
   inline basic_set apply(basic_map bmap) const;
   static inline basic_set box_from_points(point pnt1, point pnt2);
public:
   inline /* implicit */ basic_set_list(const basic_set_list &obj);
   inline basic_set_list &operator=(basic_set_list obj);
   inline ~basic_set_list();
   inline __isl_give isl_basic_set_list *copy() const &;
   inline __isl_give isl_basic_set_list *copy() && = delete;
   inline __isl_keep isl_basic_set_list *get() const;
   inline __isl_give isl_basic_set_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline basic_set_list add(basic_set el) const;
   static inline basic_set_list alloc(ctx ctx, int n);
   inline basic_set_list clear() const;
   inline basic_set_list coefficients() const;
public:
   inline /* implicit */ constraint(const constraint &obj);
   inline constraint &operator=(constraint obj);
   inline ~constraint();
   inline __isl_give isl_constraint *copy() const &;
   inline __isl_give isl_constraint *copy() && = delete;
   inline __isl_keep isl_constraint *get() const;
   inline __isl_give isl_constraint *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   static inline constraint alloc_equality(local_space ls);
   static inline constraint alloc_inequality(local_space ls);
   inline int cmp_last_non_zero(const constraint &c2) const;
   inline aff get_aff() const;
   inline aff get_bound(isl::dim type, int pos) const;
public:
   inline /* implicit */ constraint_list(const constraint_list &obj);
   inline constraint_list &operator=(constraint_list obj);
   inline ~constraint_list();
   inline __isl_give isl_constraint_list *copy() const &;
   inline __isl_give isl_constraint_list *copy() && = delete;
   inline __isl_keep isl_constraint_list *get() const;
   inline __isl_give isl_constraint_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline constraint_list add(constraint el) const;
   static inline constraint_list alloc(ctx ctx, int n);
   inline constraint_list clear() const;
   inline constraint_list concat(constraint_list list2) const;
public:
   inline /* implicit */ fixed_box(const fixed_box &obj);
   inline fixed_box &operator=(fixed_box obj);
   inline ~fixed_box();
   inline __isl_give isl_fixed_box *copy() const &;
   inline __isl_give isl_fixed_box *copy() && = delete;
   inline __isl_keep isl_fixed_box *get() const;
   inline __isl_give isl_fixed_box *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_aff get_offset() const;
   inline multi_val get_size() const;
   inline space get_space() const;
   inline boolean is_valid() const;
public:
   inline explicit id(ctx ctx, const std::string &str);
   inline id &operator=(id obj);
   inline ~id();
   inline __isl_give isl_id *copy() const &;
   inline __isl_give isl_id *copy() && = delete;
   inline __isl_keep isl_id *get() const;
   inline __isl_give isl_id *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   static inline id alloc(ctx ctx, const std::string &name, void * user);
   inline uint32_t get_hash() const;
   inline std::string get_name() const;
   inline void * get_user() const;
public:
   inline /* implicit */ id_list(const id_list &obj);
   inline id_list &operator=(id_list obj);
   inline ~id_list();
   inline __isl_give isl_id_list *copy() const &;
   inline __isl_give isl_id_list *copy() && = delete;
   inline __isl_keep isl_id_list *get() const;
   inline __isl_give isl_id_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline id_list add(id el) const;
   static inline id_list alloc(ctx ctx, int n);
   inline id_list clear() const;
   inline id_list concat(id_list list2) const;
public:
   inline /* implicit */ id_to_ast_expr(const id_to_ast_expr &obj);
   inline id_to_ast_expr &operator=(id_to_ast_expr obj);
   inline ~id_to_ast_expr();
   inline __isl_give isl_id_to_ast_expr *copy() const &;
   inline __isl_give isl_id_to_ast_expr *copy() && = delete;
   inline __isl_keep isl_id_to_ast_expr *get() const;
   inline __isl_give isl_id_to_ast_expr *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   static inline id_to_ast_expr alloc(ctx ctx, int min_size);
   inline id_to_ast_expr drop(id key) const;
   inline stat foreach(const std::function<stat(id, ast_expr)> &fn) const;
   inline ast_expr get(id key) const;
   inline boolean has(const id &key) const;
public:
   inline explicit local_space(space space);
   inline local_space &operator=(local_space obj);
   inline ~local_space();
   inline __isl_give isl_local_space *copy() const &;
   inline __isl_give isl_local_space *copy() && = delete;
   inline __isl_keep isl_local_space *get() const;
   inline __isl_give isl_local_space *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   inline local_space add_dims(isl::dim type, unsigned int n) const;
   inline isl_size dim(isl::dim type) const;
   inline local_space domain() const;
   inline local_space drop_dims(isl::dim type, unsigned int first, unsigned int n) const;
   inline int find_dim_by_name(isl::dim type, const std::string &name) const;
public:
   inline explicit map(ctx ctx, const std::string &str);
   inline map &operator=(map obj);
   inline ~map();
   inline __isl_give isl_map *copy() const &;
   inline __isl_give isl_map *copy() && = delete;
   inline __isl_keep isl_map *get() const;
   inline __isl_give isl_map *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline map add_constraint(constraint constraint) const;
   inline map add_dims(isl::dim type, unsigned int n) const;
   inline basic_map affine_hull() const;
   inline map align_params(space model) const;
public:
   inline /* implicit */ map_list(const map_list &obj);
   inline map_list &operator=(map_list obj);
   inline ~map_list();
   inline __isl_give isl_map_list *copy() const &;
   inline __isl_give isl_map_list *copy() && = delete;
   inline __isl_keep isl_map_list *get() const;
   inline __isl_give isl_map_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline map_list add(map el) const;
   static inline map_list alloc(ctx ctx, int n);
   inline map_list clear() const;
   inline map_list concat(map_list list2) const;
public:
   inline /* implicit */ mat(const mat &obj);
   inline mat &operator=(mat obj);
   inline ~mat();
   inline __isl_give isl_mat *copy() const &;
   inline __isl_give isl_mat *copy() && = delete;
   inline __isl_keep isl_mat *get() const;
   inline __isl_give isl_mat *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   inline mat add_rows(unsigned int n) const;
   inline mat add_zero_cols(unsigned int n) const;
   inline mat add_zero_rows(unsigned int n) const;
   inline mat aff_direct_sum(mat right) const;
   static inline mat alloc(ctx ctx, unsigned int n_row, unsigned int n_col);
public:
   inline explicit multi_aff(ctx ctx, const std::string &str);
   inline multi_aff &operator=(multi_aff obj);
   inline ~multi_aff();
   inline __isl_give isl_multi_aff *copy() const &;
   inline __isl_give isl_multi_aff *copy() && = delete;
   inline __isl_keep isl_multi_aff *get() const;
   inline __isl_give isl_multi_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_aff add(multi_aff multi2) const;
   inline multi_aff add_constant(multi_val mv) const;
   inline multi_aff add_constant(val v) const;
   inline multi_aff add_dims(isl::dim type, unsigned int n) const;
public:
   inline explicit multi_id(ctx ctx, const std::string &str);
   inline multi_id &operator=(multi_id obj);
   inline ~multi_id();
   inline __isl_give isl_multi_id *copy() const &;
   inline __isl_give isl_multi_id *copy() && = delete;
   inline __isl_keep isl_multi_id *get() const;
   inline __isl_give isl_multi_id *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_id align_params(space model) const;
   inline multi_id factor_range() const;
   inline multi_id flat_range_product(multi_id multi2) const;
   inline multi_id flatten_range() const;
public:
   inline explicit multi_pw_aff(ctx ctx, const std::string &str);
   inline multi_pw_aff &operator=(multi_pw_aff obj);
   inline ~multi_pw_aff();
   inline __isl_give isl_multi_pw_aff *copy() const &;
   inline __isl_give isl_multi_pw_aff *copy() && = delete;
   inline __isl_keep isl_multi_pw_aff *get() const;
   inline __isl_give isl_multi_pw_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_pw_aff add(multi_pw_aff multi2) const;
   inline multi_pw_aff add_constant(multi_val mv) const;
   inline multi_pw_aff add_constant(val v) const;
   inline multi_pw_aff add_dims(isl::dim type, unsigned int n) const;
public:
   inline explicit multi_union_pw_aff(ctx ctx, const std::string &str);
   inline multi_union_pw_aff &operator=(multi_union_pw_aff obj);
   inline ~multi_union_pw_aff();
   inline __isl_give isl_multi_union_pw_aff *copy() const &;
   inline __isl_give isl_multi_union_pw_aff *copy() && = delete;
   inline __isl_keep isl_multi_union_pw_aff *get() const;
   inline __isl_give isl_multi_union_pw_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_union_pw_aff add(multi_union_pw_aff multi2) const;
   inline multi_union_pw_aff align_params(space model) const;
   inline union_pw_aff apply_aff(aff aff) const;
   inline union_pw_aff apply_pw_aff(pw_aff pa) const;
public:
   inline explicit multi_val(ctx ctx, const std::string &str);
   inline multi_val &operator=(multi_val obj);
   inline ~multi_val();
   inline __isl_give isl_multi_val *copy() const &;
   inline __isl_give isl_multi_val *copy() && = delete;
   inline __isl_keep isl_multi_val *get() const;
   inline __isl_give isl_multi_val *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline multi_val add(multi_val multi2) const;
   inline multi_val add(val v) const;
   inline multi_val add_dims(isl::dim type, unsigned int n) const;
   inline multi_val align_params(space model) const;
public:
   inline explicit point(space dim);
   inline point &operator=(point obj);
   inline ~point();
   inline __isl_give isl_point *copy() const &;
   inline __isl_give isl_point *copy() && = delete;
   inline __isl_keep isl_point *get() const;
   inline __isl_give isl_point *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline point add_ui(isl::dim type, int pos, unsigned int val) const;
   inline val get_coordinate_val(isl::dim type, int pos) const;
   inline multi_val get_multi_val() const;
   inline space get_space() const;
public:
   inline explicit pw_aff(local_space ls);
   inline pw_aff &operator=(pw_aff obj);
   inline ~pw_aff();
   inline __isl_give isl_pw_aff *copy() const &;
   inline __isl_give isl_pw_aff *copy() && = delete;
   inline __isl_keep isl_pw_aff *get() const;
   inline __isl_give isl_pw_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_aff add(pw_aff pwaff2) const;
   inline pw_aff add_constant(val v) const;
   inline pw_aff add_dims(isl::dim type, unsigned int n) const;
   inline pw_aff align_params(space model) const;
public:
   inline /* implicit */ pw_aff_list(const pw_aff_list &obj);
   inline pw_aff_list &operator=(pw_aff_list obj);
   inline ~pw_aff_list();
   inline __isl_give isl_pw_aff_list *copy() const &;
   inline __isl_give isl_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_aff_list *get() const;
   inline __isl_give isl_pw_aff_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_aff_list add(pw_aff el) const;
   static inline pw_aff_list alloc(ctx ctx, int n);
   inline pw_aff_list clear() const;
   inline pw_aff_list concat(pw_aff_list list2) const;
public:
   inline explicit pw_multi_aff(ctx ctx, const std::string &str);
   inline pw_multi_aff &operator=(pw_multi_aff obj);
   inline ~pw_multi_aff();
   inline __isl_give isl_pw_multi_aff *copy() const &;
   inline __isl_give isl_pw_multi_aff *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff *get() const;
   inline __isl_give isl_pw_multi_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_multi_aff add(pw_multi_aff pma2) const;
   inline pw_multi_aff add_constant(multi_val mv) const;
   inline pw_multi_aff add_constant(val v) const;
   inline pw_multi_aff align_params(space model) const;
public:
   inline /* implicit */ pw_multi_aff_list(const pw_multi_aff_list &obj);
   inline pw_multi_aff_list &operator=(pw_multi_aff_list obj);
   inline ~pw_multi_aff_list();
   inline __isl_give isl_pw_multi_aff_list *copy() const &;
   inline __isl_give isl_pw_multi_aff_list *copy() && = delete;
   inline __isl_keep isl_pw_multi_aff_list *get() const;
   inline __isl_give isl_pw_multi_aff_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_multi_aff_list add(pw_multi_aff el) const;
   static inline pw_multi_aff_list alloc(ctx ctx, int n);
   inline pw_multi_aff_list clear() const;
   inline pw_multi_aff_list concat(pw_multi_aff_list list2) const;
public:
   inline explicit pw_qpolynomial(ctx ctx, const std::string &str);
   inline pw_qpolynomial &operator=(pw_qpolynomial obj);
   inline ~pw_qpolynomial();
   inline __isl_give isl_pw_qpolynomial *copy() const &;
   inline __isl_give isl_pw_qpolynomial *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial *get() const;
   inline __isl_give isl_pw_qpolynomial *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_qpolynomial add(pw_qpolynomial pwqp2) const;
   inline pw_qpolynomial add_dims(isl::dim type, unsigned int n) const;
   static inline pw_qpolynomial alloc(set set, qpolynomial qp);
   inline qpolynomial as_qpolynomial() const;
public:
   inline /* implicit */ pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj);
   inline pw_qpolynomial_fold_list &operator=(pw_qpolynomial_fold_list obj);
   inline ~pw_qpolynomial_fold_list();
   inline __isl_give isl_pw_qpolynomial_fold_list *copy() const &;
   inline __isl_give isl_pw_qpolynomial_fold_list *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial_fold_list *get() const;
   inline __isl_give isl_pw_qpolynomial_fold_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
 };
 
 // declarations for isl::pw_qpolynomial_list
 inline pw_qpolynomial_list manage(__isl_take isl_pw_qpolynomial_list *ptr);
public:
   inline /* implicit */ pw_qpolynomial_list(const pw_qpolynomial_list &obj);
   inline pw_qpolynomial_list &operator=(pw_qpolynomial_list obj);
   inline ~pw_qpolynomial_list();
   inline __isl_give isl_pw_qpolynomial_list *copy() const &;
   inline __isl_give isl_pw_qpolynomial_list *copy() && = delete;
   inline __isl_keep isl_pw_qpolynomial_list *get() const;
   inline __isl_give isl_pw_qpolynomial_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline pw_qpolynomial_list add(pw_qpolynomial el) const;
   static inline pw_qpolynomial_list alloc(ctx ctx, int n);
   inline pw_qpolynomial_list clear() const;
   inline pw_qpolynomial_list concat(pw_qpolynomial_list list2) const;
public:
   inline /* implicit */ qpolynomial(const qpolynomial &obj);
   inline qpolynomial &operator=(qpolynomial obj);
   inline ~qpolynomial();
   inline __isl_give isl_qpolynomial *copy() const &;
   inline __isl_give isl_qpolynomial *copy() && = delete;
   inline __isl_keep isl_qpolynomial *get() const;
   inline __isl_give isl_qpolynomial *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   inline qpolynomial add(qpolynomial qp2) const;
   inline qpolynomial add_dims(isl::dim type, unsigned int n) const;
   inline qpolynomial align_params(space model) const;
   inline stat as_polynomial_on_domain(const basic_set &bset, const std::function<stat(basic_set, qpolynomial)> &fn) const;
   inline isl_size dim(isl::dim type) const;
public:
   inline /* implicit */ qpolynomial_list(const qpolynomial_list &obj);
   inline qpolynomial_list &operator=(qpolynomial_list obj);
   inline ~qpolynomial_list();
   inline __isl_give isl_qpolynomial_list *copy() const &;
   inline __isl_give isl_qpolynomial_list *copy() && = delete;
   inline __isl_keep isl_qpolynomial_list *get() const;
   inline __isl_give isl_qpolynomial_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline qpolynomial_list add(qpolynomial el) const;
   static inline qpolynomial_list alloc(ctx ctx, int n);
   inline qpolynomial_list clear() const;
   inline qpolynomial_list concat(qpolynomial_list list2) const;
public:
   inline explicit schedule(ctx ctx, const std::string &str);
   inline schedule &operator=(schedule obj);
   inline ~schedule();
   inline __isl_give isl_schedule *copy() const &;
   inline __isl_give isl_schedule *copy() && = delete;
   inline __isl_keep isl_schedule *get() const;
   inline __isl_give isl_schedule *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule align_params(space space) const;
   static inline schedule empty(space space);
   static inline schedule from_domain(union_set domain);
   inline union_set get_domain() const;
public:
   inline explicit schedule_constraints(ctx ctx, const std::string &str);
   inline schedule_constraints &operator=(schedule_constraints obj);
   inline ~schedule_constraints();
   inline __isl_give isl_schedule_constraints *copy() const &;
   inline __isl_give isl_schedule_constraints *copy() && = delete;
   inline __isl_keep isl_schedule_constraints *get() const;
   inline __isl_give isl_schedule_constraints *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule_constraints apply(union_map umap) const;
   inline schedule compute_schedule() const;
   inline union_map get_coincidence() const;
   inline union_map get_conditional_validity() const;
public:
   inline /* implicit */ schedule_node(const schedule_node &obj);
   inline schedule_node &operator=(schedule_node obj);
   inline ~schedule_node();
   inline __isl_give isl_schedule_node *copy() const &;
   inline __isl_give isl_schedule_node *copy() && = delete;
   inline __isl_keep isl_schedule_node *get() const;
   inline __isl_give isl_schedule_node *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline schedule_node align_params(space space) const;
   inline schedule_node ancestor(int generation) const;
   inline boolean band_member_get_coincident(int pos) const;
   inline schedule_node band_member_set_coincident(int pos, int coincident) const;
public:
   inline explicit set(ctx ctx, const std::string &str);
   inline set &operator=(set obj);
   inline ~set();
   inline __isl_give isl_set *copy() const &;
   inline __isl_give isl_set *copy() && = delete;
   inline __isl_keep isl_set *get() const;
   inline __isl_give isl_set *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline set add_constraint(constraint constraint) const;
   inline set add_dims(isl::dim type, unsigned int n) const;
   inline basic_set affine_hull() const;
   inline set align_params(space model) const;
public:
   inline /* implicit */ set_list(const set_list &obj);
   inline set_list &operator=(set_list obj);
   inline ~set_list();
   inline __isl_give isl_set_list *copy() const &;
   inline __isl_give isl_set_list *copy() && = delete;
   inline __isl_keep isl_set_list *get() const;
   inline __isl_give isl_set_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline set_list add(set el) const;
   static inline set_list alloc(ctx ctx, int n);
   inline set_list clear() const;
   inline set_list concat(set_list list2) const;
public:
   inline explicit space(ctx ctx, unsigned int nparam, unsigned int dim);
   inline space &operator=(space obj);
   inline ~space();
   inline __isl_give isl_space *copy() const &;
   inline __isl_give isl_space *copy() && = delete;
   inline __isl_keep isl_space *get() const;
   inline __isl_give isl_space *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline space add_dims(isl::dim type, unsigned int n) const;
   inline space add_named_tuple(id tuple_id, unsigned int dim) const;
   inline space add_param_id(id id) const;
   inline space add_unnamed_tuple(unsigned int dim) const;
public:
   inline /* implicit */ term(const term &obj);
   inline term &operator=(term obj);
   inline ~term();
   inline __isl_give isl_term *copy() const &;
   inline __isl_give isl_term *copy() && = delete;
   inline __isl_keep isl_term *get() const;
   inline __isl_give isl_term *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
 
   inline isl_size dim(isl::dim type) const;
   inline val get_coefficient_val() const;
   inline aff get_div(unsigned int pos) const;
   inline isl_size get_exp(isl::dim type, unsigned int pos) const;
 };
 
public:
   inline explicit union_access_info(union_map sink);
   inline union_access_info &operator=(union_access_info obj);
   inline ~union_access_info();
   inline __isl_give isl_union_access_info *copy() const &;
   inline __isl_give isl_union_access_info *copy() && = delete;
   inline __isl_keep isl_union_access_info *get() const;
   inline __isl_give isl_union_access_info *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
 
   inline union_flow compute_flow() const;
   inline union_access_info set_kill(union_map kill) const;
   inline union_access_info set_may_source(union_map may_source) const;
   inline union_access_info set_must_source(union_map must_source) const;
   inline union_access_info set_schedule(schedule schedule) const;
public:
   inline /* implicit */ union_flow(const union_flow &obj);
   inline union_flow &operator=(union_flow obj);
   inline ~union_flow();
   inline __isl_give isl_union_flow *copy() const &;
   inline __isl_give isl_union_flow *copy() && = delete;
   inline __isl_keep isl_union_flow *get() const;
   inline __isl_give isl_union_flow *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
 
   inline union_map get_full_may_dependence() const;
   inline union_map get_full_must_dependence() const;
   inline union_map get_may_dependence() const;
   inline union_map get_may_no_source() const;
   inline union_map get_must_dependence() const;
public:
   inline explicit union_map(ctx ctx, const std::string &str);
   inline union_map &operator=(union_map obj);
   inline ~union_map();
   inline __isl_give isl_union_map *copy() const &;
   inline __isl_give isl_union_map *copy() && = delete;
   inline __isl_keep isl_union_map *get() const;
   inline __isl_give isl_union_map *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_map add_map(map map) const;
   inline union_map affine_hull() const;
   inline union_map align_params(space model) const;
   inline union_map apply_domain(union_map umap2) const;
public:
   inline /* implicit */ union_map_list(const union_map_list &obj);
   inline union_map_list &operator=(union_map_list obj);
   inline ~union_map_list();
   inline __isl_give isl_union_map_list *copy() const &;
   inline __isl_give isl_union_map_list *copy() && = delete;
   inline __isl_keep isl_union_map_list *get() const;
   inline __isl_give isl_union_map_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_map_list add(union_map el) const;
   static inline union_map_list alloc(ctx ctx, int n);
   inline union_map_list clear() const;
   inline union_map_list concat(union_map_list list2) const;
public:
   inline explicit union_pw_aff(union_set domain, val v);
   inline union_pw_aff &operator=(union_pw_aff obj);
   inline ~union_pw_aff();
   inline __isl_give isl_union_pw_aff *copy() const &;
   inline __isl_give isl_union_pw_aff *copy() && = delete;
   inline __isl_keep isl_union_pw_aff *get() const;
   inline __isl_give isl_union_pw_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_aff add(union_pw_aff upa2) const;
   inline union_pw_aff add_pw_aff(pw_aff pa) const;
   static inline union_pw_aff aff_on_domain(union_set domain, aff aff);
   inline union_pw_aff align_params(space model) const;
public:
   inline /* implicit */ union_pw_aff_list(const union_pw_aff_list &obj);
   inline union_pw_aff_list &operator=(union_pw_aff_list obj);
   inline ~union_pw_aff_list();
   inline __isl_give isl_union_pw_aff_list *copy() const &;
   inline __isl_give isl_union_pw_aff_list *copy() && = delete;
   inline __isl_keep isl_union_pw_aff_list *get() const;
   inline __isl_give isl_union_pw_aff_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_aff_list add(union_pw_aff el) const;
   static inline union_pw_aff_list alloc(ctx ctx, int n);
   inline union_pw_aff_list clear() const;
   inline union_pw_aff_list concat(union_pw_aff_list list2) const;
public:
   inline explicit union_pw_multi_aff(ctx ctx, const std::string &str);
   inline union_pw_multi_aff &operator=(union_pw_multi_aff obj);
   inline ~union_pw_multi_aff();
   inline __isl_give isl_union_pw_multi_aff *copy() const &;
   inline __isl_give isl_union_pw_multi_aff *copy() && = delete;
   inline __isl_keep isl_union_pw_multi_aff *get() const;
   inline __isl_give isl_union_pw_multi_aff *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_multi_aff add(union_pw_multi_aff upma2) const;
   inline union_pw_multi_aff add_pw_multi_aff(pw_multi_aff pma) const;
   inline union_pw_multi_aff align_params(space model) const;
   inline union_pw_multi_aff apply(union_pw_multi_aff upma2) const;
public:
   inline /* implicit */ union_pw_multi_aff_list(const union_pw_multi_aff_list &obj);
   inline union_pw_multi_aff_list &operator=(union_pw_multi_aff_list obj);
   inline ~union_pw_multi_aff_list();
   inline __isl_give isl_union_pw_multi_aff_list *copy() const &;
   inline __isl_give isl_union_pw_multi_aff_list *copy() && = delete;
   inline __isl_keep isl_union_pw_multi_aff_list *get() const;
   inline __isl_give isl_union_pw_multi_aff_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_pw_multi_aff_list add(union_pw_multi_aff el) const;
   static inline union_pw_multi_aff_list alloc(ctx ctx, int n);
   inline union_pw_multi_aff_list clear() const;
   inline union_pw_multi_aff_list concat(union_pw_multi_aff_list list2) const;
public:
   inline explicit union_pw_qpolynomial(ctx ctx, const std::string &str);
   inline union_pw_qpolynomial &operator=(union_pw_qpolynomial obj);
   inline ~union_pw_qpolynomial();
   inline __isl_give isl_union_pw_qpolynomial *copy() const &;
   inline __isl_give isl_union_pw_qpolynomial *copy() && = delete;
   inline __isl_keep isl_union_pw_qpolynomial *get() const;
   inline __isl_give isl_union_pw_qpolynomial *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
 
   inline union_pw_qpolynomial add(union_pw_qpolynomial upwqp2) const;
   inline union_pw_qpolynomial add_pw_qpolynomial(pw_qpolynomial pwqp) const;
   inline union_pw_qpolynomial align_params(space model) const;
   inline union_pw_qpolynomial coalesce() const;
   inline isl_size dim(isl::dim type) const;
public:
   inline explicit union_set(ctx ctx, const std::string &str);
   inline union_set &operator=(union_set obj);
   inline ~union_set();
   inline __isl_give isl_union_set *copy() const &;
   inline __isl_give isl_union_set *copy() && = delete;
   inline __isl_keep isl_union_set *get() const;
   inline __isl_give isl_union_set *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_set add_set(set set) const;
   inline union_set affine_hull() const;
   inline union_set align_params(space model) const;
   inline union_set apply(union_map umap) const;
public:
   inline /* implicit */ union_set_list(const union_set_list &obj);
   inline union_set_list &operator=(union_set_list obj);
   inline ~union_set_list();
   inline __isl_give isl_union_set_list *copy() const &;
   inline __isl_give isl_union_set_list *copy() && = delete;
   inline __isl_keep isl_union_set_list *get() const;
   inline __isl_give isl_union_set_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline union_set_list add(union_set el) const;
   static inline union_set_list alloc(ctx ctx, int n);
   inline union_set_list clear() const;
   inline union_set_list concat(union_set_list list2) const;
public:
   inline explicit val(ctx ctx, const std::string &str);
   inline val &operator=(val obj);
   inline ~val();
   inline __isl_give isl_val *copy() const &;
   inline __isl_give isl_val *copy() && = delete;
   inline __isl_keep isl_val *get() const;
   inline __isl_give isl_val *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline val abs() const;
   inline boolean abs_eq(const val &v2) const;
   inline val add(val v2) const;
   inline val add_ui(unsigned long v2) const;
public:
   inline /* implicit */ val_list(const val_list &obj);
   inline val_list &operator=(val_list obj);
   inline ~val_list();
   inline __isl_give isl_val_list *copy() const &;
   inline __isl_give isl_val_list *copy() && = delete;
   inline __isl_keep isl_val_list *get() const;
   inline __isl_give isl_val_list *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
   inline val_list add(val el) const;
   static inline val_list alloc(ctx ctx, int n);
   inline val_list clear() const;
   inline val_list concat(val_list list2) const;
public:
   inline /* implicit */ vec(const vec &obj);
   inline vec &operator=(vec obj);
   inline ~vec();
   inline __isl_give isl_vec *copy() const &;
   inline __isl_give isl_vec *copy() && = delete;
   inline __isl_keep isl_vec *get() const;
   inline __isl_give isl_vec *release();
   inline bool is_null() const;
-  inline explicit operator bool() const;
   inline ctx get_ctx() const;
   inline void dump() const;
 
   inline vec add(vec vec2) const;
   inline vec add_els(unsigned int n) const;
   static inline vec alloc(ctx ctx, unsigned int size);
   inline vec ceil() const;
   inline vec clr() const;
__isl_give isl_aff *aff::release() {
   isl_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool aff::is_null() const {
   return ptr == nullptr;
 }
-aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx aff::get_ctx() const {
   return ctx(isl_aff_get_ctx(ptr));
 }
 std::string aff::to_str() const {
   char *Tmp = isl_aff_to_str(get());
   if (!Tmp)
__isl_give isl_aff_list *aff_list::release() {
   isl_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool aff_list::is_null() const {
   return ptr == nullptr;
 }
-aff_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx aff_list::get_ctx() const {
   return ctx(isl_aff_list_get_ctx(ptr));
 }
 std::string aff_list::to_str() const {
   char *Tmp = isl_aff_list_to_str(get());
   if (!Tmp)
__isl_give isl_ast_build *ast_build::release() {
   isl_ast_build *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_build::is_null() const {
   return ptr == nullptr;
 }
-ast_build::operator bool() const {
-  return !is_null();
-}
 
 
 ctx ast_build::get_ctx() const {
   return ctx(isl_ast_build_get_ctx(ptr));
 }
 
 
 ast_expr ast_build::access_from(multi_pw_aff mpa) const
__isl_give isl_ast_expr *ast_expr::release() {
   isl_ast_expr *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_expr::is_null() const {
   return ptr == nullptr;
 }
-ast_expr::operator bool() const {
-  return !is_null();
-}
 
 
 ctx ast_expr::get_ctx() const {
   return ctx(isl_ast_expr_get_ctx(ptr));
 }
 std::string ast_expr::to_str() const {
   char *Tmp = isl_ast_expr_to_str(get());
   if (!Tmp)
__isl_give isl_ast_expr_list *ast_expr_list::release() {
   isl_ast_expr_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_expr_list::is_null() const {
   return ptr == nullptr;
 }
-ast_expr_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx ast_expr_list::get_ctx() const {
   return ctx(isl_ast_expr_list_get_ctx(ptr));
 }
 std::string ast_expr_list::to_str() const {
   char *Tmp = isl_ast_expr_list_to_str(get());
   if (!Tmp)
__isl_give isl_ast_node *ast_node::release() {
   isl_ast_node *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_node::is_null() const {
   return ptr == nullptr;
 }
-ast_node::operator bool() const {
-  return !is_null();
-}
 
 
 ctx ast_node::get_ctx() const {
   return ctx(isl_ast_node_get_ctx(ptr));
 }
 std::string ast_node::to_str() const {
   char *Tmp = isl_ast_node_to_str(get());
   if (!Tmp)
__isl_give isl_ast_node_list *ast_node_list::release() {
   isl_ast_node_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool ast_node_list::is_null() const {
   return ptr == nullptr;
 }
-ast_node_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx ast_node_list::get_ctx() const {
   return ctx(isl_ast_node_list_get_ctx(ptr));
 }
 std::string ast_node_list::to_str() const {
   char *Tmp = isl_ast_node_list_to_str(get());
   if (!Tmp)
__isl_give isl_basic_map *basic_map::release() {
   isl_basic_map *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_map::is_null() const {
   return ptr == nullptr;
 }
-basic_map::operator bool() const {
-  return !is_null();
-}
 
 
 ctx basic_map::get_ctx() const {
   return ctx(isl_basic_map_get_ctx(ptr));
 }
 std::string basic_map::to_str() const {
   char *Tmp = isl_basic_map_to_str(get());
   if (!Tmp)
__isl_give isl_basic_map_list *basic_map_list::release() {
   isl_basic_map_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_map_list::is_null() const {
   return ptr == nullptr;
 }
-basic_map_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx basic_map_list::get_ctx() const {
   return ctx(isl_basic_map_list_get_ctx(ptr));
 }
 std::string basic_map_list::to_str() const {
   char *Tmp = isl_basic_map_list_to_str(get());
   if (!Tmp)
__isl_give isl_basic_set *basic_set::release() {
   isl_basic_set *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_set::is_null() const {
   return ptr == nullptr;
 }
-basic_set::operator bool() const {
-  return !is_null();
-}
 
 
 ctx basic_set::get_ctx() const {
   return ctx(isl_basic_set_get_ctx(ptr));
 }
 std::string basic_set::to_str() const {
   char *Tmp = isl_basic_set_to_str(get());
   if (!Tmp)
__isl_give isl_basic_set_list *basic_set_list::release() {
   isl_basic_set_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool basic_set_list::is_null() const {
   return ptr == nullptr;
 }
-basic_set_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx basic_set_list::get_ctx() const {
   return ctx(isl_basic_set_list_get_ctx(ptr));
 }
 std::string basic_set_list::to_str() const {
   char *Tmp = isl_basic_set_list_to_str(get());
   if (!Tmp)
__isl_give isl_constraint *constraint::release() {
   isl_constraint *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool constraint::is_null() const {
   return ptr == nullptr;
 }
-constraint::operator bool() const {
-  return !is_null();
-}
 
 
 ctx constraint::get_ctx() const {
   return ctx(isl_constraint_get_ctx(ptr));
 }
 
 void constraint::dump() const {
   isl_constraint_dump(get());
__isl_give isl_constraint_list *constraint_list::release() {
   isl_constraint_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool constraint_list::is_null() const {
   return ptr == nullptr;
 }
-constraint_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx constraint_list::get_ctx() const {
   return ctx(isl_constraint_list_get_ctx(ptr));
 }
 std::string constraint_list::to_str() const {
   char *Tmp = isl_constraint_list_to_str(get());
   if (!Tmp)
__isl_give isl_fixed_box *fixed_box::release() {
   isl_fixed_box *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool fixed_box::is_null() const {
   return ptr == nullptr;
 }
-fixed_box::operator bool() const {
-  return !is_null();
-}
 
 
 ctx fixed_box::get_ctx() const {
   return ctx(isl_fixed_box_get_ctx(ptr));
 }
 std::string fixed_box::to_str() const {
   char *Tmp = isl_fixed_box_to_str(get());
   if (!Tmp)
__isl_give isl_id *id::release() {
   isl_id *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool id::is_null() const {
   return ptr == nullptr;
 }
-id::operator bool() const {
-  return !is_null();
-}
 
 
 ctx id::get_ctx() const {
   return ctx(isl_id_get_ctx(ptr));
 }
 std::string id::to_str() const {
   char *Tmp = isl_id_to_str(get());
   if (!Tmp)
__isl_give isl_id_list *id_list::release() {
   isl_id_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool id_list::is_null() const {
   return ptr == nullptr;
 }
-id_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx id_list::get_ctx() const {
   return ctx(isl_id_list_get_ctx(ptr));
 }
 std::string id_list::to_str() const {
   char *Tmp = isl_id_list_to_str(get());
   if (!Tmp)
__isl_give isl_id_to_ast_expr *id_to_ast_expr::release() {
   isl_id_to_ast_expr *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool id_to_ast_expr::is_null() const {
   return ptr == nullptr;
 }
-id_to_ast_expr::operator bool() const {
-  return !is_null();
-}
 
 
 ctx id_to_ast_expr::get_ctx() const {
   return ctx(isl_id_to_ast_expr_get_ctx(ptr));
 }
 
 void id_to_ast_expr::dump() const {
   isl_id_to_ast_expr_dump(get());
__isl_give isl_local_space *local_space::release() {
   isl_local_space *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool local_space::is_null() const {
   return ptr == nullptr;
 }
-local_space::operator bool() const {
-  return !is_null();
-}
 
 
 ctx local_space::get_ctx() const {
   return ctx(isl_local_space_get_ctx(ptr));
 }
 
 void local_space::dump() const {
   isl_local_space_dump(get());
__isl_give isl_map *map::release() {
   isl_map *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool map::is_null() const {
   return ptr == nullptr;
 }
-map::operator bool() const {
-  return !is_null();
-}
 
 
 ctx map::get_ctx() const {
   return ctx(isl_map_get_ctx(ptr));
 }
 std::string map::to_str() const {
   char *Tmp = isl_map_to_str(get());
   if (!Tmp)
__isl_give isl_map_list *map_list::release() {
   isl_map_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool map_list::is_null() const {
   return ptr == nullptr;
 }
-map_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx map_list::get_ctx() const {
   return ctx(isl_map_list_get_ctx(ptr));
 }
 std::string map_list::to_str() const {
   char *Tmp = isl_map_list_to_str(get());
   if (!Tmp)
__isl_give isl_mat *mat::release() {
   isl_mat *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool mat::is_null() const {
   return ptr == nullptr;
 }
-mat::operator bool() const {
-  return !is_null();
-}
 
 
 ctx mat::get_ctx() const {
   return ctx(isl_mat_get_ctx(ptr));
 }
 
 void mat::dump() const {
   isl_mat_dump(get());
__isl_give isl_multi_aff *multi_aff::release() {
   isl_multi_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_aff::is_null() const {
   return ptr == nullptr;
 }
-multi_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx multi_aff::get_ctx() const {
   return ctx(isl_multi_aff_get_ctx(ptr));
 }
 std::string multi_aff::to_str() const {
   char *Tmp = isl_multi_aff_to_str(get());
   if (!Tmp)
__isl_give isl_multi_id *multi_id::release() {
   isl_multi_id *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_id::is_null() const {
   return ptr == nullptr;
 }
-multi_id::operator bool() const {
-  return !is_null();
-}
 
 
 ctx multi_id::get_ctx() const {
   return ctx(isl_multi_id_get_ctx(ptr));
 }
 std::string multi_id::to_str() const {
   char *Tmp = isl_multi_id_to_str(get());
   if (!Tmp)
__isl_give isl_multi_pw_aff *multi_pw_aff::release() {
   isl_multi_pw_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_pw_aff::is_null() const {
   return ptr == nullptr;
 }
-multi_pw_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx multi_pw_aff::get_ctx() const {
   return ctx(isl_multi_pw_aff_get_ctx(ptr));
 }
 std::string multi_pw_aff::to_str() const {
   char *Tmp = isl_multi_pw_aff_to_str(get());
   if (!Tmp)
__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::release() {
   isl_multi_union_pw_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
-multi_union_pw_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx multi_union_pw_aff::get_ctx() const {
   return ctx(isl_multi_union_pw_aff_get_ctx(ptr));
 }
 std::string multi_union_pw_aff::to_str() const {
   char *Tmp = isl_multi_union_pw_aff_to_str(get());
   if (!Tmp)
__isl_give isl_multi_val *multi_val::release() {
   isl_multi_val *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool multi_val::is_null() const {
   return ptr == nullptr;
 }
-multi_val::operator bool() const {
-  return !is_null();
-}
 
 
 ctx multi_val::get_ctx() const {
   return ctx(isl_multi_val_get_ctx(ptr));
 }
 std::string multi_val::to_str() const {
   char *Tmp = isl_multi_val_to_str(get());
   if (!Tmp)
__isl_give isl_point *point::release() {
   isl_point *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool point::is_null() const {
   return ptr == nullptr;
 }
-point::operator bool() const {
-  return !is_null();
-}
 
 
 ctx point::get_ctx() const {
   return ctx(isl_point_get_ctx(ptr));
 }
 std::string point::to_str() const {
   char *Tmp = isl_point_to_str(get());
   if (!Tmp)
__isl_give isl_pw_aff *pw_aff::release() {
   isl_pw_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_aff::is_null() const {
   return ptr == nullptr;
 }
-pw_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_aff::get_ctx() const {
   return ctx(isl_pw_aff_get_ctx(ptr));
 }
 std::string pw_aff::to_str() const {
   char *Tmp = isl_pw_aff_to_str(get());
   if (!Tmp)
__isl_give isl_pw_aff_list *pw_aff_list::release() {
   isl_pw_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
-pw_aff_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_aff_list::get_ctx() const {
   return ctx(isl_pw_aff_list_get_ctx(ptr));
 }
 std::string pw_aff_list::to_str() const {
   char *Tmp = isl_pw_aff_list_to_str(get());
   if (!Tmp)
__isl_give isl_pw_multi_aff *pw_multi_aff::release() {
   isl_pw_multi_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_multi_aff::is_null() const {
   return ptr == nullptr;
 }
-pw_multi_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_multi_aff::get_ctx() const {
   return ctx(isl_pw_multi_aff_get_ctx(ptr));
 }
 std::string pw_multi_aff::to_str() const {
   char *Tmp = isl_pw_multi_aff_to_str(get());
   if (!Tmp)
__isl_give isl_pw_multi_aff_list *pw_multi_aff_list::release() {
   isl_pw_multi_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_multi_aff_list::is_null() const {
   return ptr == nullptr;
 }
-pw_multi_aff_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_multi_aff_list::get_ctx() const {
   return ctx(isl_pw_multi_aff_list_get_ctx(ptr));
 }
 std::string pw_multi_aff_list::to_str() const {
   char *Tmp = isl_pw_multi_aff_list_to_str(get());
   if (!Tmp)
__isl_give isl_pw_qpolynomial *pw_qpolynomial::release() {
   isl_pw_qpolynomial *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_qpolynomial::is_null() const {
   return ptr == nullptr;
 }
-pw_qpolynomial::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_qpolynomial::get_ctx() const {
   return ctx(isl_pw_qpolynomial_get_ctx(ptr));
 }
 std::string pw_qpolynomial::to_str() const {
   char *Tmp = isl_pw_qpolynomial_to_str(get());
   if (!Tmp)
__isl_give isl_pw_qpolynomial_fold_list *pw_qpolynomial_fold_list::release() {
   isl_pw_qpolynomial_fold_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_qpolynomial_fold_list::is_null() const {
   return ptr == nullptr;
 }
-pw_qpolynomial_fold_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_qpolynomial_fold_list::get_ctx() const {
   return ctx(isl_pw_qpolynomial_fold_list_get_ctx(ptr));
 }
 std::string pw_qpolynomial_fold_list::to_str() const {
   char *Tmp = isl_pw_qpolynomial_fold_list_to_str(get());
   if (!Tmp)
__isl_give isl_pw_qpolynomial_list *pw_qpolynomial_list::release() {
   isl_pw_qpolynomial_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool pw_qpolynomial_list::is_null() const {
   return ptr == nullptr;
 }
-pw_qpolynomial_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx pw_qpolynomial_list::get_ctx() const {
   return ctx(isl_pw_qpolynomial_list_get_ctx(ptr));
 }
 std::string pw_qpolynomial_list::to_str() const {
   char *Tmp = isl_pw_qpolynomial_list_to_str(get());
   if (!Tmp)
__isl_give isl_qpolynomial *qpolynomial::release() {
   isl_qpolynomial *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool qpolynomial::is_null() const {
   return ptr == nullptr;
 }
-qpolynomial::operator bool() const {
-  return !is_null();
-}
 
 
 ctx qpolynomial::get_ctx() const {
   return ctx(isl_qpolynomial_get_ctx(ptr));
 }
 
 void qpolynomial::dump() const {
   isl_qpolynomial_dump(get());
__isl_give isl_qpolynomial_list *qpolynomial_list::release() {
   isl_qpolynomial_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool qpolynomial_list::is_null() const {
   return ptr == nullptr;
 }
-qpolynomial_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx qpolynomial_list::get_ctx() const {
   return ctx(isl_qpolynomial_list_get_ctx(ptr));
 }
 std::string qpolynomial_list::to_str() const {
   char *Tmp = isl_qpolynomial_list_to_str(get());
   if (!Tmp)
__isl_give isl_schedule *schedule::release() {
   isl_schedule *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule::is_null() const {
   return ptr == nullptr;
 }
-schedule::operator bool() const {
-  return !is_null();
-}
 
 
 ctx schedule::get_ctx() const {
   return ctx(isl_schedule_get_ctx(ptr));
 }
 std::string schedule::to_str() const {
   char *Tmp = isl_schedule_to_str(get());
   if (!Tmp)
__isl_give isl_schedule_constraints *schedule_constraints::release() {
   isl_schedule_constraints *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule_constraints::is_null() const {
   return ptr == nullptr;
 }
-schedule_constraints::operator bool() const {
-  return !is_null();
-}
 
 
 ctx schedule_constraints::get_ctx() const {
   return ctx(isl_schedule_constraints_get_ctx(ptr));
 }
 std::string schedule_constraints::to_str() const {
   char *Tmp = isl_schedule_constraints_to_str(get());
   if (!Tmp)
__isl_give isl_schedule_node *schedule_node::release() {
   isl_schedule_node *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool schedule_node::is_null() const {
   return ptr == nullptr;
 }
-schedule_node::operator bool() const {
-  return !is_null();
-}
 
 
 ctx schedule_node::get_ctx() const {
   return ctx(isl_schedule_node_get_ctx(ptr));
 }
 std::string schedule_node::to_str() const {
   char *Tmp = isl_schedule_node_to_str(get());
   if (!Tmp)
__isl_give isl_set *set::release() {
   isl_set *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool set::is_null() const {
   return ptr == nullptr;
 }
-set::operator bool() const {
-  return !is_null();
-}
 
 
 ctx set::get_ctx() const {
   return ctx(isl_set_get_ctx(ptr));
 }
 std::string set::to_str() const {
   char *Tmp = isl_set_to_str(get());
   if (!Tmp)
__isl_give isl_set_list *set_list::release() {
   isl_set_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool set_list::is_null() const {
   return ptr == nullptr;
 }
-set_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx set_list::get_ctx() const {
   return ctx(isl_set_list_get_ctx(ptr));
 }
 std::string set_list::to_str() const {
   char *Tmp = isl_set_list_to_str(get());
   if (!Tmp)
__isl_give isl_space *space::release() {
   isl_space *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool space::is_null() const {
   return ptr == nullptr;
 }
-space::operator bool() const {
-  return !is_null();
-}
 
 
 ctx space::get_ctx() const {
   return ctx(isl_space_get_ctx(ptr));
 }
 std::string space::to_str() const {
   char *Tmp = isl_space_to_str(get());
   if (!Tmp)
__isl_give isl_term *term::release() {
   isl_term *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool term::is_null() const {
   return ptr == nullptr;
 }
-term::operator bool() const {
-  return !is_null();
-}
 
 
 ctx term::get_ctx() const {
   return ctx(isl_term_get_ctx(ptr));
 }
 
 
 isl_size term::dim(isl::dim type) const
__isl_give isl_union_access_info *union_access_info::release() {
   isl_union_access_info *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_access_info::is_null() const {
   return ptr == nullptr;
 }
-union_access_info::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_access_info::get_ctx() const {
   return ctx(isl_union_access_info_get_ctx(ptr));
 }
 std::string union_access_info::to_str() const {
   char *Tmp = isl_union_access_info_to_str(get());
   if (!Tmp)
__isl_give isl_union_flow *union_flow::release() {
   isl_union_flow *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_flow::is_null() const {
   return ptr == nullptr;
 }
-union_flow::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_flow::get_ctx() const {
   return ctx(isl_union_flow_get_ctx(ptr));
 }
 std::string union_flow::to_str() const {
   char *Tmp = isl_union_flow_to_str(get());
   if (!Tmp)
__isl_give isl_union_map *union_map::release() {
   isl_union_map *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_map::is_null() const {
   return ptr == nullptr;
 }
-union_map::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_map::get_ctx() const {
   return ctx(isl_union_map_get_ctx(ptr));
 }
 std::string union_map::to_str() const {
   char *Tmp = isl_union_map_to_str(get());
   if (!Tmp)
__isl_give isl_union_map_list *union_map_list::release() {
   isl_union_map_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_map_list::is_null() const {
   return ptr == nullptr;
 }
-union_map_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_map_list::get_ctx() const {
   return ctx(isl_union_map_list_get_ctx(ptr));
 }
 std::string union_map_list::to_str() const {
   char *Tmp = isl_union_map_list_to_str(get());
   if (!Tmp)
__isl_give isl_union_pw_aff *union_pw_aff::release() {
   isl_union_pw_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_aff::is_null() const {
   return ptr == nullptr;
 }
-union_pw_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_pw_aff::get_ctx() const {
   return ctx(isl_union_pw_aff_get_ctx(ptr));
 }
 std::string union_pw_aff::to_str() const {
   char *Tmp = isl_union_pw_aff_to_str(get());
   if (!Tmp)
__isl_give isl_union_pw_aff_list *union_pw_aff_list::release() {
   isl_union_pw_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_aff_list::is_null() const {
   return ptr == nullptr;
 }
-union_pw_aff_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_pw_aff_list::get_ctx() const {
   return ctx(isl_union_pw_aff_list_get_ctx(ptr));
 }
 std::string union_pw_aff_list::to_str() const {
   char *Tmp = isl_union_pw_aff_list_to_str(get());
   if (!Tmp)
__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::release() {
   isl_union_pw_multi_aff *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_multi_aff::is_null() const {
   return ptr == nullptr;
 }
-union_pw_multi_aff::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_pw_multi_aff::get_ctx() const {
   return ctx(isl_union_pw_multi_aff_get_ctx(ptr));
 }
 std::string union_pw_multi_aff::to_str() const {
   char *Tmp = isl_union_pw_multi_aff_to_str(get());
   if (!Tmp)
__isl_give isl_union_pw_multi_aff_list *union_pw_multi_aff_list::release() {
   isl_union_pw_multi_aff_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_multi_aff_list::is_null() const {
   return ptr == nullptr;
 }
-union_pw_multi_aff_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_pw_multi_aff_list::get_ctx() const {
   return ctx(isl_union_pw_multi_aff_list_get_ctx(ptr));
 }
 std::string union_pw_multi_aff_list::to_str() const {
   char *Tmp = isl_union_pw_multi_aff_list_to_str(get());
   if (!Tmp)
__isl_give isl_union_pw_qpolynomial *union_pw_qpolynomial::release() {
   isl_union_pw_qpolynomial *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_pw_qpolynomial::is_null() const {
   return ptr == nullptr;
 }
-union_pw_qpolynomial::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_pw_qpolynomial::get_ctx() const {
   return ctx(isl_union_pw_qpolynomial_get_ctx(ptr));
 }
 std::string union_pw_qpolynomial::to_str() const {
   char *Tmp = isl_union_pw_qpolynomial_to_str(get());
   if (!Tmp)
__isl_give isl_union_set *union_set::release() {
   isl_union_set *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_set::is_null() const {
   return ptr == nullptr;
 }
-union_set::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_set::get_ctx() const {
   return ctx(isl_union_set_get_ctx(ptr));
 }
 std::string union_set::to_str() const {
   char *Tmp = isl_union_set_to_str(get());
   if (!Tmp)
__isl_give isl_union_set_list *union_set_list::release() {
   isl_union_set_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool union_set_list::is_null() const {
   return ptr == nullptr;
 }
-union_set_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx union_set_list::get_ctx() const {
   return ctx(isl_union_set_list_get_ctx(ptr));
 }
 std::string union_set_list::to_str() const {
   char *Tmp = isl_union_set_list_to_str(get());
   if (!Tmp)
__isl_give isl_val *val::release() {
   isl_val *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool val::is_null() const {
   return ptr == nullptr;
 }
-val::operator bool() const {
-  return !is_null();
-}
 
 
 ctx val::get_ctx() const {
   return ctx(isl_val_get_ctx(ptr));
 }
 std::string val::to_str() const {
   char *Tmp = isl_val_to_str(get());
   if (!Tmp)
__isl_give isl_val_list *val_list::release() {
   isl_val_list *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool val_list::is_null() const {
   return ptr == nullptr;
 }
-val_list::operator bool() const {
-  return !is_null();
-}
 
 
 ctx val_list::get_ctx() const {
   return ctx(isl_val_list_get_ctx(ptr));
 }
 std::string val_list::to_str() const {
   char *Tmp = isl_val_list_to_str(get());
   if (!Tmp)
__isl_give isl_vec *vec::release() {
   isl_vec *tmp = ptr;
   ptr = nullptr;
   return tmp;
 }
 
 bool vec::is_null() const {
   return ptr == nullptr;
 }
-vec::operator bool() const {
-  return !is_null();
-}
 
 
 ctx vec::get_ctx() const {
   return ctx(isl_vec_get_ctx(ptr));
 }
 
 void vec::dump() const {
   isl_vec_dump(get());

polly/lib/Support/ISLTools.cpp

 ///
 /// @param FromSpace1 { Space1[] }
 /// @param FromSpace2 { Space2[] }
 ///
 /// @return { [Space1[] -> Space2[]] -> [Space2[] -> Space1[]] }
 isl::basic_map makeTupleSwapBasicMap(isl::space FromSpace1,
                                      isl::space FromSpace2) {
   // Fast-path on out-of-quota.
-  if (!FromSpace1 || !FromSpace2)
+  if (FromSpace1.is_null() || FromSpace2.is_null())
     return {};
 
   assert(FromSpace1.is_set());
   assert(FromSpace2.is_set());
 
   unsigned Dims1 = FromSpace1.dim(isl::dim::set);
   unsigned Dims2 = FromSpace2.dim(isl::dim::set);
 
isl::union_map polly::betweenScatter(isl::union_map From, isl::union_map To,
                                      bool InclFrom, bool InclTo) {
   isl::union_map AfterFrom = afterScatter(From, !InclFrom);
   isl::union_map BeforeTo = beforeScatter(To, !InclTo);
 
   return AfterFrom.intersect(BeforeTo);
 }
 
 isl::map polly::singleton(isl::union_map UMap, isl::space ExpectedSpace) {
-  if (!UMap)
+  if (UMap.is_null())
     return {};
 
   if (isl_union_map_n_map(UMap.get()) == 0)
     return isl::map::empty(ExpectedSpace);
 
   isl::map Result = isl::map::from_union_map(UMap);
-  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
+  assert(Result.is_null() ||
+         Result.get_space().has_equal_tuples(ExpectedSpace));
 
   return Result;
 }
 
 isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
-  if (!USet)
+  if (USet.is_null())
     return {};
 
   if (isl_union_set_n_set(USet.get()) == 0)
     return isl::set::empty(ExpectedSpace);
 
   isl::set Result(USet);
-  assert(!Result || Result.get_space().has_equal_tuples(ExpectedSpace));
+  assert(Result.is_null() ||
+         Result.get_space().has_equal_tuples(ExpectedSpace));
 
   return Result;
 }
 
 isl_size polly::getNumScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
-    if (!Map)
+    if (Map.is_null())
       continue;
 
     Dims = std::max(Dims, Map.dim(isl::dim::out));
   }
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
-  if (!Schedule)
+  if (Schedule.is_null())
     return {};
   unsigned Dims = getNumScatterDims(Schedule);
   isl::space ScatterSpace = Schedule.get_space().set_from_params();
   return ScatterSpace.add_dims(isl::dim::set, Dims);
 }
 
 isl::union_map polly::makeIdentityMap(const isl::union_set &USet,
                                       bool RestrictDomain) {

 
 isl::map polly::distributeDomain(isl::map Map) {
   // Note that we cannot take Map apart into { Domain[] -> Range1[] } and {
   // Domain[] -> Range2[] } and combine again. We would loose any relation
   // between Range1[] and Range2[] that is not also a constraint to Domain[].
 
   isl::space Space = Map.get_space();
   isl::space DomainSpace = Space.domain();
-  if (!DomainSpace)
+  if (DomainSpace.is_null())
     return {};
   unsigned DomainDims = DomainSpace.dim(isl::dim::set);
   isl::space RangeSpace = Space.range().unwrap();
   isl::space Range1Space = RangeSpace.domain();
-  if (!Range1Space)
+  if (Range1Space.is_null())
     return {};
   unsigned Range1Dims = Range1Space.dim(isl::dim::set);
   isl::space Range2Space = RangeSpace.range();
-  if (!Range2Space)
+  if (Range2Space.is_null())
     return {};
   unsigned Range2Dims = Range2Space.dim(isl::dim::set);
 
   isl::space OutputSpace =
       DomainSpace.map_from_domain_and_range(Range1Space)
           .wrap()
           .map_from_domain_and_range(
               DomainSpace.map_from_domain_and_range(Range2Space).wrap());
isl::set polly::subtractParams(isl::set Set, isl::set Params) {
   return Set.subtract(ParamsSet);
 }
 
 isl::val polly::getConstant(isl::pw_aff PwAff, bool Max, bool Min) {
   assert(!Max || !Min); // Cannot return min and max at the same time.
   isl::val Result;
   isl::stat Stat = PwAff.foreach_piece(
       [=, &Result](isl::set Set, isl::aff Aff) -> isl::stat {
-        if (Result && Result.is_nan())
+        if (!Result.is_null() && Result.is_nan())
           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();
         }
 
         isl::val ThisVal = Aff.get_constant_val();
-        if (!Result) {
+        if (Result.is_null()) {
           Result = ThisVal;
           return isl::stat::ok();
         }
 
         if (Result.eq(ThisVal))
           return isl::stat::ok();
 
         if (Max && ThisVal.gt(Result)) {

 
 /// Determine the sorting order of the sets @p A and @p B without considering
 /// the space structure.
 ///
 /// Ordering is based on the lower bounds of the set's dimensions. First
 /// dimensions are considered first.
 static int flatCompare(const isl::basic_set &A, const isl::basic_set &B) {
   // Quick bail-out on out-of-quota.
-  if (!A || !B)
+  if (A.is_null() || B.is_null())
     return 0;
 
   unsigned ALen = A.dim(isl::dim::set);
   unsigned BLen = B.dim(isl::dim::set);
   unsigned Len = std::min(ALen, BLen);
 
   for (unsigned i = 0; i < Len; i += 1) {
     isl::basic_set ADim =

 ///
 /// @param USet     Polyhedra to print.
 /// @param OS       Target stream.
 /// @param Simplify Whether to simplify the polyhedron before printing.
 /// @param IsMap    Whether @p USet is a wrapped map. If true, sets are
 ///                 unwrapped before printing to again appear as a map.
 static void printSortedPolyhedra(isl::union_set USet, llvm::raw_ostream &OS,
                                  bool Simplify, bool IsMap) {
-  if (!USet) {
+  if (USet.is_null()) {
     OS << "<null>\n";
     return;
   }
 
   if (Simplify)
     simplify(USet);
 
   // Get all the polyhedra.

polly/lib/Support/SCEVAffinator.cpp

if (NAry->getNoWrapFlags() & SCEV::FlagNSW)
       return false;
   return Width <= MaxSmallBitWidth;
 }
 
 PWACtx SCEVAffinator::visit(const SCEV *Expr) {
 
   auto Key = std::make_pair(Expr, BB);
   PWACtx PWAC = CachedExpressions[Key];
-  if (PWAC.first)
+  if (!PWAC.first.is_null())
     return PWAC;
 
   auto ConstantAndLeftOverPair = extractConstantFactor(Expr, SE);
   auto *Factor = ConstantAndLeftOverPair.first;
   Expr = ConstantAndLeftOverPair.second;
 
   auto *Scope = getScope();
   S->addParams(getParamsInAffineExpr(&S->getRegion(), Scope, Expr, SE));

polly/lib/Transform/DeLICM.cpp

private:
   /// Written values that cannot be identified are represented by an unknown
   /// ValInst[] (an unnamed tuple of 0 dimension). It conflicts with itself.
   isl::union_map Written;
 
   /// Check whether this Knowledge object is well-formed.
   void checkConsistency() const {
 #ifndef NDEBUG
     // Default-initialized object
-    if (!Occupied && !Unused && !Known && !Written)
+    if (Occupied.is_null() && Unused.is_null() && Known.is_null() &&
+        Written.is_null())
       return;
 
-    assert(Occupied || Unused);
-    assert(Known);
-    assert(Written);
+    assert(!Occupied.is_null() || !Unused.is_null());
+    assert(!Known.is_null());
+    assert(!Written.is_null());
 
     // If not all fields are defined, we cannot derived the universe.
-    if (!Occupied || !Unused)
+    if (Occupied.is_null() || Unused.is_null())
       return;
 
     assert(Occupied.is_disjoint(Unused));
     auto Universe = Occupied.unite(Unused);
 
     assert(!Known.domain().is_subset(Universe).is_false());
     assert(!Written.domain().is_subset(Universe).is_false());
 #endif
   }
 
 public:
   /// Initialize a nullptr-Knowledge. This is only provided for convenience; do
   /// not use such an object.
   Knowledge() {}
 
   /// Create a new object with the given members.
   Knowledge(isl::union_set Occupied, isl::union_set Unused,
             isl::union_map Known, isl::union_map Written)
       : Occupied(std::move(Occupied)), Unused(std::move(Unused)),
         Known(std::move(Known)), Written(std::move(Written)) {
     checkConsistency();
   }
 
   /// Return whether this object was not default-constructed.
-  bool isUsable() const { return (Occupied || Unused) && Known && Written; }
+  bool isUsable() const {
+    return (Occupied.is_null() || Unused.is_null()) && !Known.is_null() &&
+           !Written.is_null();
+  }
 
   /// Print the content of this object to @p OS.
   void print(llvm::raw_ostream &OS, unsigned Indent = 0) const {
     if (isUsable()) {
-      if (Occupied)
+      if (!Occupied.is_null())
         OS.indent(Indent) << "Occupied: " << Occupied << "\n";
       else
         OS.indent(Indent) << "Occupied: <Everything else not in Unused>\n";
-      if (Unused)
+      if (!Unused.is_null())
         OS.indent(Indent) << "Unused:   " << Unused << "\n";
       else
         OS.indent(Indent) << "Unused:   <Everything else not in Occupied>\n";
       OS.indent(Indent) << "Known:    " << Known << "\n";
       OS.indent(Indent) << "Written : " << Written << '\n';
     } else {
       OS.indent(Indent) << "Invalid knowledge\n";
     }
   }
 
   /// Combine two knowledges, this and @p That.
   void learnFrom(Knowledge That) {
     assert(!isConflicting(*this, That));
-    assert(Unused && That.Occupied);
+    assert(!Unused.is_null() && !That.Occupied.is_null());
     assert(
-        !That.Unused &&
+        That.Unused.is_null() &&
         "This function is only prepared to learn occupied elements from That");
-    assert(!Occupied && "This function does not implement "
+    assert(Occupied.is_null() && "This function does not implement "
                                  "`this->Occupied = "
                                  "this->Occupied.unite(That.Occupied);`");
 
     Unused = Unused.subtract(That.Occupied);
     Known = Known.unite(That.Known);
     Written = Written.unite(That.Written);
 
     checkConsistency();
   }
 
public:
   ///                 nullptr to not output anything.
   /// @param Indent   Indention for the conflict reason.
   ///
   /// @return True, iff the two knowledges are conflicting.
   static bool isConflicting(const Knowledge &Existing,
                             const Knowledge &Proposed,
                             llvm::raw_ostream *OS = nullptr,
                             unsigned Indent = 0) {
-    assert(Existing.Unused);
-    assert(Proposed.Occupied);
+    assert(!Existing.Unused.is_null());
+    assert(!Proposed.Occupied.is_null());
 
 #ifndef NDEBUG
-    if (Existing.Occupied && Proposed.Unused) {
+    if (!Existing.Occupied.is_null() && !Proposed.Unused.is_null()) {
       auto ExistingUniverse = Existing.Occupied.unite(Existing.Unused);
       auto ProposedUniverse = Proposed.Occupied.unite(Proposed.Unused);
       assert(ExistingUniverse.is_equal(ProposedUniverse) &&
              "Both inputs' Knowledges must be over the same universe");
     }
 #endif
 
     // Do the Existing and Proposed lifetimes conflict?
if (!OrigDomain.is_subset(MappedDomain)) {
       LLVM_DEBUG(
           dbgs()
           << "    Reject because mapping does not encompass all instances\n");
       return false;
     }
 
     // { DomainRead[] -> DomainWrite[] }
     auto PerPHIWrites = computePerPHI(SAI);
-    if (!PerPHIWrites) {
+    if (PerPHIWrites.is_null()) {
       LLVM_DEBUG(
           dbgs() << "    Reject because cannot determine incoming values\n");
       return false;
     }
 
     // { DomainWrite[] -> Element[] }
     auto WritesTarget = PerPHIWrites.apply_domain(PHITarget).reverse();
     simplify(WritesTarget);
isl::union_map EltKnown, EltWritten;
       computeCommon();
 
       EltUnused = computeLifetime();
       EltKnown = computeKnown(true, false);
       EltWritten = computeWritten();
     }
     DeLICMAnalyzed++;
 
-    if (!EltUnused || !EltKnown || !EltWritten) {
+    if (EltUnused.is_null() || EltKnown.is_null() || EltWritten.is_null()) {
       assert(isl_ctx_last_error(IslCtx.get()) == isl_error_quota &&
              "The only reason that these things have not been computed should "
              "be if the max-operations limit hit");
       DeLICMOutOfQuota++;
       LLVM_DEBUG(dbgs() << "DeLICM analysis exceeded max_operations\n");
       DebugLoc Begin, End;
       getDebugLocations(getBBPairForRegion(&S->getRegion()), Begin, End);
       OptimizationRemarkAnalysis R(DEBUG_TYPE, "OutOfQuota", Begin,

polly/lib/Transform/FlattenAlgo.cpp

bool isDimBoundedByParameter(isl::set Set, unsigned dim) {
   auto SetDims = Set.dim(isl::dim::set);
   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   return bool(Set.is_bounded());
 }
 
 /// 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();
+  return FixedVal.is_null() || FixedVal.is_nan();
 }
 
 /// Whether Map's first out dimension is no constant nor piecewise constant.
 bool isVariableDim(const isl::map &Map) {
   for (isl::basic_map BMap : Map.get_basic_map_list())
     if (isVariableDim(BMap))
       return false;
 

 /// 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.
 isl_size scheduleScatterDims(const isl::union_map &Schedule) {
   isl_size Dims = 0;
   for (isl::map Map : Schedule.get_map_list()) {
-    if (!Map)
+    if (Map.is_null())
       continue;
 
     Dims = std::max(Dims, Map.dim(isl::dim::out));
   }
   return Dims;
 }
 
 /// Return the @p pos' range dimension, converted to an isl_union_pw_aff.
isl::union_map tryFlattenLoop(isl::union_map Schedule) {
 
   auto Min = SubExtent.dim_min(0);
   LLVM_DEBUG(dbgs() << "Min bound:\n  " << Min << "\n");
   auto MinVal = getConstant(Min, false, true);
   auto Max = SubExtent.dim_max(0);
   LLVM_DEBUG(dbgs() << "Max bound:\n  " << Max << "\n");
   auto MaxVal = getConstant(Max, true, false);
 
-  if (!MinVal || !MaxVal || MinVal.is_nan() || MaxVal.is_nan()) {
+  if (MinVal.is_null() || MaxVal.is_null() || MinVal.is_nan() ||
+      MaxVal.is_nan()) {
     LLVM_DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
     return {};
   }
 
   auto FirstSubScheduleAff = scheduleExtractDimAff(SubSchedule, 0);
   auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
 
   auto LenVal = MaxVal.sub(MinVal).add_ui(1);
isl::union_map polly::flattenSchedule(isl::union_map Schedule) {
   // Base case; already one-dimensional
   if (Dims == 1)
     return Schedule;
 
   // Fixed dimension; no need to preserve variabledness.
   if (!isVariableDim(Schedule)) {
     LLVM_DEBUG(dbgs() << "Fixed dimension; try sequence flattening\n");
     auto NewScheduleSequence = tryFlattenSequence(Schedule);
-    if (NewScheduleSequence)
+    if (!NewScheduleSequence.is_null())
       return NewScheduleSequence;
   }
 
   // Constant stride
   LLVM_DEBUG(dbgs() << "Try loop flattening\n");
   auto NewScheduleLoop = tryFlattenLoop(Schedule);
-  if (NewScheduleLoop)
+  if (!NewScheduleLoop.is_null())
     return NewScheduleLoop;
 
   // Try again without loop condition (may blow up the number of pieces!!)
   LLVM_DEBUG(dbgs() << "Try sequence flattening again\n");
   auto NewScheduleSequence = tryFlattenSequence(Schedule);
-  if (NewScheduleSequence)
+  if (!NewScheduleSequence.is_null())
     return NewScheduleSequence;
 
   // Cannot flatten
   return Schedule;
 }

polly/lib/Transform/ForwardOpTree.cpp

collectCompatibleElts();
       if (NormalizePHIs)
         computeNormalizedPHIs();
       Known = computeKnown(true, true);
 
       // Preexisting ValInsts use the known content analysis of themselves.
       Translator = makeIdentityMap(Known.range(), false);
     }
 
-    if (!Known || !Translator || !NormalizeMap) {
+    if (Known.is_null() || Translator.is_null() || NormalizeMap.is_null()) {
       assert(isl_ctx_last_error(IslCtx.get()) == isl_error_quota);
       Known = {};
       Translator = {};
       NormalizeMap = {};
       LLVM_DEBUG(dbgs() << "Known analysis exceeded max_operations\n");
       return false;
     }
 
ForwardingAction forwardKnownLoad(ScopStmt *TargetStmt, Instruction *Inst,
     isl::map TargetExpectedVal = ExpectedVal.apply_domain(UseToTarget);
     isl::union_map TranslatedExpectedVal =
         isl::union_map(TargetExpectedVal).apply_range(Translator);
 
     // { DomainTarget[] -> Element[] }
     isl::union_map Candidates = findSameContentElements(TranslatedExpectedVal);
 
     isl::map SameVal = singleLocation(Candidates, getDomainFor(TargetStmt));
-    if (!SameVal)
+    if (SameVal.is_null())
       return ForwardingAction::notApplicable();
 
     LLVM_DEBUG(dbgs() << "      expected values where " << TargetExpectedVal
                       << "\n");
     LLVM_DEBUG(dbgs() << "      candidate elements where " << Candidates
                       << "\n");
 
     // { ValInst[] }
if (!ValInstSpace.is_wrapping().is_false()) {
       // { DomainDef[] -> DomainTarget[] }
       isl::map DefToTarget = getDefToTarget(DefStmt, TargetStmt);
 
       // { [TargetDomain[] -> Value[]] -> [DefDomain[] -> Value] }
       LocalTranslator = DefToTarget.reverse().product(ValToVal);
       LLVM_DEBUG(dbgs() << "      local translator is " << LocalTranslator
                         << "\n");
 
-      if (!LocalTranslator)
+      if (LocalTranslator.is_null())
         return ForwardingAction::notApplicable();
     }
 
     auto ExecAction = [this, TargetStmt, LI, SameVal,
                        LocalTranslator]() -> bool {
       TargetStmt->prependInstruction(LI);
       MemoryAccess *Access = makeReadArrayAccess(TargetStmt, LI, SameVal);
       LLVM_DEBUG(dbgs() << "    forwarded known load with new MemoryAccess"
                         << Access << "\n");
       (void)Access;
 
-      if (LocalTranslator)
+      if (!LocalTranslator.is_null())
         Translator = Translator.add_map(LocalTranslator);
 
       NumKnownLoadsForwarded++;
       TotalKnownLoadsForwarded++;
       return true;
     };
     return ForwardingAction::canForward(
         ExecAction, {{LI->getPointerOperand(), DefStmt}}, true);
ForwardingAction reloadKnownContent(ScopStmt *TargetStmt, Instruction *Inst,
     isl::union_map TranslatedExpectedVal =
         TargetExpectedVal.apply_range(Translator);
 
     // { DomainTarget[] -> Element[] }
     isl::union_map Candidates = findSameContentElements(TranslatedExpectedVal);
 
     isl::map SameVal = singleLocation(Candidates, getDomainFor(TargetStmt));
     simplify(SameVal);
-    if (!SameVal)
+    if (SameVal.is_null())
       return ForwardingAction::notApplicable();
 
     auto ExecAction = [this, TargetStmt, Inst, SameVal]() {
       MemoryAccess *Access = TargetStmt->lookupInputAccessOf(Inst);
       if (!Access)
         Access = TargetStmt->ensureValueRead(Inst);
       Access->setNewAccessRelation(SameVal);
 

polly/lib/Transform/ManualOptimizer.cpp

 
 /// Apply full or partial unrolling.
 static isl::schedule applyLoopUnroll(MDNode *LoopMD,
                                      isl::schedule_node BandToUnroll) {
   TransformationMode UnrollMode = ::hasUnrollTransformation(LoopMD);
   if (UnrollMode & TM_Disable)
     return {};
 
-  assert(BandToUnroll);
+  assert(!BandToUnroll.is_null());
   // TODO: Isl's codegen also supports unrolling by isl_ast_build via
   // isl_schedule_node_band_set_ast_build_options({ unroll[x] }) which would be
   // more efficient because the content duplication is delayed. However, the
   // unrolled loop could be input of another loop transformation which expects
   // the explicit schedule nodes. That is, we would need this explicit expansion
   // anyway and using the ISL codegen option is a compile-time optimization.
   int64_t Factor = getOptionalIntLoopAttribute(LoopMD, "llvm.loop.unroll.count")
                        .getValueOr(0);
static isl::schedule applyOneTransformation(const isl::schedule &Sched) {
     SearchTransformVisitor Transformer;
     Transformer.visit(Sched);
     return Transformer.Result;
   }
 
   void visitBand(const isl::schedule_node &Band) {
     // Transform inner loops first (depth-first search).
     getBase().visitBand(Band);
-    if (Result)
+    if (!Result.is_null())
       return;
 
     // Since it is (currently) not possible to have a BandAttr marker that is
     // specific to each loop in a band, we only support single-loop bands.
     if (isl_schedule_node_band_n_member(Band.get()) != 1)
       return;
 
     BandAttr *Attr = getBandAttr(Band);
for (MDNode *MD : getLoopMDProps(LoopMD)) {
       StringRef AttrName = NameMD->getString();
 
       // Honor transformation order; transform the first transformation in the
       // list first.
       if (AttrName == "llvm.loop.unroll.enable" ||
           AttrName == "llvm.loop.unroll.count" ||
           AttrName == "llvm.loop.unroll.full") {
         Result = applyLoopUnroll(LoopMD, Band);
-        if (Result)
+        if (!Result.is_null())
           return;
       }
 
       // not a loop transformation; look for next property
       continue;
     }
   }
 
   void visitNode(const isl::schedule_node &Other) {
-    if (Result)
+    if (!Result.is_null())
       return;
     getBase().visitNode(Other);
   }
 };
 
 } // namespace
 
 isl::schedule polly::applyManualTransformations(Scop *S, isl::schedule Sched) {
   // Search the loop nest for transformations until fixpoint.
   while (true) {
     isl::schedule Result =
         SearchTransformVisitor::applyOneTransformation(Sched);
-    if (!Result) {
+    if (Result.is_null()) {
       // No (more) transformation has been found.
       break;
     }
 
     // Use transformed schedule and look for more transformations.
     Sched = Result;
   }
 
   return Sched;
 }

polly/lib/Transform/MatmulOptimizer.cpp

static isl::map permuteDimensions(isl::map Map, isl::dim DimType,
   if (Map.has_tuple_id(FreeDim))
     FreeDimId = Map.get_tuple_id(FreeDim);
   auto MaxDim = std::max(DstPos, SrcPos);
   auto MinDim = std::min(DstPos, SrcPos);
   Map = Map.move_dims(FreeDim, 0, DimType, MaxDim, 1);
   Map = Map.move_dims(FreeDim, 0, DimType, MinDim, 1);
   Map = Map.move_dims(DimType, MinDim, FreeDim, 1, 1);
   Map = Map.move_dims(DimType, MaxDim, FreeDim, 0, 1);
-  if (DimId)
+  if (!DimId.is_null())
     Map = Map.set_tuple_id(DimType, DimId);
-  if (FreeDimId)
+  if (!FreeDimId.is_null())
     Map = Map.set_tuple_id(FreeDim, FreeDimId);
   return Map;
 }
 
 /// Check the form of the access relation.
 ///
 /// Check that the access relation @p AccMap has the form M[i][j], where i
 /// is a @p FirstPos and j is a @p SecondPos.

 ///             In case it has a negative value, try to determine its
 ///             acceptable value.
 /// @return True in case dependencies correspond to the matrix multiplication
 ///         and false, otherwise.
 static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
                                   int &Pos) {
   isl::union_map Dep = D->getDependences(Dependences::TYPE_RAW);
   isl::union_map Red = D->getDependences(Dependences::TYPE_RED);
-  if (Red)
+  if (!Red.is_null())
     Dep = Dep.unite(Red);
   auto DomainSpace = Schedule.get_space().domain();
   auto Space = DomainSpace.map_from_domain_and_range(DomainSpace);
   auto Deltas = Dep.extract_map(Space).deltas();
   isl_size DeltasDimNum = Deltas.dim(isl::dim::set);
   for (int i = 0; i < DeltasDimNum; i++) {
     auto Val = Deltas.plain_get_val_if_fixed(isl::dim::set, i);
     Pos = Pos < 0 && Val.is_one() ? i : Pos;
static isl::schedule_node optimizeMatMulPattern(isl::schedule_node Node,
   auto MacroKernelParams = getMacroKernelParams(TTI, MicroKernelParams, MMI);
   Node = createMacroKernel(Node, MacroKernelParams);
   Node = createMicroKernel(Node, MicroKernelParams);
   if (MacroKernelParams.Mc == 1 || MacroKernelParams.Nc == 1 ||
       MacroKernelParams.Kc == 1)
     return Node;
   auto MapOldIndVar = getInductionVariablesSubstitution(Node, MicroKernelParams,
                                                         MacroKernelParams);
-  if (!MapOldIndVar)
+  if (MapOldIndVar.is_null())
     return Node;
   Node = markLoopVectorizerDisabled(Node.parent()).child(0);
   Node = isolateAndUnrollMatMulInnerLoops(Node, MicroKernelParams);
   return optimizeDataLayoutMatrMulPattern(Node, MapOldIndVar, MicroKernelParams,
                                           MacroKernelParams, MMI);
 }
 
 /// Check if this node contains a partial schedule that could

polly/lib/Transform/ScheduleOptimizer.cpp

ScheduleTreeOptimizer::optimizeBand(__isl_take isl_schedule_node *Node,
                                     void *User) {
   if (!isTileableBandNode(isl::manage_copy(Node)))
     return Node;
 
   const OptimizerAdditionalInfoTy *OAI =
       static_cast<const OptimizerAdditionalInfoTy *>(User);
 
   if (PMBasedOpts && User) {
-    if (isl::schedule_node PatternOptimizedSchedule = tryOptimizeMatMulPattern(
-            isl::manage_copy(Node), OAI->TTI, OAI->D)) {
+    isl::schedule_node PatternOptimizedSchedule =
+        tryOptimizeMatMulPattern(isl::manage_copy(Node), OAI->TTI, OAI->D);
+    if (!PatternOptimizedSchedule.is_null()) {
       MatMulOpts++;
       isl_schedule_node_free(Node);
       return PatternOptimizedSchedule.release();
     }
   }
 
   return standardBandOpts(isl::manage(Node), User).release();
 }
bool ScheduleTreeOptimizer::isProfitableSchedule(Scop &S,
   // transformations have been performed. This can e.g. be tiling, loop
   // interchange, or ...) We can track this either at the place where the
   // transformation has been performed or, in case of automatic ILP based
   // optimizations, by comparing (yet to be defined) performance metrics
   // before/after the scheduling optimizer
   // (e.g., #stride-one accesses)
   auto NewScheduleMap = NewSchedule.get_map();
   auto OldSchedule = S.getSchedule();
-  assert(OldSchedule && "Only IslScheduleOptimizer can insert extension nodes "
-                        "that make Scop::getSchedule() return nullptr.");
+  assert(!OldSchedule.is_null() &&
+         "Only IslScheduleOptimizer can insert extension nodes "
   bool changed = !OldSchedule.is_equal(NewScheduleMap);
   return changed;
 }
 
 class IslScheduleOptimizerWrapperPass : public ScopPass {
 public:
   static char ID;
 

 /// ignored.
 /// @param Version  The version of the schedule tree that is analyzed.
 ///                 0 for the original schedule tree before any transformation.
 ///                 1 for the schedule tree after isl's rescheduling.
 ///                 2 for the schedule tree after optimizations are applied
 ///                 (tiling, pattern matching)
 static void walkScheduleTreeForStatistics(isl::schedule Schedule, int Version) {
   auto Root = Schedule.get_root();
-  if (!Root)
+  if (Root.is_null())
     return;
 
   isl_schedule_node_foreach_descendant_top_down(
       Root.get(),
       [](__isl_keep isl_schedule_node *nodeptr, void *user) -> isl_bool {
         isl::schedule_node Node = isl::manage_copy(nodeptr);
         int Version = *static_cast<int *>(user);
 
static bool runIslScheduleOptimizer(
   isl::schedule Schedule = S.getScheduleTree();
   walkScheduleTreeForStatistics(S.getScheduleTree(), 0);
   LLVM_DEBUG(printSchedule(dbgs(), Schedule, "Original schedule tree"));
 
   bool HasUserTransformation = false;
   if (PragmaBasedOpts) {
     isl::schedule ManuallyTransformed =
         applyManualTransformations(&S, Schedule);
-    if (!ManuallyTransformed) {
+    if (ManuallyTransformed.is_null()) {
       LLVM_DEBUG(dbgs() << "Error during manual optimization\n");
       return false;
     }
 
     if (ManuallyTransformed.get() != Schedule.get()) {
       // User transformations have precedence over other transformations.
       HasUserTransformation = true;
       Schedule = std::move(ManuallyTransformed);
else {
       errs() << "Do not know how to optimize for '" << OptimizeDeps << "'"
              << " Falling back to optimizing all dependences.\n";
       ProximityKinds =
           Dependences::TYPE_RAW | Dependences::TYPE_WAR | Dependences::TYPE_WAW;
     }
 
     isl::union_set Domain = S.getDomains();
 
-    if (!Domain)
+    if (Domain.is_null())
       return false;
 
     isl::union_map Validity = D.getDependences(ValidityKinds);
     isl::union_map Proximity = D.getDependences(ProximityKinds);
 
     // Simplify the dependences by removing the constraints introduced by the
     // domains. This can speed up the scheduling time significantly, as large
     // constant coefficients will be removed from the dependences. The
if (HasUserTransformation) {
     ScopsRescheduled++;
     LLVM_DEBUG(printSchedule(dbgs(), Schedule, "After rescheduling"));
   }
 
   walkScheduleTreeForStatistics(Schedule, 1);
 
   // In cases the scheduler is not able to optimize the code, we just do not
   // touch the schedule.
-  if (!Schedule)
+  if (Schedule.is_null())
     return false;
 
   // Apply post-rescheduling optimizations.
   const OptimizerAdditionalInfoTy OAI = {TTI, const_cast<Dependences *>(&D)};
   Schedule = ScheduleTreeOptimizer::optimizeSchedule(Schedule, &OAI);
   Schedule = hoistExtensionNodes(Schedule);
   LLVM_DEBUG(printSchedule(dbgs(), Schedule, "After post-optimizations"));
   walkScheduleTreeForStatistics(Schedule, 2);

 
 static void runScheduleOptimizerPrinter(raw_ostream &OS,
                                         isl::schedule LastSchedule) {
   isl_printer *p;
   char *ScheduleStr;
 
   OS << "Calculated schedule:\n";
 
-  if (!LastSchedule) {
+  if (LastSchedule.is_null()) {
     OS << "n/a\n";
     return;
   }
 
   p = isl_printer_to_str(LastSchedule.get_ctx().get());
   p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
   p = isl_printer_print_schedule(p, LastSchedule.get());
   ScheduleStr = isl_printer_get_str(p);

polly/lib/Transform/ScheduleTreeTransform.cpp

using BaseTy = ScheduleTreeRewriter<ExtensionNodeRewriter,
                                       const isl::union_set &, isl::union_map &>;
   BaseTy &getBase() { return *this; }
   const BaseTy &getBase() const { return *this; }
 
   isl::schedule visitSchedule(const isl::schedule &Schedule) {
     isl::union_map Extensions;
     isl::schedule Result =
         visit(Schedule.get_root(), Schedule.get_domain(), Extensions);
-    assert(Extensions && Extensions.is_empty());
+    assert(!Extensions.is_null() && Extensions.is_empty());
     return Result;
   }
 
   isl::schedule visitSequence(const isl::schedule_node &Sequence,
                               const isl::union_set &Domain,
                               isl::union_map &Extensions) {
     int NumChildren = isl_schedule_node_n_children(Sequence.get());
     isl::schedule NewNode = visit(Sequence.first_child(), Domain, Extensions);
isl::schedule_node NewLoop =
       Body.insert_partial_schedule(StridedPartialSchedUAff);
 
   MDNode *FollowupMD = nullptr;
   if (Attr && Attr->Metadata)
     FollowupMD =
         findOptionalNodeOperand(Attr->Metadata, LLVMLoopUnrollFollowupUnrolled);
 
   isl::id NewBandId = createGeneratedLoopAttr(Ctx, FollowupMD);
-  if (NewBandId)
+  if (!NewBandId.is_null())
     NewLoop = insertMark(NewLoop, NewBandId);
 
   return NewLoop.get_schedule();
 }
 
 isl::set polly::getPartialTilePrefixes(isl::set ScheduleRange,
                                        int VectorWidth) {
   isl_size Dims = ScheduleRange.dim(isl::dim::set);

polly/lib/Transform/ZoneAlgo.cpp

void ZoneAlgorithm::addArrayWriteAccess(MemoryAccess *MA) {
   if (MA->isMustWrite())
     AllMustWrites = AllMustWrites.add_map(AccRel);
 
   if (MA->isMayWrite())
     AllMayWrites = AllMayWrites.add_map(AccRel);
 
   // { Domain[] -> ValInst[] }
   isl::union_map WriteValInstance = getWrittenValue(MA, AccRel);
-  if (!WriteValInstance)
+  if (WriteValInstance.is_null())
     WriteValInstance = makeUnknownForDomain(Stmt);
 
   // { Domain[] -> [Element[] -> Domain[]] }
   isl::map IncludeElement = AccRel.domain_map().curry();
 
   // { [Element[] -> DomainWrite[]] -> ValInst[] }
   isl::union_map EltWriteValInst =
       WriteValInstance.apply_domain(IncludeElement);
isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
   auto It = PerPHIMaps.find(PHI);
   if (It != PerPHIMaps.end())
     return It->second;
 
   // Cannot reliably compute immediate predecessor for undefined executions, so
   // bail out if we do not know. This in particular applies to undefined control
   // flow.
   isl::set DefinedContext = S->getDefinedBehaviorContext();
-  if (!DefinedContext)
+  if (DefinedContext.is_null())
     return {};
 
   assert(SAI->isPHIKind());
 
   // { DomainPHIWrite[] -> Scatter[] }
   isl::union_map PHIWriteScatter = makeEmptyUnionMap();
 
   // Collect all incoming block timepoints.
isl::union_map ZoneAlgorithm::getScatterFor(isl::union_set Domain) const {
   return Schedule.intersect_domain(Domain);
 }
 
 isl::map ZoneAlgorithm::getScatterFor(isl::set Domain) const {
   auto ResultSpace = Domain.get_space().map_from_domain_and_range(ScatterSpace);
   auto UDomain = isl::union_set(Domain);
   auto UResult = getScatterFor(std::move(UDomain));
   auto Result = singleton(std::move(UResult), std::move(ResultSpace));
-  assert(!Result || Result.domain().is_equal(Domain) == isl_bool_true);
+  assert(Result.is_null() || Result.domain().is_equal(Domain) == isl_bool_true);
   return Result;
 }
 
 isl::set ZoneAlgorithm::getDomainFor(ScopStmt *Stmt) const {
   return Stmt->getDomain().remove_redundancies();
 }
 
 isl::set ZoneAlgorithm::getDomainFor(MemoryAccess *MA) const {
isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
   //  }
   //
   // Here, the value used in TargetStmt is defined in the corresponding
   // DefStmt, i.e.
   //
   //   { DefStmt[i] -> TargetStmt[i,j] }
   //
   // In practice, this should cover the majority of cases.
-  if (!Result && S->isOriginalSchedule() &&
+  if (Result.is_null() && S->isOriginalSchedule() &&
       isInsideLoop(DefStmt->getSurroundingLoop(),
                    TargetStmt->getSurroundingLoop())) {
     isl::set DefDomain = getDomainFor(DefStmt);
     isl::set TargetDomain = getDomainFor(TargetStmt);
     assert(DefDomain.dim(isl::dim::set) <= TargetDomain.dim(isl::dim::set));
 
     Result = isl::map::from_domain_and_range(DefDomain, TargetDomain);
     for (unsigned i = 0, DefDims = DefDomain.dim(isl::dim::set); i < DefDims;
          i += 1)
       Result = Result.equate(isl::dim::in, i, isl::dim::out, i);
   }
 
-  if (!Result) {
+  if (Result.is_null()) {
     // { DomainDef[] -> DomainTarget[] }
     Result = computeUseToDefFlowDependency(TargetStmt, DefStmt).reverse();
     simplify(Result);
   }
 
   return Result;
 }
 
 isl::map ZoneAlgorithm::getScalarReachingDefinition(ScopStmt *Stmt) {
   auto &Result = ScalarReachDefZone[Stmt];
-  if (Result)
+  if (!Result.is_null())
     return Result;
 
   auto Domain = getDomainFor(Stmt);
   Result = computeScalarReachingDefinition(Schedule, Domain, false, true);
   simplify(Result);
 
   return Result;
 }
for (MemoryAccess *MA : Stmt) {
 
       auto *PHI = cast<PHINode>(MA->getAccessInstruction());
       const ScopArrayInfo *SAI = MA->getOriginalScopArrayInfo();
 
       // Determine which instance of the PHI statement corresponds to which
       // incoming value. Skip if we cannot determine PHI predecessors.
       // { PHIDomain[] -> IncomingDomain[] }
       isl::union_map PerPHI = computePerPHI(SAI);
-      if (!PerPHI)
+      if (PerPHI.is_null())
         continue;
 
       // { PHIDomain[] -> PHIValInst[] }
       isl::map PHIValInst = makeValInst(PHI, &Stmt, Stmt.getSurroundingLoop());
 
       // { IncomingDomain[] -> IncomingValInst[] }
       isl::union_map IncomingValInsts = makeEmptyUnionMap();
 
for (ScopStmt &Stmt : *S) {
     }
   }
   simplify(AllPHIMaps);
 
   // Apply the normalization.
   ComputedPHIs = AllPHIs;
   NormalizeMap = AllPHIMaps;
 
-  assert(!NormalizeMap || isNormalized(NormalizeMap));
+  assert(NormalizeMap.is_null() || isNormalized(NormalizeMap));
 }
 
 void ZoneAlgorithm::printAccesses(llvm::raw_ostream &OS, int Indent) const {
   OS.indent(Indent) << "After accesses {\n";
   for (auto &Stmt : *S) {
     OS.indent(Indent + 4) << Stmt.getBaseName() << "\n";
     for (auto *MA : Stmt)
       MA->print(OS);

polly/unittests/DeLICM/DeLICMTest.cpp

isl::union_set unionSpace(const isl::union_set &USet) {
   return Result;
 }
 
 void completeLifetime(isl::union_set Universe, isl::union_map OccupiedAndKnown,
                       isl::union_set &Occupied, isl::union_map &Known,
                       isl::union_set &Undef) {
   auto ParamSpace = Universe.get_space();
 
-  if (Undef && !Occupied) {
-    assert(!Occupied);
+  if (!Undef.is_null() && Occupied.is_null()) {
+    assert(Occupied.is_null());
     Occupied = Universe.subtract(Undef);
   }
 
-  if (OccupiedAndKnown) {
-    assert(!Known);
+  if (!OccupiedAndKnown.is_null()) {
+    assert(Known.is_null());
 
     Known = isl::union_map::empty(ParamSpace);
 
-    if (!Occupied)
+    if (Occupied.is_null())
       Occupied = OccupiedAndKnown.domain();
 
     for (isl::map Map : OccupiedAndKnown.get_map_list()) {
       if (!Map.has_tuple_name(isl::dim::out))
         continue;
       Known = Known.add_map(Map);
     }
   }
 
-  if (!Undef) {
-    assert(Occupied);
+  if (Undef.is_null()) {
+    assert(!Occupied.is_null());
     Undef = Universe.subtract(Occupied);
   }
 
-  if (!Known) { // By default, nothing is known.
+  if (Known.is_null()) { // By default, nothing is known.
     Known = isl::union_map::empty(ParamSpace);
   }
 
   // Conditions that must hold when returning.
-  assert(Occupied);
-  assert(Undef);
-  assert(Known);
+  assert(!Occupied.is_null());
+  assert(!Undef.is_null());
+  assert(!Known.is_null());
 }
 
 typedef struct {
   const char *OccupiedStr;
   const char *UndefStr;
   const char *WrittenStr;
 } KnowledgeStr;
 

 
 bool checkIsConflictingNonsymmetricCommon(
     isl_ctx *Ctx, isl::union_map ExistingOccupiedAndKnown,
     isl::union_set ExistingUnused, isl::union_map ExistingWritten,
     isl::union_map ProposedOccupiedAndKnown, isl::union_set ProposedUnused,
     isl::union_map ProposedWritten) {
   // Determine universe (set of all possible domains).
   auto Universe = isl::union_set::empty(isl::space::params_alloc(Ctx, 0));
-  if (ExistingOccupiedAndKnown)
+  if (!ExistingOccupiedAndKnown.is_null())
     Universe = Universe.unite(ExistingOccupiedAndKnown.domain());
-  if (ExistingUnused)
+  if (!ExistingUnused.is_null())
     Universe = Universe.unite(ExistingUnused);
-  if (ExistingWritten)
+  if (!ExistingWritten.is_null())
     Universe = Universe.unite(ExistingWritten.domain());
-  if (ProposedOccupiedAndKnown)
+  if (!ProposedOccupiedAndKnown.is_null())
     Universe = Universe.unite(ProposedOccupiedAndKnown.domain());
-  if (ProposedUnused)
+  if (!ProposedUnused.is_null())
     Universe = Universe.unite(ProposedUnused);
-  if (ProposedWritten)
+  if (!ProposedWritten.is_null())
     Universe = Universe.unite(ProposedWritten.domain());
 
   Universe = unionSpace(Universe);
 
   // Add a space the universe that does not occur anywhere else to ensure
   // robustness. Use &NewId to ensure that this Id is unique.
   isl::id NewId = isl::id::alloc(Ctx, "Unrelated", &NewId);
   // The space must contains at least one dimension to allow order