Add const information about AST nodes used to construct CFG elements.

[merrymeerkat]

Summary

Most constructors and destructors in CFG.h already specify const arguments, but some are missing this.

clang/include/clang/Analysis/CFG.h

public:
 
   void dump() const {
     dumpToStream(llvm::errs());
   }
 };
 
 class CFGStmt : public CFGElement {
 public:
-  explicit CFGStmt(Stmt *S, Kind K = Statement) : CFGElement(K, S) {
+  explicit CFGStmt(const Stmt *S, Kind K = Statement) : CFGElement(K, S) {
     assert(isKind(*this));
   }
 
   const Stmt *getStmt() const {
     return static_cast<const Stmt *>(Data1.getPointer());
   }
 
 private:
   friend class CFGElement;
 
   static bool isKind(const CFGElement &E) {
     return E.getKind() >= STMT_BEGIN && E.getKind() <= STMT_END;
   }
 
 protected:
   CFGStmt() = default;
 };
 
 /// Represents C++ constructor call. Maintains information necessary to figure
 /// out what memory is being initialized by the constructor expression. For now
 /// this is only used by the analyzer's CFG.
 class CFGConstructor : public CFGStmt {
 public:
-  explicit CFGConstructor(CXXConstructExpr *CE, const ConstructionContext *C)
+  explicit CFGConstructor(const CXXConstructExpr *CE,
+                          const ConstructionContext *C)
       : CFGStmt(CE, Constructor) {
     assert(C);
     Data2.setPointer(const_cast<ConstructionContext *>(C));
   }
 
   const ConstructionContext *getConstructionContext() const {
     return static_cast<ConstructionContext *>(Data2.getPointer());
   }

 /// storage of the returned object . In C such tracking is not necessary because
 /// no additional effort is required for destroying the object or modeling copy
 /// elision. Like CFGConstructor, this element is for now only used by the
 /// analyzer's CFG.
 class CFGCXXRecordTypedCall : public CFGStmt {
 public:
   /// Returns true when call expression \p CE needs to be represented
   /// by CFGCXXRecordTypedCall, as opposed to a regular CFGStmt.
-  static bool isCXXRecordTypedCall(Expr *E) {
+  static bool isCXXRecordTypedCall(const Expr *E) {
     assert(isa<CallExpr>(E) || isa<ObjCMessageExpr>(E));
     // There is no such thing as reference-type expression. If the function
     // returns a reference, it'll return the respective lvalue or xvalue
     // instead, and we're only interested in objects.
     return !E->isGLValue() &&
            E->getType().getCanonicalType()->getAsCXXRecordDecl();
   }
 
-  explicit CFGCXXRecordTypedCall(Expr *E, const ConstructionContext *C)
+  explicit CFGCXXRecordTypedCall(const Expr *E, const ConstructionContext *C)
       : CFGStmt(E, CXXRecordTypedCall) {
     assert(isCXXRecordTypedCall(E));
     assert(C && (isa<TemporaryObjectConstructionContext>(C) ||
                  // These are possible in C++17 due to mandatory copy elision.
                  isa<ReturnedValueConstructionContext>(C) ||
                  isa<VariableConstructionContext>(C) ||
                  isa<ConstructorInitializerConstructionContext>(C) ||
                  isa<ArgumentConstructionContext>(C) ||
static bool isKind(const CFGElement &E) {
     return E.getKind() == CXXRecordTypedCall;
   }
 };
 
 /// Represents C++ base or member initializer from constructor's initialization
 /// list.
 class CFGInitializer : public CFGElement {
 public:
-  explicit CFGInitializer(CXXCtorInitializer *initializer)
+  explicit CFGInitializer(const CXXCtorInitializer *initializer)
       : CFGElement(Initializer, initializer) {}
 
   CXXCtorInitializer* getInitializer() const {
     return static_cast<CXXCtorInitializer*>(Data1.getPointer());
   }
 
 private:
   friend class CFGElement;
static bool isKind(const CFGElement &E) {
     return E.getKind() == MemberDtor;
   }
 };
 
 /// Represents C++ object destructor implicitly generated at the end of full
 /// expression for temporary object.
 class CFGTemporaryDtor : public CFGImplicitDtor {
 public:
-  CFGTemporaryDtor(CXXBindTemporaryExpr *expr)
+  CFGTemporaryDtor(const CXXBindTemporaryExpr *expr)
       : CFGImplicitDtor(TemporaryDtor, expr, nullptr) {}
 
   const CXXBindTemporaryExpr *getBindTemporaryExpr() const {
     return static_cast<const CXXBindTemporaryExpr *>(Data1.getPointer());
   }
 
 private:
   friend class CFGElement;