blob: 8fe589b0985c4cdbd221b0a39dc4e6047dd72add [file] [log] [blame]
//===--- Stencil.cpp - Stencil implementation -------------------*- C++ -*-===//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#include "clang/Tooling/Refactoring/Stencil.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTTypeTraits.h"
#include "clang/AST/Expr.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
#include "clang/Lex/Lexer.h"
#include "clang/Tooling/Refactoring/SourceCode.h"
#include "llvm/Support/Errc.h"
#include <atomic>
#include <memory>
#include <string>
using namespace clang;
using namespace tooling;
using ast_matchers::MatchFinder;
using llvm::Error;
// A down_cast function to safely down cast a StencilPartInterface to a subclass
// D. Returns nullptr if P is not an instance of D.
template <typename D> const D *down_cast(const StencilPartInterface *P) {
if (P == nullptr || D::typeId() != P->typeId())
return nullptr;
return static_cast<const D *>(P);
static llvm::Expected<ast_type_traits::DynTypedNode>
getNode(const ast_matchers::BoundNodes &Nodes, StringRef Id) {
auto &NodesMap = Nodes.getMap();
auto It = NodesMap.find(Id);
if (It == NodesMap.end())
return llvm::make_error<llvm::StringError>(llvm::errc::invalid_argument,
"Id not bound: " + Id);
return It->second;
namespace {
// An arbitrary fragment of code within a stencil.
struct RawTextData {
explicit RawTextData(std::string T) : Text(std::move(T)) {}
std::string Text;
// A debugging operation to dump the AST for a particular (bound) AST node.
struct DebugPrintNodeOpData {
explicit DebugPrintNodeOpData(std::string S) : Id(std::move(S)) {}
std::string Id;
// Whether to associate a trailing semicolon with a node when identifying it's
// text. This flag is needed for expressions (clang::Expr), because their role
// is ambiguous when they are also complete statements. When this flag is
// `Always`, an expression node will be treated like a statement, and will
// therefore be associated with any trailing semicolon.
enum class SemiAssociation : bool {
// A reference to a particular (bound) AST node.
struct NodeRefData {
explicit NodeRefData(std::string S, SemiAssociation SA)
: Id(std::move(S)), SemiAssoc(SA) {}
std::string Id;
SemiAssociation SemiAssoc;
} // namespace
bool isEqualData(const RawTextData &A, const RawTextData &B) {
return A.Text == B.Text;
bool isEqualData(const DebugPrintNodeOpData &A, const DebugPrintNodeOpData &B) {
return A.Id == B.Id;
bool isEqualData(const NodeRefData &A, const NodeRefData &B) {
return A.Id == B.Id && A.SemiAssoc == B.SemiAssoc;
// The `evalData()` overloads evaluate the given stencil data to a string, given
// the match result, and append it to `Result`. We define an overload for each
// type of stencil data.
Error evalData(const RawTextData &Data, const MatchFinder::MatchResult &,
std::string *Result) {
return Error::success();
Error evalData(const DebugPrintNodeOpData &Data,
const MatchFinder::MatchResult &Match, std::string *Result) {
std::string Output;
llvm::raw_string_ostream Os(Output);
auto NodeOrErr = getNode(Match.Nodes, Data.Id);
if (auto Err = NodeOrErr.takeError())
return Err;
NodeOrErr->print(Os, PrintingPolicy(Match.Context->getLangOpts()));
*Result += Os.str();
return Error::success();
Error evalData(const NodeRefData &Data, const MatchFinder::MatchResult &Match,
std::string *Result) {
auto NodeOrErr = getNode(Match.Nodes, Data.Id);
if (auto Err = NodeOrErr.takeError())
return Err;
auto &Node = *NodeOrErr;
switch (Data.SemiAssoc) {
case SemiAssociation::Inferred:
// Include the semicolon for non-expression statements:
*Result += Node.get<Stmt>() != nullptr && Node.get<Expr>() == nullptr
? getExtendedText(NodeOrErr.get(), tok::TokenKind::semi,
: getText(NodeOrErr.get(), *Match.Context);
case SemiAssociation::Always:
*Result +=
getExtendedText(NodeOrErr.get(), tok::TokenKind::semi, *Match.Context);
return Error::success();
template <typename T>
class StencilPartImpl : public StencilPartInterface {
T Data;
template <typename... Ps>
explicit StencilPartImpl(Ps &&... Args)
: StencilPartInterface(StencilPartImpl::typeId()),
Data(std::forward<Ps>(Args)...) {}
// Generates a unique identifier for this class (specifically, one per
// instantiation of the template).
static const void* typeId() {
static bool b;
return &b;
Error eval(const MatchFinder::MatchResult &Match,
std::string *Result) const override {
return evalData(Data, Match, Result);
bool isEqual(const StencilPartInterface &Other) const override {
if (const auto *OtherPtr = down_cast<StencilPartImpl>(&Other))
return isEqualData(Data, OtherPtr->Data);
return false;
namespace {
using RawText = StencilPartImpl<RawTextData>;
using DebugPrintNodeOp = StencilPartImpl<DebugPrintNodeOpData>;
using NodeRef = StencilPartImpl<NodeRefData>;
} // namespace
StencilPart Stencil::wrap(StringRef Text) {
return stencil::text(Text);
void Stencil::append(Stencil OtherStencil) {
for (auto &Part : OtherStencil.Parts)
Stencil::eval(const MatchFinder::MatchResult &Match) const {
std::string Result;
for (const auto &Part : Parts)
if (auto Err = Part.eval(Match, &Result))
return std::move(Err);
return Result;
StencilPart stencil::text(StringRef Text) {
return StencilPart(std::make_shared<RawText>(Text));
StencilPart stencil::node(StringRef Id) {
return StencilPart(std::make_shared<NodeRef>(Id, SemiAssociation::Inferred));
StencilPart stencil::sNode(StringRef Id) {
return StencilPart(std::make_shared<NodeRef>(Id, SemiAssociation::Always));
StencilPart stencil::dPrint(StringRef Id) {
return StencilPart(std::make_shared<DebugPrintNodeOp>(Id));