1 //===--- Stencil.cpp - Stencil implementation -------------------*- 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 "clang/Tooling/Transformer/Stencil.h"
10 #include "clang/AST/ASTContext.h"
11 #include "clang/AST/ASTTypeTraits.h"
12 #include "clang/AST/Expr.h"
13 #include "clang/ASTMatchers/ASTMatchFinder.h"
14 #include "clang/Basic/SourceLocation.h"
15 #include "clang/Lex/Lexer.h"
16 #include "clang/Tooling/Transformer/SourceCode.h"
17 #include "clang/Tooling/Transformer/SourceCodeBuilders.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/Twine.h"
20 #include "llvm/Support/Errc.h"
21 #include "llvm/Support/Error.h"
22 #include <atomic>
23 #include <memory>
24 #include <string>
25 
26 using namespace clang;
27 using namespace transformer;
28 
29 using ast_matchers::BoundNodes;
30 using ast_matchers::MatchFinder;
31 using llvm::errc;
32 using llvm::Error;
33 using llvm::Expected;
34 using llvm::StringError;
35 
36 static llvm::Expected<DynTypedNode> getNode(const BoundNodes &Nodes,
37                                             StringRef Id) {
38   auto &NodesMap = Nodes.getMap();
39   auto It = NodesMap.find(Id);
40   if (It == NodesMap.end())
41     return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
42                                                "Id not bound: " + Id);
43   return It->second;
44 }
45 
46 static Error printNode(StringRef Id, const MatchFinder::MatchResult &Match,
47                        std::string *Result) {
48   std::string Output;
49   llvm::raw_string_ostream Os(Output);
50   auto NodeOrErr = getNode(Match.Nodes, Id);
51   if (auto Err = NodeOrErr.takeError())
52     return Err;
53   NodeOrErr->print(Os, PrintingPolicy(Match.Context->getLangOpts()));
54   *Result += Os.str();
55   return Error::success();
56 }
57 
58 namespace {
59 // An arbitrary fragment of code within a stencil.
60 class RawTextStencil : public StencilInterface {
61   std::string Text;
62 
63 public:
64   explicit RawTextStencil(std::string T) : Text(std::move(T)) {}
65 
66   std::string toString() const override {
67     std::string Result;
68     llvm::raw_string_ostream OS(Result);
69     OS << "\"";
70     OS.write_escaped(Text);
71     OS << "\"";
72     OS.flush();
73     return Result;
74   }
75 
76   Error eval(const MatchFinder::MatchResult &Match,
77              std::string *Result) const override {
78     Result->append(Text);
79     return Error::success();
80   }
81 };
82 
83 // A debugging operation to dump the AST for a particular (bound) AST node.
84 class DebugPrintNodeStencil : public StencilInterface {
85   std::string Id;
86 
87 public:
88   explicit DebugPrintNodeStencil(std::string S) : Id(std::move(S)) {}
89 
90   std::string toString() const override {
91     return (llvm::Twine("dPrint(\"") + Id + "\")").str();
92   }
93 
94   Error eval(const MatchFinder::MatchResult &Match,
95              std::string *Result) const override {
96     return printNode(Id, Match, Result);
97   }
98 };
99 
100 // Operators that take a single node Id as an argument.
101 enum class UnaryNodeOperator {
102   Parens,
103   Deref,
104   MaybeDeref,
105   AddressOf,
106   MaybeAddressOf,
107   Describe,
108 };
109 
110 // Generic container for stencil operations with a (single) node-id argument.
111 class UnaryOperationStencil : public StencilInterface {
112   UnaryNodeOperator Op;
113   std::string Id;
114 
115 public:
116   UnaryOperationStencil(UnaryNodeOperator Op, std::string Id)
117       : Op(Op), Id(std::move(Id)) {}
118 
119   std::string toString() const override {
120     StringRef OpName;
121     switch (Op) {
122     case UnaryNodeOperator::Parens:
123       OpName = "expression";
124       break;
125     case UnaryNodeOperator::Deref:
126       OpName = "deref";
127       break;
128     case UnaryNodeOperator::MaybeDeref:
129       OpName = "maybeDeref";
130       break;
131     case UnaryNodeOperator::AddressOf:
132       OpName = "addressOf";
133       break;
134     case UnaryNodeOperator::MaybeAddressOf:
135       OpName = "maybeAddressOf";
136       break;
137     case UnaryNodeOperator::Describe:
138       OpName = "describe";
139       break;
140     }
141     return (OpName + "(\"" + Id + "\")").str();
142   }
143 
144   Error eval(const MatchFinder::MatchResult &Match,
145              std::string *Result) const override {
146     // The `Describe` operation can be applied to any node, not just
147     // expressions, so it is handled here, separately.
148     if (Op == UnaryNodeOperator::Describe)
149       return printNode(Id, Match, Result);
150 
151     const auto *E = Match.Nodes.getNodeAs<Expr>(Id);
152     if (E == nullptr)
153       return llvm::make_error<StringError>(errc::invalid_argument,
154                                            "Id not bound or not Expr: " + Id);
155     llvm::Optional<std::string> Source;
156     switch (Op) {
157     case UnaryNodeOperator::Parens:
158       Source = tooling::buildParens(*E, *Match.Context);
159       break;
160     case UnaryNodeOperator::Deref:
161       Source = tooling::buildDereference(*E, *Match.Context);
162       break;
163     case UnaryNodeOperator::MaybeDeref:
164       if (E->getType()->isAnyPointerType() ||
165           tooling::isKnownPointerLikeType(E->getType(), *Match.Context)) {
166         // Strip off any operator->. This can only occur inside an actual arrow
167         // member access, so we treat it as equivalent to an actual object
168         // expression.
169         if (const auto *OpCall = dyn_cast<clang::CXXOperatorCallExpr>(E)) {
170           if (OpCall->getOperator() == clang::OO_Arrow &&
171               OpCall->getNumArgs() == 1) {
172             E = OpCall->getArg(0);
173           }
174         }
175         Source = tooling::buildDereference(*E, *Match.Context);
176         break;
177       }
178       *Result += tooling::getText(*E, *Match.Context);
179       return Error::success();
180     case UnaryNodeOperator::AddressOf:
181       Source = tooling::buildAddressOf(*E, *Match.Context);
182       break;
183     case UnaryNodeOperator::MaybeAddressOf:
184       if (E->getType()->isAnyPointerType() ||
185           tooling::isKnownPointerLikeType(E->getType(), *Match.Context)) {
186         // Strip off any operator->. This can only occur inside an actual arrow
187         // member access, so we treat it as equivalent to an actual object
188         // expression.
189         if (const auto *OpCall = dyn_cast<clang::CXXOperatorCallExpr>(E)) {
190           if (OpCall->getOperator() == clang::OO_Arrow &&
191               OpCall->getNumArgs() == 1) {
192             E = OpCall->getArg(0);
193           }
194         }
195         *Result += tooling::getText(*E, *Match.Context);
196         return Error::success();
197       }
198       Source = tooling::buildAddressOf(*E, *Match.Context);
199       break;
200     case UnaryNodeOperator::Describe:
201       llvm_unreachable("This case is handled at the start of the function");
202     }
203     if (!Source)
204       return llvm::make_error<StringError>(
205           errc::invalid_argument,
206           "Could not construct expression source from ID: " + Id);
207     *Result += *Source;
208     return Error::success();
209   }
210 };
211 
212 // The fragment of code corresponding to the selected range.
213 class SelectorStencil : public StencilInterface {
214   RangeSelector Selector;
215 
216 public:
217   explicit SelectorStencil(RangeSelector S) : Selector(std::move(S)) {}
218 
219   std::string toString() const override { return "selection(...)"; }
220 
221   Error eval(const MatchFinder::MatchResult &Match,
222              std::string *Result) const override {
223     auto RawRange = Selector(Match);
224     if (!RawRange)
225       return RawRange.takeError();
226     CharSourceRange Range = Lexer::makeFileCharRange(
227         *RawRange, *Match.SourceManager, Match.Context->getLangOpts());
228     if (Range.isInvalid()) {
229       // Validate the original range to attempt to get a meaningful error
230       // message. If it's valid, then something else is the cause and we just
231       // return the generic failure message.
232       if (auto Err =
233               tooling::validateEditRange(*RawRange, *Match.SourceManager))
234         return handleErrors(std::move(Err), [](std::unique_ptr<StringError> E) {
235           assert(E->convertToErrorCode() ==
236                      llvm::make_error_code(errc::invalid_argument) &&
237                  "Validation errors must carry the invalid_argument code");
238           return llvm::createStringError(
239               errc::invalid_argument,
240               "selected range could not be resolved to a valid source range; " +
241                   E->getMessage());
242         });
243       return llvm::createStringError(
244           errc::invalid_argument,
245           "selected range could not be resolved to a valid source range");
246     }
247     // Validate `Range`, because `makeFileCharRange` accepts some ranges that
248     // `validateEditRange` rejects.
249     if (auto Err = tooling::validateEditRange(Range, *Match.SourceManager))
250       return joinErrors(
251           llvm::createStringError(errc::invalid_argument,
252                                   "selected range is not valid for editing"),
253           std::move(Err));
254     *Result += tooling::getText(Range, *Match.Context);
255     return Error::success();
256   }
257 };
258 
259 // A stencil operation to build a member access `e.m` or `e->m`, as appropriate.
260 class AccessStencil : public StencilInterface {
261   std::string BaseId;
262   Stencil Member;
263 
264 public:
265   AccessStencil(StringRef BaseId, Stencil Member)
266       : BaseId(std::string(BaseId)), Member(std::move(Member)) {}
267 
268   std::string toString() const override {
269     return (llvm::Twine("access(\"") + BaseId + "\", " + Member->toString() +
270             ")")
271         .str();
272   }
273 
274   Error eval(const MatchFinder::MatchResult &Match,
275              std::string *Result) const override {
276     const auto *E = Match.Nodes.getNodeAs<Expr>(BaseId);
277     if (E == nullptr)
278       return llvm::make_error<StringError>(errc::invalid_argument,
279                                            "Id not bound: " + BaseId);
280     llvm::Optional<std::string> S = tooling::buildAccess(*E, *Match.Context);
281     if (!S.hasValue())
282       return llvm::make_error<StringError>(
283           errc::invalid_argument,
284           "Could not construct object text from ID: " + BaseId);
285     *Result += *S;
286     return Member->eval(Match, Result);
287   }
288 };
289 
290 class IfBoundStencil : public StencilInterface {
291   std::string Id;
292   Stencil TrueStencil;
293   Stencil FalseStencil;
294 
295 public:
296   IfBoundStencil(StringRef Id, Stencil TrueStencil, Stencil FalseStencil)
297       : Id(std::string(Id)), TrueStencil(std::move(TrueStencil)),
298         FalseStencil(std::move(FalseStencil)) {}
299 
300   std::string toString() const override {
301     return (llvm::Twine("ifBound(\"") + Id + "\", " + TrueStencil->toString() +
302             ", " + FalseStencil->toString() + ")")
303         .str();
304   }
305 
306   Error eval(const MatchFinder::MatchResult &Match,
307              std::string *Result) const override {
308     auto &M = Match.Nodes.getMap();
309     return (M.find(Id) != M.end() ? TrueStencil : FalseStencil)
310         ->eval(Match, Result);
311   }
312 };
313 
314 class SelectBoundStencil : public clang::transformer::StencilInterface {
315   static bool containsNoNullStencils(
316       const std::vector<std::pair<std::string, Stencil>> &Cases) {
317     for (const auto &S : Cases)
318       if (S.second == nullptr)
319         return false;
320     return true;
321   }
322 
323 public:
324   SelectBoundStencil(std::vector<std::pair<std::string, Stencil>> Cases,
325                      Stencil Default)
326       : CaseStencils(std::move(Cases)), DefaultStencil(std::move(Default)) {
327     assert(containsNoNullStencils(CaseStencils) &&
328            "cases of selectBound may not be null");
329   }
330   ~SelectBoundStencil() override{};
331 
332   llvm::Error eval(const MatchFinder::MatchResult &match,
333                    std::string *result) const override {
334     const BoundNodes::IDToNodeMap &NodeMap = match.Nodes.getMap();
335     for (const auto &S : CaseStencils) {
336       if (NodeMap.count(S.first) > 0) {
337         return S.second->eval(match, result);
338       }
339     }
340 
341     if (DefaultStencil != nullptr) {
342       return DefaultStencil->eval(match, result);
343     }
344 
345     llvm::SmallVector<llvm::StringRef, 2> CaseIDs;
346     CaseIDs.reserve(CaseStencils.size());
347     for (const auto &S : CaseStencils)
348       CaseIDs.emplace_back(S.first);
349 
350     return llvm::createStringError(
351         errc::result_out_of_range,
352         llvm::Twine("selectBound failed: no cases bound and no default: {") +
353             llvm::join(CaseIDs, ", ") + "}");
354   }
355 
356   std::string toString() const override {
357     std::string Buffer;
358     llvm::raw_string_ostream Stream(Buffer);
359     Stream << "selectBound({";
360     bool First = true;
361     for (const auto &S : CaseStencils) {
362       if (First)
363         First = false;
364       else
365         Stream << "}, ";
366       Stream << "{\"" << S.first << "\", " << S.second->toString();
367     }
368     Stream << "}}";
369     if (DefaultStencil != nullptr) {
370       Stream << ", " << DefaultStencil->toString();
371     }
372     Stream << ")";
373     return Stream.str();
374   }
375 
376 private:
377   std::vector<std::pair<std::string, Stencil>> CaseStencils;
378   Stencil DefaultStencil;
379 };
380 
381 class SequenceStencil : public StencilInterface {
382   std::vector<Stencil> Stencils;
383 
384 public:
385   SequenceStencil(std::vector<Stencil> Stencils)
386       : Stencils(std::move(Stencils)) {}
387 
388   std::string toString() const override {
389     llvm::SmallVector<std::string, 2> Parts;
390     Parts.reserve(Stencils.size());
391     for (const auto &S : Stencils)
392       Parts.push_back(S->toString());
393     return (llvm::Twine("seq(") + llvm::join(Parts, ", ") + ")").str();
394   }
395 
396   Error eval(const MatchFinder::MatchResult &Match,
397              std::string *Result) const override {
398     for (const auto &S : Stencils)
399       if (auto Err = S->eval(Match, Result))
400         return Err;
401     return Error::success();
402   }
403 };
404 
405 class RunStencil : public StencilInterface {
406   MatchConsumer<std::string> Consumer;
407 
408 public:
409   explicit RunStencil(MatchConsumer<std::string> C) : Consumer(std::move(C)) {}
410 
411   std::string toString() const override { return "run(...)"; }
412 
413   Error eval(const MatchFinder::MatchResult &Match,
414              std::string *Result) const override {
415 
416     Expected<std::string> Value = Consumer(Match);
417     if (!Value)
418       return Value.takeError();
419     *Result += *Value;
420     return Error::success();
421   }
422 };
423 } // namespace
424 
425 Stencil transformer::detail::makeStencil(StringRef Text) {
426   return std::make_shared<RawTextStencil>(std::string(Text));
427 }
428 
429 Stencil transformer::detail::makeStencil(RangeSelector Selector) {
430   return std::make_shared<SelectorStencil>(std::move(Selector));
431 }
432 
433 Stencil transformer::dPrint(StringRef Id) {
434   return std::make_shared<DebugPrintNodeStencil>(std::string(Id));
435 }
436 
437 Stencil transformer::expression(llvm::StringRef Id) {
438   return std::make_shared<UnaryOperationStencil>(UnaryNodeOperator::Parens,
439                                                  std::string(Id));
440 }
441 
442 Stencil transformer::deref(llvm::StringRef ExprId) {
443   return std::make_shared<UnaryOperationStencil>(UnaryNodeOperator::Deref,
444                                                  std::string(ExprId));
445 }
446 
447 Stencil transformer::maybeDeref(llvm::StringRef ExprId) {
448   return std::make_shared<UnaryOperationStencil>(UnaryNodeOperator::MaybeDeref,
449                                                  std::string(ExprId));
450 }
451 
452 Stencil transformer::addressOf(llvm::StringRef ExprId) {
453   return std::make_shared<UnaryOperationStencil>(UnaryNodeOperator::AddressOf,
454                                                  std::string(ExprId));
455 }
456 
457 Stencil transformer::maybeAddressOf(llvm::StringRef ExprId) {
458   return std::make_shared<UnaryOperationStencil>(
459       UnaryNodeOperator::MaybeAddressOf, std::string(ExprId));
460 }
461 
462 Stencil transformer::describe(StringRef Id) {
463   return std::make_shared<UnaryOperationStencil>(UnaryNodeOperator::Describe,
464                                                  std::string(Id));
465 }
466 
467 Stencil transformer::access(StringRef BaseId, Stencil Member) {
468   return std::make_shared<AccessStencil>(BaseId, std::move(Member));
469 }
470 
471 Stencil transformer::ifBound(StringRef Id, Stencil TrueStencil,
472                              Stencil FalseStencil) {
473   return std::make_shared<IfBoundStencil>(Id, std::move(TrueStencil),
474                                           std::move(FalseStencil));
475 }
476 
477 Stencil transformer::selectBound(
478     std::vector<std::pair<std::string, Stencil>> CaseStencils,
479     Stencil DefaultStencil) {
480   return std::make_shared<SelectBoundStencil>(std::move(CaseStencils),
481                                               std::move(DefaultStencil));
482 }
483 
484 Stencil transformer::run(MatchConsumer<std::string> Fn) {
485   return std::make_shared<RunStencil>(std::move(Fn));
486 }
487 
488 Stencil transformer::catVector(std::vector<Stencil> Parts) {
489   // Only one argument, so don't wrap in sequence.
490   if (Parts.size() == 1)
491     return std::move(Parts[0]);
492   return std::make_shared<SequenceStencil>(std::move(Parts));
493 }
494