clang-tools-extra/clangd/HeuristicResolver.cpp

   1 //===--- HeuristicResolver.cpp ---------------------------*- C++-*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "HeuristicResolver.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/AST/DeclTemplate.h"
  12 #include "clang/AST/ExprCXX.h"
  13
  14 namespace clang {
  15 namespace clangd {
  16
  17 // Convenience lambdas for use as the 'Filter' parameter of
  18 // HeuristicResolver::resolveDependentMember().
  19 const auto NoFilter = [](const NamedDecl *D) { return true; };
  20 const auto NonStaticFilter = [](const NamedDecl *D) {
  21   return D->isCXXInstanceMember();
  22 };
  23 const auto StaticFilter = [](const NamedDecl *D) {
  24   return !D->isCXXInstanceMember();
  25 };
  26 const auto ValueFilter = [](const NamedDecl *D) { return isa<ValueDecl>(D); };
  27 const auto TypeFilter = [](const NamedDecl *D) { return isa<TypeDecl>(D); };
  28 const auto TemplateFilter = [](const NamedDecl *D) {
  29   return isa<TemplateDecl>(D);
  30 };
  31
  32 // Helper function for HeuristicResolver::resolveDependentMember()
  33 // which takes a possibly-dependent type `T` and heuristically
  34 // resolves it to a CXXRecordDecl in which we can try name lookup.
  35 CXXRecordDecl *resolveTypeToRecordDecl(const Type *T) {
  36   assert(T);
  37
  38   if (const auto *RT = T->getAs<RecordType>())
  39     return dyn_cast<CXXRecordDecl>(RT->getDecl());
  40
  41   if (const auto *ICNT = T->getAs<InjectedClassNameType>())
  42     T = ICNT->getInjectedSpecializationType().getTypePtrOrNull();
  43   if (!T)
  44     return nullptr;
  45
  46   const auto *TST = T->getAs<TemplateSpecializationType>();
  47   if (!TST)
  48     return nullptr;
  49
  50   const ClassTemplateDecl *TD = dyn_cast_or_null<ClassTemplateDecl>(
  51       TST->getTemplateName().getAsTemplateDecl());
  52   if (!TD)
  53     return nullptr;
  54
  55   return TD->getTemplatedDecl();
  56 }
  57
  58 const Type *HeuristicResolver::getPointeeType(const Type *T) const {
  59   if (!T)
  60     return nullptr;
  61
  62   if (T->isPointerType())
  63     return T->castAs<PointerType>()->getPointeeType().getTypePtrOrNull();
  64
  65   // Try to handle smart pointer types.
  66
  67   // Look up operator-> in the primary template. If we find one, it's probably a
  68   // smart pointer type.
  69   auto ArrowOps = resolveDependentMember(
  70       T, Ctx.DeclarationNames.getCXXOperatorName(OO_Arrow), NonStaticFilter);
  71   if (ArrowOps.empty())
  72     return nullptr;
  73
  74   // Getting the return type of the found operator-> method decl isn't useful,
  75   // because we discarded template arguments to perform lookup in the primary
  76   // template scope, so the return type would just have the form U* where U is a
  77   // template parameter type.
  78   // Instead, just handle the common case where the smart pointer type has the
  79   // form of SmartPtr<X, ...>, and assume X is the pointee type.
  80   auto *TST = T->getAs<TemplateSpecializationType>();
  81   if (!TST)
  82     return nullptr;
  83   if (TST->getNumArgs() == 0)
  84     return nullptr;
  85   const TemplateArgument &FirstArg = TST->getArg(0);
  86   if (FirstArg.getKind() != TemplateArgument::Type)
  87     return nullptr;
  88   return FirstArg.getAsType().getTypePtrOrNull();
  89 }
  90
  91 std::vector<const NamedDecl *> HeuristicResolver::resolveMemberExpr(
  92     const CXXDependentScopeMemberExpr *ME) const {
  93   // If the expression has a qualifier, first try resolving the member
  94   // inside the qualifier's type.
  95   // Note that we cannot use a NonStaticFilter in either case, for a couple
  96   // of reasons:
  97   //   1. It's valid to access a static member using instance member syntax,
  98   //      e.g. `instance.static_member`.
  99   //   2. We can sometimes get a CXXDependentScopeMemberExpr for static
 100   //      member syntax too, e.g. if `X::static_member` occurs inside
 101   //      an instance method, it's represented as a CXXDependentScopeMemberExpr
 102   //      with `this` as the base expression as `X` as the qualifier
 103   //      (which could be valid if `X` names a base class after instantiation).
 104   if (NestedNameSpecifier *NNS = ME->getQualifier()) {
 105     if (const Type *QualifierType = resolveNestedNameSpecifierToType(NNS)) {
 106       auto Decls =
 107           resolveDependentMember(QualifierType, ME->getMember(), NoFilter);
 108       if (!Decls.empty())
 109         return Decls;
 110     }
 111   }
 112
 113   // If that didn't yield any results, try resolving the member inside
 114   // the expression's base type.
 115   const Type *BaseType = ME->getBaseType().getTypePtrOrNull();
 116   if (ME->isArrow()) {
 117     BaseType = getPointeeType(BaseType);
 118   }
 119   if (!BaseType)
 120     return {};
 121   if (const auto *BT = BaseType->getAs<BuiltinType>()) {
 122     // If BaseType is the type of a dependent expression, it's just
 123     // represented as BuiltinType::Dependent which gives us no information. We
 124     // can get further by analyzing the dependent expression.
 125     Expr *Base = ME->isImplicitAccess() ? nullptr : ME->getBase();
 126     if (Base && BT->getKind() == BuiltinType::Dependent) {
 127       BaseType = resolveExprToType(Base);
 128     }
 129   }
 130   return resolveDependentMember(BaseType, ME->getMember(), NoFilter);
 131 }
 132
 133 std::vector<const NamedDecl *> HeuristicResolver::resolveDeclRefExpr(
 134     const DependentScopeDeclRefExpr *RE) const {
 135   return resolveDependentMember(RE->getQualifier()->getAsType(),
 136                                 RE->getDeclName(), StaticFilter);
 137 }
 138
 139 std::vector<const NamedDecl *>
 140 HeuristicResolver::resolveTypeOfCallExpr(const CallExpr *CE) const {
 141   const auto *CalleeType = resolveExprToType(CE->getCallee());
 142   if (!CalleeType)
 143     return {};
 144   if (const auto *FnTypePtr = CalleeType->getAs<PointerType>())
 145     CalleeType = FnTypePtr->getPointeeType().getTypePtr();
 146   if (const FunctionType *FnType = CalleeType->getAs<FunctionType>()) {
 147     if (const auto *D =
 148             resolveTypeToRecordDecl(FnType->getReturnType().getTypePtr())) {
 149       return {D};
 150     }
 151   }
 152   return {};
 153 }
 154
 155 std::vector<const NamedDecl *>
 156 HeuristicResolver::resolveCalleeOfCallExpr(const CallExpr *CE) const {
 157   if (const auto *ND = dyn_cast_or_null<NamedDecl>(CE->getCalleeDecl())) {
 158     return {ND};
 159   }
 160
 161   return resolveExprToDecls(CE->getCallee());
 162 }
 163
 164 std::vector<const NamedDecl *> HeuristicResolver::resolveUsingValueDecl(
 165     const UnresolvedUsingValueDecl *UUVD) const {
 166   return resolveDependentMember(UUVD->getQualifier()->getAsType(),
 167                                 UUVD->getNameInfo().getName(), ValueFilter);
 168 }
 169
 170 std::vector<const NamedDecl *> HeuristicResolver::resolveDependentNameType(
 171     const DependentNameType *DNT) const {
 172   return resolveDependentMember(
 173       resolveNestedNameSpecifierToType(DNT->getQualifier()),
 174       DNT->getIdentifier(), TypeFilter);
 175 }
 176
 177 std::vector<const NamedDecl *>
 178 HeuristicResolver::resolveTemplateSpecializationType(
 179     const DependentTemplateSpecializationType *DTST) const {
 180   return resolveDependentMember(
 181       resolveNestedNameSpecifierToType(DTST->getQualifier()),
 182       DTST->getIdentifier(), TemplateFilter);
 183 }
 184
 185 const Type *resolveDeclsToType(const std::vector<const NamedDecl *> &Decls) {
 186   if (Decls.size() != 1) // Names an overload set -- just bail.
 187     return nullptr;
 188   if (const auto *TD = dyn_cast<TypeDecl>(Decls[0])) {
 189     return TD->getTypeForDecl();
 190   }
 191   if (const auto *VD = dyn_cast<ValueDecl>(Decls[0])) {
 192     return VD->getType().getTypePtrOrNull();
 193   }
 194   return nullptr;
 195 }
 196
 197 std::vector<const NamedDecl *>
 198 HeuristicResolver::resolveExprToDecls(const Expr *E) const {
 199   if (const auto *ME = dyn_cast<CXXDependentScopeMemberExpr>(E)) {
 200     return resolveMemberExpr(ME);
 201   }
 202   if (const auto *RE = dyn_cast<DependentScopeDeclRefExpr>(E)) {
 203     return resolveDeclRefExpr(RE);
 204   }
 205   if (const auto *OE = dyn_cast<OverloadExpr>(E)) {
 206     return {OE->decls_begin(), OE->decls_end()};
 207   }
 208   if (const auto *CE = dyn_cast<CallExpr>(E)) {
 209     return resolveTypeOfCallExpr(CE);
 210   }
 211   if (const auto *ME = dyn_cast<MemberExpr>(E))
 212     return {ME->getMemberDecl()};
 213
 214   return {};
 215 }
 216
 217 const Type *HeuristicResolver::resolveExprToType(const Expr *E) const {
 218   std::vector<const NamedDecl *> Decls = resolveExprToDecls(E);
 219   if (!Decls.empty())
 220     return resolveDeclsToType(Decls);
 221
 222   return E->getType().getTypePtr();
 223 }
 224
 225 const Type *HeuristicResolver::resolveNestedNameSpecifierToType(
 226     const NestedNameSpecifier *NNS) const {
 227   if (!NNS)
 228     return nullptr;
 229
 230   // The purpose of this function is to handle the dependent (Kind ==
 231   // Identifier) case, but we need to recurse on the prefix because
 232   // that may be dependent as well, so for convenience handle
 233   // the TypeSpec cases too.
 234   switch (NNS->getKind()) {
 235   case NestedNameSpecifier::TypeSpec:
 236   case NestedNameSpecifier::TypeSpecWithTemplate:
 237     return NNS->getAsType();
 238   case NestedNameSpecifier::Identifier: {
 239     return resolveDeclsToType(resolveDependentMember(
 240         resolveNestedNameSpecifierToType(NNS->getPrefix()),
 241         NNS->getAsIdentifier(), TypeFilter));
 242   }
 243   default:
 244     break;
 245   }
 246   return nullptr;
 247 }
 248
 249 std::vector<const NamedDecl *> HeuristicResolver::resolveDependentMember(
 250     const Type *T, DeclarationName Name,
 251     llvm::function_ref<bool(const NamedDecl *ND)> Filter) const {
 252   if (!T)
 253     return {};
 254   if (auto *ET = T->getAs<EnumType>()) {
 255     auto Result = ET->getDecl()->lookup(Name);
 256     return {Result.begin(), Result.end()};
 257   }
 258   if (auto *RD = resolveTypeToRecordDecl(T)) {
 259     if (!RD->hasDefinition())
 260       return {};
 261     RD = RD->getDefinition();
 262     return RD->lookupDependentName(Name, Filter);
 263   }
 264   return {};
 265 }
 266
 267 } // namespace clangd
 268 } // namespace clang