AST: Relax an assertion in constexpr constructor evaluation.

[pcc]

Summary

It's possible for the base type specified in a constructor to be
qualified via sugar, so the existing assertion was too strict. Relax
it so that we only check that the unqualified types are the same.

clang/lib/AST/ExprConstant.cpp

for (const auto *I : Definition->inits()) {
     // Determine the subobject to initialize.
     FieldDecl *FD = nullptr;
     if (I->isBaseInitializer()) {
       QualType BaseType(I->getBaseClass(), 0);
 #ifndef NDEBUG
       // Non-virtual base classes are initialized in the order in the class
       // definition. We have already checked for virtual base classes.
       assert(!BaseIt->isVirtual() && "virtual base for literal type");
-      assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
+      assert(Info.Ctx.hasSameUnqualifiedType(BaseIt->getType(), BaseType) &&
              "base class initializers not in expected order");
       ++BaseIt;
 #endif
       if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,
                                   BaseType->getAsCXXRecordDecl(), &Layout))
         return false;
       Value = &Result.getStructBase(BasesSeen++);
     } else if ((FD = I->getMember())) {

clang/test/SemaCXX/constant-expression-cxx11.cpp

namespace PointerArithmeticOverflow {
   constexpr int *e = a + 1 + (long)-1;
   constexpr int *f = a + 1 + (unsigned long)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element 1844}}
   constexpr int *g = a + 1 - (unsigned long)1;
 
   constexpr int *p = (&n + 1) + (unsigned __int128)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element 3402}}
   constexpr int *q = (&n + 1) - (unsigned __int128)-1; // expected-error {{constant expression}} expected-note {{cannot refer to element -3402}}
   constexpr int *r = &(&n + 1)[(unsigned __int128)-1]; // expected-error {{constant expression}} expected-note {{cannot refer to element 3402}}
 }
+
+namespace QualifiedBaseType {
+  template <class T>
+  struct A : T {
+  public:
+    constexpr A() : T() {}
+  };
+
+  struct S {};
+
+  A<const S> a;
+}