================
@@ -46,6 +50,98 @@ const Type *resolveDeclsToType(const std::vector<const
NamedDecl *> &Decls,
return nullptr;
}
+// Visitor that helps to extract deduced type from instantiated entities.
+// This merely performs the source location comparison against each Decl
+// until it finds a Decl with the same location as the
+// dependent one. Its associated type will then be extracted.
+struct InstantiatedDeclVisitor : RecursiveASTVisitor<InstantiatedDeclVisitor> {
+
+ InstantiatedDeclVisitor(NamedDecl *DependentDecl) :
DependentDecl(DependentDecl) {}
+
+ bool shouldVisitTemplateInstantiations() const { return true; }
+
+ bool shouldVisitLambdaBody() const { return true; }
+
+ bool shouldVisitImplicitCode() const { return true; }
+
+ template <typename D>
+ bool onDeclVisited(D *MaybeInstantiated) {
+ if (MaybeInstantiated->getDeclContext()->isDependentContext())
+ return true;
+ auto *Dependent = dyn_cast<D>(DependentDecl);
+ if (!Dependent)
+ return true;
+ auto LHS = MaybeInstantiated->getTypeSourceInfo(),
+ RHS = Dependent->getTypeSourceInfo();
+ if (!LHS || !RHS)
+ return true;
+ if (LHS->getTypeLoc().getSourceRange() !=
+ RHS->getTypeLoc().getSourceRange())
+ return true;
+ DeducedType = MaybeInstantiated->getType();
+ return false;
+ }
+
+ bool VisitFieldDecl(FieldDecl *FD) {
+ return onDeclVisited(FD);
+ }
+
+ bool VisitVarDecl(VarDecl *VD) {
+ return onDeclVisited(VD);
+ }
+
+ NamedDecl *DependentDecl;
+ QualType DeducedType;
+};
+
+/// Attempt to resolve the dependent type from the surrounding context for
which
+/// a single instantiation is available.
+const Type *
+resolveTypeFromInstantiatedTemplate(const CXXDependentScopeMemberExpr *Expr) {
+ if (Expr->isImplicitAccess())
+ return nullptr;
+
+ auto *Base = Expr->getBase();
+ NamedDecl *ND = nullptr;
+ if (auto *CXXMember = dyn_cast<MemberExpr>(Base))
+ ND = CXXMember->getMemberDecl();
+
+ if (auto *DRExpr = dyn_cast<DeclRefExpr>(Base))
+ ND = DRExpr->getFoundDecl();
+
+ // FIXME: Handle CXXUnresolvedConstructExpr. This kind of type doesn't have
+ // available Decls to be matched against. Which inhibits the current
heuristic
+ // from resolving expressions such as `T().fo^o()`, where T is a
+ // single-instantiated template parameter.
+ if (!ND)
+ return nullptr;
----------------
zyn0217 wrote:
RFC: Do we have a neat approach to deal with such an expression? One approach
that comes to mind is:
1) Extract the TemplateTypeParmDecl (TTPD) from the expression.
2) Traverse every Decls inside the enclosing DeclContext for TTPD until we find
a template entity whose template parameters contain TTPD.
3) Find the instantiation for that entity. If succeeds, perform the similar
steps below to extract the Stmt corresponding to the dependent expression (i.e.
our interest).
4) Figure out a way to extract the type from that expression, which can be
intricate, as we don't know to which Decl the dependent expression is tied.
https://github.com/llvm/llvm-project/pull/71279
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
