[Polly][Isl] Removing nullptr constructor from C++ bindings. NFC.

[patacca]

Summary

[Polly][Isl] Removing nullptr constructor from C++ bindings. NFC.

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:

• Removed std::nullptr_t constructor from all the classes in the isl C++ bindings.
• isl-noexceptions.h has been generated by this https://github.com/patacca/isl/commit/a7e00bea38f251a4bcf5c2c6ce5fa7ee5f661528

[patacca]

Rebase to main

[Meinersbur]

LGTM.

Could you mention in the commit message/summary that the goal/motivation is to make the isl-noexceptions.h converge towards the official bindings?

polly/lib/Transform/ScheduleOptimizer.cpp

1702

This might have been there to ensure the order in which the objects are freed. LastSchedule must be free'd before IslCtx.

However, destruction order is defined to be in reverse of the field declaration order, so indeed what we want.

[patacca]

Replacing calls to nullptr constructor of isl::schedule to the default constructor in lib/CodeGen/PPCGCodeGeneration.cpp

[patacca]

Rebase to main

polly/include/polly/ScopInfo.h

private:
 
   /// A map from instructions to SCoP statements.
   DenseMap<Instruction *, ScopStmt *> InstStmtMap;
 
   /// A map from basic blocks to their domains.
   DenseMap<BasicBlock *, isl::set> DomainMap;
 
   /// Constraints on parameters.
-  isl::set Context = nullptr;
+  isl::set Context;
 
   /// The affinator used to translate SCEVs to isl expressions.
   SCEVAffinator Affinator;
 
   using ArrayInfoMapTy =
       std::map<std::pair<AssertingVH<const Value>, MemoryKind>,
                std::unique_ptr<ScopArrayInfo>>;
 
private:
   /// the schedule vector of A is lexicographic smaller than the schedule
   /// vector of B.
   ///
   /// Besides band nodes, schedule trees contain additional nodes that specify
   /// a textual ordering between two subtrees or filter nodes that filter the
   /// set of statement instances that will be scheduled in a subtree. There
   /// are also several other nodes. A full description of the different nodes
   /// in a schedule tree is given in the isl manual.
-  isl::schedule Schedule = nullptr;
+  isl::schedule Schedule;
 
   /// Is this Scop marked as not to be transformed by an optimization heuristic?
   bool HasDisableHeuristicsHint = false;
 
   /// Whether the schedule has been modified after derived from the CFG by
   /// ScopBuilder.
   bool ScheduleModified = false;
 

polly/lib/Analysis/ScopBuilder.cpp

bool ScopBuilder::addLoopBoundsToHeaderDomain(
 
   for (BasicBlock *LatchBB : LatchBlocks) {
     // If the latch is only reachable via error statements we skip it.
     if (!scop->isDomainDefined(LatchBB))
       continue;
 
     isl::set LatchBBDom = scop->getDomainConditions(LatchBB);
 
-    isl::set BackedgeCondition = nullptr;
+    isl::set BackedgeCondition;
 
     Instruction *TI = LatchBB->getTerminator();
     BranchInst *BI = dyn_cast<BranchInst>(TI);
     assert(BI && "Only branch instructions allowed in loop latches");
 
     if (BI->isUnconditional())
       BackedgeCondition = LatchBBDom;
     else {
for (LoadInst *LInst : RIL) {
     LoadInst *&ClassRep = EquivClasses[std::make_pair(PointerSCEV, Ty)];
     if (ClassRep) {
       scop->addInvariantLoadMapping(LInst, ClassRep);
       continue;
     }
 
     ClassRep = LInst;
     scop->addInvariantEquivClass(
-        InvariantEquivClassTy{PointerSCEV, MemoryAccessList(), nullptr, Ty});
+        InvariantEquivClassTy{PointerSCEV, MemoryAccessList(), {}, Ty});
   }
 }
 
 bool ScopBuilder::buildDomains(
     Region *R, DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
   bool IsOnlyNonAffineRegion = scop->isNonAffineSubRegion(R);
   auto *EntryBB = R->getEntry();
   auto *L = IsOnlyNonAffineRegion ? nullptr : LI.getLoopFor(EntryBB);
for (isl::set S : USet.get_set_list()) {
     Result = Result.add_pw_multi_aff(PMA);
   }
 
   return isl::multi_union_pw_aff(isl::union_pw_multi_aff(Result));
 }
 
 void ScopBuilder::buildSchedule() {
   Loop *L = getLoopSurroundingScop(*scop, LI);
-  LoopStackTy LoopStack({LoopStackElementTy(L, nullptr, 0)});
+  LoopStackTy LoopStack({LoopStackElementTy(L, {}, 0)});
   buildSchedule(scop->getRegion().getNode(), LoopStack);
   assert(LoopStack.size() == 1 && LoopStack.back().L == L);
   scop->setScheduleTree(LoopStack[0].Schedule);
 }
 
 /// To generate a schedule for the elements in a Region we traverse the Region
 /// in reverse-post-order and add the contained RegionNodes in traversal order
 /// to the schedule of the loop that is currently at the top of the LoopStack.
while (!WorkList.empty() || !DelayList.empty()) {
 
     Loop *LastLoop = LoopStack.back().L;
     if (LastLoop != L) {
       if (LastLoop && !LastLoop->contains(L)) {
         LastRNWaiting = true;
         DelayList.push_back(RN);
         continue;
       }
-      LoopStack.push_back({L, nullptr, 0});
+      LoopStack.push_back({L, {}, 0});
     }
     buildSchedule(RN, LoopStack);
   }
 }
 
 void ScopBuilder::buildSchedule(RegionNode *RN, LoopStackTy &LoopStack) {
   if (RN->isSubRegion()) {
     auto *LocalRegion = RN->getNodeAs<Region>();
isl::set ScopBuilder::getNonHoistableCtx(MemoryAccess *Access,
   //       them to be treated as parameters (e.g., in conditions) and our code
   //       generation would otherwise use the old value.
 
   auto &Stmt = *Access->getStatement();
   BasicBlock *BB = Stmt.getEntryBlock();
 
   if (Access->isScalarKind() || Access->isWrite() || !Access->isAffine() ||
       Access->isMemoryIntrinsic())
-    return nullptr;
+    return {};
 
   // Skip accesses that have an invariant base pointer which is defined but
   // not loaded inside the SCoP. This can happened e.g., if a readnone call
   // returns a pointer that is used as a base address. However, as we want
   // to hoist indirect pointers, we allow the base pointer to be defined in
   // the region if it is also a memory access. Each ScopArrayInfo object
   // that has a base pointer origin has a base pointer that is loaded and
   // that it is invariant, thus it will be hoisted too. However, if there is
   // no base pointer origin we check that the base pointer is defined
   // outside the region.
   auto *LI = cast<LoadInst>(Access->getAccessInstruction());
   if (hasNonHoistableBasePtrInScop(Access, Writes))
-    return nullptr;
+    return {};
 
   isl::map AccessRelation = Access->getAccessRelation();
   assert(!AccessRelation.is_empty());
 
   if (AccessRelation.involves_dims(isl::dim::in, 0, Stmt.getNumIterators()))
-    return nullptr;
+    return {};
 
   AccessRelation = AccessRelation.intersect_domain(Stmt.getDomain());
   isl::set SafeToLoad;
 
   auto &DL = scop->getFunction().getParent()->getDataLayout();
   if (isSafeToLoadUnconditionally(LI->getPointerOperand(), LI->getType(),
                                   LI->getAlign(), DL)) {
     SafeToLoad = isl::set::universe(AccessRelation.get_space().range());
   } else if (BB != LI->getParent()) {
     // Skip accesses in non-affine subregions as they might not be executed
     // under the same condition as the entry of the non-affine subregion.
-    return nullptr;
+    return {};
   } else {
     SafeToLoad = AccessRelation.range();
   }
 
   if (isAccessRangeTooComplex(AccessRelation.range()))
-    return nullptr;
+    return {};
 
   isl::union_map Written = Writes.intersect_range(SafeToLoad);
   isl::set WrittenCtx = Written.params();
   bool IsWritten = !WrittenCtx.is_empty();
 
   if (!IsWritten)
     return WrittenCtx;
 
   WrittenCtx = WrittenCtx.remove_divs();
   bool TooComplex = WrittenCtx.n_basic_set() >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))
-    return nullptr;
+    return {};
 
   scop->addAssumption(INVARIANTLOAD, WrittenCtx, LI->getDebugLoc(),
                       AS_RESTRICTION, LI->getParent());
   return WrittenCtx;
 }
 
 static bool isAParameter(llvm::Value *maybeParam, const Function &F) {
   for (const llvm::Argument &Arg : F.args())

polly/lib/Analysis/ScopInfo.cpp

bool ScopArrayInfo::updateSizes(ArrayRef<const SCEV *> NewSizes,
   }
 
   DimensionSizes.clear();
   DimensionSizes.insert(DimensionSizes.begin(), NewSizes.begin(),
                         NewSizes.end());
   DimensionSizesPw.clear();
   for (const SCEV *Expr : DimensionSizes) {
     if (!Expr) {
-      DimensionSizesPw.push_back(nullptr);
+      DimensionSizesPw.push_back(isl::pw_aff());
       continue;
     }
     isl::pw_aff Size = S.getPwAffOnly(Expr);
     DimensionSizesPw.push_back(Size);
   }
   return true;
 }
 

 }
 
 MemoryAccess::MemoryAccess(ScopStmt *Stmt, Instruction *AccessInst,
                            AccessType AccType, Value *BaseAddress,
                            Type *ElementType, bool Affine,
                            ArrayRef<const SCEV *> Subscripts,
                            ArrayRef<const SCEV *> Sizes, Value *AccessValue,
                            MemoryKind Kind)
-    : Kind(Kind), AccType(AccType), Statement(Stmt), InvalidDomain(nullptr),
+    : Kind(Kind), AccType(AccType), Statement(Stmt), InvalidDomain(),
       BaseAddr(BaseAddress), ElementType(ElementType),
       Sizes(Sizes.begin(), Sizes.end()), AccessInstruction(AccessInst),
       AccessValue(AccessValue), IsAffine(Affine),
-      Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(nullptr),
-      NewAccessRelation(nullptr), FAD(nullptr) {
+      Subscripts(Subscripts.begin(), Subscripts.end()), AccessRelation(),
+      NewAccessRelation(), FAD(nullptr) {
   static const std::string TypeStrings[] = {"", "_Read", "_Write", "_MayWrite"};
   const std::string Access = TypeStrings[AccType] + utostr(Stmt->size());
 
   std::string IdName = Stmt->getBaseName() + Access;
   Id = isl::id::alloc(Stmt->getParent()->getIslCtx(), IdName, this);
 }
 
 MemoryAccess::MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel)
     : Kind(MemoryKind::Array), AccType(AccType), Statement(Stmt),
-      InvalidDomain(nullptr), AccessRelation(nullptr),
-      NewAccessRelation(AccRel), FAD(nullptr) {
+      InvalidDomain(), AccessRelation(), NewAccessRelation(AccRel),
+      FAD(nullptr) {
   isl::id ArrayInfoId = NewAccessRelation.get_tuple_id(isl::dim::out);
   auto *SAI = ScopArrayInfo::getFromId(ArrayInfoId);
   Sizes.push_back(nullptr);
   for (unsigned i = 1; i < SAI->getNumberOfDimensions(); i++)
     Sizes.push_back(SAI->getDimensionSize(i));
   ElementType = SAI->getElementType();
   BaseAddr = SAI->getBasePtr();
   static const std::string TypeStrings[] = {"", "_Read", "_Write", "_MayWrite"};

 //===----------------------------------------------------------------------===//
 
 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)
-    return nullptr;
+    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();
   return M;
void ScopStmt::realignParams() {
   isl::space CtxSpace = Ctx.get_space();
   InvalidDomain = InvalidDomain.align_params(CtxSpace);
   Domain = Domain.align_params(CtxSpace);
 }
 
 ScopStmt::ScopStmt(Scop &parent, Region &R, StringRef Name,
                    Loop *SurroundingLoop,
                    std::vector<Instruction *> EntryBlockInstructions)
-    : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), R(&R),
-      Build(nullptr), BaseName(Name), SurroundingLoop(SurroundingLoop),
-      Instructions(EntryBlockInstructions) {}
+    : Parent(parent), InvalidDomain(), Domain(), R(&R), Build(), BaseName(Name),
+      SurroundingLoop(SurroundingLoop), Instructions(EntryBlockInstructions) {}
 
 ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb, StringRef Name,
                    Loop *SurroundingLoop,
                    std::vector<Instruction *> Instructions)
-    : Parent(parent), InvalidDomain(nullptr), Domain(nullptr), BB(&bb),
-      Build(nullptr), BaseName(Name), SurroundingLoop(SurroundingLoop),
+    : Parent(parent), InvalidDomain(), Domain(), BB(&bb), Build(),
+      BaseName(Name), SurroundingLoop(SurroundingLoop),
       Instructions(Instructions) {}
 
 ScopStmt::ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
                    isl::set NewDomain)
-    : Parent(parent), InvalidDomain(nullptr), Domain(NewDomain),
-      Build(nullptr) {
+    : Parent(parent), InvalidDomain(), Domain(NewDomain), Build() {
   BaseName = getIslCompatibleName("CopyStmt_", "",
                                   std::to_string(parent.getCopyStmtsNum()));
   isl::id Id = isl::id::alloc(getIslCtx(), getBaseName(), this);
   Domain = Domain.set_tuple_id(Id);
   TargetRel = TargetRel.set_tuple_id(isl::dim::in, Id);
   auto *Access =
       new MemoryAccess(this, MemoryAccess::AccessType::MUST_WRITE, TargetRel);
   parent.addAccessFunction(Access);
void Scop::intersectDefinedBehavior(isl::set Set, AssumptionSign Sign) {
 
   // Limit the complexity of the context. If complexity is exceeded, simplify
   // the set and check again.
   if (DefinedBehaviorContext.n_basic_set() >
       MaxDisjunktsInDefinedBehaviourContext) {
     simplify(DefinedBehaviorContext);
     if (DefinedBehaviorContext.n_basic_set() >
         MaxDisjunktsInDefinedBehaviourContext)
-      DefinedBehaviorContext = nullptr;
+      DefinedBehaviorContext = {};
   }
 }
 
 void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB) {
   LLVM_DEBUG(dbgs() << "Invalidate SCoP because of reason " << Kind << "\n");
   addAssumption(Kind, isl::set::empty(getParamSpace()), Loc, AS_ASSUMPTION, BB);
 }
 

polly/lib/CodeGen/IslAst.cpp

if (!PollyParallelForce && isInnermost(Node))
     return false;
 
   return isOutermostParallel(Node) && !isReductionParallel(Node);
 }
 
 isl::union_map IslAstInfo::getSchedule(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   if (!Payload)
-    return nullptr;
+    return {};
 
   isl::ast_build Build = isl::manage_copy(Payload->Build);
   return Build.get_schedule();
 }
 
 isl::pw_aff
 IslAstInfo::getMinimalDependenceDistance(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
-  return Payload ? Payload->MinimalDependenceDistance : nullptr;
+  return Payload ? Payload->MinimalDependenceDistance : isl::pw_aff();
 }
 
 IslAstInfo::MemoryAccessSet *
 IslAstInfo::getBrokenReductions(const isl::ast_node &Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? &Payload->BrokenReductions : nullptr;
 }
 

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

class aff {
 
   isl_aff *ptr = nullptr;
 
   inline explicit aff(__isl_take isl_aff *ptr);
 
 public:
   inline /* implicit */ aff();
   inline /* implicit */ aff(const aff &obj);
-  inline /* implicit */ aff(std::nullptr_t);
   inline explicit aff(ctx ctx, const std::string &str);
   inline explicit aff(local_space ls, val val);
   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;
class aff_list {
 
   isl_aff_list *ptr = nullptr;
 
   inline explicit aff_list(__isl_take isl_aff_list *ptr);
 
 public:
   inline /* implicit */ aff_list();
   inline /* implicit */ aff_list(const aff_list &obj);
-  inline /* implicit */ aff_list(std::nullptr_t);
   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;
class ast_build {
 
   isl_ast_build *ptr = nullptr;
 
   inline explicit ast_build(__isl_take isl_ast_build *ptr);
 
 public:
   inline /* implicit */ ast_build();
   inline /* implicit */ ast_build(const ast_build &obj);
-  inline /* implicit */ ast_build(std::nullptr_t);
   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;
class ast_expr {
 
   isl_ast_expr *ptr = nullptr;
 
   inline explicit ast_expr(__isl_take isl_ast_expr *ptr);
 
 public:
   inline /* implicit */ ast_expr();
   inline /* implicit */ ast_expr(const ast_expr &obj);
-  inline /* implicit */ ast_expr(std::nullptr_t);
   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;
class ast_expr_list {
 
   isl_ast_expr_list *ptr = nullptr;
 
   inline explicit ast_expr_list(__isl_take isl_ast_expr_list *ptr);
 
 public:
   inline /* implicit */ ast_expr_list();
   inline /* implicit */ ast_expr_list(const ast_expr_list &obj);
-  inline /* implicit */ ast_expr_list(std::nullptr_t);
   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;
class ast_node {
 
   isl_ast_node *ptr = nullptr;
 
   inline explicit ast_node(__isl_take isl_ast_node *ptr);
 
 public:
   inline /* implicit */ ast_node();
   inline /* implicit */ ast_node(const ast_node &obj);
-  inline /* implicit */ ast_node(std::nullptr_t);
   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;
class ast_node_list {
 
   isl_ast_node_list *ptr = nullptr;
 
   inline explicit ast_node_list(__isl_take isl_ast_node_list *ptr);
 
 public:
   inline /* implicit */ ast_node_list();
   inline /* implicit */ ast_node_list(const ast_node_list &obj);
-  inline /* implicit */ ast_node_list(std::nullptr_t);
   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;
class basic_map {
 
   isl_basic_map *ptr = nullptr;
 
   inline explicit basic_map(__isl_take isl_basic_map *ptr);
 
 public:
   inline /* implicit */ basic_map();
   inline /* implicit */ basic_map(const basic_map &obj);
-  inline /* implicit */ basic_map(std::nullptr_t);
   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;
class basic_map_list {
 
   isl_basic_map_list *ptr = nullptr;
 
   inline explicit basic_map_list(__isl_take isl_basic_map_list *ptr);
 
 public:
   inline /* implicit */ basic_map_list();
   inline /* implicit */ basic_map_list(const basic_map_list &obj);
-  inline /* implicit */ basic_map_list(std::nullptr_t);
   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;
class basic_set {
 
   isl_basic_set *ptr = nullptr;
 
   inline explicit basic_set(__isl_take isl_basic_set *ptr);
 
 public:
   inline /* implicit */ basic_set();
   inline /* implicit */ basic_set(const basic_set &obj);
-  inline /* implicit */ basic_set(std::nullptr_t);
   inline /* implicit */ basic_set(point pnt);
   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();
class basic_set_list {
 
   isl_basic_set_list *ptr = nullptr;
 
   inline explicit basic_set_list(__isl_take isl_basic_set_list *ptr);
 
 public:
   inline /* implicit */ basic_set_list();
   inline /* implicit */ basic_set_list(const basic_set_list &obj);
-  inline /* implicit */ basic_set_list(std::nullptr_t);
   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;
class constraint {
 
   isl_constraint *ptr = nullptr;
 
   inline explicit constraint(__isl_take isl_constraint *ptr);
 
 public:
   inline /* implicit */ constraint();
   inline /* implicit */ constraint(const constraint &obj);
-  inline /* implicit */ constraint(std::nullptr_t);
   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;
class constraint_list {
 
   isl_constraint_list *ptr = nullptr;
 
   inline explicit constraint_list(__isl_take isl_constraint_list *ptr);
 
 public:
   inline /* implicit */ constraint_list();
   inline /* implicit */ constraint_list(const constraint_list &obj);
-  inline /* implicit */ constraint_list(std::nullptr_t);
   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;
class fixed_box {
 
   isl_fixed_box *ptr = nullptr;
 
   inline explicit fixed_box(__isl_take isl_fixed_box *ptr);
 
 public:
   inline /* implicit */ fixed_box();
   inline /* implicit */ fixed_box(const fixed_box &obj);
-  inline /* implicit */ fixed_box(std::nullptr_t);
   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;
class id {
 
   isl_id *ptr = nullptr;
 
   inline explicit id(__isl_take isl_id *ptr);
 
 public:
   inline /* implicit */ id();
   inline /* implicit */ id(const id &obj);
-  inline /* implicit */ id(std::nullptr_t);
   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;
class id_list {
 
   isl_id_list *ptr = nullptr;
 
   inline explicit id_list(__isl_take isl_id_list *ptr);
 
 public:
   inline /* implicit */ id_list();
   inline /* implicit */ id_list(const id_list &obj);
-  inline /* implicit */ id_list(std::nullptr_t);
   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;
class id_to_ast_expr {
 
   isl_id_to_ast_expr *ptr = nullptr;
 
   inline explicit id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr);
 
 public:
   inline /* implicit */ id_to_ast_expr();
   inline /* implicit */ id_to_ast_expr(const id_to_ast_expr &obj);
-  inline /* implicit */ id_to_ast_expr(std::nullptr_t);
   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;
class local_space {
 
   isl_local_space *ptr = nullptr;
 
   inline explicit local_space(__isl_take isl_local_space *ptr);
 
 public:
   inline /* implicit */ local_space();
   inline /* implicit */ local_space(const local_space &obj);
-  inline /* implicit */ local_space(std::nullptr_t);
   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;
class map {
 
   isl_map *ptr = nullptr;
 
   inline explicit map(__isl_take isl_map *ptr);
 
 public:
   inline /* implicit */ map();
   inline /* implicit */ map(const map &obj);
-  inline /* implicit */ map(std::nullptr_t);
   inline /* implicit */ map(basic_map bmap);
   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();
class map_list {
 
   isl_map_list *ptr = nullptr;
 
   inline explicit map_list(__isl_take isl_map_list *ptr);
 
 public:
   inline /* implicit */ map_list();
   inline /* implicit */ map_list(const map_list &obj);
-  inline /* implicit */ map_list(std::nullptr_t);
   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;
class mat {
 
   isl_mat *ptr = nullptr;
 
   inline explicit mat(__isl_take isl_mat *ptr);
 
 public:
   inline /* implicit */ mat();
   inline /* implicit */ mat(const mat &obj);
-  inline /* implicit */ mat(std::nullptr_t);
   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;
class multi_aff {
 
   isl_multi_aff *ptr = nullptr;
 
   inline explicit multi_aff(__isl_take isl_multi_aff *ptr);
 
 public:
   inline /* implicit */ multi_aff();
   inline /* implicit */ multi_aff(const multi_aff &obj);
-  inline /* implicit */ multi_aff(std::nullptr_t);
   inline /* implicit */ multi_aff(aff aff);
   inline explicit multi_aff(space space, aff_list list);
   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;
class multi_id {
 
   isl_multi_id *ptr = nullptr;
 
   inline explicit multi_id(__isl_take isl_multi_id *ptr);
 
 public:
   inline /* implicit */ multi_id();
   inline /* implicit */ multi_id(const multi_id &obj);
-  inline /* implicit */ multi_id(std::nullptr_t);
   inline explicit multi_id(space space, id_list list);
   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();
class multi_pw_aff {
 
   isl_multi_pw_aff *ptr = nullptr;
 
   inline explicit multi_pw_aff(__isl_take isl_multi_pw_aff *ptr);
 
 public:
   inline /* implicit */ multi_pw_aff();
   inline /* implicit */ multi_pw_aff(const multi_pw_aff &obj);
-  inline /* implicit */ multi_pw_aff(std::nullptr_t);
   inline /* implicit */ multi_pw_aff(aff aff);
   inline /* implicit */ multi_pw_aff(multi_aff ma);
   inline /* implicit */ multi_pw_aff(pw_aff pa);
   inline explicit multi_pw_aff(space space, pw_aff_list list);
   inline /* implicit */ multi_pw_aff(pw_multi_aff pma);
   inline explicit multi_pw_aff(ctx ctx, const std::string &str);
   inline multi_pw_aff &operator=(multi_pw_aff obj);
   inline ~multi_pw_aff();
class multi_union_pw_aff {
 
   isl_multi_union_pw_aff *ptr = nullptr;
 
   inline explicit multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr);
 
 public:
   inline /* implicit */ multi_union_pw_aff();
   inline /* implicit */ multi_union_pw_aff(const multi_union_pw_aff &obj);
-  inline /* implicit */ multi_union_pw_aff(std::nullptr_t);
   inline /* implicit */ multi_union_pw_aff(multi_pw_aff mpa);
   inline /* implicit */ multi_union_pw_aff(union_pw_aff upa);
   inline explicit multi_union_pw_aff(space space, union_pw_aff_list list);
   inline explicit multi_union_pw_aff(union_pw_multi_aff upma);
   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 &;
class multi_val {
 
   isl_multi_val *ptr = nullptr;
 
   inline explicit multi_val(__isl_take isl_multi_val *ptr);
 
 public:
   inline /* implicit */ multi_val();
   inline /* implicit */ multi_val(const multi_val &obj);
-  inline /* implicit */ multi_val(std::nullptr_t);
   inline explicit multi_val(space space, val_list list);
   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();
class point {
 
   isl_point *ptr = nullptr;
 
   inline explicit point(__isl_take isl_point *ptr);
 
 public:
   inline /* implicit */ point();
   inline /* implicit */ point(const point &obj);
-  inline /* implicit */ point(std::nullptr_t);
   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;
class pw_aff {
 
   isl_pw_aff *ptr = nullptr;
 
   inline explicit pw_aff(__isl_take isl_pw_aff *ptr);
 
 public:
   inline /* implicit */ pw_aff();
   inline /* implicit */ pw_aff(const pw_aff &obj);
-  inline /* implicit */ pw_aff(std::nullptr_t);
   inline /* implicit */ pw_aff(aff aff);
   inline explicit pw_aff(ctx ctx, const std::string &str);
   inline explicit pw_aff(set domain, val v);
   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;
class pw_aff_list {
 
   isl_pw_aff_list *ptr = nullptr;
 
   inline explicit pw_aff_list(__isl_take isl_pw_aff_list *ptr);
 
 public:
   inline /* implicit */ pw_aff_list();
   inline /* implicit */ pw_aff_list(const pw_aff_list &obj);
-  inline /* implicit */ pw_aff_list(std::nullptr_t);
   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;
class pw_multi_aff {
 
   isl_pw_multi_aff *ptr = nullptr;
 
   inline explicit pw_multi_aff(__isl_take isl_pw_multi_aff *ptr);
 
 public:
   inline /* implicit */ pw_multi_aff();
   inline /* implicit */ pw_multi_aff(const pw_multi_aff &obj);
-  inline /* implicit */ pw_multi_aff(std::nullptr_t);
   inline /* implicit */ pw_multi_aff(multi_aff ma);
   inline /* implicit */ pw_multi_aff(pw_aff pa);
   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;
class pw_multi_aff_list {
 
   isl_pw_multi_aff_list *ptr = nullptr;
 
   inline explicit pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr);
 
 public:
   inline /* implicit */ pw_multi_aff_list();
   inline /* implicit */ pw_multi_aff_list(const pw_multi_aff_list &obj);
-  inline /* implicit */ pw_multi_aff_list(std::nullptr_t);
   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;
class pw_qpolynomial {
 
   isl_pw_qpolynomial *ptr = nullptr;
 
   inline explicit pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr);
 
 public:
   inline /* implicit */ pw_qpolynomial();
   inline /* implicit */ pw_qpolynomial(const pw_qpolynomial &obj);
-  inline /* implicit */ pw_qpolynomial(std::nullptr_t);
   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;
class pw_qpolynomial_fold_list {
 
   isl_pw_qpolynomial_fold_list *ptr = nullptr;
 
   inline explicit pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr);
 
 public:
   inline /* implicit */ pw_qpolynomial_fold_list();
   inline /* implicit */ pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj);
-  inline /* implicit */ pw_qpolynomial_fold_list(std::nullptr_t);
   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;
class pw_qpolynomial_list {
 
   isl_pw_qpolynomial_list *ptr = nullptr;
 
   inline explicit pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr);
 
 public:
   inline /* implicit */ pw_qpolynomial_list();
   inline /* implicit */ pw_qpolynomial_list(const pw_qpolynomial_list &obj);
-  inline /* implicit */ pw_qpolynomial_list(std::nullptr_t);
   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;
class qpolynomial {
 
   isl_qpolynomial *ptr = nullptr;
 
   inline explicit qpolynomial(__isl_take isl_qpolynomial *ptr);
 
 public:
   inline /* implicit */ qpolynomial();
   inline /* implicit */ qpolynomial(const qpolynomial &obj);
-  inline /* implicit */ qpolynomial(std::nullptr_t);
   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;
class qpolynomial_list {
 
   isl_qpolynomial_list *ptr = nullptr;
 
   inline explicit qpolynomial_list(__isl_take isl_qpolynomial_list *ptr);
 
 public:
   inline /* implicit */ qpolynomial_list();
   inline /* implicit */ qpolynomial_list(const qpolynomial_list &obj);
-  inline /* implicit */ qpolynomial_list(std::nullptr_t);
   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;
class schedule {
 
   isl_schedule *ptr = nullptr;
 
   inline explicit schedule(__isl_take isl_schedule *ptr);
 
 public:
   inline /* implicit */ schedule();
   inline /* implicit */ schedule(const schedule &obj);
-  inline /* implicit */ schedule(std::nullptr_t);
   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;
class schedule_constraints {
 
   isl_schedule_constraints *ptr = nullptr;
 
   inline explicit schedule_constraints(__isl_take isl_schedule_constraints *ptr);
 
 public:
   inline /* implicit */ schedule_constraints();
   inline /* implicit */ schedule_constraints(const schedule_constraints &obj);
-  inline /* implicit */ schedule_constraints(std::nullptr_t);
   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;
class schedule_node {
 
   isl_schedule_node *ptr = nullptr;
 
   inline explicit schedule_node(__isl_take isl_schedule_node *ptr);
 
 public:
   inline /* implicit */ schedule_node();
   inline /* implicit */ schedule_node(const schedule_node &obj);
-  inline /* implicit */ schedule_node(std::nullptr_t);
   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;
class set {
 
   isl_set *ptr = nullptr;
 
   inline explicit set(__isl_take isl_set *ptr);
 
 public:
   inline /* implicit */ set();
   inline /* implicit */ set(const set &obj);
-  inline /* implicit */ set(std::nullptr_t);
   inline /* implicit */ set(basic_set bset);
   inline /* implicit */ set(point pnt);
   inline explicit set(union_set uset);
   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;
class set_list {
 
   isl_set_list *ptr = nullptr;
 
   inline explicit set_list(__isl_take isl_set_list *ptr);
 
 public:
   inline /* implicit */ set_list();
   inline /* implicit */ set_list(const set_list &obj);
-  inline /* implicit */ set_list(std::nullptr_t);
   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;
class space {
 
   isl_space *ptr = nullptr;
 
   inline explicit space(__isl_take isl_space *ptr);
 
 public:
   inline /* implicit */ space();
   inline /* implicit */ space(const space &obj);
-  inline /* implicit */ space(std::nullptr_t);
   inline explicit space(ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out);
   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();
class term {
 
   isl_term *ptr = nullptr;
 
   inline explicit term(__isl_take isl_term *ptr);
 
 public:
   inline /* implicit */ term();
   inline /* implicit */ term(const term &obj);
-  inline /* implicit */ term(std::nullptr_t);
   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;
class union_access_info {
 
   isl_union_access_info *ptr = nullptr;
 
   inline explicit union_access_info(__isl_take isl_union_access_info *ptr);
 
 public:
   inline /* implicit */ union_access_info();
   inline /* implicit */ union_access_info(const union_access_info &obj);
-  inline /* implicit */ union_access_info(std::nullptr_t);
   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;
class union_flow {
 
   isl_union_flow *ptr = nullptr;
 
   inline explicit union_flow(__isl_take isl_union_flow *ptr);
 
 public:
   inline /* implicit */ union_flow();
   inline /* implicit */ union_flow(const union_flow &obj);
-  inline /* implicit */ union_flow(std::nullptr_t);
   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;
class union_map {
 
   isl_union_map *ptr = nullptr;
 
   inline explicit union_map(__isl_take isl_union_map *ptr);
 
 public:
   inline /* implicit */ union_map();
   inline /* implicit */ union_map(const union_map &obj);
-  inline /* implicit */ union_map(std::nullptr_t);
   inline /* implicit */ union_map(basic_map bmap);
   inline /* implicit */ union_map(map map);
   inline explicit union_map(union_pw_multi_aff upma);
   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;
class union_map_list {
 
   isl_union_map_list *ptr = nullptr;
 
   inline explicit union_map_list(__isl_take isl_union_map_list *ptr);
 
 public:
   inline /* implicit */ union_map_list();
   inline /* implicit */ union_map_list(const union_map_list &obj);
-  inline /* implicit */ union_map_list(std::nullptr_t);
   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;
class union_pw_aff {
 
   isl_union_pw_aff *ptr = nullptr;
 
   inline explicit union_pw_aff(__isl_take isl_union_pw_aff *ptr);
 
 public:
   inline /* implicit */ union_pw_aff();
   inline /* implicit */ union_pw_aff(const union_pw_aff &obj);
-  inline /* implicit */ union_pw_aff(std::nullptr_t);
   inline /* implicit */ union_pw_aff(aff aff);
   inline /* implicit */ union_pw_aff(pw_aff pa);
   inline explicit union_pw_aff(ctx ctx, const std::string &str);
   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;
class union_pw_aff_list {
 
   isl_union_pw_aff_list *ptr = nullptr;
 
   inline explicit union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr);
 
 public:
   inline /* implicit */ union_pw_aff_list();
   inline /* implicit */ union_pw_aff_list(const union_pw_aff_list &obj);
-  inline /* implicit */ union_pw_aff_list(std::nullptr_t);
   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;
class union_pw_multi_aff {
 
   isl_union_pw_multi_aff *ptr = nullptr;
 
   inline explicit union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr);
 
 public:
   inline /* implicit */ union_pw_multi_aff();
   inline /* implicit */ union_pw_multi_aff(const union_pw_multi_aff &obj);
-  inline /* implicit */ union_pw_multi_aff(std::nullptr_t);
   inline /* implicit */ union_pw_multi_aff(aff aff);
   inline explicit union_pw_multi_aff(union_set uset);
   inline /* implicit */ union_pw_multi_aff(multi_aff ma);
   inline explicit union_pw_multi_aff(multi_union_pw_aff mupa);
   inline /* implicit */ union_pw_multi_aff(pw_multi_aff pma);
   inline explicit union_pw_multi_aff(union_map umap);
   inline /* implicit */ union_pw_multi_aff(union_pw_aff upa);
   inline explicit union_pw_multi_aff(ctx ctx, const std::string &str);
class union_pw_multi_aff_list {
 
   isl_union_pw_multi_aff_list *ptr = nullptr;
 
   inline explicit union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr);
 
 public:
   inline /* implicit */ union_pw_multi_aff_list();
   inline /* implicit */ union_pw_multi_aff_list(const union_pw_multi_aff_list &obj);
-  inline /* implicit */ union_pw_multi_aff_list(std::nullptr_t);
   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;
class union_pw_qpolynomial {
 
   isl_union_pw_qpolynomial *ptr = nullptr;
 
   inline explicit union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr);
 
 public:
   inline /* implicit */ union_pw_qpolynomial();
   inline /* implicit */ union_pw_qpolynomial(const union_pw_qpolynomial &obj);
-  inline /* implicit */ union_pw_qpolynomial(std::nullptr_t);
   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;
class union_set {
 
   isl_union_set *ptr = nullptr;
 
   inline explicit union_set(__isl_take isl_union_set *ptr);
 
 public:
   inline /* implicit */ union_set();
   inline /* implicit */ union_set(const union_set &obj);
-  inline /* implicit */ union_set(std::nullptr_t);
   inline /* implicit */ union_set(basic_set bset);
   inline /* implicit */ union_set(point pnt);
   inline /* implicit */ union_set(set set);
   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;
class union_set_list {
 
   isl_union_set_list *ptr = nullptr;
 
   inline explicit union_set_list(__isl_take isl_union_set_list *ptr);
 
 public:
   inline /* implicit */ union_set_list();
   inline /* implicit */ union_set_list(const union_set_list &obj);
-  inline /* implicit */ union_set_list(std::nullptr_t);
   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;
class val {
 
   isl_val *ptr = nullptr;
 
   inline explicit val(__isl_take isl_val *ptr);
 
 public:
   inline /* implicit */ val();
   inline /* implicit */ val(const val &obj);
-  inline /* implicit */ val(std::nullptr_t);
   inline explicit val(ctx ctx, long i);
   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();
class val_list {
 
   isl_val_list *ptr = nullptr;
 
   inline explicit val_list(__isl_take isl_val_list *ptr);
 
 public:
   inline /* implicit */ val_list();
   inline /* implicit */ val_list(const val_list &obj);
-  inline /* implicit */ val_list(std::nullptr_t);
   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;
class vec {
 
   isl_vec *ptr = nullptr;
 
   inline explicit vec(__isl_take isl_vec *ptr);
 
 public:
   inline /* implicit */ vec();
   inline /* implicit */ vec(const vec &obj);
-  inline /* implicit */ vec(std::nullptr_t);
   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;

 aff::aff()
     : ptr(nullptr) {}
 
 aff::aff(const aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-aff::aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 aff::aff(__isl_take isl_aff *ptr)
     : ptr(ptr) {}
 
 aff::aff(ctx ctx, const std::string &str)
 {
   auto res = isl_aff_read_from_str(ctx.release(), str.c_str());

 aff_list::aff_list()
     : ptr(nullptr) {}
 
 aff_list::aff_list(const aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-aff_list::aff_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 aff_list::aff_list(__isl_take isl_aff_list *ptr)
     : ptr(ptr) {}
 
 
 aff_list &aff_list::operator=(aff_list obj) {
   std::swap(this->ptr, obj.ptr);

 ast_build::ast_build()
     : ptr(nullptr) {}
 
 ast_build::ast_build(const ast_build &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-ast_build::ast_build(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 ast_build::ast_build(__isl_take isl_ast_build *ptr)
     : ptr(ptr) {}
 
 ast_build::ast_build(ctx ctx)
 {
   auto res = isl_ast_build_alloc(ctx.release());

 ast_expr::ast_expr()
     : ptr(nullptr) {}
 
 ast_expr::ast_expr(const ast_expr &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-ast_expr::ast_expr(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 ast_expr::ast_expr(__isl_take isl_ast_expr *ptr)
     : ptr(ptr) {}
 
 
 ast_expr &ast_expr::operator=(ast_expr obj) {
   std::swap(this->ptr, obj.ptr);

 ast_expr_list::ast_expr_list()
     : ptr(nullptr) {}
 
 ast_expr_list::ast_expr_list(const ast_expr_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-ast_expr_list::ast_expr_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 ast_expr_list::ast_expr_list(__isl_take isl_ast_expr_list *ptr)
     : ptr(ptr) {}
 
 
 ast_expr_list &ast_expr_list::operator=(ast_expr_list obj) {
   std::swap(this->ptr, obj.ptr);

 ast_node::ast_node()
     : ptr(nullptr) {}
 
 ast_node::ast_node(const ast_node &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-ast_node::ast_node(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 ast_node::ast_node(__isl_take isl_ast_node *ptr)
     : ptr(ptr) {}
 
 
 ast_node &ast_node::operator=(ast_node obj) {
   std::swap(this->ptr, obj.ptr);

 ast_node_list::ast_node_list()
     : ptr(nullptr) {}
 
 ast_node_list::ast_node_list(const ast_node_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-ast_node_list::ast_node_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 ast_node_list::ast_node_list(__isl_take isl_ast_node_list *ptr)
     : ptr(ptr) {}
 
 
 ast_node_list &ast_node_list::operator=(ast_node_list obj) {
   std::swap(this->ptr, obj.ptr);

 basic_map::basic_map()
     : ptr(nullptr) {}
 
 basic_map::basic_map(const basic_map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-basic_map::basic_map(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 basic_map::basic_map(__isl_take isl_basic_map *ptr)
     : ptr(ptr) {}
 
 basic_map::basic_map(ctx ctx, const std::string &str)
 {
   auto res = isl_basic_map_read_from_str(ctx.release(), str.c_str());

 basic_map_list::basic_map_list()
     : ptr(nullptr) {}
 
 basic_map_list::basic_map_list(const basic_map_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-basic_map_list::basic_map_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 basic_map_list::basic_map_list(__isl_take isl_basic_map_list *ptr)
     : ptr(ptr) {}
 
 
 basic_map_list &basic_map_list::operator=(basic_map_list obj) {
   std::swap(this->ptr, obj.ptr);

 basic_set::basic_set()
     : ptr(nullptr) {}
 
 basic_set::basic_set(const basic_set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-basic_set::basic_set(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 basic_set::basic_set(__isl_take isl_basic_set *ptr)
     : ptr(ptr) {}
 
 basic_set::basic_set(point pnt)
 {
   auto res = isl_basic_set_from_point(pnt.release());

 basic_set_list::basic_set_list()
     : ptr(nullptr) {}
 
 basic_set_list::basic_set_list(const basic_set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-basic_set_list::basic_set_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 basic_set_list::basic_set_list(__isl_take isl_basic_set_list *ptr)
     : ptr(ptr) {}
 
 
 basic_set_list &basic_set_list::operator=(basic_set_list obj) {
   std::swap(this->ptr, obj.ptr);

 constraint::constraint()
     : ptr(nullptr) {}
 
 constraint::constraint(const constraint &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-constraint::constraint(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 constraint::constraint(__isl_take isl_constraint *ptr)
     : ptr(ptr) {}
 
 
 constraint &constraint::operator=(constraint obj) {
   std::swap(this->ptr, obj.ptr);

 constraint_list::constraint_list()
     : ptr(nullptr) {}
 
 constraint_list::constraint_list(const constraint_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-constraint_list::constraint_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 constraint_list::constraint_list(__isl_take isl_constraint_list *ptr)
     : ptr(ptr) {}
 
 
 constraint_list &constraint_list::operator=(constraint_list obj) {
   std::swap(this->ptr, obj.ptr);

 fixed_box::fixed_box()
     : ptr(nullptr) {}
 
 fixed_box::fixed_box(const fixed_box &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-fixed_box::fixed_box(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 fixed_box::fixed_box(__isl_take isl_fixed_box *ptr)
     : ptr(ptr) {}
 
 
 fixed_box &fixed_box::operator=(fixed_box obj) {
   std::swap(this->ptr, obj.ptr);

 id::id()
     : ptr(nullptr) {}
 
 id::id(const id &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-id::id(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 id::id(__isl_take isl_id *ptr)
     : ptr(ptr) {}
 
 id::id(ctx ctx, const std::string &str)
 {
   auto res = isl_id_read_from_str(ctx.release(), str.c_str());

 id_list::id_list()
     : ptr(nullptr) {}
 
 id_list::id_list(const id_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-id_list::id_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 id_list::id_list(__isl_take isl_id_list *ptr)
     : ptr(ptr) {}
 
 
 id_list &id_list::operator=(id_list obj) {
   std::swap(this->ptr, obj.ptr);

 id_to_ast_expr::id_to_ast_expr()
     : ptr(nullptr) {}
 
 id_to_ast_expr::id_to_ast_expr(const id_to_ast_expr &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-id_to_ast_expr::id_to_ast_expr(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 id_to_ast_expr::id_to_ast_expr(__isl_take isl_id_to_ast_expr *ptr)
     : ptr(ptr) {}
 
 
 id_to_ast_expr &id_to_ast_expr::operator=(id_to_ast_expr obj) {
   std::swap(this->ptr, obj.ptr);

 local_space::local_space()
     : ptr(nullptr) {}
 
 local_space::local_space(const local_space &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-local_space::local_space(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 local_space::local_space(__isl_take isl_local_space *ptr)
     : ptr(ptr) {}
 
 local_space::local_space(space space)
 {
   auto res = isl_local_space_from_space(space.release());

 map::map()
     : ptr(nullptr) {}
 
 map::map(const map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-map::map(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 map::map(__isl_take isl_map *ptr)
     : ptr(ptr) {}
 
 map::map(basic_map bmap)
 {
   auto res = isl_map_from_basic_map(bmap.release());

 map_list::map_list()
     : ptr(nullptr) {}
 
 map_list::map_list(const map_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-map_list::map_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 map_list::map_list(__isl_take isl_map_list *ptr)
     : ptr(ptr) {}
 
 
 map_list &map_list::operator=(map_list obj) {
   std::swap(this->ptr, obj.ptr);

 mat::mat()
     : ptr(nullptr) {}
 
 mat::mat(const mat &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-mat::mat(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 mat::mat(__isl_take isl_mat *ptr)
     : ptr(ptr) {}
 
 
 mat &mat::operator=(mat obj) {
   std::swap(this->ptr, obj.ptr);

 multi_aff::multi_aff()
     : ptr(nullptr) {}
 
 multi_aff::multi_aff(const multi_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-multi_aff::multi_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
     : ptr(ptr) {}
 
 multi_aff::multi_aff(aff aff)
 {
   auto res = isl_multi_aff_from_aff(aff.release());

 multi_id::multi_id()
     : ptr(nullptr) {}
 
 multi_id::multi_id(const multi_id &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-multi_id::multi_id(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 multi_id::multi_id(__isl_take isl_multi_id *ptr)
     : ptr(ptr) {}
 
 multi_id::multi_id(space space, id_list list)
 {
   auto res = isl_multi_id_from_id_list(space.release(), list.release());

 multi_pw_aff::multi_pw_aff()
     : ptr(nullptr) {}
 
 multi_pw_aff::multi_pw_aff(const multi_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-multi_pw_aff::multi_pw_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 multi_pw_aff::multi_pw_aff(__isl_take isl_multi_pw_aff *ptr)
     : ptr(ptr) {}
 
 multi_pw_aff::multi_pw_aff(aff aff)
 {
   auto res = isl_multi_pw_aff_from_aff(aff.release());

 multi_union_pw_aff::multi_union_pw_aff()
     : ptr(nullptr) {}
 
 multi_union_pw_aff::multi_union_pw_aff(const multi_union_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-multi_union_pw_aff::multi_union_pw_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 multi_union_pw_aff::multi_union_pw_aff(__isl_take isl_multi_union_pw_aff *ptr)
     : ptr(ptr) {}
 
 multi_union_pw_aff::multi_union_pw_aff(multi_pw_aff mpa)
 {
   auto res = isl_multi_union_pw_aff_from_multi_pw_aff(mpa.release());

 multi_val::multi_val()
     : ptr(nullptr) {}
 
 multi_val::multi_val(const multi_val &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-multi_val::multi_val(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 multi_val::multi_val(__isl_take isl_multi_val *ptr)
     : ptr(ptr) {}
 
 multi_val::multi_val(space space, val_list list)
 {
   auto res = isl_multi_val_from_val_list(space.release(), list.release());

 point::point()
     : ptr(nullptr) {}
 
 point::point(const point &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-point::point(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 point::point(__isl_take isl_point *ptr)
     : ptr(ptr) {}
 
 point::point(space dim)
 {
   auto res = isl_point_zero(dim.release());

 pw_aff::pw_aff()
     : ptr(nullptr) {}
 
 pw_aff::pw_aff(const pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_aff::pw_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
     : ptr(ptr) {}
 
 pw_aff::pw_aff(aff aff)
 {
   auto res = isl_pw_aff_from_aff(aff.release());

 pw_aff_list::pw_aff_list()
     : ptr(nullptr) {}
 
 pw_aff_list::pw_aff_list(const pw_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_aff_list::pw_aff_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
     : ptr(ptr) {}
 
 
 pw_aff_list &pw_aff_list::operator=(pw_aff_list obj) {
   std::swap(this->ptr, obj.ptr);

 pw_multi_aff::pw_multi_aff()
     : ptr(nullptr) {}
 
 pw_multi_aff::pw_multi_aff(const pw_multi_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_multi_aff::pw_multi_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_multi_aff::pw_multi_aff(__isl_take isl_pw_multi_aff *ptr)
     : ptr(ptr) {}
 
 pw_multi_aff::pw_multi_aff(multi_aff ma)
 {
   auto res = isl_pw_multi_aff_from_multi_aff(ma.release());

 pw_multi_aff_list::pw_multi_aff_list()
     : ptr(nullptr) {}
 
 pw_multi_aff_list::pw_multi_aff_list(const pw_multi_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_multi_aff_list::pw_multi_aff_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_multi_aff_list::pw_multi_aff_list(__isl_take isl_pw_multi_aff_list *ptr)
     : ptr(ptr) {}
 
 
 pw_multi_aff_list &pw_multi_aff_list::operator=(pw_multi_aff_list obj) {
   std::swap(this->ptr, obj.ptr);

 pw_qpolynomial::pw_qpolynomial()
     : ptr(nullptr) {}
 
 pw_qpolynomial::pw_qpolynomial(const pw_qpolynomial &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_qpolynomial::pw_qpolynomial(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_qpolynomial::pw_qpolynomial(__isl_take isl_pw_qpolynomial *ptr)
     : ptr(ptr) {}
 
 pw_qpolynomial::pw_qpolynomial(ctx ctx, const std::string &str)
 {
   auto res = isl_pw_qpolynomial_read_from_str(ctx.release(), str.c_str());

 pw_qpolynomial_fold_list::pw_qpolynomial_fold_list()
     : ptr(nullptr) {}
 
 pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(const pw_qpolynomial_fold_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_qpolynomial_fold_list::pw_qpolynomial_fold_list(__isl_take isl_pw_qpolynomial_fold_list *ptr)
     : ptr(ptr) {}
 
 
 pw_qpolynomial_fold_list &pw_qpolynomial_fold_list::operator=(pw_qpolynomial_fold_list obj) {
   std::swap(this->ptr, obj.ptr);

 pw_qpolynomial_list::pw_qpolynomial_list()
     : ptr(nullptr) {}
 
 pw_qpolynomial_list::pw_qpolynomial_list(const pw_qpolynomial_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-pw_qpolynomial_list::pw_qpolynomial_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 pw_qpolynomial_list::pw_qpolynomial_list(__isl_take isl_pw_qpolynomial_list *ptr)
     : ptr(ptr) {}
 
 
 pw_qpolynomial_list &pw_qpolynomial_list::operator=(pw_qpolynomial_list obj) {
   std::swap(this->ptr, obj.ptr);

 qpolynomial::qpolynomial()
     : ptr(nullptr) {}
 
 qpolynomial::qpolynomial(const qpolynomial &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-qpolynomial::qpolynomial(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 qpolynomial::qpolynomial(__isl_take isl_qpolynomial *ptr)
     : ptr(ptr) {}
 
 
 qpolynomial &qpolynomial::operator=(qpolynomial obj) {
   std::swap(this->ptr, obj.ptr);

 qpolynomial_list::qpolynomial_list()
     : ptr(nullptr) {}
 
 qpolynomial_list::qpolynomial_list(const qpolynomial_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-qpolynomial_list::qpolynomial_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 qpolynomial_list::qpolynomial_list(__isl_take isl_qpolynomial_list *ptr)
     : ptr(ptr) {}
 
 
 qpolynomial_list &qpolynomial_list::operator=(qpolynomial_list obj) {
   std::swap(this->ptr, obj.ptr);

 schedule::schedule()
     : ptr(nullptr) {}
 
 schedule::schedule(const schedule &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-schedule::schedule(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 schedule::schedule(__isl_take isl_schedule *ptr)
     : ptr(ptr) {}
 
 schedule::schedule(ctx ctx, const std::string &str)
 {
   auto res = isl_schedule_read_from_str(ctx.release(), str.c_str());

 schedule_constraints::schedule_constraints()
     : ptr(nullptr) {}
 
 schedule_constraints::schedule_constraints(const schedule_constraints &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-schedule_constraints::schedule_constraints(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 schedule_constraints::schedule_constraints(__isl_take isl_schedule_constraints *ptr)
     : ptr(ptr) {}
 
 schedule_constraints::schedule_constraints(ctx ctx, const std::string &str)
 {
   auto res = isl_schedule_constraints_read_from_str(ctx.release(), str.c_str());

 schedule_node::schedule_node()
     : ptr(nullptr) {}
 
 schedule_node::schedule_node(const schedule_node &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-schedule_node::schedule_node(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 schedule_node::schedule_node(__isl_take isl_schedule_node *ptr)
     : ptr(ptr) {}
 
 
 schedule_node &schedule_node::operator=(schedule_node obj) {
   std::swap(this->ptr, obj.ptr);

 set::set()
     : ptr(nullptr) {}
 
 set::set(const set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-set::set(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 set::set(__isl_take isl_set *ptr)
     : ptr(ptr) {}
 
 set::set(basic_set bset)
 {
   auto res = isl_set_from_basic_set(bset.release());

 set_list::set_list()
     : ptr(nullptr) {}
 
 set_list::set_list(const set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-set_list::set_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 set_list::set_list(__isl_take isl_set_list *ptr)
     : ptr(ptr) {}
 
 
 set_list &set_list::operator=(set_list obj) {
   std::swap(this->ptr, obj.ptr);

 space::space()
     : ptr(nullptr) {}
 
 space::space(const space &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-space::space(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 space::space(__isl_take isl_space *ptr)
     : ptr(ptr) {}
 
 space::space(ctx ctx, unsigned int nparam, unsigned int n_in, unsigned int n_out)
 {
   auto res = isl_space_alloc(ctx.release(), nparam, n_in, n_out);

 term::term()
     : ptr(nullptr) {}
 
 term::term(const term &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-term::term(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 term::term(__isl_take isl_term *ptr)
     : ptr(ptr) {}
 
 
 term &term::operator=(term obj) {
   std::swap(this->ptr, obj.ptr);

 union_access_info::union_access_info()
     : ptr(nullptr) {}
 
 union_access_info::union_access_info(const union_access_info &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_access_info::union_access_info(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_access_info::union_access_info(__isl_take isl_union_access_info *ptr)
     : ptr(ptr) {}
 
 union_access_info::union_access_info(union_map sink)
 {
   auto res = isl_union_access_info_from_sink(sink.release());

 union_flow::union_flow()
     : ptr(nullptr) {}
 
 union_flow::union_flow(const union_flow &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_flow::union_flow(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_flow::union_flow(__isl_take isl_union_flow *ptr)
     : ptr(ptr) {}
 
 
 union_flow &union_flow::operator=(union_flow obj) {
   std::swap(this->ptr, obj.ptr);

 union_map::union_map()
     : ptr(nullptr) {}
 
 union_map::union_map(const union_map &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_map::union_map(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_map::union_map(__isl_take isl_union_map *ptr)
     : ptr(ptr) {}
 
 union_map::union_map(basic_map bmap)
 {
   auto res = isl_union_map_from_basic_map(bmap.release());

 union_map_list::union_map_list()
     : ptr(nullptr) {}
 
 union_map_list::union_map_list(const union_map_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_map_list::union_map_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_map_list::union_map_list(__isl_take isl_union_map_list *ptr)
     : ptr(ptr) {}
 
 
 union_map_list &union_map_list::operator=(union_map_list obj) {
   std::swap(this->ptr, obj.ptr);

 union_pw_aff::union_pw_aff()
     : ptr(nullptr) {}
 
 union_pw_aff::union_pw_aff(const union_pw_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_pw_aff::union_pw_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_pw_aff::union_pw_aff(__isl_take isl_union_pw_aff *ptr)
     : ptr(ptr) {}
 
 union_pw_aff::union_pw_aff(aff aff)
 {
   auto res = isl_union_pw_aff_from_aff(aff.release());

 union_pw_aff_list::union_pw_aff_list()
     : ptr(nullptr) {}
 
 union_pw_aff_list::union_pw_aff_list(const union_pw_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_pw_aff_list::union_pw_aff_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_pw_aff_list::union_pw_aff_list(__isl_take isl_union_pw_aff_list *ptr)
     : ptr(ptr) {}
 
 
 union_pw_aff_list &union_pw_aff_list::operator=(union_pw_aff_list obj) {
   std::swap(this->ptr, obj.ptr);

 union_pw_multi_aff::union_pw_multi_aff()
     : ptr(nullptr) {}
 
 union_pw_multi_aff::union_pw_multi_aff(const union_pw_multi_aff &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_pw_multi_aff::union_pw_multi_aff(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_pw_multi_aff::union_pw_multi_aff(__isl_take isl_union_pw_multi_aff *ptr)
     : ptr(ptr) {}
 
 union_pw_multi_aff::union_pw_multi_aff(aff aff)
 {
   auto res = isl_union_pw_multi_aff_from_aff(aff.release());

 union_pw_multi_aff_list::union_pw_multi_aff_list()
     : ptr(nullptr) {}
 
 union_pw_multi_aff_list::union_pw_multi_aff_list(const union_pw_multi_aff_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_pw_multi_aff_list::union_pw_multi_aff_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_pw_multi_aff_list::union_pw_multi_aff_list(__isl_take isl_union_pw_multi_aff_list *ptr)
     : ptr(ptr) {}
 
 
 union_pw_multi_aff_list &union_pw_multi_aff_list::operator=(union_pw_multi_aff_list obj) {
   std::swap(this->ptr, obj.ptr);

 union_pw_qpolynomial::union_pw_qpolynomial()
     : ptr(nullptr) {}
 
 union_pw_qpolynomial::union_pw_qpolynomial(const union_pw_qpolynomial &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_pw_qpolynomial::union_pw_qpolynomial(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_pw_qpolynomial::union_pw_qpolynomial(__isl_take isl_union_pw_qpolynomial *ptr)
     : ptr(ptr) {}
 
 union_pw_qpolynomial::union_pw_qpolynomial(ctx ctx, const std::string &str)
 {
   auto res = isl_union_pw_qpolynomial_read_from_str(ctx.release(), str.c_str());

 union_set::union_set()
     : ptr(nullptr) {}
 
 union_set::union_set(const union_set &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_set::union_set(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_set::union_set(__isl_take isl_union_set *ptr)
     : ptr(ptr) {}
 
 union_set::union_set(basic_set bset)
 {
   auto res = isl_union_set_from_basic_set(bset.release());

 union_set_list::union_set_list()
     : ptr(nullptr) {}
 
 union_set_list::union_set_list(const union_set_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-union_set_list::union_set_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 union_set_list::union_set_list(__isl_take isl_union_set_list *ptr)
     : ptr(ptr) {}
 
 
 union_set_list &union_set_list::operator=(union_set_list obj) {
   std::swap(this->ptr, obj.ptr);

 val::val()
     : ptr(nullptr) {}
 
 val::val(const val &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-val::val(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 val::val(__isl_take isl_val *ptr)
     : ptr(ptr) {}
 
 val::val(ctx ctx, long i)
 {
   auto res = isl_val_int_from_si(ctx.release(), i);

 val_list::val_list()
     : ptr(nullptr) {}
 
 val_list::val_list(const val_list &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-val_list::val_list(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 val_list::val_list(__isl_take isl_val_list *ptr)
     : ptr(ptr) {}
 
 
 val_list &val_list::operator=(val_list obj) {
   std::swap(this->ptr, obj.ptr);

 vec::vec()
     : ptr(nullptr) {}
 
 vec::vec(const vec &obj)
     : ptr(nullptr)
 {
   ptr = obj.copy();
 }
-vec::vec(std::nullptr_t)
-    : ptr(nullptr) {}
 
 
 vec::vec(__isl_take isl_vec *ptr)
     : ptr(ptr) {}
 
 
 vec &vec::operator=(vec obj) {
   std::swap(this->ptr, obj.ptr);

polly/lib/Support/ISLTools.cpp

isl::union_map polly::betweenScatter(isl::union_map From, isl::union_map To,
   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)
-    return nullptr;
+    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));
 
   return Result;
 }
 
 isl::set polly::singleton(isl::union_set USet, isl::space ExpectedSpace) {
   if (!USet)
-    return nullptr;
+    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));
 
   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)
       continue;
 
     Dims = std::max(Dims, Map.dim(isl::dim::out));
   }
   return Dims;
 }
 
 isl::space polly::getScatterSpace(const isl::union_map &Schedule) {
   if (!Schedule)
-    return nullptr;
+    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::union_map Result = isl::union_map::empty(USet.get_space());

polly/lib/Transform/DeLICM.cpp

bool tryMapValue(const ScopArrayInfo *SAI, isl::map TargetElt) {
 
     // { DomainDef[] -> [Element[] -> Scatter[]] }
     auto WrittenTranslator = DefTarget.range_product(DefSched);
 
     // { [Element[] -> Scatter[]] -> ValInst[] }
     auto DefEltSched = ValInst.apply_domain(WrittenTranslator);
     simplify(DefEltSched);
 
-    Knowledge Proposed(EltZone, nullptr, filterKnownValInst(EltKnown),
-                       DefEltSched);
+    Knowledge Proposed(EltZone, {}, filterKnownValInst(EltKnown), DefEltSched);
     if (isConflicting(Proposed))
       return false;
 
     // { DomainUse[] -> Element[] }
     auto UseTarget = DefUses.reverse().apply_range(DefTarget);
 
     mapValue(SAI, std::move(DefTarget), std::move(UseTarget),
              std::move(Lifetime), std::move(Proposed));
bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
     // { [Element[] -> Zone[]] -> ValInst[] }
     auto EltLifetimeInst = WrittenKnownValue.apply_domain(LifetimeTranslator);
     simplify(EltLifetimeInst);
 
     // { [Element[] -> Zone[] }
     auto Occupied = LifetimeTranslator.range();
     simplify(Occupied);
 
-    Knowledge Proposed(Occupied, nullptr, EltLifetimeInst, Written);
+    Knowledge Proposed(Occupied, {}, EltLifetimeInst, Written);
     if (isConflicting(Proposed))
       return false;
 
     mapPHI(SAI, std::move(PHITarget), std::move(WritesTarget),
            std::move(Lifetime), std::move(Proposed));
     return true;
   }
 
if (!EltUnused || !EltKnown || !EltWritten) {
       getDebugLocations(getBBPairForRegion(&S->getRegion()), Begin, End);
       OptimizationRemarkAnalysis R(DEBUG_TYPE, "OutOfQuota", Begin,
                                    S->getEntry());
       R << "maximal number of operations exceeded during zone analysis";
       S->getFunction().getContext().diagnose(R);
       return false;
     }
 
-    Zone = OriginalZone = Knowledge(nullptr, EltUnused, EltKnown, EltWritten);
+    Zone = OriginalZone = Knowledge({}, EltUnused, EltKnown, EltWritten);
     LLVM_DEBUG(dbgs() << "Computed Zone:\n"; OriginalZone.print(dbgs(), 4));
 
     assert(Zone.isUsable() && OriginalZone.isUsable());
     return true;
   }
 
   /// Try to map as many scalars to unused array elements as possible.
   ///

polly/lib/Transform/FlattenAlgo.cpp

isl::union_map tryFlattenSequence(isl::union_map Schedule) {
 
   auto ParamSpace = Schedule.get_space().params();
   auto Dims = ScatterSet.dim(isl::dim::set);
   assert(Dims >= 2);
 
   // Would cause an infinite loop.
   if (!isDimBoundedByConstant(ScatterSet, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension is not of fixed size\n");
-    return nullptr;
+    return {};
   }
 
   auto AllDomains = Schedule.domain();
   auto AllDomainsToNull = isl::union_pw_multi_aff(AllDomains);
 
   auto NewSchedule = isl::union_map::empty(ParamSpace);
   auto Counter = isl::pw_aff(isl::local_space(ParamSpace.set_from_params()));
 
while (!ScatterSet.is_empty()) {
     auto RemainingSubSchedule = scheduleProjectOut(SubSchedule, 0, 1);
 
     auto FirstSubScatter = isl::set(FirstSubSchedule.range());
     LLVM_DEBUG(dbgs() << "Next step in sequence is:\n  " << FirstSubScatter
                       << "\n");
 
     if (!isDimBoundedByParameter(FirstSubScatter, 0)) {
       LLVM_DEBUG(dbgs() << "Abort; sequence step is not bounded\n");
-      return nullptr;
+      return {};
     }
 
     auto FirstSubScatterMap = isl::map::from_range(FirstSubScatter);
 
     // isl_set_dim_max returns a strange isl_pw_aff with domain tuple_id of
     // 'none'. It doesn't match with any space including a 0-dimensional
     // anonymous tuple.
     // Interesting, one can create such a set using
isl::union_map tryFlattenLoop(isl::union_map Schedule) {
 
   auto SubExtent = isl::set(SubSchedule.range());
   auto SubExtentDims = SubExtent.dim(isl::dim::param);
   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);
 
   if (!isDimBoundedByConstant(SubExtent, 0)) {
     LLVM_DEBUG(dbgs() << "Abort; dimension not bounded by constant\n");
-    return nullptr;
+    return {};
   }
 
   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()) {
     LLVM_DEBUG(dbgs() << "Abort; dimension bounds could not be determined\n");
-    return nullptr;
+    return {};
   }
 
   auto FirstSubScheduleAff = scheduleExtractDimAff(SubSchedule, 0);
   auto RemainingSubSchedule = scheduleProjectOut(std::move(SubSchedule), 0, 1);
 
   auto LenVal = MaxVal.sub(MinVal).add_ui(1);
   auto FirstSubScheduleNormalized = subtract(FirstSubScheduleAff, MinVal);
 

polly/lib/Transform/FlattenSchedule.cpp

virtual void printScop(raw_ostream &OS, Scop &S) const override {
     OS << "}\n\n";
 
     OS << "Schedule after flattening {\n";
     printSchedule(OS, S.getSchedule(), 4);
     OS << "}\n";
   }
 
   virtual void releaseMemory() override {
-    OldSchedule = nullptr;
+    OldSchedule = {};
     IslCtx.reset();
   }
 };
 
 char FlattenSchedule::ID;
 } // anonymous namespace
 
 Pass *polly::createFlattenSchedulePass() { return new FlattenSchedule(); }
 
 INITIALIZE_PASS_BEGIN(FlattenSchedule, "polly-flatten-schedule",
                       "Polly - Flatten schedule", false, false)
 INITIALIZE_PASS_END(FlattenSchedule, "polly-flatten-schedule",
                     "Polly - Flatten schedule", false, false)

polly/lib/Transform/ForwardOpTree.cpp

collectCompatibleElts();
       Known = computeKnown(true, true);
 
       // Preexisting ValInsts use the known content analysis of themselves.
       Translator = makeIdentityMap(Known.range(), false);
     }
 
     if (!Known || !Translator || !NormalizeMap) {
       assert(isl_ctx_last_error(IslCtx.get()) == isl_error_quota);
-      Known = nullptr;
-      Translator = nullptr;
-      NormalizeMap = nullptr;
+      Known = {};
+      Translator = {};
+      NormalizeMap = {};
       LLVM_DEBUG(dbgs() << "Known analysis exceeded max_operations\n");
       return false;
     }
 
     KnownAnalyzed++;
     LLVM_DEBUG(dbgs() << "All known: " << Known << "\n");
 
     return true;

polly/lib/Transform/ScheduleOptimizer.cpp

 }
 
 class IslScheduleOptimizerWrapperPass : public ScopPass {
 public:
   static char ID;
 
   explicit IslScheduleOptimizerWrapperPass() : ScopPass(ID) {}
 
-  ~IslScheduleOptimizerWrapperPass() override { releaseMemory(); }
-
   /// Optimize the schedule of the SCoP @p S.
   bool runOnScop(Scop &S) override;
 
   /// Print the new schedule for the SCoP @p S.
   void printScop(raw_ostream &OS, Scop &S) const override;
 
   /// Register all analyses and transformation required.
   void getAnalysisUsage(AnalysisUsage &AU) const override;
 
   /// Release the internal memory.
   void releaseMemory() override {
-    LastSchedule = nullptr;
+    LastSchedule = {};
     IslCtx.reset();
   }
 
 private:
   std::shared_ptr<isl_ctx> IslCtx;
   isl::schedule LastSchedule;
 };
 

polly/lib/Transform/ZoneAlgo.cpp

isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
   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)
-    return nullptr;
+    return {};
 
   assert(SAI->isPHIKind());
 
   // { DomainPHIWrite[] -> Scatter[] }
   isl::union_map PHIWriteScatter = makeEmptyUnionMap();
 
   // Collect all incoming block timepoints.
   for (MemoryAccess *MA : S->getPHIIncomings(SAI)) {

 }
 
 isl::map ZoneAlgorithm::makeUnknownForDomain(ScopStmt *Stmt) const {
   return ::makeUnknownForDomain(getDomainFor(Stmt));
 }
 
 isl::id ZoneAlgorithm::makeValueId(Value *V) {
   if (!V)
-    return nullptr;
+    return {};
 
   auto &Id = ValueIds[V];
   if (Id.is_null()) {
     auto Name = getIslCompatibleName("Val_", V, ValueIds.size() - 1,
                                      std::string(), UseInstructionNames);
     Id = isl::id::alloc(IslCtx.get(), Name.c_str(), V);
   }
   return Id;

polly/unittests/DeLICM/DeLICMTest.cpp

 typedef struct {
   const char *OccupiedStr;
   const char *UndefStr;
   const char *WrittenStr;
 } KnowledgeStr;
 
 isl::union_set parseSetOrNull(isl_ctx *Ctx, const char *Str) {
   if (!Str)
-    return nullptr;
+    return {};
   return isl::union_set(Ctx, Str);
 }
 
 isl::union_map parseMapOrNull(isl_ctx *Ctx, const char *Str) {
   if (!Str)
-    return nullptr;
+    return {};
   return isl::union_map(Ctx, Str);
 }
 
 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) {