[clang] Misc type sugar preservation improvements

[mizvekov]

Summary

WIP - Not ready for review

Missing standalone tests.

Signed-off-by: Matheus Izvekov <[e-mail]>

clang/lib/Sema/SemaCXXScopeSpec.cpp

if (EnteringContext) {
       if (const TemplateSpecializationType *SpecType
             = NNSType->getAs<TemplateSpecializationType>()) {
         // We are entering the context of the nested name specifier, so try to
         // match the nested name specifier to either a primary class template
         // or a class template partial specialization.
         if (ClassTemplateDecl *ClassTemplate
               = dyn_cast_or_null<ClassTemplateDecl>(
                             SpecType->getTemplateName().getAsTemplateDecl())) {
-          QualType ContextType
-            = Context.getCanonicalType(QualType(SpecType, 0));
+          auto ContextType = QualType(SpecType, 0);
 
           // If the type of the nested name specifier is the same as the
           // injected class name of the named class template, we're entering
           // into that class template definition.
           QualType Injected
             = ClassTemplate->getInjectedClassNameSpecialization();
           if (Context.hasSameType(Injected, ContextType))
             return ClassTemplate->getTemplatedDecl();

clang/lib/Sema/SemaExpr.cpp

// The method was named without a qualifier.
           << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual);
       }
     }
 
     // Taking the address of a dtor is illegal per C++ [class.dtor]p2.
     if (isa<CXXDestructorDecl>(MD))
       Diag(OpLoc, diag::err_typecheck_addrof_dtor) << op->getSourceRange();
 
-    QualType MPTy = Context.getMemberPointerType(
-        op->getType(), Context.getTypeDeclType(MD->getParent()).getTypePtr());
+    const CXXRecordDecl *Cls = MD->getParent();
+    const Type *ClsType = nullptr;
+    if (const NestedNameSpecifier *NNS = DRE->getQualifier()) {
+      const Type *Type = NNS->getAsType();
+      const CXXRecordDecl *ClsAsWritten =
+          Type ? Type->getAsCXXRecordDecl() : NNS->getAsRecordDecl();
+      assert(ClsAsWritten != nullptr);
+      if (declaresSameEntity(Cls, ClsAsWritten))
+        ClsType =
+            Type ? Type : Context.getTypeDeclType(ClsAsWritten).getTypePtr();
+      else
+        // FIXME: Can we do better here?
+        assert(ClsAsWritten->isDerivedFrom(Cls));
+    }
+    if (!ClsType)
+      ClsType = Context.getTypeDeclType(Cls).getTypePtr();
+
+    QualType MPTy = Context.getMemberPointerType(op->getType(), ClsType);
     // Under the MS ABI, lock down the inheritance model now.
     if (Context.getTargetInfo().getCXXABI().isMicrosoft())
       (void)isCompleteType(OpLoc, MPTy);
     return MPTy;
   } else if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) {
     // C99 6.5.3.2p1
     // The operand must be either an l-value or a function designator
     if (!op->getType()->isFunctionType()) {

clang/lib/Sema/SemaType.cpp

QualType Sema::BuildTypeofExprType(Expr *E) {
   if (!E->isTypeDependent()) {
     QualType T = E->getType();
     if (const TagType *TT = T->getAs<TagType>())
       DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc());
   }
   return Context.getTypeOfExprType(E);
 }
 
+static QualType getSameReferencedType(ASTContext &Context, QualType VT,
+                                      QualType ET) {
+  assert(!ET->isReferenceType());
+  if (const auto *VTL = VT->getAs<LValueReferenceType>())
+    ET = Context.getLValueReferenceType(ET, VTL->isSpelledAsLValue());
+  else if (VT->isRValueReferenceType())
+    ET = Context.getRValueReferenceType(ET);
+
+  if (!Context.hasSameUnqualifiedType(ET, VT)) {
+    ET.dump();
+    VT.dump();
+    assert(false && "!hasSameUnqualifiedType");
+  }
+
+  Qualifiers ToAdd = VT.getQualifiers(), ToRemove = ET.getQualifiers();
+  (void)Qualifiers::removeCommonQualifiers(ToAdd, ToRemove);
+
+  SplitQualType Split = ET.split();
+  while (!ToRemove.empty()) {
+    (void)Qualifiers::removeCommonQualifiers(Split.Quals, ToRemove);
+    if (ToRemove.empty())
+      break;
+    QualType Next;
+    switch (ET->getTypeClass()) {
+#define ABSTRACT_TYPE(Class, Parent)
+#define TYPE(Class, Parent)                                                    \
+  case Type::Class: {                                                          \
+    const auto *ty = cast<Class##Type>(ET);                                    \
+    if (!ty->isSugared())                                                      \
+      goto done;                                                               \
+    Next = ty->desugar();                                                      \
+    break;                                                                     \
+  }
+#include "clang/AST/TypeNodes.inc"
+    }
+    Split = Next.split();
+  }
+done:
+  assert(ToRemove.empty());
+  Split.Quals += ToAdd;
+  ET = Context.getQualifiedType(Split);
+
+  if (!Context.hasSameType(ET, VT)) {
+    ET.dump();
+    VT.dump();
+    assert(false && "!hasSameType");
+  }
+  return ET;
+}
+
 /// getDecltypeForExpr - Given an expr, will return the decltype for
 /// that expression, according to the rules in C++11
 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
 QualType Sema::getDecltypeForExpr(Expr *E) {
   if (E->isTypeDependent())
     return Context.DependentTy;
 
   Expr *IDExpr = E;
QualType Sema::getDecltypeForExpr(Expr *E) {
   //     - if e is an unparenthesized id-expression or an unparenthesized class
   //       member access (5.2.5), decltype(e) is the type of the entity named
   //       by e. If there is no such entity, or if e names a set of overloaded
   //       functions, the program is ill-formed;
   //
   // We apply the same rules for Objective-C ivar and property references.
   if (const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
     const ValueDecl *VD = DRE->getDecl();
-    QualType T = VD->getType();
+    QualType T = getSameReferencedType(Context, VD->getType(), DRE->getType());
     return isa<TemplateParamObjectDecl>(VD) ? T.getUnqualifiedType() : T;
   }
   if (const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
     if (const auto *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
-        return VD->getType();
+        return getSameReferencedType(Context, VD->getType(), ME->getType());
   } else if (const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
+    // FIXME: Sugar these. Breaks Modules/odr_hash.mm.
     return IR->getDecl()->getType();
   } else if (const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
     if (PR->isExplicitProperty())
-      return PR->getExplicitProperty()->getType();
+      return getSameReferencedType(
+          Context, PR->getExplicitProperty()->getType(), PR->getType());
   } else if (const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
     return PE->getType();
   }
 
   // C++11 [expr.lambda.prim]p18:
   //   Every occurrence of decltype((x)) where x is a possibly
   //   parenthesized id-expression that names an entity of automatic
   //   storage duration is treated as if x were transformed into an