Remove redundant check for value dependency of null pointer constant

[dyp-cpp]

Summary

In SemaOverload.cpp, the isNullPointerConstantForConversion function contains a redundant check for value dependency of a null pointer constant. The same check is performed in Expr::isNullPointerConstant, where the implementation is adapted to various special cases and better maintained. E.g. in C++11 and C++14 modes, the version in SemaOverload.cpp yields wrong results.

As it turned out, the test case for PR20110 already contained a note that this test should actually fail in C++11 mode. I've split this test case into two files for C++03 mode (which reproduces the original behaviour) and C++11 mode (new behaviour).

lib/Sema/SemaOverload.cpp

BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
   if (isa<ObjCObjectPointerType>(ToType))
     return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
   return Context.getPointerType(QualifiedCanonToPointee);
 }
 
 static bool isNullPointerConstantForConversion(Expr *Expr,
                                                bool InOverloadResolution,
                                                ASTContext &Context) {
-  // Handle value-dependent integral null pointer constants correctly.
-  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
-  if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
-      Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
-    return !InOverloadResolution;
+  // Within overload resolution, pre CWG 903, value-dependent integral constant
+  // expressions shall not be considered as null pointer constants.
+  // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#903
+  // The resolution of CWG 903 requires null pointer constants to be literals,
+  // which has also been implemented in C++11 mode. In those cases, the
+  // @InOverloadResolution parameter is effectively unused.
+  const Expr::NullPointerConstantValueDependence vd = InOverloadResolution
+    ? Expr::NPC_ValueDependentIsNotNull
+    : Expr::NPC_ValueDependentIsNull;
   
-  return Expr->isNullPointerConstant(Context,
-                    InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
-                                        : Expr::NPC_ValueDependentIsNull);
+  return Expr->isNullPointerConstant(Context, vd);
 }
 
 /// IsPointerConversion - Determines whether the conversion of the
 /// expression From, which has the (possibly adjusted) type FromType,
 /// can be converted to the type ToType via a pointer conversion (C++
 /// 4.10). If so, returns true and places the converted type (that
 /// might differ from ToType in its cv-qualifiers at some level) into
 /// ConvertedType.

test/SemaCXX/PR20110.cpp

-// RUN: %clang_cc1 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++03 %s
 // expected-no-diagnostics
 
-// FIXME: These templates should trigger errors in C++11 mode.
-
 template <char const *p>
 class A {
   char const *get_p() { return *p; }
 };
 template <int p>
 class B {
   char const *get_p() { return p; }
 };
 

test/SemaCXX/cxx11-PR20110.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
+
+template <char const *p>
+class A {
+  char const *get_p() { return *p; } // expected-error {{cannot initialize}}
+};
+template <int p>
+class B {
+  char const *get_p() { return p; } // expected-error {{cannot initialize}}
+};
+