commit c9e8f606787b0bc0c3b08e566b87cc1751694168
author Eli Friedman <eli.friedman@gmail.com> Sun Jan 25 02:32:41 2009 +0000
committer Eli Friedman <eli.friedman@gmail.com> Sun Jan 25 02:32:41 2009 +0000
tree 7002417366ea3667e62ae3c9dc744226f02fae8e
parent 1ef0965bbd46a2915746ffe8067d411b18117415

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

include/clang/AST/Expr.h

diff --git a/include/clang/AST/Expr.h b/include/clang/AST/Expr.h
index 19cd5d5..5d768cd 100644
--- a/include/clang/AST/Expr.h
+++ b/include/clang/AST/Expr.h
@@ -181,8 +181,9 @@
     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 {

lib/AST/Expr.cpp

diff --git a/lib/AST/Expr.cpp b/lib/AST/Expr.cpp
index 70b63fe..86f1cd9 100644
--- a/lib/AST/Expr.cpp
+++ b/lib/AST/Expr.cpp
@@ -692,11 +692,10 @@
   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 @@
     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;
     }
   }

lib/Analysis/CheckDeadStores.cpp

diff --git a/lib/Analysis/CheckDeadStores.cpp b/lib/Analysis/CheckDeadStores.cpp
index 4f51cd8..d5e5f4c 100644
--- a/lib/Analysis/CheckDeadStores.cpp
+++ b/lib/Analysis/CheckDeadStores.cpp
@@ -195,7 +195,7 @@
               // 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());
             }
           }

lib/CodeGen/CGDecl.cpp

diff --git a/lib/CodeGen/CGDecl.cpp b/lib/CodeGen/CGDecl.cpp
index 1acebae..6774f33 100644
--- a/lib/CodeGen/CGDecl.cpp
+++ b/lib/CodeGen/CGDecl.cpp
@@ -86,7 +86,7 @@
   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 && 

lib/CodeGen/CGExprAgg.cpp

diff --git a/lib/CodeGen/CGExprAgg.cpp b/lib/CodeGen/CGExprAgg.cpp
index 5e36751..058b561 100644
--- a/lib/CodeGen/CGExprAgg.cpp
+++ b/lib/CodeGen/CGExprAgg.cpp
@@ -394,7 +394,7 @@
   // 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,