[analyzer] NFC: Mark default constructors for ProgramPoints.

[NoQ]

Summary

As suggested by Gabor in D41800, replace {} with = default for ProgramPoint default constructors.

[dcoughlin]

LGTM!

cfe/trunk/include/clang/Analysis/ProgramPoint.h

private:
 
   // The LocationContext could be NULL to allow ProgramPoint to be used in
   // context insensitive analysis.
   llvm::PointerIntPair<const LocationContext *, 2, unsigned> L;
 
   llvm::PointerIntPair<const ProgramPointTag *, 2, unsigned> Tag;
 
 protected:
-  ProgramPoint() {}
+  ProgramPoint() = default;
   ProgramPoint(const void *P,
                Kind k,
                const LocationContext *l,
                const ProgramPointTag *tag = nullptr)
     : Data1(P),
       Data2(nullptr, (((unsigned) k) >> 0) & 0x3),
       L(l, (((unsigned) k) >> 2) & 0x3),
       Tag(tag, (((unsigned) k) >> 4) & 0x3) {
public:
 
   Optional<CFGElement> getFirstElement() const {
     const CFGBlock *B = getBlock();
     return B->empty() ? Optional<CFGElement>() : B->front();
   }
   
 private:
   friend class ProgramPoint;
-  BlockEntrance() {}
+  BlockEntrance() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockEntranceKind;
   }
 };
 
 class BlockExit : public ProgramPoint {
 public:
   BlockExit(const CFGBlock *B, const LocationContext *L)
     : ProgramPoint(B, BlockExitKind, L) {}
 
   const CFGBlock *getBlock() const {
     return reinterpret_cast<const CFGBlock*>(getData1());
   }
 
   const Stmt *getTerminator() const {
     return getBlock()->getTerminator();
   }
 
 private:
   friend class ProgramPoint;
-  BlockExit() {}
+  BlockExit() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockExitKind;
   }
 };
 
 class StmtPoint : public ProgramPoint {
 public:
   StmtPoint(const Stmt *S, const void *p2, Kind k, const LocationContext *L,
             const ProgramPointTag *tag)
     : ProgramPoint(S, p2, k, L, tag) {
     assert(S);
   }
 
   const Stmt *getStmt() const { return (const Stmt*) getData1(); }
 
   template <typename T>
   const T* getStmtAs() const { return dyn_cast<T>(getStmt()); }
 
 protected:
-  StmtPoint() {}
+  StmtPoint() = default;
 private:
   friend class ProgramPoint;
   static bool isKind(const ProgramPoint &Location) {
     unsigned k = Location.getKind();
     return k >= PreStmtKind && k <= MaxPostStmtKind;
   }
 };
 
 
 class PreStmt : public StmtPoint {
 public:
   PreStmt(const Stmt *S, const LocationContext *L, const ProgramPointTag *tag,
           const Stmt *SubStmt = nullptr)
     : StmtPoint(S, SubStmt, PreStmtKind, L, tag) {}
 
   const Stmt *getSubStmt() const { return (const Stmt*) getData2(); }
 
 private:
   friend class ProgramPoint;
-  PreStmt() {}
+  PreStmt() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PreStmtKind;
   }
 };
 
 class PostStmt : public StmtPoint {
 protected:
-  PostStmt() {}
+  PostStmt() = default;
   PostStmt(const Stmt *S, const void *data, Kind k, const LocationContext *L,
            const ProgramPointTag *tag = nullptr)
     : StmtPoint(S, data, k, L, tag) {}
 
 public:
   explicit PostStmt(const Stmt *S, Kind k, const LocationContext *L,
                     const ProgramPointTag *tag = nullptr)
     : StmtPoint(S, nullptr, k, L, tag) {}

 class PostCondition : public PostStmt {
 public:
   PostCondition(const Stmt *S, const LocationContext *L,
                 const ProgramPointTag *tag = nullptr)
     : PostStmt(S, PostConditionKind, L, tag) {}
 
 private:
   friend class ProgramPoint;
-  PostCondition() {}
+  PostCondition() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostConditionKind;
   }
 };
 
 class LocationCheck : public StmtPoint {
 protected:
-  LocationCheck() {}
+  LocationCheck() = default;
   LocationCheck(const Stmt *S, const LocationContext *L,
                 ProgramPoint::Kind K, const ProgramPointTag *tag)
     : StmtPoint(S, nullptr, K, L, tag) {}
     
 private:
   friend class ProgramPoint;
   static bool isKind(const ProgramPoint &location) {
     unsigned k = location.getKind();
     return k == PreLoadKind || k == PreStoreKind;
   }
 };
   
 class PreLoad : public LocationCheck {
 public:
   PreLoad(const Stmt *S, const LocationContext *L,
           const ProgramPointTag *tag = nullptr)
     : LocationCheck(S, L, PreLoadKind, tag) {}
   
 private:
   friend class ProgramPoint;
-  PreLoad() {}
+  PreLoad() = default;
   static bool isKind(const ProgramPoint &location) {
     return location.getKind() == PreLoadKind;
   }
 };
 
 class PreStore : public LocationCheck {
 public:
   PreStore(const Stmt *S, const LocationContext *L,
            const ProgramPointTag *tag = nullptr)
   : LocationCheck(S, L, PreStoreKind, tag) {}
   
 private:
   friend class ProgramPoint;
-  PreStore() {}
+  PreStore() = default;
   static bool isKind(const ProgramPoint &location) {
     return location.getKind() == PreStoreKind;
   }
 };
 
 class PostLoad : public PostStmt {
 public:
   PostLoad(const Stmt *S, const LocationContext *L,
            const ProgramPointTag *tag = nullptr)
     : PostStmt(S, PostLoadKind, L, tag) {}
 
 private:
   friend class ProgramPoint;
-  PostLoad() {}
+  PostLoad() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostLoadKind;
   }
 };
 
 /// \brief Represents a program point after a store evaluation.
 class PostStore : public PostStmt {
 public:
public:
   /// \brief Returns the information about the location used in the store,
   /// how it was uttered in the code.
   const void *getLocationValue() const {
     return getData2();
   }
 
 private:
   friend class ProgramPoint;
-  PostStore() {}
+  PostStore() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostStoreKind;
   }
 };
 
 class PostLValue : public PostStmt {
 public:
   PostLValue(const Stmt *S, const LocationContext *L,
              const ProgramPointTag *tag = nullptr)
     : PostStmt(S, PostLValueKind, L, tag) {}
 
 private:
   friend class ProgramPoint;
-  PostLValue() {}
+  PostLValue() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostLValueKind;
   }
 };
 
 /// Represents a point after we ran remove dead bindings BEFORE
 /// processing the given statement.
 class PreStmtPurgeDeadSymbols : public StmtPoint {
 public:
   PreStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
                        const ProgramPointTag *tag = nullptr)
     : StmtPoint(S, nullptr, PreStmtPurgeDeadSymbolsKind, L, tag) { }
 
 private:
   friend class ProgramPoint;
-  PreStmtPurgeDeadSymbols() {}
+  PreStmtPurgeDeadSymbols() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PreStmtPurgeDeadSymbolsKind;
   }
 };
 
 /// Represents a point after we ran remove dead bindings AFTER
 /// processing the  given statement.
 class PostStmtPurgeDeadSymbols : public StmtPoint {
 public:
   PostStmtPurgeDeadSymbols(const Stmt *S, const LocationContext *L,
                        const ProgramPointTag *tag = nullptr)
     : StmtPoint(S, nullptr, PostStmtPurgeDeadSymbolsKind, L, tag) { }
 
 private:
   friend class ProgramPoint;
-  PostStmtPurgeDeadSymbols() {}
+  PostStmtPurgeDeadSymbols() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostStmtPurgeDeadSymbolsKind;
   }
 };
 
 class BlockEdge : public ProgramPoint {
 public:
   BlockEdge(const CFGBlock *B1, const CFGBlock *B2, const LocationContext *L)
     : ProgramPoint(B1, B2, BlockEdgeKind, L) {
     assert(B1 && "BlockEdge: source block must be non-null");
     assert(B2 && "BlockEdge: destination block must be non-null");    
   }
 
   const CFGBlock *getSrc() const {
     return static_cast<const CFGBlock*>(getData1());
   }
 
   const CFGBlock *getDst() const {
     return static_cast<const CFGBlock*>(getData2());
   }
 
 private:
   friend class ProgramPoint;
-  BlockEdge() {}
+  BlockEdge() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == BlockEdgeKind;
   }
 };
 
 class PostInitializer : public ProgramPoint {
 public:
   /// \brief Construct a PostInitializer point that represents a location after
public:
 
   /// \brief Returns the location of the field.
   const void *getLocationValue() const {
     return getData2();
   }
 
 private:
   friend class ProgramPoint;
-  PostInitializer() {}
+  PostInitializer() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostInitializerKind;
   }
 };
 
 /// Represents an implicit call event.
 ///
 /// The nearest statement is provided for diagnostic purposes.
 class ImplicitCallPoint : public ProgramPoint {
 public:
   ImplicitCallPoint(const Decl *D, SourceLocation Loc, Kind K,
                     const LocationContext *L, const ProgramPointTag *Tag)
     : ProgramPoint(Loc.getPtrEncoding(), D, K, L, Tag) {}
 
   const Decl *getDecl() const { return static_cast<const Decl *>(getData2()); }
   SourceLocation getLocation() const {
     return SourceLocation::getFromPtrEncoding(getData1());
   }
 
 protected:
-  ImplicitCallPoint() {}
+  ImplicitCallPoint() = default;
 private:
   friend class ProgramPoint;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() >= MinImplicitCallKind &&
            Location.getKind() <= MaxImplicitCallKind;
   }
 };
 
 /// Represents a program point just before an implicit call event.
 ///
 /// Explicit calls will appear as PreStmt program points.
 class PreImplicitCall : public ImplicitCallPoint {
 public:
   PreImplicitCall(const Decl *D, SourceLocation Loc, const LocationContext *L,
                   const ProgramPointTag *Tag = nullptr)
     : ImplicitCallPoint(D, Loc, PreImplicitCallKind, L, Tag) {}
 
 private:
   friend class ProgramPoint;
-  PreImplicitCall() {}
+  PreImplicitCall() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PreImplicitCallKind;
   }
 };
 
 /// Represents a program point just after an implicit call event.
 ///
 /// Explicit calls will appear as PostStmt program points.
 class PostImplicitCall : public ImplicitCallPoint {
 public:
   PostImplicitCall(const Decl *D, SourceLocation Loc, const LocationContext *L,
                    const ProgramPointTag *Tag = nullptr)
     : ImplicitCallPoint(D, Loc, PostImplicitCallKind, L, Tag) {}
 
 private:
   friend class ProgramPoint;
-  PostImplicitCall() {}
+  PostImplicitCall() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostImplicitCallKind;
   }
 };
 
 class PostAllocatorCall : public StmtPoint {
 public:
   PostAllocatorCall(const Stmt *S, const LocationContext *L,
                     const ProgramPointTag *Tag = nullptr)
       : StmtPoint(S, nullptr, PostAllocatorCallKind, L, Tag) {}
 
 private:
   friend class ProgramPoint;
-  PostAllocatorCall() {}
+  PostAllocatorCall() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == PostAllocatorCallKind;
   }
 };
 
 /// Represents a point when we begin processing an inlined call.
 /// CallEnter uses the caller's location context.
 class CallEnter : public ProgramPoint {
public:
   const CFGBlock *getEntry() const {
     const StackFrameContext *CalleeCtx = getCalleeContext();
     const CFG *CalleeCFG = CalleeCtx->getCFG();
     return &(CalleeCFG->getEntry());
   }
 
 private:
   friend class ProgramPoint;
-  CallEnter() {}
+  CallEnter() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallEnterKind;
   }
 };
 
 /// Represents a point when we start the call exit sequence (for inlined call).
 ///
 /// The call exit is simulated with a sequence of nodes, which occur between
 /// CallExitBegin and CallExitEnd. The following operations occur between the
 /// two program points:
 /// - CallExitBegin
 /// - Bind the return value
 /// - Run Remove dead bindings (to clean up the dead symbols from the callee).
 /// - CallExitEnd
 class CallExitBegin : public ProgramPoint {
 public:
   // CallExitBegin uses the callee's location context.
   CallExitBegin(const StackFrameContext *L, const ReturnStmt *RS)
     : ProgramPoint(RS, CallExitBeginKind, L, nullptr) { }
 
 private:
   friend class ProgramPoint;
-  CallExitBegin() {}
+  CallExitBegin() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitBeginKind;
   }
 };
 
 /// Represents a point when we finish the call exit sequence (for inlined call).
 /// \sa CallExitBegin
 class CallExitEnd : public ProgramPoint {
 public:
   // CallExitEnd uses the caller's location context.
   CallExitEnd(const StackFrameContext *CalleeCtx,
               const LocationContext *CallerCtx)
     : ProgramPoint(CalleeCtx, CallExitEndKind, CallerCtx, nullptr) {}
 
   const StackFrameContext *getCalleeContext() const {
     return static_cast<const StackFrameContext *>(getData1());
   }
 
 private:
   friend class ProgramPoint;
-  CallExitEnd() {}
+  CallExitEnd() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == CallExitEndKind;
   }
 };
 
 /// Represents a point when we exit a loop.
 /// When this ProgramPoint is encountered we can be sure that the symbolic
 /// execution of the corresponding LoopStmt is finished on the given path.
 /// Note: It is possible to encounter a LoopExit element when we haven't even
 /// encountered the loop itself. At the current state not all loop exits will
 /// result in a LoopExit program point.
 class LoopExit : public ProgramPoint {
 public:
     LoopExit(const Stmt *LoopStmt, const LocationContext *LC)
             : ProgramPoint(LoopStmt, nullptr, LoopExitKind, LC) {}
 
     const Stmt *getLoopStmt() const {
       return static_cast<const Stmt *>(getData1());
     }
 
 private:
     friend class ProgramPoint;
-    LoopExit() {}
+    LoopExit() = default;
     static bool isKind(const ProgramPoint &Location) {
       return Location.getKind() == LoopExitKind;
     }
 };
 
 /// This is a meta program point, which should be skipped by all the diagnostic
 /// reasoning etc.
 class EpsilonPoint : public ProgramPoint {
 public:
   EpsilonPoint(const LocationContext *L, const void *Data1,
                const void *Data2 = nullptr,
                const ProgramPointTag *tag = nullptr)
     : ProgramPoint(Data1, Data2, EpsilonKind, L, tag) {}
 
   const void *getData() const { return getData1(); }
 
 private:
   friend class ProgramPoint;
-  EpsilonPoint() {}
+  EpsilonPoint() = default;
   static bool isKind(const ProgramPoint &Location) {
     return Location.getKind() == EpsilonKind;
   }
 };
 
 } // end namespace clang