| 1 |
//===--- InsertionPoint.cpp - Where should we add new code? ---------------===// |
| 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 "refactor/InsertionPoint.h" |
| 10 |
#include "support/Logger.h" |
| 11 |
#include "clang/AST/ASTContext.h" |
| 12 |
#include "clang/AST/DeclCXX.h" |
| 13 |
#include "clang/AST/DeclObjC.h" |
| 14 |
#include "clang/AST/DeclTemplate.h" |
| 15 |
#include "clang/Basic/SourceManager.h" |
| 16 |
#include <optional> |
| 17 |
|
| 18 |
namespace clang { |
| 19 |
namespace clangd { |
| 20 |
namespace { |
| 21 |
|
| 22 |
// Choose the decl to insert before, according to an anchor. |
| 23 |
// Nullptr means insert at end of DC. |
| 24 |
// std::nullopt means no valid place to insert. |
| 25 |
std::optional<const Decl *> insertionDecl(const DeclContext &DC, |
| 26 |
const Anchor &A) { |
| 27 |
bool LastMatched = false; |
| 28 |
bool ReturnNext = false; |
| 29 |
for (const auto *D : DC.decls()) { |
| 30 |
if (D->isImplicit()) |
| 31 |
continue; |
| 32 |
if (ReturnNext) |
| 33 |
return D; |
| 34 |
|
| 35 |
const Decl *NonTemplate = D; |
| 36 |
if (auto *TD = llvm::dyn_cast<TemplateDecl>(D)) |
| 37 |
NonTemplate = TD->getTemplatedDecl(); |
| 38 |
bool Matches = A.Match(NonTemplate); |
| 39 |
dlog(" {0} {1} {2}", Matches, D->getDeclKindName(), D); |
| 40 |
|
| 41 |
switch (A.Direction) { |
| 42 |
case Anchor::Above: |
| 43 |
if (Matches && !LastMatched) { |
| 44 |
// Special case: if "above" matches an access specifier, we actually |
| 45 |
// want to insert below it! |
| 46 |
if (llvm::isa<AccessSpecDecl>(D)) { |
| 47 |
ReturnNext = true; |
| 48 |
continue; |
| 49 |
} |
| 50 |
return D; |
| 51 |
} |
| 52 |
break; |
| 53 |
case Anchor::Below: |
| 54 |
if (LastMatched && !Matches) |
| 55 |
return D; |
| 56 |
break; |
| 57 |
} |
| 58 |
|
| 59 |
LastMatched = Matches; |
| 60 |
} |
| 61 |
if (ReturnNext || (LastMatched && A.Direction == Anchor::Below)) |
| 62 |
return nullptr; |
| 63 |
return std::nullopt; |
| 64 |
} |
| 65 |
|
| 66 |
SourceLocation beginLoc(const Decl &D) { |
| 67 |
auto Loc = D.getBeginLoc(); |
| 68 |
if (RawComment *Comment = D.getASTContext().getRawCommentForDeclNoCache(&D)) { |
| 69 |
auto CommentLoc = Comment->getBeginLoc(); |
| 70 |
if (CommentLoc.isValid() && Loc.isValid() && |
| 71 |
D.getASTContext().getSourceManager().isBeforeInTranslationUnit( |
| 72 |
CommentLoc, Loc)) |
| 73 |
Loc = CommentLoc; |
| 74 |
} |
| 75 |
return Loc; |
| 76 |
} |
| 77 |
|
| 78 |
bool any(const Decl *D) { return true; } |
| 79 |
|
| 80 |
SourceLocation endLoc(const DeclContext &DC) { |
| 81 |
const Decl *D = llvm::cast<Decl>(&DC); |
| 82 |
if (auto *OCD = llvm::dyn_cast<ObjCContainerDecl>(D)) |
| 83 |
return OCD->getAtEndRange().getBegin(); |
| 84 |
return D->getEndLoc(); |
| 85 |
} |
| 86 |
|
| 87 |
AccessSpecifier getAccessAtEnd(const CXXRecordDecl &C) { |
| 88 |
AccessSpecifier Spec = |
| 89 |
(C.getTagKind() == TagTypeKind::Class ? AS_private : AS_public); |
| 90 |
for (const auto *D : C.decls()) |
| 91 |
if (const auto *ASD = llvm::dyn_cast<AccessSpecDecl>(D)) |
| 92 |
Spec = ASD->getAccess(); |
| 93 |
return Spec; |
| 94 |
} |
| 95 |
|
| 96 |
} // namespace |
| 97 |
|
| 98 |
SourceLocation insertionPoint(const DeclContext &DC, |
| 99 |
llvm::ArrayRef<Anchor> Anchors) { |
| 100 |
dlog("Looking for insertion point in {0}", DC.getDeclKindName()); |
| 101 |
for (const auto &A : Anchors) { |
| 102 |
dlog(" anchor ({0})", A.Direction == Anchor::Above ? "above" : "below"); |
| 103 |
if (auto D = insertionDecl(DC, A)) { |
| 104 |
dlog(" anchor matched before {0}", *D); |
| 105 |
return *D ? beginLoc(**D) : endLoc(DC); |
| 106 |
} |
| 107 |
} |
| 108 |
dlog("no anchor matched"); |
| 109 |
return SourceLocation(); |
| 110 |
} |
| 111 |
|
| 112 |
llvm::Expected<tooling::Replacement> |
| 113 |
insertDecl(llvm::StringRef Code, const DeclContext &DC, |
| 114 |
llvm::ArrayRef<Anchor> Anchors) { |
| 115 |
auto Loc = insertionPoint(DC, Anchors); |
| 116 |
// Fallback: insert at the end. |
| 117 |
if (Loc.isInvalid()) |
| 118 |
Loc = endLoc(DC); |
| 119 |
const auto &SM = DC.getParentASTContext().getSourceManager(); |
| 120 |
if (!SM.isWrittenInSameFile(Loc, cast<Decl>(DC).getLocation())) |
| 121 |
return error("{0} body in wrong file: {1}", DC.getDeclKindName(), |
| 122 |
Loc.printToString(SM)); |
| 123 |
return tooling::Replacement(SM, Loc, 0, Code); |
| 124 |
} |
| 125 |
|
| 126 |
SourceLocation insertionPoint(const CXXRecordDecl &InClass, |
| 127 |
std::vector<Anchor> Anchors, |
| 128 |
AccessSpecifier Protection) { |
| 129 |
for (auto &A : Anchors) |
| 130 |
A.Match = [Inner(std::move(A.Match)), Protection](const Decl *D) { |
| 131 |
return D->getAccess() == Protection && Inner(D); |
| 132 |
}; |
| 133 |
return insertionPoint(InClass, Anchors); |
| 134 |
} |
| 135 |
|
| 136 |
llvm::Expected<tooling::Replacement> insertDecl(llvm::StringRef Code, |
| 137 |
const CXXRecordDecl &InClass, |
| 138 |
std::vector<Anchor> Anchors, |
| 139 |
AccessSpecifier Protection) { |
| 140 |
// Fallback: insert at the bottom of the relevant access section. |
| 141 |
Anchors.push_back({any, Anchor::Below}); |
| 142 |
auto Loc = insertionPoint(InClass, std::move(Anchors), Protection); |
| 143 |
std::string CodeBuffer; |
| 144 |
auto &SM = InClass.getASTContext().getSourceManager(); |
| 145 |
// Fallback: insert at the end of the class. Check if protection matches! |
| 146 |
if (Loc.isInvalid()) { |
| 147 |
Loc = InClass.getBraceRange().getEnd(); |
| 148 |
if (Protection != getAccessAtEnd(InClass)) { |
| 149 |
CodeBuffer = (getAccessSpelling(Protection) + ":\n" + Code).str(); |
| 150 |
Code = CodeBuffer; |
| 151 |
} |
| 152 |
} |
| 153 |
if (!SM.isWrittenInSameFile(Loc, InClass.getLocation())) |
| 154 |
return error("Class body in wrong file: {0}", Loc.printToString(SM)); |
| 155 |
return tooling::Replacement(SM, Loc, 0, Code); |
| 156 |
} |
| 157 |
|
| 158 |
} // namespace clangd |
| 159 |
} // namespace clang |