Rename Expr::isConstantExpr to Expr::isConstantInitializer; this more

accurately states what the function is trying to do and how it is
different from Expr::isEvaluatable.  Also get rid of a parameter that is both
unused and inaccurate.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@62951 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 19cd5d5786bc6bf4dbc4fbbba651de9bc78fc19e..5d768cd9dba319881cbf8bb18a89deb4f5cb1edf 100644 (file)
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -181,8 +181,9 @@ public:
     llvm::APSInt X;
     return isIntegerConstantExpr(X, Ctx, Loc);
   }
-  /// isConstantExpr - Return true if this expression is a valid constant expr.
-  bool isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const;
+  /// isConstantInitializer - Returns true if this expression is a constant
+  /// initializer, which can be emitted at compile-time.
+  bool isConstantInitializer(ASTContext &Ctx) const;
   
   /// EvalResult is a struct with detailed info about an evaluated expression.
   struct EvalResult {

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 70b63fea1bd6cf0897538f33f9e37005a684ba7b..86f1cd9fdbad424ac65154abe23f52f4b6ee6a15 100644 (file)
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -692,11 +692,10 @@ bool Expr::hasAnyValueDependentArguments(Expr** Exprs, unsigned NumExprs) {
   return false;
 }
 
-bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
+bool Expr::isConstantInitializer(ASTContext &Ctx) const {
   switch (getStmtClass()) {
   default:
     if (!isEvaluatable(Ctx)) {
-      if (Loc) *Loc = getLocStart();
       return false;
     }
     break;
@@ -704,13 +703,13 @@ bool Expr::isConstantExpr(ASTContext &Ctx, SourceLocation *Loc) const {
     return true;
   case CompoundLiteralExprClass: {
     const Expr *Exp = cast<CompoundLiteralExpr>(this)->getInitializer();
-    return Exp->isConstantExpr(Ctx, Loc);
+    return Exp->isConstantInitializer(Ctx);
   }
   case InitListExprClass: {
     const InitListExpr *Exp = cast<InitListExpr>(this);
     unsigned numInits = Exp->getNumInits();
     for (unsigned i = 0; i < numInits; i++) {
-      if (!Exp->getInit(i)->isConstantExpr(Ctx, Loc)) 
+      if (!Exp->getInit(i)->isConstantInitializer(Ctx)) 
         return false;
     }
   }

diff --git a/lib/Analysis/CheckDeadStores.cpp b/lib/Analysis/CheckDeadStores.cpp
index 4f51cd8d9ae7bf3d7a0a2ecf4d578b1d7ee4dbbb..d5e5f4c9b2a207d99342d722d98858c13223aa1c 100644 (file)
--- a/lib/Analysis/CheckDeadStores.cpp
+++ b/lib/Analysis/CheckDeadStores.cpp
@@ -195,7 +195,7 @@ public:
               // If x is EVER assigned a new value later, don't issue
               // a warning.  This is because such initialization can be
               // due to defensive programming.
-              if (!E->isConstantExpr(Ctx,NULL))
+              if (!E->isConstantInitializer(Ctx))
                 Report(V, DeadInit, V->getLocation(), E->getSourceRange());
             }
           }

diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp
index 1acebaed4b936ff36b9de7a752f0205b05512b89..6774f33337ae34d7e809edb9294efdd4f7db818f 100644 (file)
--- a/lib/CodeGen/CGDecl.cpp
+++ b/lib/CodeGen/CGDecl.cpp
@@ -86,7 +86,7 @@ CodeGenFunction::GenerateStaticBlockVarDecl(const VarDecl &D,
   if ((D.getInit() == 0) || NoInit) {
     Init = llvm::Constant::getNullValue(LTy);
   } else {
-    if (D.getInit()->isConstantExpr(getContext(), 0))
+    if (D.getInit()->isConstantInitializer(getContext()))
       Init = CGM.EmitConstantExpr(D.getInit(), this);
     else {
       assert(getContext().getLangOptions().CPlusPlus && 

diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 5e36751fb7693ae2baa2d19af94880e4cb91e408..058b561f95b3874d8e108af100ae33a5a625f6f8 100644 (file)
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -394,7 +394,7 @@ void AggExprEmitter::VisitInitListExpr(InitListExpr *E) {
   // FIXME: Should we really be doing this? Should we try to avoid
   // cases where we emit a global with a lot of zeros?  Should
   // we try to avoid short globals? 
-  if (E->isConstantExpr(CGF.getContext(), 0)) {
+  if (E->isConstantInitializer(CGF.getContext(), 0)) {
     llvm::Constant* C = CGF.CGM.EmitConstantExpr(E, &CGF);
     llvm::GlobalVariable* GV =
     new llvm::GlobalVariable(C->getType(), true,