//===--- USRFinder.cpp - Clang refactoring library ------------------------===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file Implements a recursive AST visitor that finds the USR of a symbol at a
/// point.
///
//===----------------------------------------------------------------------===//

#include "clang/Tooling/Refactor/USRFinder.h"
#include "SourceLocationUtilities.h"
#include "clang/AST/AST.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DependentASTVisitor.h"
#include "clang/Index/USRGeneration.h"
#include "clang/Lex/Lexer.h"
#include "clang/Tooling/Core/RefactoringDiagnostic.h"
#include "llvm/ADT/SmallVector.h"
#include <functional>

using namespace llvm;

namespace clang {
namespace tooling {
namespace rename {

typedef std::function<bool(const NamedDecl *, SourceLocation, SourceLocation)>
    OccurrenceCheckerType;

// NamedDeclFindingASTVisitor recursively visits each AST node to find the
// symbol underneath the cursor.
// FIXME: move to seperate .h/.cc file if this gets too large.
namespace {
class NamedDeclFindingASTVisitor
    : public DependentASTVisitor<NamedDeclFindingASTVisitor> {
public:
  // \brief Finds the NamedDecl at a point in the source.
  // \param Point the location in the source to search for the NamedDecl.
  explicit NamedDeclFindingASTVisitor(
      const OccurrenceCheckerType &OccurrenceChecker, const ASTContext &Context)
      : Result(nullptr), OccurrenceChecker(OccurrenceChecker),
        Context(Context) {}

  // Declaration visitors:

  // \brief Checks if the point falls within the NameDecl. This covers every
  // declaration of a named entity that we may come across. Usually, just
  // checking if the point lies within the length of the name of the declaration
  // and the start location is sufficient.
  bool VisitNamedDecl(const NamedDecl *Decl) {
    return dyn_cast<CXXConversionDecl>(Decl)
               ? true
               : checkOccurrence(Decl, Decl->getLocation(),
                                 Decl->getNameAsString().length());
  }

  bool WalkUpFromTypedefNameDecl(const TypedefNameDecl *D) {
    // Don't visit the NamedDecl for TypedefNameDecl.
    return VisitTypedefNamedDecl(D);
  }

  bool VisitTypedefNamedDecl(const TypedefNameDecl *D) {
    if (D->isTransparentTag()) {
      if (const auto *Underlying = D->getUnderlyingType()->getAsTagDecl())
        return checkOccurrence(Underlying, D->getLocation(),
                               D->getNameAsString().size());
    }
    return VisitNamedDecl(D);
  }

  bool WalkUpFromUsingDecl(const UsingDecl *D) {
    // Don't visit the NamedDecl for UsingDecl.
    return VisitUsingDecl(D);
  }

  bool VisitUsingDecl(const UsingDecl *D) {
    for (const auto *Shadow : D->shadows()) {
      // Currently we always find the first declaration, but is this the right
      // behaviour?
      const NamedDecl *UD = Shadow->getUnderlyingDecl();
      if (UD->isImplicit() || UD == D)
        continue;
      if (const auto *FTD = dyn_cast<FunctionTemplateDecl>(UD)) {
        UD = FTD->getTemplatedDecl();
        if (!UD)
          continue;
      }
      if (!checkOccurrence(UD, D->getLocation()))
        return false;
    }
    return true;
  }

  bool WalkUpFromUsingDirectiveDecl(const UsingDirectiveDecl *D) {
    // Don't visit the NamedDecl for UsingDirectiveDecl.
    return VisitUsingDirectiveDecl(D);
  }

  bool VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
    return checkOccurrence(D->getNominatedNamespaceAsWritten(),
                           D->getLocation());
  }

  bool WalkUpFromUnresolvedUsingValueDecl(const UnresolvedUsingValueDecl *D) {
    // Don't visit the NamedDecl for UnresolvedUsingValueDecl.
    // FIXME: Can we try to lookup the name?
    return true;
  }

  bool
  WalkUpFromUnresolvedUsingTypenameDecl(const UnresolvedUsingTypenameDecl *D) {
    // Don't visit the NamedDecl for UnresolvedUsingTypenameDecl.
    // FIXME: Can we try to lookup the name?
    return true;
  }

  bool WalkUpFromObjCMethodDecl(const ObjCMethodDecl *Decl) {
    // Don't visit the NamedDecl for Objective-C methods.
    return VisitObjCMethodDecl(Decl);
  }

  bool VisitObjCMethodDecl(const ObjCMethodDecl *Decl) {
    // Check all of the selector source ranges.
    for (unsigned I = 0, E = Decl->getNumSelectorLocs(); I != E; ++I) {
      SourceLocation Loc = Decl->getSelectorLoc(I);
      if (!checkOccurrence(Decl, Loc,
                           Loc.getLocWithOffset(
                               Decl->getSelector().getNameForSlot(I).size())))
        return false;
    }
    return true;
  }

  bool VisitObjCProtocolList(const ObjCProtocolList &Protocols) {
    for (unsigned I = 0, E = Protocols.size(); I != E; ++I) {
      if (!checkOccurrence(Protocols[I], Protocols.loc_begin()[I]))
        return false;
    }
    return true;
  }

  bool VisitObjCInterfaceDecl(const ObjCInterfaceDecl *Decl) {
    if (!Decl->hasDefinition())
      return true;
    return VisitObjCProtocolList(Decl->getReferencedProtocols());
  }

  bool VisitObjCProtocolDecl(const ObjCProtocolDecl *Decl) {
    if (!Decl->hasDefinition())
      return true;
    return VisitObjCProtocolList(Decl->getReferencedProtocols());
  }

  bool WalkUpFromObjCCategoryDecl(const ObjCCategoryDecl *Decl) {
    // Don't visit the NamedDecl for Objective-C categories because the location
    // of the name refers to the interface declaration.
    return VisitObjCCategoryDecl(Decl);
  }

  bool VisitObjCCategoryDecl(const ObjCCategoryDecl *Decl) {
    if (!checkOccurrence(Decl, Decl->getCategoryNameLoc()))
      return false;
    if (const auto *Class = Decl->getClassInterface()) {
      // The location of the class name is the location of the declaration.
      if (!checkOccurrence(Class, Decl->getLocation()))
        return false;
    }
    return VisitObjCProtocolList(Decl->getReferencedProtocols());
  }

  bool WalkUpFromObjCCategoryImplDecl(const ObjCCategoryImplDecl *Decl) {
    // Don't visit the NamedDecl for Objective-C categories because the location
    // of the name refers to the interface declaration.
    return VisitObjCCategoryImplDecl(Decl);
  }

  bool VisitObjCCategoryImplDecl(const ObjCCategoryImplDecl *Decl) {
    if (!checkOccurrence(Decl, Decl->getCategoryNameLoc()))
      return false;
    if (const auto *Class = Decl->getClassInterface()) {
      // The location of the class name is the location of the declaration.
      if (!checkOccurrence(Class, Decl->getLocation()))
        return false;
    }
    return true;
  }

  bool VisitObjCCompatibleAliasDecl(const ObjCCompatibleAliasDecl *Decl) {
    return checkOccurrence(Decl->getClassInterface(),
                           Decl->getClassInterfaceLoc());
  }

  bool WalkUpFromObjCIvarDecl(ObjCIvarDecl *Decl) {
    // Don't visit the NamedDecl for automatically synthesized ivars as the
    // implicit ivars have the same location as the property declarations, and
    // we want to find the property declarations.
    if (Decl->getSynthesize())
      return true;
    return RecursiveASTVisitor::WalkUpFromObjCIvarDecl(Decl);
  }

  bool VisitObjCPropertyDecl(const ObjCPropertyDecl *Decl) {
    if (Decl->hasExplicitGetterName()) {
      if (const auto *Getter = Decl->getGetterMethodDecl())
        if (!checkOccurrence(Getter, Decl->getGetterNameLoc(),
                             Decl->getGetterName().getNameForSlot(0).size()))
          return false;
    }
    if (Decl->hasExplicitSetterName()) {
      if (const auto *Setter = Decl->getSetterMethodDecl())
        return checkOccurrence(Setter, Decl->getSetterNameLoc(),
                               Decl->getSetterName().getNameForSlot(0).size());
    }
    return true;
  }

  bool VisitObjCPropertyImplDecl(const ObjCPropertyImplDecl *Decl) {
    if (!checkOccurrence(Decl->getPropertyDecl(), Decl->getLocation()))
      return false;
    if (Decl->isIvarNameSpecified())
      return checkOccurrence(Decl->getPropertyIvarDecl(),
                             Decl->getPropertyIvarDeclLoc());
    return true;
  }

  // Expression visitors:

  bool VisitDeclRefExpr(const DeclRefExpr *Expr) {
    const NamedDecl *Decl = Expr->getFoundDecl();
    return checkOccurrence(Decl, Expr->getLocation(),
                           Decl->getNameAsString().length());
  }

  bool VisitMemberExpr(const MemberExpr *Expr) {
    const NamedDecl *Decl = Expr->getFoundDecl().getDecl();
    return checkOccurrence(Decl, Expr->getMemberLoc(),
                           Decl->getNameAsString().length());
  }

  bool VisitObjCMessageExpr(const ObjCMessageExpr *Expr) {
    const ObjCMethodDecl *Decl = Expr->getMethodDecl();
    if (Decl == nullptr)
      return true;

    // Check all of the selector source ranges.
    for (unsigned I = 0, E = Expr->getNumSelectorLocs(); I != E; ++I) {
      SourceLocation Loc = Expr->getSelectorLoc(I);
      if (!checkOccurrence(Decl, Loc,
                           Loc.getLocWithOffset(
                               Decl->getSelector().getNameForSlot(I).size())))
        return false;
    }
    return true;
  }

  bool VisitObjCProtocolExpr(const ObjCProtocolExpr *Expr) {
    return checkOccurrence(Expr->getProtocol(), Expr->getProtocolIdLoc());
  }

  bool VisitObjCIvarRefExpr(const ObjCIvarRefExpr *Expr) {
    return checkOccurrence(Expr->getDecl(), Expr->getLocation());
  }

  bool VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *Expr) {
    if (Expr->isClassReceiver())
      checkOccurrence(Expr->getClassReceiver(), Expr->getReceiverLocation());
    if (Expr->isImplicitProperty()) {
      // Class properties that are explicitly defined using @property
      // declarations are represented implicitly as there is no ivar for class
      // properties.
      if (const ObjCMethodDecl *Getter = Expr->getImplicitPropertyGetter()) {
        if (Getter->isClassMethod()) {
          if (const auto *PD = Getter->getCanonicalDecl()->findPropertyDecl())
            return checkOccurrence(PD, Expr->getLocation());
        }
      }

      if (Expr->isMessagingGetter()) {
        if (const ObjCMethodDecl *Getter = Expr->getImplicitPropertyGetter())
          return checkOccurrence(Getter, Expr->getLocation());
      } else if (const ObjCMethodDecl *Setter =
                     Expr->getImplicitPropertySetter()) {
        return checkOccurrence(Setter, Expr->getLocation());
      }

      return true;
    }
    return checkOccurrence(Expr->getExplicitProperty(), Expr->getLocation());
  }

  // Other visitors:

  bool VisitTypeLoc(const TypeLoc Loc) {
    const SourceLocation TypeBeginLoc = Loc.getBeginLoc();
    const SourceLocation TypeEndLoc = Lexer::getLocForEndOfToken(
        TypeBeginLoc, 0, Context.getSourceManager(), Context.getLangOpts());
    if (const auto *TemplateTypeParm =
            dyn_cast<TemplateTypeParmType>(Loc.getType()))
      return checkOccurrence(TemplateTypeParm->getDecl(), TypeBeginLoc,
                             TypeEndLoc);
    if (const auto *TemplateSpecType =
            dyn_cast<TemplateSpecializationType>(Loc.getType())) {
      return checkOccurrence(
          TemplateSpecType->getTemplateName().getAsTemplateDecl(), TypeBeginLoc,
          TypeEndLoc);
    }
    TypedefTypeLoc TTL = Loc.getAs<TypedefTypeLoc>();
    if (TTL) {
      const auto *TND = TTL.getTypedefNameDecl();
      if (TND->isTransparentTag()) {
        if (const auto *Underlying = TND->getUnderlyingType()->getAsTagDecl())
          return checkOccurrence(Underlying, TTL.getNameLoc());
      }
      return checkOccurrence(TND, TTL.getNameLoc());
    }
    TypeSpecTypeLoc TSTL = Loc.getAs<TypeSpecTypeLoc>();
    if (TSTL) {
      return checkOccurrence(Loc.getType()->getAsTagDecl(), TSTL.getNameLoc());
    }
    return true;
  }

  bool VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc Loc) {
    return checkOccurrence(Loc.getIFaceDecl(), Loc.getNameLoc());
  }

  bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc Loc) {
    for (unsigned I = 0, E = Loc.getNumProtocols(); I < E; ++I) {
      if (!checkOccurrence(Loc.getProtocol(I), Loc.getProtocolLoc(I)))
        return false;
    }
    return true;
  }

  bool VisitCXXConstructorDecl(clang::CXXConstructorDecl *ConstructorDecl) {
    for (const auto *Initializer : ConstructorDecl->inits()) {
      // Ignore implicit initializers.
      if (!Initializer->isWritten())
        continue;
      if (const clang::FieldDecl *FieldDecl = Initializer->getMember()) {
        const SourceLocation InitBeginLoc = Initializer->getSourceLocation(),
                             InitEndLoc = Lexer::getLocForEndOfToken(
                                 InitBeginLoc, 0, Context.getSourceManager(),
                                 Context.getLangOpts());
        if (!checkOccurrence(FieldDecl, InitBeginLoc, InitEndLoc))
          return false;
      }
    }
    return true;
  }

  bool VisitDependentSymbolReference(const NamedDecl *Symbol,
                                     SourceLocation SymbolNameLoc) {
    return checkOccurrence(Symbol, SymbolNameLoc);
  }

  // Other:

  const NamedDecl *getNamedDecl() { return Result; }

  bool isDone() const { return Result; }

  // \brief Determines if a namespace qualifier contains the point.
  // \returns false on success and sets Result.
  void handleNestedNameSpecifierLoc(NestedNameSpecifierLoc NameLoc) {
    while (NameLoc) {
      const NamespaceDecl *Decl =
          NameLoc.getNestedNameSpecifier()->getAsNamespace();
      checkOccurrence(Decl, NameLoc.getLocalBeginLoc(),
                      NameLoc.getLocalEndLoc());
      NameLoc = NameLoc.getPrefix();
    }
  }

private:
  /// \brief Sets Result to \p Decl if the occurrence checker returns true.
  ///
  /// \returns false on success.
  bool checkRange(const NamedDecl *Decl, SourceLocation Start,
                  SourceLocation End) {
    assert(!Start.isMacroID() && !End.isMacroID() && "Macro location?");
    if (!Decl)
      return true;
    if (isa<ImplicitParamDecl>(Decl))
      return true;
    if (const auto *FD = dyn_cast<FunctionDecl>(Decl)) {
      // Don't match operators.
      if (FD->isOverloadedOperator())
        return true;
    }
    if (!OccurrenceChecker(Decl, Start, End))
      return true;
    Result = Decl;
    return false;
  }

  /// Checks if the given declaration is valid, and if it is, sets Result to
  /// \p Decl if the occurrence checker returns true.
  ///
  /// \returns false if the point of interest is inside the range that
  /// corresponds the occurrence of this declaration.
  bool checkOccurrence(const NamedDecl *Decl, SourceLocation Loc) {
    if (!Decl)
      return true;
    return checkOccurrence(Decl, Loc, Decl->getNameAsString().size());
  }

  /// \brief Sets Result to \p Decl if the occurrence checker returns true.
  ///
  /// \returns false on success.
  bool checkOccurrence(const NamedDecl *Decl, SourceLocation Loc,
                       unsigned Length) {
    if (Loc.isMacroID()) {
      const SourceManager &SM = Context.getSourceManager();
      if (SM.isMacroArgExpansion(Loc))
        Loc = SM.getSpellingLoc(Loc);
      else
        return true;
    }

    return Length == 0 ||
           checkRange(Decl, Loc, Loc.getLocWithOffset(Length - 1));
  }

  bool checkOccurrence(const NamedDecl *ND, SourceLocation Start,
                       SourceLocation End) {
    const SourceManager &SM = Context.getSourceManager();
    if (Start.isMacroID()) {
      if (SM.isMacroArgExpansion(Start))
        Start = SM.getSpellingLoc(Start);
      else
        return true;
    }
    if (End.isMacroID()) {
      if (SM.isMacroArgExpansion(End))
        End = SM.getSpellingLoc(End);
      else
        return true;
    }
    return checkRange(ND, Start, End);
  }

  const NamedDecl *Result;
  const OccurrenceCheckerType &OccurrenceChecker;
  const ASTContext &Context;
};

} // namespace

static const ExternalSourceSymbolAttr *getExternalSymAttr(const Decl *D) {
  if (const auto *A = D->getAttr<ExternalSourceSymbolAttr>())
    return A;
  if (const auto *DCD = dyn_cast<Decl>(D->getDeclContext())) {
    if (const auto *A = DCD->getAttr<ExternalSourceSymbolAttr>())
      return A;
  }
  return nullptr;
}

static bool overridesSystemMethod(const ObjCMethodDecl *MD,
                                  const SourceManager &SM) {
  SmallVector<const ObjCMethodDecl *, 8> Overrides;
  MD->getOverriddenMethods(Overrides);
  for (const auto *Override : Overrides) {
    SourceLocation Loc = Override->getLocStart();
    if (Loc.isValid()) {
      if (SM.getFileCharacteristic(Loc) != SrcMgr::C_User)
        return true;
    }
    if (overridesSystemMethod(Override, SM))
      return true;
  }
  return false;
}

// TODO: Share with the indexer?
static bool isTemplateImplicitInstantiation(const Decl *D) {
  TemplateSpecializationKind TKind = TSK_Undeclared;
  if (const ClassTemplateSpecializationDecl *SD =
          dyn_cast<ClassTemplateSpecializationDecl>(D)) {
    TKind = SD->getSpecializationKind();
  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    TKind = FD->getTemplateSpecializationKind();
  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
    TKind = VD->getTemplateSpecializationKind();
  } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
    if (RD->getInstantiatedFromMemberClass())
      TKind = RD->getTemplateSpecializationKind();
  } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
    if (ED->getInstantiatedFromMemberEnum())
      TKind = ED->getTemplateSpecializationKind();
  } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D) ||
             isa<EnumConstantDecl>(D)) {
    if (const auto *Parent = dyn_cast<Decl>(D->getDeclContext()))
      return isTemplateImplicitInstantiation(Parent);
  }
  switch (TKind) {
  case TSK_Undeclared:
  case TSK_ExplicitSpecialization:
    return false;
  case TSK_ImplicitInstantiation:
  case TSK_ExplicitInstantiationDeclaration:
  case TSK_ExplicitInstantiationDefinition:
    return true;
  }
  llvm_unreachable("invalid TemplateSpecializationKind");
}

static const CXXRecordDecl *
getDeclContextForTemplateInstationPattern(const Decl *D) {
  if (const auto *CTSD =
          dyn_cast<ClassTemplateSpecializationDecl>(D->getDeclContext()))
    return CTSD->getTemplateInstantiationPattern();
  else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
    return RD->getInstantiatedFromMemberClass();
  return nullptr;
}

static const NamedDecl *
adjustTemplateImplicitInstantiation(const NamedDecl *D) {
  if (const ClassTemplateSpecializationDecl *SD =
          dyn_cast<ClassTemplateSpecializationDecl>(D)) {
    return SD->getTemplateInstantiationPattern();
  } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
    return FD->getTemplateInstantiationPattern();
  } else if (auto *VD = dyn_cast<VarDecl>(D)) {
    return VD->getTemplateInstantiationPattern();
  } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
    return RD->getInstantiatedFromMemberClass();
  } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
    return ED->getInstantiatedFromMemberEnum();
  } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
    const auto *ND = cast<NamedDecl>(D);
    if (const CXXRecordDecl *Pattern =
            getDeclContextForTemplateInstationPattern(ND)) {
      for (const NamedDecl *BaseND : Pattern->lookup(ND->getDeclName())) {
        if (BaseND->isImplicit())
          continue;
        if (BaseND->getKind() == ND->getKind())
          return BaseND;
      }
    }
  } else if (const auto *ECD = dyn_cast<EnumConstantDecl>(D)) {
    if (const auto *ED = dyn_cast<EnumDecl>(ECD->getDeclContext())) {
      if (const EnumDecl *Pattern = ED->getInstantiatedFromMemberEnum()) {
        for (const NamedDecl *BaseECD : Pattern->lookup(ECD->getDeclName()))
          return BaseECD;
      }
    }
  }
  return D;
}

const NamedDecl *getNamedDeclAt(const ASTContext &Context,
                                SourceLocation Point) {
  if (Point.isMacroID())
    Point = Context.getSourceManager().getSpellingLoc(Point);
  // FIXME: If point is in a system header, return early here.

  OccurrenceCheckerType PointChecker = [Point, &Context](
      const NamedDecl *Decl, SourceLocation Start, SourceLocation End) -> bool {
    return Start.isValid() && Start.isFileID() && End.isValid() &&
           End.isFileID() &&
           isPointWithin(Point, Start, End, Context.getSourceManager());
  };
  NamedDeclFindingASTVisitor Visitor(PointChecker, Context);

  // We only want to search the decls that exist in the same file as the point.
  FileID InitiationFile = Context.getSourceManager().getFileID(Point);
  for (auto *CurrDecl : Context.getTranslationUnitDecl()->decls()) {
    const SourceRange DeclRange = CurrDecl->getSourceRange();
    SourceLocation FileLoc;
    if (DeclRange.getBegin().isMacroID() && !DeclRange.getEnd().isMacroID())
      FileLoc = DeclRange.getEnd();
    else
      FileLoc = Context.getSourceManager().getSpellingLoc(DeclRange.getBegin());
    // FIXME: Add test.
    if (Context.getSourceManager().getFileID(FileLoc) == InitiationFile)
      Visitor.TraverseDecl(CurrDecl);
    if (Visitor.isDone())
      break;
  }

  if (!Visitor.isDone()) {
    NestedNameSpecifierLocFinder Finder(const_cast<ASTContext &>(Context));
    for (const auto &Location : Finder.getNestedNameSpecifierLocations()) {
      Visitor.handleNestedNameSpecifierLoc(Location);
      if (Visitor.isDone())
        break;
    }
  }

  const auto Diag = [&](unsigned DiagID) -> DiagnosticBuilder {
    return Context.getDiagnostics().Report(Point, DiagID);
  };
  const auto *ND = Visitor.getNamedDecl();
  if (!ND)
    return nullptr;

  // Canonicalize the found declaration.
  //
  // If FoundDecl is a constructor or destructor, we want to instead take
  // the Decl of the corresponding class.
  if (const auto *CtorDecl = dyn_cast<CXXConstructorDecl>(ND))
    ND = CtorDecl->getParent();
  else if (const auto *DtorDecl = dyn_cast<CXXDestructorDecl>(ND))
    ND = DtorDecl->getParent();

  if (isTemplateImplicitInstantiation(ND))
    ND = adjustTemplateImplicitInstantiation(ND);

  // Builtins can't be renamed.
  if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
    if (FD->getBuiltinID()) {
      Diag(diag::err_rename_builtin_function) << ND->getDeclName();
      return nullptr;
    }
  }
  // Declarations with invalid locations are probably implicit.
  if (ND->getLocStart().isInvalid())
    return nullptr;
  // Declarations in system headers can't be renamed.
  auto CheckSystemLoc = [&](SourceLocation Loc) -> bool {
    if (Context.getSourceManager().getFileCharacteristic(Loc) !=
        SrcMgr::C_User) {
      Diag(diag::err_rename_sys_header) << ND->getDeclName();
      return true;
    }
    return false;
  };
  if (CheckSystemLoc(ND->getLocStart()))
    return nullptr;
  if (const auto *TD = dyn_cast<TypedefNameDecl>(ND)) {
    if (const TypedefNameDecl *CTD = TD->getCanonicalDecl()) {
      if (CheckSystemLoc(CTD->getLocStart()))
        return nullptr;
    }
  } else if (const auto *TD = dyn_cast<TagDecl>(ND)) {
    if (const TagDecl *CTD = TD->getCanonicalDecl()) {
      if (CheckSystemLoc(CTD->getLocStart()))
        return nullptr;
    }
  } else if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
    if (const FunctionDecl *CFD = FD->getCanonicalDecl()) {
      if (CheckSystemLoc(CFD->getLocStart()))
        return nullptr;
    }
  } else if (const auto *VD = dyn_cast<VarDecl>(ND)) {
    if (const VarDecl *CVD = VD->getCanonicalDecl()) {
      if (CheckSystemLoc(CVD->getLocStart()))
        return nullptr;
    }
  }
  // Declarations from other languages can't be renamed.
  if (const ExternalSourceSymbolAttr *ESSA = getExternalSymAttr(ND)) {
    Diag(diag::err_rename_external_source_symbol) << ND->getDeclName()
                                                  << ESSA->getLanguage();
    return nullptr;
  }
  // Methods that override methods from system headers can't be renamed.
  if (const auto *MD = dyn_cast<ObjCMethodDecl>(ND)) {
    if (overridesSystemMethod(MD, Context.getSourceManager())) {
      Diag(diag::err_method_rename_override_sys_framework) << ND->getDeclName();
      return nullptr;
    }
  }
  return ND;
}

const NamedDecl *getNamedDeclWithUSR(const ASTContext &Context, StringRef USR) {
  // TODO: Remove in favour of the new converter.
  OccurrenceCheckerType USRChecker =
      [USR](const NamedDecl *Decl, SourceLocation Start, SourceLocation End) {
        return USR == getUSRForDecl(Decl);
      };
  NamedDeclFindingASTVisitor Visitor(USRChecker, Context);

  for (auto *CurrDecl : Context.getTranslationUnitDecl()->decls()) {
    Visitor.TraverseDecl(CurrDecl);
    if (Visitor.isDone())
      break;
  }

  // Don't need to visit nested name specifiers as they refer to previously
  // declared declarations that we've already seen.
  return Visitor.getNamedDecl();
}

std::string getUSRForDecl(const Decl *Decl) {
  llvm::SmallVector<char, 128> Buff;

  // FIXME: Add test for the nullptr case.
  if (Decl == nullptr || index::generateUSRForDecl(Decl, Buff))
    return "";

  return std::string(Buff.data(), Buff.size());
}

} // end namespace rename
} // end namespace tooling
} // end namespace clang