From: Eli Friedman <eli.friedman@gmail.com>
Date: Sun, 25 Jan 2009 02:32:41 +0000 (+0000)
Subject: Rename Expr::isConstantExpr to Expr::isConstantInitializer; this more
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=c9e8f606787b0bc0c3b08e566b87cc1751694168;p=clang

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 19cd5d5786..5d768cd9db 100644
--- 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 70b63fea1b..86f1cd9fdb 100644
--- 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 4f51cd8d9a..d5e5f4c9b2 100644
--- 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 1acebaed4b..6774f33337 100644
--- 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 5e36751fb7..058b561f95 100644
--- 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,