Revert change that made isNullPointerConstant start emitting warnings. We don't want that :)

llvm-svn: 60333

1 files changed, 9 insertions, 11 deletions

diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 4c86ce67efa..948dbc24189 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -1009,12 +1009,6 @@ bool Expr::isIntegerConstantExpr(llvm::APSInt &Result, ASTContext &Ctx,
 /// cast to void*.
 bool Expr::isNullPointerConstant(ASTContext &Ctx) const
 {
-  EvalResult EvalResult;
-  
-  return isNullPointerConstant(EvalResult, Ctx);
-}
-
-bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
   // Strip off a cast to void*, if it exists. Except in C++.
   if (const ExplicitCastExpr *CE = dyn_cast<ExplicitCastExpr>(this)) {
     if (!Ctx.getLangOptions().CPlusPlus) {
@@ -1024,20 +1018,20 @@ bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
         if (Pointee.getCVRQualifiers() == 0 && 
             Pointee->isVoidType() &&                              // to void*
             CE->getSubExpr()->getType()->isIntegerType())         // from int.
-          return CE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+          return CE->getSubExpr()->isNullPointerConstant(Ctx);
       }
     }
   } else if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(this)) {
     // Ignore the ImplicitCastExpr type entirely.
-    return ICE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+    return ICE->getSubExpr()->isNullPointerConstant(Ctx);
   } else if (const ParenExpr *PE = dyn_cast<ParenExpr>(this)) {
     // Accept ((void*)0) as a null pointer constant, as many other
     // implementations do.
-    return PE->getSubExpr()->isNullPointerConstant(Result, Ctx);
+    return PE->getSubExpr()->isNullPointerConstant(Ctx);
   } else if (const CXXDefaultArgExpr *DefaultArg 
                = dyn_cast<CXXDefaultArgExpr>(this)) {
     // See through default argument expressions
-    return DefaultArg->getExpr()->isNullPointerConstant(Result, Ctx);
+    return DefaultArg->getExpr()->isNullPointerConstant(Ctx);
   } else if (isa<GNUNullExpr>(this)) {
     // The GNU __null extension is always a null pointer constant.
     return true;
@@ -1049,8 +1043,12 @@ bool Expr::isNullPointerConstant(EvalResult &Result, ASTContext &Ctx) const {
   
   // If we have an integer constant expression, we need to *evaluate* it and
   // test for the value 0.
+  // FIXME: We should probably return false if we're compiling in strict mode
+  // and Diag is not null (this indicates that the value was foldable but not
+  // an ICE.
+  EvalResult Result;
   return Evaluate(Result, Ctx) && !Result.HasSideEffects &&
-      Result.Val.isInt() && Result.Val.getInt() == 0;
+        Result.Val.isInt() && Result.Val.getInt() == 0;
 }
 
 /// isBitField - Return true if this expression is a bit-field.