1 //===- ComputeReplacements.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 #include "clang/Tooling/Core/Replacement.h"
9 #include "clang/Tooling/Syntax/Mutations.h"
10 #include "clang/Tooling/Syntax/Tokens.h"
11 #include "llvm/Support/Error.h"
12
13 using namespace clang;
14
15 namespace {
16 using ProcessTokensFn = llvm::function_ref<void(llvm::ArrayRef<syntax::Token>,
17 bool /*IsOriginal*/)>;
18 /// Enumerates spans of tokens from the tree consecutively laid out in memory.
enumerateTokenSpans(const syntax::Tree * Root,ProcessTokensFn Callback)19 void enumerateTokenSpans(const syntax::Tree *Root, ProcessTokensFn Callback) {
20 struct Enumerator {
21 Enumerator(ProcessTokensFn Callback)
22 : SpanBegin(nullptr), SpanEnd(nullptr), SpanIsOriginal(false),
23 Callback(Callback) {}
24
25 void run(const syntax::Tree *Root) {
26 process(Root);
27 // Report the last span to the user.
28 if (SpanBegin)
29 Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
30 }
31
32 private:
33 void process(const syntax::Node *N) {
34 if (auto *T = dyn_cast<syntax::Tree>(N)) {
35 for (auto *C = T->firstChild(); C != nullptr; C = C->nextSibling())
36 process(C);
37 return;
38 }
39
40 auto *L = cast<syntax::Leaf>(N);
41 if (SpanEnd == L->token() && SpanIsOriginal == L->isOriginal()) {
42 // Extend the current span.
43 ++SpanEnd;
44 return;
45 }
46 // Report the current span to the user.
47 if (SpanBegin)
48 Callback(llvm::makeArrayRef(SpanBegin, SpanEnd), SpanIsOriginal);
49 // Start recording a new span.
50 SpanBegin = L->token();
51 SpanEnd = SpanBegin + 1;
52 SpanIsOriginal = L->isOriginal();
53 }
54
55 const syntax::Token *SpanBegin;
56 const syntax::Token *SpanEnd;
57 bool SpanIsOriginal;
58 ProcessTokensFn Callback;
59 };
60
61 return Enumerator(Callback).run(Root);
62 }
63
rangeOfExpanded(const syntax::Arena & A,llvm::ArrayRef<syntax::Token> Expanded)64 syntax::FileRange rangeOfExpanded(const syntax::Arena &A,
65 llvm::ArrayRef<syntax::Token> Expanded) {
66 auto &Buffer = A.tokenBuffer();
67 auto &SM = A.sourceManager();
68
69 // Check that \p Expanded actually points into expanded tokens.
70 assert(Buffer.expandedTokens().begin() <= Expanded.begin());
71 assert(Expanded.end() < Buffer.expandedTokens().end());
72
73 if (Expanded.empty())
74 // (!) empty tokens must always point before end().
75 return syntax::FileRange(
76 SM, SM.getExpansionLoc(Expanded.begin()->location()), /*Length=*/0);
77
78 auto Spelled = Buffer.spelledForExpanded(Expanded);
79 assert(Spelled && "could not find spelled tokens for expanded");
80 return syntax::Token::range(SM, Spelled->front(), Spelled->back());
81 }
82 } // namespace
83
84 tooling::Replacements
computeReplacements(const syntax::Arena & A,const syntax::TranslationUnit & TU)85 syntax::computeReplacements(const syntax::Arena &A,
86 const syntax::TranslationUnit &TU) {
87 auto &Buffer = A.tokenBuffer();
88 auto &SM = A.sourceManager();
89
90 tooling::Replacements Replacements;
91 // Text inserted by the replacement we are building now.
92 std::string Replacement;
93 auto emitReplacement = [&](llvm::ArrayRef<syntax::Token> ReplacedRange) {
94 if (ReplacedRange.empty() && Replacement.empty())
95 return;
96 llvm::cantFail(Replacements.add(tooling::Replacement(
97 SM, rangeOfExpanded(A, ReplacedRange).toCharRange(SM), Replacement)));
98 Replacement = "";
99 };
100
101 const syntax::Token *NextOriginal = Buffer.expandedTokens().begin();
102 enumerateTokenSpans(
103 &TU, [&](llvm::ArrayRef<syntax::Token> Tokens, bool IsOriginal) {
104 if (!IsOriginal) {
105 Replacement +=
106 syntax::Token::range(SM, Tokens.front(), Tokens.back()).text(SM);
107 return;
108 }
109 assert(NextOriginal <= Tokens.begin());
110 // We are looking at a span of original tokens.
111 if (NextOriginal != Tokens.begin()) {
112 // There is a gap, record a replacement or deletion.
113 emitReplacement(llvm::makeArrayRef(NextOriginal, Tokens.begin()));
114 } else {
115 // No gap, but we may have pending insertions. Emit them now.
116 emitReplacement(llvm::makeArrayRef(NextOriginal, /*Length=*/0));
117 }
118 NextOriginal = Tokens.end();
119 });
120
121 // We might have pending replacements at the end of file. If so, emit them.
122 emitReplacement(llvm::makeArrayRef(
123 NextOriginal, Buffer.expandedTokens().drop_back().end()));
124
125 return Replacements;
126 }
127