[clang] Template Specialization Resugaring - Expressions

[mizvekov]

Summary

WIP

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

clang/include/clang/Sema/Sema.h

public:
   DeclRefExpr *
   BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK,
                    const DeclarationNameInfo &NameInfo,
                    NestedNameSpecifierLoc NNS, NamedDecl *FoundD = nullptr,
                    SourceLocation TemplateKWLoc = SourceLocation(),
                    const TemplateArgumentListInfo *TemplateArgs = nullptr,
                    const TemplateArgumentList *ConvertedArgs = nullptr);
 
-  ExprResult
-  BuildAnonymousStructUnionMemberReference(
-      const CXXScopeSpec &SS,
-      SourceLocation nameLoc,
+  ExprResult BuildAnonymousStructUnionMemberReference(
+      const CXXScopeSpec &SS, SourceLocation nameLoc,
       IndirectFieldDecl *indirectField,
       DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_none),
-      Expr *baseObjectExpr = nullptr,
+      Expr *baseObjectExpr = nullptr, const Type *BaseType = nullptr,
       SourceLocation opLoc = SourceLocation());
 
   ExprResult BuildPossibleImplicitMemberExpr(
       const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R,
       const TemplateArgumentListInfo *TemplateArgs, const Scope *S,
       UnresolvedLookupExpr *AsULE = nullptr);
   ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc,
                            NamedDecl *FirstQualifierInScope, LookupResult &R,
                            const TemplateArgumentListInfo *TemplateArgs,
                            const Scope *S,
                            bool SuppressQualifierCheck = false,
                            ActOnMemberAccessExtraArgs *ExtraArgs = nullptr);
 
   ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
                                      SourceLocation OpLoc,
-                                     const CXXScopeSpec &SS, FieldDecl *Field,
+                                     const NestedNameSpecifierLoc &NNS,
+                                     FieldDecl *Field, QualType FieldType,
                                      DeclAccessPair FoundDecl,
                                      const DeclarationNameInfo &MemberNameInfo);
 
   ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow);
 
   bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
                                      const CXXScopeSpec &SS,
                                      const LookupResult &R);
public:
     getPointerOrNull(unsigned numParams) {
       if (!HasInteresting) return nullptr;
       Infos.resize(numParams);
       return Infos.data();
     }
   };
 
   QualType resugar(const NestedNameSpecifier *NNS, QualType T);
+  QualType resugar(const NestedNameSpecifier *NNS, NamedDecl *ND,
+                   ArrayRef<TemplateArgument> Args, QualType T);
+  QualType resugar(NamedDecl *ND, ArrayRef<TemplateArgument> Args, QualType T);
+  QualType resugar(const Type *Base, const NestedNameSpecifier *FieldNNS,
+                   QualType T);
+  QualType resugar(const Type *Base, const NestedNameSpecifier *FieldNNS,
+                   NamedDecl *ND, ArrayRef<TemplateArgument> Args, QualType T);
+  QualType resugar(const Type *Base, QualType T);
+  QualType resugar(const Type *Base, NamedDecl *ND,
+                   ArrayRef<TemplateArgument> Args, QualType T);
 
   void PerformPendingInstantiations(bool LocalOnly = false);
 
   TypeSourceInfo *SubstType(TypeSourceInfo *T,
                             const MultiLevelTemplateArgumentList &TemplateArgs,
                             SourceLocation Loc, DeclarationName Entity,
                             bool AllowDeducedTST = false);
 

clang/lib/Sema/SemaChecking.cpp

bool dumpRecordValue(const RecordDecl *RD, Expr *E, Expr *RecordIndent,
 
     // Dump each field.
     for (auto *D : RD->decls()) {
       auto *IFD = dyn_cast<IndirectFieldDecl>(D);
       auto *FD = IFD ? IFD->getAnonField() : dyn_cast<FieldDecl>(D);
       if (!FD || FD->isUnnamedBitfield() || FD->isAnonymousStructOrUnion())
         continue;
 
+      QualType FieldType = FD->getType();
+
       llvm::SmallString<20> Format = llvm::StringRef("%s%s %s ");
       llvm::SmallVector<Expr *, 5> Args = {FieldIndentArg,
-                                           getTypeString(FD->getType()),
+                                           getTypeString(FieldType),
                                            getStringLiteral(FD->getName())};
 
       if (FD->isBitField()) {
         Format += ": %zu ";
         QualType SizeT = S.Context.getSizeType();
         llvm::APInt BitWidth(S.Context.getIntWidth(SizeT),
                              FD->getBitWidthValue(S.Context));
         Args.push_back(IntegerLiteral::Create(S.Context, BitWidth, SizeT, Loc));
       }
 
       Format += "=";
 
       ExprResult Field =
           IFD ? S.BuildAnonymousStructUnionMemberReference(
                     CXXScopeSpec(), Loc, IFD,
-                    DeclAccessPair::make(IFD, AS_public), RecordArg, Loc)
+                    DeclAccessPair::make(IFD, AS_public), RecordArg, nullptr,
+                    Loc)
               : S.BuildFieldReferenceExpr(
-                    RecordArg, RecordArgIsPtr, Loc, CXXScopeSpec(), FD,
-                    DeclAccessPair::make(FD, AS_public),
+                    RecordArg, RecordArgIsPtr, Loc, NestedNameSpecifierLoc(),
+                    FD, FieldType, DeclAccessPair::make(FD, AS_public),
                     DeclarationNameInfo(FD->getDeclName(), Loc));
       if (Field.isInvalid())
         return true;
 
-      auto *InnerRD = FD->getType()->getAsRecordDecl();
+      auto *InnerRD = FieldType->getAsRecordDecl();
       auto *InnerCXXRD = dyn_cast_or_null<CXXRecordDecl>(InnerRD);
       if (InnerRD && (!InnerCXXRD || InnerCXXRD->isAggregate())) {
         // Recursively print the values of members of aggregate record type.
         if (callPrintFunction(Format, Args) ||
             dumpRecordValue(InnerRD, Field.get(), FieldIndentArg, Depth + 1))
           return true;
       } else {
         Format += " ";
-        if (appendFormatSpecifier(FD->getType(), Format)) {
+        if (appendFormatSpecifier(FieldType, Format)) {
           // We know how to print this field.
           Args.push_back(Field.get());
         } else {
           // We don't know how to print this field. Print out its address
           // with a format specifier that a smart tool will be able to
           // recognize and treat specially.
           Format += "*%p";
           ExprResult FieldAddr =

clang/lib/Sema/SemaCoroutine.cpp

static ExprResult buildCoroutineHandle(Sema &S, QualType PromiseType,
   Expr *FramePtr =
       S.BuildBuiltinCallExpr(Loc, Builtin::BI__builtin_coro_frame, {});
 
   CXXScopeSpec SS;
   ExprResult FromAddr =
       S.BuildDeclarationNameExpr(SS, Found, /*NeedsADL=*/false);
   if (FromAddr.isInvalid())
     return ExprError();
-
+  // FIXME: resugar
   return S.BuildCallExpr(nullptr, FromAddr.get(), Loc, FramePtr, Loc);
 }
 
 struct ReadySuspendResumeResult {
   enum AwaitCallType { ACT_Ready, ACT_Suspend, ACT_Resume };
   Expr *Results[3];
   OpaqueValueExpr *OpaqueValue;
   bool IsInvalid;

clang/lib/Sema/SemaDecl.cpp

bool Sema::DeduceVariableDeclarationType(VarDecl *VDecl, bool DirectInit,
   QualType DeducedType = deduceVarTypeFromInitializer(
       VDecl, VDecl->getDeclName(), VDecl->getType(), VDecl->getTypeSourceInfo(),
       VDecl->getSourceRange(), DirectInit, Init);
   if (DeducedType.isNull()) {
     VDecl->setInvalidDecl();
     return true;
   }
 
+  // FIXME: Set TypeSourceInfo?
   VDecl->setType(DeducedType);
   assert(VDecl->isLinkageValid());
 
   // In ARC, infer lifetime.
   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
     VDecl->setInvalidDecl();
 
   if (getLangOpts().OpenCL)

clang/lib/Sema/SemaDeclAttr.cpp

static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (FD->getNumParams() != 1) {
     S.Diag(Loc, diag::err_attribute_cleanup_func_must_take_one_arg)
       << NI.getName();
     return;
   }
 
   // We're currently more strict than GCC about what function types we accept.
   // If this ever proves to be a problem it should be easy to fix.
+  // FIXME: resugar
   QualType Ty = S.Context.getPointerType(cast<VarDecl>(D)->getType());
   QualType ParamTy = FD->getParamDecl(0)->getType();
   if (S.CheckAssignmentConstraints(FD->getParamDecl(0)->getLocation(),
                                    ParamTy, Ty) != Sema::Compatible) {
     S.Diag(Loc, diag::err_attribute_cleanup_func_arg_incompatible_type)
       << NI.getName() << ParamTy << Ty;
     return;
   }

clang/lib/Sema/SemaDeclCXX.cpp

static bool checkMemberDecomposition(Sema &S, ArrayRef<BindingDecl*> Bindings,
   //   all of E's non-static data members shall be [...] well-formed
   //   when named as e.name in the context of the structured binding,
   //   E shall not have an anonymous union member, ...
   unsigned I = 0;
   for (auto *FD : RD->fields()) {
     if (FD->isUnnamedBitfield())
       continue;
 
+    // FIXME: Avoid having to recreate the naming context for every field.
+    QualType FieldType = S.resugar(DecompType.getTypePtr(), FD->getType());
+
     // All the non-static data members are required to be nameable, so they
     // must all have names.
     if (!FD->getDeclName()) {
       if (RD->isLambda()) {
         S.Diag(Src->getLocation(), diag::err_decomp_decl_lambda);
         S.Diag(RD->getLocation(), diag::note_lambda_decl);
         return true;
       }
 
       if (FD->isAnonymousStructOrUnion()) {
         S.Diag(Src->getLocation(), diag::err_decomp_decl_anon_union_member)
-          << DecompType << FD->getType()->isUnionType();
+            << DecompType << FieldType->isUnionType();
         S.Diag(FD->getLocation(), diag::note_declared_at);
         return true;
       }
 
       // FIXME: Are there any other ways we could have an anonymous member?
     }
 
     // We have a real field to bind.
for (auto *FD : RD->fields()) {
     ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
     if (E.isInvalid())
       return true;
     E = S.ImpCastExprToType(E.get(), BaseType, CK_UncheckedDerivedToBase,
                             VK_LValue, &BasePath);
     if (E.isInvalid())
       return true;
     E = S.BuildFieldReferenceExpr(E.get(), /*IsArrow*/ false, Loc,
-                                  CXXScopeSpec(), FD,
+                                  NestedNameSpecifierLoc(), FD, FieldType,
                                   DeclAccessPair::make(FD, FD->getAccess()),
                                   DeclarationNameInfo(FD->getDeclName(), Loc));
     if (E.isInvalid())
       return true;
 
     // If the type of the member is T, the referenced type is cv T, where cv is
     // the cv-qualification of the decomposition expression.
     //
     // FIXME: We resolve a defect here: if the field is mutable, we do not add
     // 'const' to the type of the field.
     Qualifiers Q = DecompType.getQualifiers();
     if (FD->isMutable())
       Q.removeConst();
-    B->setBinding(S.BuildQualifiedType(FD->getType(), Loc, Q), E.get());
+    B->setBinding(S.BuildQualifiedType(FieldType, Loc, Q), E.get());
   }
 
   if (I != Bindings.size())
     return DiagnoseBadNumberOfBindings();
 
   return false;
 }
 
private:
 
   ExprPair getField(FieldDecl *Field) {
     ExprPair Obj = getCompleteObject();
     if (Obj.first.isInvalid() || Obj.second.isInvalid())
       return {ExprError(), ExprError()};
 
     DeclAccessPair Found = DeclAccessPair::make(Field, Field->getAccess());
     DeclarationNameInfo NameInfo(Field->getDeclName(), Loc);
+    QualType FieldType = Field->getType();
     return {S.BuildFieldReferenceExpr(Obj.first.get(), /*IsArrow=*/false, Loc,
-                                      CXXScopeSpec(), Field, Found, NameInfo),
+                                      NestedNameSpecifierLoc(), Field,
+                                      FieldType, Found, NameInfo),
             S.BuildFieldReferenceExpr(Obj.second.get(), /*IsArrow=*/false, Loc,
-                                      CXXScopeSpec(), Field, Found, NameInfo)};
+                                      NestedNameSpecifierLoc(), Field,
+                                      FieldType, Found, NameInfo)};
   }
 
   // FIXME: When expanding a subobject, register a note in the code synthesis
   // stack to say which subobject we're comparing.
 
   StmtResult buildIfNotCondReturnFalse(ExprResult Cond) {
     if (Cond.isInvalid())
       return StmtError();

clang/lib/Sema/SemaExpr.cpp

 ExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS,
                                           LookupResult &R, bool NeedsADL,
                                           bool AcceptInvalidDecl) {
   // If this is a single, fully-resolved result and we don't need ADL,
   // just build an ordinary singleton decl ref.
   if (!NeedsADL && R.isSingleResult() &&
       !R.getAsSingle<FunctionTemplateDecl>() &&
       !ShouldLookupResultBeMultiVersionOverload(R))
+    // FIXME: get ConvertedArgs
     return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), R.getFoundDecl(),
                                     R.getRepresentativeDecl(), nullptr, nullptr,
                                     AcceptInvalidDecl);
 
   // We only need to check the declaration if there's exactly one
   // result, because in the overloaded case the results can only be
   // functions and function templates.
   if (R.isSingleResult() && !ShouldLookupResultBeMultiVersionOverload(R) &&
ExprResult Sema::BuildDeclarationNameExpr(
   if (IndirectFieldDecl *indirectField = dyn_cast<IndirectFieldDecl>(VD))
     if (!indirectField->isCXXClassMember())
       return BuildAnonymousStructUnionMemberReference(SS, NameInfo.getLoc(),
                                                       indirectField);
 
   QualType type = VD->getType();
   if (type.isNull())
     return ExprError();
+  assert(!TemplateArgs || ConvertedArgs);
+  type = ConvertedArgs
+             ? resugar(SS.getScopeRep(), VD, ConvertedArgs->asArray(), type)
+             : resugar(SS.getScopeRep(), type);
   ExprValueKind valueKind = VK_PRValue;
 
   // In 'T ...V;', the type of the declaration 'V' is 'T...', but the type of
   // a reference to 'V' is simply (unexpanded) 'T'. The type, like the value,
   // is expanded by some outer '...' in the context of the use.
   type = type.getNonPackExpansionType();
 
   switch (D->getKind()) {
if (TryInstantiating) {
         // Do not defer instantiations of variables that could be used in a
         // constant expression.
         SemaRef.runWithSufficientStackSpace(PointOfInstantiation, [&] {
           SemaRef.InstantiateVariableDefinition(PointOfInstantiation, Var);
         });
 
         // Re-set the member to trigger a recomputation of the dependence bits
         // for the expression.
-        if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E))
+        CXXScopeSpec SS;
+        if (auto *DRE = dyn_cast_or_null<DeclRefExpr>(E)) {
           DRE->setDecl(DRE->getDecl());
-        else if (auto *ME = dyn_cast_or_null<MemberExpr>(E))
+          SS.Adopt(DRE->getQualifierLoc());
+          assert(DRE->template_arguments().size() == 0 ||
+                 DRE->getConvertedArgs() != nullptr);
+          QualType T = DRE->getConvertedArgs()
+                           ? SemaRef.resugar(SS.getScopeRep(), DRE->getDecl(),
+                                             DRE->getConvertedArgs()->asArray(),
+                                             DRE->getType())
+                           : SemaRef.resugar(SS.getScopeRep(), DRE->getType());
+          DRE->setType(T);
+        } else if (auto *ME = dyn_cast_or_null<MemberExpr>(E)) {
           ME->setMemberDecl(ME->getMemberDecl());
+          SS.Adopt(ME->getQualifierLoc());
+          assert(ME->template_arguments().size() == 0 ||
+                 ME->getDeduced() != nullptr);
+          QualType T =
+              ME->getDeduced()
+                  ? SemaRef.resugar(SS.getScopeRep(), ME->getMemberDecl(),
+                                    ME->getDeduced()->asArray(), ME->getType())
+                  : SemaRef.resugar(SS.getScopeRep(), ME->getType());
+          ME->setType(T);
+        }
       } else if (FirstInstantiation ||
                  isa<VarTemplateSpecializationDecl>(Var)) {
         // FIXME: For a specialization of a variable template, we don't
         // distinguish between "declaration and type implicitly instantiated"
         // and "implicit instantiation of definition requested", so we have
         // no direct way to avoid enqueueing the pending instantiation
         // multiple times.
         SemaRef.PendingInstantiations
if (DRE) {
                                         /*DefinitionRequired=*/true,
                                         /*AtEndOfTU=*/false);
         }
         // Produce a properly-typed reference to the function.
         CXXScopeSpec SS;
         SS.Adopt(DRE->getQualifierLoc());
         TemplateArgumentListInfo TemplateArgs;
         DRE->copyTemplateArgumentsInto(TemplateArgs);
+        // FIXME: resugar
         return BuildDeclRefExpr(
             FD, FD->getType(), VK_LValue, DRE->getNameInfo(),
             DRE->hasQualifier() ? &SS : nullptr, DRE->getFoundDecl(),
             DRE->getTemplateKeywordLoc(),
             DRE->hasExplicitTemplateArgs() ? &TemplateArgs : nullptr,
             DRE->getConvertedArgs());
       }
     }

clang/lib/Sema/SemaExprMember.cpp

Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
   }
 
   return BuildMemberReferenceExpr(Base, BaseType,
                                   OpLoc, IsArrow, SS, TemplateKWLoc,
                                   FirstQualifierInScope, R, TemplateArgs, S,
                                   false, ExtraArgs);
 }
 
-ExprResult
-Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
-                                               SourceLocation loc,
-                                               IndirectFieldDecl *indirectField,
-                                               DeclAccessPair foundDecl,
-                                               Expr *baseObjectExpr,
-                                               SourceLocation opLoc) {
+ExprResult Sema::BuildAnonymousStructUnionMemberReference(
+    const CXXScopeSpec &SS, SourceLocation loc,
+    IndirectFieldDecl *indirectField, DeclAccessPair foundDecl,
+    Expr *baseObjectExpr, const Type *BaseType, SourceLocation opLoc) {
   // First, build the expression that refers to the base object.
 
   // Case 1:  the base of the indirect field is not a field.
   VarDecl *baseVariable = indirectField->getVarDecl();
-  CXXScopeSpec EmptySS;
   if (baseVariable) {
     assert(baseVariable->getType()->isRecordType());
 
     // In principle we could have a member access expression that
     // accesses an anonymous struct/union that's a static member of
     // the base object's class.  However, under the current standard,
     // static data members cannot be anonymous structs or unions.
     // Supporting this is as easy as building a MemberExpr here.
     assert(!baseObjectExpr && "anonymous struct/union is static data member?");
 
     DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
 
+    CXXScopeSpec EmptySS;
     ExprResult result
       = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
     if (result.isInvalid()) return ExprError();
 
     baseObjectExpr = result.get();
   }
 
   assert((baseVariable || baseObjectExpr) &&
          "referencing anonymous struct/union without a base variable or "
          "expression");
 
   // Build the implicit member references to the field of the
   // anonymous struct/union.
   Expr *result = baseObjectExpr;
   IndirectFieldDecl::chain_iterator
   FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
 
+  NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+
   // Case 2: the base of the indirect field is a field and the user
   // wrote a member expression.
   if (!baseVariable) {
     FieldDecl *field = cast<FieldDecl>(*FI);
 
     bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType();
 
     // Make a nameInfo that properly uses the anonymous name.
     DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
 
+    // FIXME: Avoid redundant setting of the naming scope with the loop below.
+    QualType FieldType =
+        BaseType ? resugar(BaseType, SS.getScopeRep(), field->getType())
+                 : field->getType();
+
     // Build the first member access in the chain with full information.
-    result =
-        BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(),
-                                SS, field, foundDecl, memberNameInfo)
+    result = BuildFieldReferenceExpr(result, baseObjectIsPointer,
+                                     SourceLocation(), NNS, field, FieldType,
+                                     foundDecl, memberNameInfo)
                  .get();
     if (!result)
       return ExprError();
   }
 
   // In all cases, we should now skip the first declaration in the chain.
   ++FI;
 
   while (FI != FEnd) {
     FieldDecl *field = cast<FieldDecl>(*FI++);
 
     // FIXME: these are somewhat meaningless
     DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
     DeclAccessPair fakeFoundDecl =
         DeclAccessPair::make(field, field->getAccess());
 
+    QualType FieldType =
+        BaseType && FI == FEnd
+            ? resugar(BaseType, SS.getScopeRep(), field->getType())
+            : field->getType();
+
     result =
         BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(),
-                                (FI == FEnd ? SS : EmptySS), field,
-                                fakeFoundDecl, memberNameInfo)
+                                (FI == FEnd ? NNS : NestedNameSpecifierLoc()),
+                                field, FieldType, fakeFoundDecl, memberNameInfo)
             .get();
   }
 
   return result;
 }
 
 static ExprResult
 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
if (SS.getRange().isValid())
       Loc = SS.getRange().getBegin();
     BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
   }
 
   // Check the use of this member.
   if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
     return ExprError();
 
-  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
-    return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
-                                   MemberNameInfo);
+  if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) {
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType FieldType =
+        resugar(BaseType.getTypePtr(), SS.getScopeRep(), FD->getType());
+    return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, NNS, FD, FieldType,
+                                   FoundDecl, MemberNameInfo);
+  }
 
   if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
+    // FIXME: resugar these.
     return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
                                   MemberNameInfo);
 
   if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
     // We may have found a field within an anonymous union or struct
     // (C++ [class.union]).
-    return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
-                                                    FoundDecl, BaseExpr,
-                                                    OpLoc);
+    return BuildAnonymousStructUnionMemberReference(
+        SS, MemberLoc, FD, FoundDecl, BaseExpr, BaseType.getTypePtr(), OpLoc);
 
   if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType VarType =
+        resugar(BaseType.getTypePtr(), SS.getScopeRep(), Var->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Var,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Var->getType().getNonReferenceType(),
+                           MemberNameInfo, VarType.getNonReferenceType(),
                            VK_LValue, OK_Ordinary);
   }
 
   if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+
     ExprValueKind valueKind;
     QualType type;
     if (MemberFn->isInstance()) {
       valueKind = VK_PRValue;
       type = Context.BoundMemberTy;
     } else {
       valueKind = VK_LValue;
-      type = MemberFn->getType();
+      type =
+          resugar(BaseType.getTypePtr(), SS.getScopeRep(), MemberFn->getType());
     }
 
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc,
                            MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
                            MemberNameInfo, type, valueKind, OK_Ordinary);
   }
   assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
 
   if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
+    assert(!TemplateArgs);
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    // FIXME: EnumType resugaring not implemented.
+    QualType EnumType =
+        resugar(BaseType.getTypePtr(), SS.getScopeRep(), Enum->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Enum,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Enum->getType(), VK_PRValue,
-                           OK_Ordinary);
+                           MemberNameInfo, EnumType, VK_PRValue, OK_Ordinary);
   }
 
   if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
     if (!TemplateArgs) {
       diagnoseMissingTemplateArguments(TemplateName(VarTempl), MemberLoc);
       return ExprError();
     }
 
if (!VDecl.get())
       return ActOnDependentMemberExpr(
           BaseExpr, BaseExpr->getType(), IsArrow, OpLoc, SS, TemplateKWLoc,
           FirstQualifierInScope, MemberNameInfo, TemplateArgs);
 
     VarDecl *Var = cast<VarDecl>(VDecl.get());
     if (!Var->getTemplateSpecializationKind())
       Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation, MemberLoc);
 
-    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
+    NestedNameSpecifierLoc NNS = SS.getWithLocInContext(Context);
+    QualType VarType = resugar(BaseType.getTypePtr(), SS.getScopeRep(), Var,
+                               ConvertedArgs->asArray(), Var->getType());
+    return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, NNS, TemplateKWLoc, Var,
                            FoundDecl, /*HadMultipleCandidates=*/false,
-                           MemberNameInfo, Var->getType().getNonReferenceType(),
+                           MemberNameInfo, VarType.getNonReferenceType(),
                            VK_LValue, OK_Ordinary, TemplateArgs, ConvertedArgs);
   }
 
   // We found something that we didn't expect. Complain.
   if (isa<TypeDecl>(MemberDecl))
     Diag(MemberLoc, diag::err_typecheck_member_reference_type)
       << MemberName << BaseType << int(IsArrow);
   else
if (ResultTy->isArrayType()) {
     if (const auto *Ptr = dyn_cast<PointerType>(
             E->getBase()->getType().getDesugaredType(Context))) {
       if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
         ExprEvalContexts.back().PossibleDerefs.insert(E);
     }
   }
 }
 
-ExprResult
-Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
-                              SourceLocation OpLoc, const CXXScopeSpec &SS,
-                              FieldDecl *Field, DeclAccessPair FoundDecl,
-                              const DeclarationNameInfo &MemberNameInfo) {
+ExprResult Sema::BuildFieldReferenceExpr(
+    Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc,
+    const NestedNameSpecifierLoc &NNS, FieldDecl *Field, QualType FieldType,
+    DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo) {
   // x.a is an l-value if 'a' has a reference type. Otherwise:
   // x.a is an l-value/x-value/pr-value if the base is (and note
   //   that *x is always an l-value), except that if the base isn't
   //   an ordinary object then we must have an rvalue.
   ExprValueKind VK = VK_LValue;
   ExprObjectKind OK = OK_Ordinary;
   if (!IsArrow) {
     if (BaseExpr->getObjectKind() == OK_Ordinary)
       VK = BaseExpr->getValueKind();
     else
       VK = VK_PRValue;
   }
   if (VK != VK_PRValue && Field->isBitField())
     OK = OK_BitField;
 
   // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
-  QualType MemberType = Field->getType();
-  if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
-    MemberType = Ref->getPointeeType();
+  if (const ReferenceType *Ref = FieldType->getAs<ReferenceType>()) {
+    FieldType = Ref->getPointeeType();
     VK = VK_LValue;
   } else {
     QualType BaseType = BaseExpr->getType();
     if (IsArrow) BaseType = BaseType->castAs<PointerType>()->getPointeeType();
 
     Qualifiers BaseQuals = BaseType.getQualifiers();
 
     // GC attributes are never picked up by members.
     BaseQuals.removeObjCGCAttr();
 
     // CVR attributes from the base are picked up by members,
     // except that 'mutable' members don't pick up 'const'.
     if (Field->isMutable()) BaseQuals.removeConst();
 
-    Qualifiers MemberQuals =
-        Context.getCanonicalType(MemberType).getQualifiers();
+    Qualifiers FieldQuals = Context.getCanonicalType(FieldType).getQualifiers();
 
-    assert(!MemberQuals.hasAddressSpace());
+    assert(!FieldQuals.hasAddressSpace());
 
-    Qualifiers Combined = BaseQuals + MemberQuals;
-    if (Combined != MemberQuals)
-      MemberType = Context.getQualifiedType(MemberType, Combined);
+    Qualifiers Combined = BaseQuals + FieldQuals;
+    if (Combined != FieldQuals)
+      FieldType = Context.getQualifiedType(FieldType, Combined);
 
     // Pick up NoDeref from the base in case we end up using AddrOf on the
     // result. E.g. the expression
     //     &someNoDerefPtr->pointerMember
     // should be a noderef pointer again.
     if (BaseType->hasAttr(attr::NoDeref))
-      MemberType =
-          Context.getAttributedType(attr::NoDeref, MemberType, MemberType);
+      FieldType =
+          Context.getAttributedType(attr::NoDeref, FieldType, FieldType);
   }
 
   auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
   if (!(CurMethod && CurMethod->isDefaulted()))
     UnusedPrivateFields.remove(Field);
 
-  ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
-                                                  FoundDecl, Field);
+  ExprResult Base = PerformObjectMemberConversion(
+      BaseExpr, NNS.getNestedNameSpecifier(), FoundDecl, Field);
   if (Base.isInvalid())
     return ExprError();
 
   // Build a reference to a private copy for non-static data members in
   // non-static member functions, privatized by OpenMP constructs.
   if (getLangOpts().OpenMP && IsArrow &&
       !CurContext->isDependentContext() &&
       isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
     if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
       return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
                                    MemberNameInfo.getLoc());
     }
   }
 
-  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
+  return BuildMemberExpr(Base.get(), IsArrow, OpLoc, NNS,
                          /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
                          /*HadMultipleCandidates=*/false, MemberNameInfo,
-                         MemberType, VK, OK);
+                         FieldType, VK, OK);
 }
 
 /// Builds an implicit member access expression.  The current context
 /// is known to be an instance method, and the given unqualified lookup
 /// set is known to contain only instance members, at least one of which
 /// is from an appropriate type.
 ExprResult
 Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,

clang/lib/Sema/SemaInit.cpp

case OR_Success:
     }
 
     // Make sure we didn't select an unusable deduction guide, and mark it
     // as referenced.
     DiagnoseUseOfDecl(Best->Function, Kind.getLocation());
     MarkFunctionReferenced(Kind.getLocation(), Best->Function);
     break;
   }
+  QualType RT = Best->Function->getReturnType();
+  // FIXME: resugar here
 
   // C++ [dcl.type.class.deduct]p1:
   //  The placeholder is replaced by the return type of the function selected
   //  by overload resolution for class template deduction.
-  QualType DeducedType =
-      SubstAutoType(TSInfo->getType(), Best->Function->getReturnType());
+  QualType DeducedType = SubstAutoType(TSInfo->getType(), RT);
   Diag(TSInfo->getTypeLoc().getBeginLoc(),
        diag::warn_cxx14_compat_class_template_argument_deduction)
       << TSInfo->getTypeLoc().getSourceRange() << 1 << DeducedType;
 
   // Warn if CTAD was used on a type that does not have any user-defined
   // deduction guides.
   if (!HasAnyDeductionGuide) {
     Diag(TSInfo->getTypeLoc().getBeginLoc(),
          diag::warn_ctad_maybe_unsupported)
         << TemplateName;
     Diag(Template->getLocation(), diag::note_suppress_ctad_maybe_unsupported);
   }
 
   return DeducedType;
 }

clang/lib/Sema/SemaOverload.cpp

static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
   if (FromType == S.Context.OverloadTy) {
     DeclAccessPair AccessPair;
     const TemplateArgumentList *ConvertedArgs;
     if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
             From, ToType, false, AccessPair, ConvertedArgs)) {
       // We were able to resolve the address of the overloaded function,
       // so we can convert to the type of that function.
       FromType = Fn->getType();
+      // FIXME: resugar
       SCS.setFromType(FromType);
 
       // we can sometimes resolve &foo<int> regardless of ToType, so check
       // if the type matches (identity) or we are converting to bool
       if (!S.Context.hasSameUnqualifiedType(
                       S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
         QualType resultTy;
         // if the function type matches except for [[noreturn]], it's ok
TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
   // If the initializer is the address of an overloaded function, try
   // to resolve the overloaded function. If all goes well, T2 is the
   // type of the resulting function.
   if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
     DeclAccessPair Found;
     const TemplateArgumentList *ConvertedArgs;
     if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
             Init, DeclType, false, Found, ConvertedArgs))
+      // FIXME: resugar
       T2 = Fn->getType();
   }
 
   // Compute some basic properties of the types and the initializer.
   bool isRValRef = DeclType->isRValueReferenceType();
   Expr::Classification InitCategory = Init->Classify(S.Context);
 
   Sema::ReferenceConversions RefConv;
if (From->getNumInits() == 1) {
       // If the initializer is the address of an overloaded function, try
       // to resolve the overloaded function. If all goes well, T2 is the
       // type of the resulting function.
       if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
         DeclAccessPair Found;
         const TemplateArgumentList *ConvertedArgs;
         if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
                 Init, ToType, false, Found, ConvertedArgs))
+          // FIXME: resugar
           T2 = Fn->getType();
       }
 
       // Compute some basic properties of the types and the initializer.
       Sema::ReferenceCompareResult RefRelationship =
           S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
 
       if (RefRelationship >= Sema::Ref_Related) {
if (!Found || Found->isCPUDispatchMultiVersion() ||
       Found->isCPUSpecificMultiVersion())
     return false;
 
   // Emitting multiple diagnostics for a function that is both inaccessible and
   // unavailable is consistent with our behavior elsewhere. So, always check
   // for both.
   DiagnoseUseOfDecl(Found, E->getExprLoc());
   CheckAddressOfMemberAccess(E, DAP);
+  // FIXME: resugar
   Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found, nullptr);
   if (DoFunctionPointerConversion && Fixed->getType()->isFunctionType())
     SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
   else
     SrcExpr = Fixed;
   return true;
 }
 
if (isa<MemberExpr>(NakedMemExpr)) {
     // non-member call based on that function.
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args, RParenLoc,
                                    ExecConfig, IsExecConfig);
     }
 
     MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
   }
+  assert(Method && "Member call to something that isn't a method?");
 
-  QualType ResultType = Method->getReturnType();
-  ExprValueKind VK = Expr::getValueKindForType(ResultType);
-  ResultType = ResultType.getNonLValueExprType(Context);
+  QualType MethodType;
+  {
+    QualType BaseType = MemExpr->getBase()->getType();
+    if (MemExpr->isArrow())
+      BaseType = BaseType->castAs<PointerType>()->getPointeeType();
+    NestedNameSpecifierLoc NNS = MemExpr->getQualifierLoc();
+    // FIXME: Should we resugar the explicit template arguments as well?
+    const TemplateArgumentList *Deduced = MemExpr->getDeduced();
+    MethodType =
+        Deduced ? resugar(BaseType.getTypePtr(), NNS.getNestedNameSpecifier(),
+                          Method, Deduced->asArray(), Method->getType())
+                : resugar(BaseType.getTypePtr(), NNS.getNestedNameSpecifier(),
+                          Method->getType());
+  }
+
+  const auto *Proto = MethodType->castAs<FunctionProtoType>();
+  QualType ReturnType = Proto->getReturnType();
+
+  ExprValueKind VK = Expr::getValueKindForType(ReturnType);
+  QualType ResultType = ReturnType.getNonLValueExprType(Context);
 
-  assert(Method && "Member call to something that isn't a method?");
-  const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
   CXXMemberCallExpr *TheCall = CXXMemberCallExpr::Create(
       Context, MemExprE, Args, ResultType, VK, RParenLoc,
       CurFPFeatureOverrides(), Proto->getNumParams());
 
   // Check for a valid return type.
-  if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
-                          TheCall, Method))
+  if (CheckCallReturnType(ReturnType, MemExpr->getMemberLoc(), TheCall, Method))
     return BuildRecoveryExpr(ResultType);
 
   // Convert the object argument (for a non-static member function call).
   // We only need to do this if there was actually an overload; otherwise
   // it was done at lookup.
   if (!Method->isStatic()) {
     ExprResult ObjectArg =
       PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
         assert(isa<DeclRefExpr>(SubExpr)
                && "fixed to something other than a decl ref");
         assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
                && "fixed to a member ref with no nested name qualifier");
 
         // We have taken the address of a pointer to member
         // function. Perform the computation here so that we get the
         // appropriate pointer to member type.
-        QualType ClassType
-          = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
-        QualType MemPtrType
-          = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
+        // FIXME: get sugared class type
+        const Type *ClassType =
+            Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()))
+                .getTypePtr();
+
+        QualType Type =
+            Deduced ? resugar(ClassType, Fn, Deduced->asArray(), Fn->getType())
+                    : resugar(ClassType, Fn->getType());
+        QualType MemPtrType = Context.getMemberPointerType(Type, ClassType);
         // Under the MS ABI, lock down the inheritance model now.
         if (Context.getTargetInfo().getCXXABI().isMicrosoft())
           (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
 
         return UnaryOperator::Create(
             Context, SubExpr, UO_AddrOf, MemPtrType, VK_PRValue, OK_Ordinary,
             UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
       }
Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
 
   if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (ULE->hasExplicitTemplateArgs()) {
       ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
+    NestedNameSpecifierLoc NNS = ULE->getQualifierLoc();
 
-    QualType Type = Fn->getType();
     ExprValueKind ValueKind = getLangOpts().CPlusPlus ? VK_LValue : VK_PRValue;
 
     // FIXME: Duplicated from BuildDeclarationNameExpr.
-    if (unsigned BID = Fn->getBuiltinID()) {
-      if (!Context.BuiltinInfo.isDirectlyAddressable(BID)) {
+    QualType Type;
+    {
+      unsigned BID = Fn->getBuiltinID();
+      if (BID && !Context.BuiltinInfo.isDirectlyAddressable(BID)) {
         Type = Context.BuiltinFnTy;
         ValueKind = VK_PRValue;
+      } else {
+        Type = Deduced ? resugar(NNS.getNestedNameSpecifier(), Fn,
+                                 Deduced->asArray(), Fn->getType())
+                       : resugar(NNS.getNestedNameSpecifier(), Fn->getType());
       }
     }
 
     DeclRefExpr *DRE = BuildDeclRefExpr(
-        Fn, Type, ValueKind, ULE->getNameInfo(), ULE->getQualifierLoc(),
-        Found.getDecl(), ULE->getTemplateKeywordLoc(), TemplateArgs, Deduced);
+        Fn, Type, ValueKind, ULE->getNameInfo(), NNS, Found.getDecl(),
+        ULE->getTemplateKeywordLoc(), TemplateArgs, Deduced);
     DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
     return DRE;
   }
 
   if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (MemExpr->hasExplicitTemplateArgs()) {
       MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
     }
+    QualType BaseType = MemExpr->getBaseType();
+    const Type *BasePointeeType = BaseType->getPointeeType().getTypePtrOrNull();
+    if (!BasePointeeType)
+      BasePointeeType = BaseType.getTypePtr();
 
     Expr *Base;
 
     // If we're filling in a static method where we used to have an
     // implicit member access, rewrite to a simple decl ref.
     if (MemExpr->isImplicitAccess()) {
       if (cast<CXXMethodDecl>(Fn)->isStatic()) {
+        QualType Type = Deduced ? resugar(BasePointeeType, Fn,
+                                          Deduced->asArray(), Fn->getType())
+                                : resugar(BasePointeeType, Fn->getType());
         DeclRefExpr *DRE = BuildDeclRefExpr(
-            Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
+            Fn, Type, VK_LValue, MemExpr->getNameInfo(),
             MemExpr->getQualifierLoc(), Found.getDecl(),
             MemExpr->getTemplateKeywordLoc(), TemplateArgs, Deduced);
         DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
         return DRE;
       } else {
         SourceLocation Loc = MemExpr->getMemberLoc();
         if (MemExpr->getQualifier())
           Loc = MemExpr->getQualifierLoc().getBeginLoc();
-        Base =
-            BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
+        Base = BuildCXXThisExpr(Loc, BaseType, /*IsImplicit=*/true);
       }
     } else
       Base = MemExpr->getBase();
 
     ExprValueKind valueKind;
-    QualType type;
+    QualType Type;
     if (cast<CXXMethodDecl>(Fn)->isStatic()) {
       valueKind = VK_LValue;
-      type = Fn->getType();
+      Type = Deduced ? resugar(BasePointeeType, Fn, Deduced->asArray(),
+                               Fn->getType())
+                     : resugar(BasePointeeType, Fn->getType());
     } else {
       valueKind = VK_PRValue;
-      type = Context.BoundMemberTy;
+      Type = Context.BoundMemberTy;
     }
 
     return BuildMemberExpr(
         Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
         MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
-        /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
-        type, valueKind, OK_Ordinary, TemplateArgs);
+        /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(), Type,
+        valueKind, OK_Ordinary, TemplateArgs, Deduced);
   }
 
   llvm_unreachable("Invalid reference to overloaded function");
 }
 
 ExprResult
 Sema::FixOverloadedFunctionReference(ExprResult E, DeclAccessPair Found,
                                      FunctionDecl *Fn,

clang/lib/Sema/SemaTemplate.cpp

[[maybe_unused]] Sema::TemplateDeductionResult Res =
         SemaRef.DeduceTemplateArguments(
             CTPSD,
             TemplateArgumentList(TemplateArgumentList::OnStackType{}, Args),
             Info);
     assert(Res == Sema::TDK_Success);
     insert(CTSD, Info.takeSugared()->asArray());
   }
 
+  void insert(Sema &SemaRef, const NamedDecl *ND,
+              ArrayRef<TemplateArgument> Args) {
+    assert(ND != nullptr);
+    ND = cast<NamedDecl>(ND->getCanonicalDecl());
+    assert(Args.size() != 0);
+    switch (ND->getKind()) {
+    case Decl::Kind::CXXConversion:
+    case Decl::Kind::CXXMethod:
+    case Decl::Kind::Function: {
+      const auto *FD = cast<FunctionDecl>(ND);
+      assert(FD->getTemplatedKind() ==
+             FunctionDecl::TK_FunctionTemplateSpecialization);
+      return insert(FD->getPrimaryTemplate(), Args);
+    }
+    case Decl::Kind::VarTemplateSpecialization: {
+      auto STP = cast<VarTemplateSpecializationDecl>(ND)
+                     ->getSpecializedTemplateOrPartial();
+      auto *VTPSD = STP.dyn_cast<VarTemplatePartialSpecializationDecl *>();
+      if (!VTPSD)
+        return insert(STP.get<VarTemplateDecl *>(), Args);
+
+      TemplateDeductionInfo Info(SourceLocation{},
+                                 VTPSD->getTemplateParameters()->getDepth());
+      [[maybe_unused]] Sema::TemplateDeductionResult Res =
+          SemaRef.DeduceTemplateArguments(
+              VTPSD,
+              TemplateArgumentList(TemplateArgumentList::OnStackType{}, Args),
+              Info);
+      assert(Res == Sema::TDK_Success);
+      return insert(VTPSD, Info.takeSugared()->asArray());
+    }
+    default:
+      ND->dumpColor();
+      llvm_unreachable("Unhandled Template Kind");
+    }
+  }
+
   void insert(Sema &SemaRef, const NestedNameSpecifier *NNS) {
     for (/**/; NNS; NNS = NNS->getPrefix()) {
       switch (NNS->getKind()) {
       case NestedNameSpecifier::Global:
       case NestedNameSpecifier::Namespace:
       case NestedNameSpecifier::NamespaceAlias:
       case NestedNameSpecifier::Super:
         return;
QualType Sema::resugar(const NestedNameSpecifier *NNS, QualType T) {
   Names.insert(*this, NNS);
   if (Names.empty())
     return T;
 
   bool Changed = false;
   return Resugarer(*this, Names).transform(T, Changed);
 }
 
+QualType Sema::resugar(const NestedNameSpecifier *NNS, NamedDecl *ND,
+                       ArrayRef<TemplateArgument> Args, QualType T) {
+  NameMap Names;
+  Names.insert(*this, ND, Args);
+  Names.insert(*this, NNS);
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+
+QualType Sema::resugar(NamedDecl *ND, ArrayRef<TemplateArgument> Args,
+                       QualType T) {
+  NameMap Names;
+  Names.insert(*this, ND, Args);
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+
+static const NestedNameSpecifier *decomposeBaseType(const Type *&Base) {
+  if (const auto *ElTy = Base->getAs<ElaboratedType>()) {
+    Base = ElTy->getNamedType().getTypePtr();
+    return ElTy->getQualifier();
+  }
+  return nullptr;
+}
+
+QualType Sema::resugar(const Type *Base, QualType T) {
+  NameMap Names;
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Names.insert(*this, Base);
+  Names.insert(*this, BaseNNS);
+  if (Names.empty())
+    return T;
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+QualType Sema::resugar(const Type *Base, NamedDecl *ND,
+                       ArrayRef<TemplateArgument> Args, QualType T) {
+  NameMap Names;
+  Names.insert(*this, ND, Args);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Names.insert(*this, Base);
+  Names.insert(*this, BaseNNS);
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+QualType Sema::resugar(const Type *Base, const NestedNameSpecifier *FieldNNS,
+                       QualType T) {
+  NameMap Names;
+  Names.insert(*this, FieldNNS);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Names.insert(*this, Base);
+  Names.insert(*this, BaseNNS);
+  if (Names.empty())
+    return T;
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+QualType Sema::resugar(const Type *Base, const NestedNameSpecifier *FieldNNS,
+                       NamedDecl *ND, ArrayRef<TemplateArgument> Args,
+                       QualType T) {
+  NameMap Names;
+  Names.insert(*this, ND, Args);
+  Names.insert(*this, FieldNNS);
+  const NestedNameSpecifier *BaseNNS = decomposeBaseType(Base);
+  Names.insert(*this, Base);
+  Names.insert(*this, BaseNNS);
+
+  bool Changed = false;
+  return Resugarer(*this, Names).transform(T, Changed);
+}
+
 /// \brief Determine whether the declaration found is acceptable as the name
 /// of a template and, if so, return that template declaration. Otherwise,
 /// returns null.
 ///
 /// Note that this may return an UnresolvedUsingValueDecl if AllowDependent
 /// is true. In all other cases it will return a TemplateDecl (or null).
 NamedDecl *Sema::getAsTemplateNameDecl(NamedDecl *D,
                                        bool AllowFunctionTemplates,

clang/lib/Sema/SemaTemplateDeduction.cpp

 static QualType GetTypeOfFunction(Sema &S, const OverloadExpr::FindResult &R,
                                   FunctionDecl *Fn,
                                   ArrayRef<TemplateArgument> Args) {
   // We may need to deduce the return type of the function now.
   if (S.getLangOpts().CPlusPlus14 && Fn->getReturnType()->isUndeducedType() &&
       S.DeduceReturnType(Fn, R.Expression->getExprLoc(), /*Diagnose*/ false))
     return {};
 
+  // FIXME: get SS.
+  QualType FT =
+      Args.size() != 0 ? S.resugar(Fn, Args, Fn->getType()) : Fn->getType();
+
   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
     if (Method->isInstance()) {
       // An instance method that's referenced in a form that doesn't
       // look like a member pointer is just invalid.
       if (!R.HasFormOfMemberPointer)
         return {};
 
-      return S.Context.getMemberPointerType(Fn->getType(),
-               S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
+      // FIXME: resugar the class type here.
+      return S.Context.getMemberPointerType(
+          FT, S.Context.getTypeDeclType(Method->getParent()).getTypePtr());
     }
 
-  if (!R.IsAddressOfOperand) return Fn->getType();
-  return S.Context.getPointerType(Fn->getType());
+  if (!R.IsAddressOfOperand)
+    return FT;
+  return S.Context.getPointerType(FT);
 }
 
 /// Apply the deduction rules for overload sets.
 ///
 /// \return the null type if this argument should be treated as an
 /// undeduced context
 static QualType
 ResolveOverloadForDeduction(Sema &S, TemplateParameterList *TemplateParams,
SmallVector<DeducedTemplateArgument, 8>
       Deduced(TemplateParams->size());
     TemplateDeductionInfo Info(Ovl->getNameLoc());
     Sema::TemplateDeductionResult Result
       = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, ParamType,
                                            ArgType, Info, Deduced, TDF);
     if (Result) continue;
     if (!Match.isNull())
       return {};
+    // FIXME: resugar
     Match = ArgType;
   }
 
   return Match;
 }
 
 /// Perform the adjustments to the parameter and argument types
 /// described in C++ [temp.deduct.call].

clang/lib/Sema/TreeTransform.h

if (!Member->getDeclName()) {
       BaseResult =
         getSema().PerformObjectMemberConversion(BaseResult.get(),
                                                 QualifierLoc.getNestedNameSpecifier(),
                                                 FoundDecl, Member);
       if (BaseResult.isInvalid())
         return ExprError();
       Base = BaseResult.get();
 
-      CXXScopeSpec EmptySS;
+      // FIXME: resugar.
       return getSema().BuildFieldReferenceExpr(
-          Base, isArrow, OpLoc, EmptySS, cast<FieldDecl>(Member),
-          DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()), MemberNameInfo);
+          Base, isArrow, OpLoc, NestedNameSpecifierLoc(),
+          cast<FieldDecl>(Member), Member->getType(),
+          DeclAccessPair::make(FoundDecl, FoundDecl->getAccess()),
+          MemberNameInfo);
     }
 
     CXXScopeSpec SS;
     SS.Adopt(QualifierLoc);
 
     Base = BaseResult.get();
     QualType BaseType = Base->getType();
 

clang/test/AST/ast-dump-expr-json.cpp

 // CHECK-NEXT:       },
 // CHECK-NEXT:       "end": {
 // CHECK-NEXT:        "offset": {{[0-9]+}},
 // CHECK-NEXT:        "col": 24,
 // CHECK-NEXT:        "tokLen": 1
 // CHECK-NEXT:       }
 // CHECK-NEXT:      },
 // CHECK-NEXT:      "type": {
-// CHECK-NEXT:       "desugaredQualType": "int",
 // CHECK-NEXT:       "qualType": "int"
 // CHECK-NEXT:      },
 // CHECK-NEXT:      "valueCategory": "prvalue",
 // CHECK-NEXT:      "inner": [
 // CHECK-NEXT:       {
 // CHECK-NEXT:        "id": "0x{{.*}}",
 // CHECK-NEXT:        "kind": "MemberExpr",
 // CHECK-NEXT:        "range": {

 // CHECK-NEXT:       },
 // CHECK-NEXT:       "end": {
 // CHECK-NEXT:        "offset": {{[0-9]+}},
 // CHECK-NEXT:        "col": 25,
 // CHECK-NEXT:        "tokLen": 1
 // CHECK-NEXT:       }
 // CHECK-NEXT:      },
 // CHECK-NEXT:      "type": {
-// CHECK-NEXT:       "desugaredQualType": "float",
 // CHECK-NEXT:       "qualType": "float"
 // CHECK-NEXT:      },
 // CHECK-NEXT:      "valueCategory": "prvalue",
 // CHECK-NEXT:      "inner": [
 // CHECK-NEXT:       {
 // CHECK-NEXT:        "id": "0x{{.*}}",
 // CHECK-NEXT:        "kind": "MemberExpr",
 // CHECK-NEXT:        "range": {

clang/test/AST/ast-dump-expr.cpp

void PostfixExpressions(S a, S *p, U<int> *r) {
   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:12> 'void'
   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:6> '<bound member function type>' ->func 0x{{[^ ]*}}
   // CHECK-NEXT: ImplicitCastExpr
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
   // CHECK-NEXT: IntegerLiteral 0x{{[^ ]*}} <col:11> 'int' 0
 
   // FIXME: there is no mention that this used the template keyword.
   p->template foo<int>();
-  // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:24> 'int':'int'
+  // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:24> 'int'
   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:22> '<bound member function type>' ->foo 0x{{[^ ]*}}
   // CHECK-NEXT: ImplicitCastExpr
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'
 
   // FIXME: there is no mention that this used the template keyword.
   a.template foo<float>();
-  // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:25> 'float':'float'
+  // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:25> 'float'
   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:23> '<bound member function type>' .foo 0x{{[^ ]*}}
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S':'S' lvalue ParmVar 0x{{[^ ]*}} 'a' 'S':'S'
 
   p->~S();
   // CHECK: CXXMemberCallExpr 0x{{[^ ]*}} <line:[[@LINE-1]]:3, col:9> 'void'
   // CHECK-NEXT: MemberExpr 0x{{[^ ]*}} <col:3, col:7> '<bound member function type>' ->~S 0x{{[^ ]*}}
   // CHECK-NEXT: ImplicitCastExpr
   // CHECK-NEXT: DeclRefExpr 0x{{[^ ]*}} <col:3> 'S *' lvalue ParmVar 0x{{[^ ]*}} 'p' 'S *'

clang/test/AST/ast-dump-openmp-begin-declare-variant_template_2.cpp

 // CHECK-NEXT:         | | | |     `-DeclRefExpr [[ADDR_150:0x[a-z0-9]*]] <col:28, col:50> 'int ({{.*}})' {{.*}}Function [[ADDR_24]] 'also_before_mismatch' 'int ({{.*}})' (FunctionTemplate [[ADDR_18]] 'also_before_mismatch')
 // CHECK-NEXT:         | | | `-CallExpr [[ADDR_151:0x[a-z0-9]*]] <col:56, col:81> 'int'
 // CHECK-NEXT:         | | |   `-ImplicitCastExpr [[ADDR_152:0x[a-z0-9]*]] <col:56> 'int (*)({{.*}})' <FunctionToPointerDecay>
 // CHECK-NEXT:         | | |     `-DeclRefExpr [[ADDR_153:0x[a-z0-9]*]] <col:56> 'int ({{.*}})' {{.*}}Function [[ADDR_27]] 'also_before_non_template' 'int ({{.*}})'
 // CHECK-NEXT:         | | `-PseudoObjectExpr [[ADDR_154:0x[a-z0-9]*]] <col:85, col:103> 'int'
 // CHECK-NEXT:         | |   |-CallExpr [[ADDR_155:0x[a-z0-9]*]] <col:85, col:103> 'int'
 // CHECK-NEXT:         | |   | |-ImplicitCastExpr [[ADDR_156:0x[a-z0-9]*]] <col:85, col:100> 'int (*)(char)' <FunctionToPointerDecay>
 // CHECK-NEXT:         | |   | | `-DeclRefExpr [[ADDR_157:0x[a-z0-9]*]] <col:85, col:100> 'int (char)' {{.*}}Function [[ADDR_47]] 'also_after' 'int (char)' (FunctionTemplate [[ADDR_114]] 'also_after')
-// CHECK-NEXT:         | |   | `-ImplicitCastExpr [[ADDR_158:0x[a-z0-9]*]] <col:102> 'char':'char' <IntegralCast>
+// CHECK-NEXT:         | |   | `-ImplicitCastExpr [[ADDR_158:0x[a-z0-9]*]] <col:102> 'char' <IntegralCast>
 // CHECK-NEXT:         | |   |   `-IntegerLiteral [[ADDR_159:0x[a-z0-9]*]] <col:102> 'int' 0
 // CHECK-NEXT:         | |   `-CallExpr [[ADDR_160:0x[a-z0-9]*]] <line:22:1, line:54:103> 'int'
 // CHECK-NEXT:         | |     |-ImplicitCastExpr [[ADDR_161:0x[a-z0-9]*]] <line:22:1> 'int (*)(char)' <FunctionToPointerDecay>
 // CHECK-NEXT:         | |     | `-DeclRefExpr [[ADDR_54]] <col:1> 'int (char)' {{.*}}Function [[ADDR_55]] 'also_after[implementation={extension(allow_templates)}]' 'int (char)'
 // CHECK-NEXT:         | |     `-ImplicitCastExpr [[ADDR_162:0x[a-z0-9]*]] <line:54:102> 'char':'char' <IntegralCast>
 // CHECK-NEXT:         | |       `-IntegerLiteral [[ADDR_159]] <col:102> 'int' 0
 // CHECK-NEXT:         | `-CallExpr [[ADDR_163:0x[a-z0-9]*]] <col:107, col:128> 'int'
 // CHECK-NEXT:         |   |-ImplicitCastExpr [[ADDR_164:0x[a-z0-9]*]] <col:107> 'int (*)(int)' <FunctionToPointerDecay>

clang/test/AST/float16.cpp

 //CHECK-NEXT:  |     | | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |     | | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
 //CHECK-NEXT:  |     | | | | `-CallExpr {{.*}} '_Float16'
 //CHECK-NEXT:  |     | | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
 //CHECK-NEXT:  |     | | | |   | `-MemberExpr {{.*}} '_Float16 (_Float16)' lvalue .func2c {{.*}}
 //CHECK-NEXT:  |     | | | |   |   `-DeclRefExpr {{.*}} 'C1':'C1' lvalue Var {{.*}} 'c1' 'C1':'C1'
 //CHECK-NEXT:  |     | | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |     | | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
-//CHECK-NEXT:  |     | | | `-CallExpr {{.*}} '_Float16':'_Float16'
+//CHECK-NEXT:  |     | | | `-CallExpr {{.*}} '_Float16'
 //CHECK-NEXT:  |     | | |   |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
 //CHECK-NEXT:  |     | | |   | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
 //CHECK-NEXT:  |     | | |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |     | | |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1l' '_Float16'
 //CHECK-NEXT:  |     | | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |     | |   `-MemberExpr {{.*}} '_Float16' lvalue .mem2 {{.*}}
 //CHECK-NEXT:  |     | |     `-DeclRefExpr {{.*}} 'S1<_Float16>':'S1<_Float16>' lvalue Var {{.*}} 's1' 'S1<_Float16>':'S1<_Float16>'
 //CHECK-NEXT:  |     | `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |     |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f1n' '_Float16'
 //CHECK-NEXT:  |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2n' '_Float16'
 
   auto f5l = -1.f16, *f6l = &f2l, f7l = func1t(f3l);
 //CHECK:       | |-VarDecl {{.*}} f5l '_Float16':'_Float16' cinit
 //CHECK-NEXT:  | | `-UnaryOperator {{.*}} '_Float16' prefix '-'
 //CHECK-NEXT:  | |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
 //CHECK-NEXT:  | |-VarDecl {{.*}} f6l '_Float16 *' cinit
 //CHECK-NEXT:  | | `-UnaryOperator {{.*}} '_Float16 *' prefix '&'
 //CHECK-NEXT:  | |   `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f2l' '_Float16'
 //CHECK-NEXT:  | `-VarDecl {{.*}} f7l '_Float16':'_Float16' cinit
-//CHECK-NEXT:  |   `-CallExpr {{.*}} '_Float16':'_Float16'
+//CHECK-NEXT:  |   `-CallExpr {{.*}} '_Float16'
 //CHECK-NEXT:  |     |-ImplicitCastExpr {{.*}} '_Float16 (*)(_Float16)' <FunctionToPointerDecay>
 //CHECK-NEXT:  |     | `-DeclRefExpr {{.*}} '_Float16 (_Float16)' lvalue Function {{.*}} 'func1t' '_Float16 (_Float16)' (FunctionTemplate {{.*}} 'func1t')
 //CHECK-NEXT:  |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
 //CHECK-NEXT:  |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'f3l' '_Float16'
 
   _Float16 f8l = f4l++;
 //CHECK:       | `-VarDecl {{.*}} f8l '_Float16' cinit
 //CHECK-NEXT:  |   `-UnaryOperator {{.*}} '_Float16' postfix '++'

clang/test/Analysis/cast-value-notes.cpp

 using namespace llvm;
 using namespace clang;
 
 void clang_analyzer_printState();
 
 #if defined(X86)
 void evalReferences(const Shape &S) {
   const auto &C = dyn_cast<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
   clang_analyzer_printState();
   // XX86-CHECK:      "dynamic_types": [
   // XX86-CHECK-NEXT:   { "region": "SymRegion{reg_$0<const struct clang::Shape & S>}", "dyn_type": "const class clang::Circle &", "sub_classable": true }
   (void)C;
 }
 #if defined(SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   const auto &C = dyn_cast<DEVICE Circle>(S);
   clang_analyzer_printState();
   // X86-CHECK-SUPPRESSED: "dynamic_types": [
-  // X86-CHECK-SUPPRESSED-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "const __attribute__((address_space(3))) class clang::Circle &", "sub_classable": true }
+  // X86-CHECK-SUPPRESSED-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "DEVICE Circle const &", "sub_classable": true }
   (void)C;
 }
 #endif
 #if defined(NOT_SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   const auto &C = dyn_cast<DEVICE Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const __attribute__((address_space(3))) class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'DEVICE Circle const &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
   clang_analyzer_printState();
   // X86-CHECK: "dynamic_types": [
-  // X86-CHECK-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "const __attribute__((address_space(3))) class clang::Circle &", "sub_classable": true }
+  // X86-CHECK-NEXT: { "region": "SymRegion{reg_$0<const Shape & S>}", "dyn_type": "DEVICE Circle const &", "sub_classable": true }
   (void)C;
 }
 #endif
 #elif defined(MIPS)
 void evalReferences(const Shape &S) {
   const auto &C = dyn_cast<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle &'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle &'}}
   // expected-note@-2 {{Dereference of null pointer}}
   // expected-warning@-3 {{Dereference of null pointer}}
 }
 #if defined(MIPS_SUPPRESSED)
 void evalReferences_addrspace(const Shape &S) {
   const auto &C = dyn_cast<DEVICE Circle>(S);
   (void)C;
 }
 #endif
 #endif
 
 void evalNonNullParamNonNullReturnReference(const Shape &S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
   // expected-note@-1 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Circle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is a 'const class clang::Circle *'}}
+    // expected-note@-1 {{Assuming 'C' is a 'const Circle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Triangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Rectangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Rectangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Rectangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Hexagon>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Hexagon *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Hexagon *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (isa<Triangle>(C)) {
     // expected-note@-1 {{'C' is not a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;
if (isa<Circle, Rectangle, Hexagon>(C)) {
     // expected-note@-1 {{'C' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 void evalNonNullParamNonNullReturn(const Shape *S) {
   const auto *C = cast<Circle>(S);
-  // expected-note@-1 {{'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Circle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is a 'const class clang::Circle *'}}
+    // expected-note@-1 {{Assuming 'C' is a 'const Circle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Triangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Rectangle>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Rectangle *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Rectangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (dyn_cast_or_null<Hexagon>(C)) {
-    // expected-note@-1 {{Assuming 'C' is not a 'const class clang::Hexagon *'}}
+    // expected-note@-1 {{Assuming 'C' is not a 'const Hexagon *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (isa<Triangle>(C)) {
     // expected-note@-1 {{'C' is not a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;
if (isa<Circle, Rectangle, Hexagon>(C)) {
     // expected-note@-1 {{'C' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 void evalNonNullParamNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle *'}}
 
   if (const auto *T = dyn_cast_or_null<Triangle>(S)) {
-    // expected-note@-1 {{Assuming 'S' is a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'S' is a 'const Triangle *'}}
     // expected-note@-2 {{'T' initialized here}}
     // expected-note@-3 {{'T' is non-null}}
     // expected-note@-4 {{Taking true branch}}
 
     (void)(1 / !T);
     // expected-note@-1 {{'T' is non-null}}
     // expected-note@-2 {{Division by zero}}
     // expected-warning@-3 {{Division by zero}}
   }
 }
 
 void evalNullParamNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
   // expected-note@-1 {{Assuming null pointer is passed into cast}}
   // expected-note@-2 {{'C' initialized to a null pointer value}}
 
   (void)(1 / (bool)C);
   // expected-note@-1 {{Division by zero}}
   // expected-warning@-2 {{Division by zero}}
 }
 
 void evalZeroParamNonNullReturnPointer(const Shape *S) {
   const auto *C = S->castAs<Circle>();
-  // expected-note@-1 {{'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   (void)(1 / !C);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 
 void evalZeroParamNonNullReturn(const Shape &S) {
   const auto *C = S.castAs<Circle>();
   // expected-note@-1 {{'C' initialized here}}
 
   (void)(1 / !C);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 
 void evalZeroParamNullReturn(const Shape *S) {
   const auto &C = S->getAs<Circle>();
-  // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is not a 'const Circle *'}}
   // expected-note@-2 {{Storing null pointer value}}
   // expected-note@-3 {{'C' initialized here}}
 
   if (!dyn_cast_or_null<Triangle>(S)) {
-    // expected-note@-1 {{Assuming 'S' is a 'const class clang::Triangle *'}}
+    // expected-note@-1 {{Assuming 'S' is a 'const Triangle *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   if (!dyn_cast_or_null<Triangle>(S)) {
     // expected-note@-1 {{'S' is a 'Triangle'}}
     // expected-note@-2 {{Taking false branch}}
     return;

clang/test/Analysis/cast-value-state-dump.cpp

 class Square : public Shape {};
 } // namespace clang
 
 using namespace llvm;
 using namespace clang;
 
 void evalNonNullParamNonNullReturn(const Shape *S) {
   const auto *C = dyn_cast_or_null<Circle>(S);
-  // expected-note@-1 {{Assuming 'S' is a 'const class clang::Circle *'}}
+  // expected-note@-1 {{Assuming 'S' is a 'const Circle *'}}
   // expected-note@-2 {{'C' initialized here}}
 
   // FIXME: We assumed that 'S' is a 'Circle' therefore it is not a 'Square'.
   if (dyn_cast_or_null<Square>(S)) {
-    // expected-note@-1 {{Assuming 'S' is not a 'const class clang::Square *'}}
+    // expected-note@-1 {{Assuming 'S' is not a 'const Square *'}}
     // expected-note@-2 {{Taking false branch}}
     return;
   }
 
   clang_analyzer_printState();
 
   // CHECK:      "dynamic_types": [
-  // CHECK-NEXT:   { "region": "SymRegion{reg_$0<const Shape * S>}", "dyn_type": "const class clang::Circle", "sub_classable": true }
+  // CHECK-NEXT:   { "region": "SymRegion{reg_$0<const Shape * S>}", "dyn_type": "const Circle", "sub_classable": true }
   // CHECK-NEXT: ],
   // CHECK-NEXT: "dynamic_casts": [
   // CHECK:        { "region": "SymRegion{reg_$0<const Shape * S>}", "casts": [
   // CHECK-NEXT:     { "from": "struct clang::Shape", "to": "class clang::Circle", "kind": "success" },
   // CHECK-NEXT:     { "from": "struct clang::Shape", "to": "class clang::Square", "kind": "fail" }
   // CHECK-NEXT:   ] }
 
   (void)(1 / !C);
   // expected-note@-1 {{'C' is non-null}}
   // expected-note@-2 {{Division by zero}}
   // expected-warning@-3 {{Division by zero}}
 }
 

clang/test/Index/print-type.cpp

 // CHECK: VarDecl=member_pointer:50:12 (Definition) [type=int Blob::*] [typekind=MemberPointer] [isPOD=1]
 // CHECK: FunctionDecl=elaboratedNamespaceType:52:42 [type=NS::Type (const NS::Type)] [typekind=FunctionProto] [canonicaltype=NS::Type (NS::Type)] [canonicaltypekind=FunctionProto] [resulttype=NS::Type] [resulttypekind=Elaborated] [args= [const NS::Type] [Elaborated]] [isPOD=0]
 // CHECK: NamespaceRef=NS:52:11 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: TypeRef=struct NS::Type:52:23 [type=NS::Type] [typekind=Record] [isPOD=1]
 // CHECK: ParmDecl=t:52:81 (Definition) [type=const NS::Type] [typekind=Elaborated] const [canonicaltype=const NS::Type] [canonicaltypekind=Record] [isPOD=1]
 // CHECK: VarDecl=autoI:54:6 (Definition) [type=int] [typekind=Auto] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: VarDecl=autoTbar:55:6 (Definition) [type=int] [typekind=Auto] [canonicaltype=int] [canonicaltypekind=Int] [isPOD=1]
-// CHECK: CallExpr=tbar:36:3 [type=int] [typekind=Unexposed] [canonicaltype=int] [canonicaltypekind=Int] [args= [int] [Int]] [isPOD=1]
-// CHECK: UnexposedExpr=tbar:36:3 [type=int (*)(int)] [typekind=Pointer] [canonicaltype=int (*)(int)] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=int (int)] [pointeekind=FunctionProto]
-// CHECK: DeclRefExpr=tbar:36:3 RefName=[55:17 - 55:21] RefName=[55:21 - 55:26] [type=int (int)] [typekind=FunctionProto] [canonicaltype=int (int)] [canonicaltypekind=FunctionProto] [isPOD=0]
+// CHECK: CallExpr=tbar:36:3 [type=int] [typekind=Int] [args= [int] [Int]] [isPOD=1] [isAnonRecDecl=0]
+// CHECK: UnexposedExpr=tbar:36:3 [type=int (*)(int)] [typekind=Pointer] [isPOD=1] [pointeetype=int (int)] [pointeekind=FunctionProto]
+// CHECK: DeclRefExpr=tbar:36:3 RefName=[55:17 - 55:21] RefName=[55:21 - 55:26] [type=int (int)] [typekind=FunctionProto] [isPOD=0]
 // CHECK: IntegerLiteral= [type=int] [typekind=Int] [isPOD=1]
 // CHECK: VarDecl=autoBlob:56:6 (Definition) [type=Blob *] [typekind=Auto] [canonicaltype=Blob *] [canonicaltypekind=Pointer] [isPOD=1]
 // CHECK: CXXNewExpr= [type=Blob *] [typekind=Pointer] [canonicaltype=Blob *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Blob] [pointeekind=Elaborated]
 // CHECK: TypeRef=struct Blob:46:8 [type=Blob] [typekind=Record] [isPOD=1] [nbFields=2]
 // CHECK: CallExpr=Blob:46:8 [type=Blob] [typekind=Elaborated] [canonicaltype=Blob] [canonicaltypekind=Record] [isPOD=1] [nbFields=2]
 // CHECK: FunctionDecl=autoFunction:57:6 (Definition) [type=int ()] [typekind=FunctionProto] [canonicaltype=int ()] [canonicaltypekind=FunctionProto] [resulttype=int] [resulttypekind=Auto] [isPOD=0]
 // CHECK: CompoundStmt= [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: ReturnStmt= [type=] [typekind=Invalid] [isPOD=0]

clang/test/Misc/diag-template-diffing.cpp

 Wrapper<S<&global2, static_cast<int *>(0)>> W11 =
     MakeWrapper<S<&global, nullptr>>();
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
 Wrapper<S<&global2, nullptr>> W12 =
     MakeWrapper<S<&global, static_cast<int *>(0)>>();
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<&global, [...]>>' to 'Wrapper<S<&global2, [...]>>'
 
 Wrapper<S<&global, &global>> W13 = MakeWrapper<S<&global, ptr>>();
-// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], nullptr>>' to 'Wrapper<S<[...], &global>>'
+// CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], ptr aka nullptr>>' to 'Wrapper<S<[...], &global>>'
 Wrapper<S<&global, ptr>> W14 = MakeWrapper<S<&global, &global>>();
 // CHECK-ELIDE-NOTREE: no viable conversion from 'Wrapper<S<[...], &global>>' to 'Wrapper<S<[...], ptr aka nullptr>>'
 }
 
 namespace TemplateTemplateDefault {
 template <class> class A{};
 template <class> class B{};
 template <class> class C{};

 }
 
 namespace DefaultNonTypeArgWithDependentType {
 // We used to crash diffing integer template arguments when the argument type
 // is dependent and default arguments were used.
 template <typename SizeType = int, SizeType = 0> struct A {};
 template <typename R = A<>> R bar();
 A<> &foo() { return bar(); }
-// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<...>' cannot bind to a temporary of type 'A<...>'
-// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<int, 0>' cannot bind to a temporary of type 'A<int, 0>'
+// CHECK-ELIDE-NOTREE: error: non-const lvalue reference to type 'A<>' cannot bind to a temporary of type 'A<>'
+// CHECK-NOELIDE-NOTREE: error: non-const lvalue reference to type 'A<>' cannot bind to a temporary of type 'A<>'
 }
 
 namespace PR24587 {
 template <typename T, T v>
 struct integral_constant {};
 
 auto false_ = integral_constant<bool, false> {};
 

clang/test/Sema/Resugar/resugar-expr.cpp

+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s
+
+enum class Z;
+
+struct bar {};
+
+using Int = int;
+using Float = float;
+using Bar = bar;
+
+namespace t1 {
+template <class A1> struct A {
+  static constexpr A1 a = {};
+};
+
+Z x1 = A<Int>::a;
+// expected-error@-1 {{with an lvalue of type 'const Int' (aka 'const int')}}
+} // namespace t1
+
+namespace t2 {
+template <class A1, class A2> struct A {
+  static constexpr A1 A2::*a = {};
+};
+
+Z x1 = A<Int, Bar>::a;
+// expected-error@-1 {{with an lvalue of type 'Int Bar::*const'}}
+} // namespace t2
+
+namespace t3 {
+template <class A1> struct A {
+  template <class B1> struct B {
+    static constexpr A1 B1::*a = {};
+  };
+};
+
+Z x1 = A<Float>::B<Bar>::a;
+// expected-error@-1 {{with an lvalue of type 'Float Bar::*const'}}
+} // namespace t3
+
+namespace t4 {
+template <class A1> A1 (*a) ();
+
+Z x1 = decltype(a<Int>){}();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t4
+
+namespace t5 {
+template <class A1> struct A {
+  A1(*a)
+  ();
+};
+
+Z x1 = decltype(A<Int>().a){}();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t5
+
+namespace t6 {
+template <class A1, class A2> struct A { A2 A1::*f(); };
+
+using M = int;
+using N = int;
+
+struct B {};
+using X = B;
+using Y = B;
+
+auto a = &A<X, M>::f;
+Z x1 = a;
+// expected-error@-1 {{with an lvalue of type 'M X::*(A<X, M>::*)()'}}
+
+A<Y, N> b;
+Z x2 = (b.*a)();
+// expected-error@-1 {{with an rvalue of type 'M X::*'}}
+
+Z x3 = decltype((b.*a)()){};
+// expected-error@-1 {{with an rvalue of type 'decltype((b .* a)())' (aka 'M X::*')}}
+} // namespace t6
+
+namespace t7 {
+template <class A1> struct A { A1 a; };
+auto [a] = A<Int>{};
+
+Z x1 = a;
+// expected-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+} // namespace t7
+
+namespace t8 {
+template <class A1> struct A {
+  template <class B1> static constexpr B1 (*b)(A1) = nullptr;
+};
+
+Z x1 = A<Float>::b<Int>;
+// expected-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)')}}
+} // namespace t8
+
+namespace t9 {
+template <class A1> struct A {
+  template <class B1> static constexpr auto b = (B1(*)(A1)){};
+};
+
+Z x1 = A<Float>::b<Int>;
+// expected-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)'}}
+} // namespace t9
+
+namespace t10 {
+template <class A1> struct A {
+  template <class B1> static constexpr A1 (*m)(B1) = nullptr;
+};
+
+Z x1 = A<Int>().template m<Float>;
+// expected-error@-1 {{with an lvalue of type 'Int (*const)(Float)' (aka 'int (*const)(float)'}}
+} // namespace t10
+
+namespace t11 {
+template <class A1> A1 a;
+template <class A2> A2 a<A2 *>;
+
+Z x1 = a<Int>;
+// expected-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+
+Z x2 = a<Float *>;
+// expected-error@-1 {{with an lvalue of type 'Float' (aka 'float')}}
+} // namespace t11
+
+namespace t12 {
+template<class A1> A1 *a;
+template<int A3, class A4> decltype(a<A4[A3 - 1]>) a<A4[A3]>;
+
+Z x1 = *a<Int[1]>;
+// expected-error@-1 {{with an lvalue of type 'Int[0]' (aka 'int[0]')}}
+} // namespace t12
+
+namespace t13 {
+template <class A1> struct A { A1 foo(); };
+
+Z x1 = A<Int>().foo();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t13
+
+namespace t14 {
+template <class A1> struct A {
+  auto foo() { return A1(); };
+};
+
+Z x1 = A<Int>().foo();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t14
+
+namespace t15 {
+template <class A1> struct A {
+  template <class B1> auto foo1() -> A1 (*)(B1);
+  template <class B1> auto foo2(B1) -> A1 (*)(B1);
+};
+
+Z x1 = A<Int>().foo1<Float>();
+// expected-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+
+Z x2 = A<Int>().foo2(Float());
+// expected-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+} // namespace t15
+
+namespace t16 {
+template <class A1> struct A {
+  static auto foo() -> A1;
+};
+
+Z x1 = A<Int>().foo();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t16
+
+namespace t17 {
+template <class A1> static auto foo() -> A1;
+
+Z x1 = foo<Int>();
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t17
+
+namespace t18 {
+template <class A1> static auto foo(A1) -> A1*;
+
+Z x1 = foo(Int());
+// expected-error@-1 {{with an rvalue of type 'Int *' (aka 'int *')}}
+} // namespace t18
+
+namespace t19 {
+template <class A1> struct A {
+  template <class B1> static auto foo() -> A1 (*)(B1);
+};
+
+Z x1 = A<Int>().template foo<Float>();
+// expected-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+
+Z x2 = A<Int>::template foo<Float>();
+// expected-error@-1 {{with an rvalue of type 'Int (*)(Float)' (aka 'int (*)(float)'}}
+} // namespace t19
+
+namespace t20 {
+template <class A1> struct A {
+  A1 m;
+};
+
+Z x1 = A<Int>().m;
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t20
+
+namespace t21 {
+template <class A1> struct A {
+  static A1 m;
+};
+
+Z x1 = A<Int>().m;
+// expected-error@-1 {{with an lvalue of type 'Int' (aka 'int')}}
+} // namespace t21
+
+namespace t22 {
+template <class A1> struct A {
+  struct {
+    A1 m;
+  };
+};
+
+Z x1 = A<Int>().m;
+// expected-error@-1 {{with an rvalue of type 'Int' (aka 'int')}}
+} // namespace t22

clang/test/SemaTemplate/attributes.cpp

template<typename T> struct MemberTemplate {
     using iterator = Iter<T>;
     using const_iterator = Iter<const T>;
     template<typename U>
     struct [[clang::preferred_name(iterator),
              clang::preferred_name(const_iterator)]] Iter {};
   };
   template<typename T> T desugar(T);
   auto it = desugar(MemberTemplate<int>::Iter<const int>());
-  int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::const_iterator' to 'int'}}
+  // FIXME: We need to implement a __builtin_canonicalize_type for this ;-)
+  int n = it; // expected-error {{no viable conversion from 'MemberTemplate<int>::Iter<const int>' to 'int'}}
 
   template<int A, int B, typename ...T> struct Foo;
   template<typename ...T> using Bar = Foo<1, 2, T...>;
   template<int A, int B, typename ...T> struct [[clang::preferred_name(::preferred_name::Bar<T...>)]] Foo {};
   Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
 }
 ::preferred_name::Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}

clang/unittests/Tooling/StencilTest.cpp

TEST_F(StencilTest, DescribeUnqualifiedType) {
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("type"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT_EXPECTED(describe("type")->eval(StmtMatch->Result),
                        HasValue(std::string(Expected)));
 }
 
 TEST_F(StencilTest, DescribeAnonNamespaceType) {
+  // FIXME: We need to implement a __builtin_canonicalize_type for this ;-)
   std::string Snippet = "auto c = desugar<AnonC>(); c;";
-  std::string Expected = "(anonymous namespace)::AnonC";
+  std::string Expected = "AnonC";
   auto StmtMatch =
       matchStmt(Snippet, declRefExpr(hasType(qualType().bind("type"))));
   ASSERT_TRUE(StmtMatch);
   EXPECT_THAT_EXPECTED(describe("type")->eval(StmtMatch->Result),
                        HasValue(std::string(Expected)));
 }
 
 TEST_F(StencilTest, RunOp) {