[SemaDeclCXX] Allow inheriting constructor declaration that specify a cv-qualified type

[cpplearner]

Summary

This will allow the following code:

struct base {};
using cbase = const base;
struct inherit : cbase {
    using cbase::cbase; // previously error: 'cbase' (aka 'const base') is not a direct base of 'inherit', cannot inherit constructors
};

See https://stackoverflow.com/questions/50534219/inherit-from-const-type-passed-as-template-parameter

[rustam]

I believe this fixed the bug #37600

[rsmith]

lib/Sema/SemaDeclCXX.cpp

9690 ↗

(On Diff #148744)

How are we getting a qualified type here? Is this actually a bug in getCanonicalTypeUnqualified?

[cpplearner]

lib/Sema/SemaDeclCXX.cpp

9690 ↗

(On Diff #148744)

It seems that getCanonicalTypeUnqualified does not strip qualifiers from the canonical type. I guess "Unqualified" here just means the method does not include local qualifiers, unlike QualType::getCanonicalType.

Thus, in the case of using cbase = const base;, getCanonicalTypeUnqualified will return the canonical type of cbase as is, which is const base, a const-qualified type.

[cpplearner]

ping

[cpplearner]

ping

[rjmccall]

lib/Sema/SemaDeclCXX.cpp

9690 ↗

(On Diff #148744)

Maybe we should have a method that promises to return an unqualified type.

This change seems reasonable overall.

cfe/trunk/lib/Sema/SemaDeclCXX.cpp

void Sema::HideUsingShadowDecl(Scope *S, UsingShadowDecl *Shadow) {
   // be possible for this to happen, because...?
 }
 
 /// Find the base specifier for a base class with the given type.
 static CXXBaseSpecifier *findDirectBaseWithType(CXXRecordDecl *Derived,
                                                 QualType DesiredBase,
                                                 bool &AnyDependentBases) {
   // Check whether the named type is a direct base class.
-  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified();
+  CanQualType CanonicalDesiredBase = DesiredBase->getCanonicalTypeUnqualified()
+    .getUnqualifiedType();
   for (auto &Base : Derived->bases()) {
     CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
     if (CanonicalDesiredBase == BaseType)
       return &Base;
     if (BaseType->isDependentType())
       AnyDependentBases = true;
   }
   return nullptr;

cfe/trunk/test/CXX/special/class.inhctor/elsewhere.cpp

 F<bool> fb; // expected-note {{here}}
 
 template<typename T>
 struct G : T {
   using T::T;
   G(int &) : G(0) {}
 };
 G<B1> g(123);
+G<const B1> g2(123);