| 1 |
//===- Synthesis.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/Basic/TokenKinds.h" |
| 9 |
#include "clang/Tooling/Syntax/BuildTree.h" |
| 10 |
#include "clang/Tooling/Syntax/Tree.h" |
| 11 |
#include "clang/Tooling/Syntax/Tokens.h" |
| 12 |
#include "clang/Tooling/Syntax/TokenBufferTokenManager.h" |
| 13 |
|
| 14 |
using namespace clang; |
| 15 |
|
| 16 |
/// Exposes private syntax tree APIs required to implement node synthesis. |
| 17 |
/// Should not be used for anything else. |
| 18 |
class clang::syntax::FactoryImpl { |
| 19 |
public: |
| 20 |
static void setCanModify(syntax::Node *N) { N->CanModify = true; } |
| 21 |
|
| 22 |
static void prependChildLowLevel(syntax::Tree *T, syntax::Node *Child, |
| 23 |
syntax::NodeRole R) { |
| 24 |
T->prependChildLowLevel(Child, R); |
| 25 |
} |
| 26 |
static void appendChildLowLevel(syntax::Tree *T, syntax::Node *Child, |
| 27 |
syntax::NodeRole R) { |
| 28 |
T->appendChildLowLevel(Child, R); |
| 29 |
} |
| 30 |
|
| 31 |
static std::pair<FileID, ArrayRef<Token>> |
| 32 |
lexBuffer(TokenBufferTokenManager &TBTM, |
| 33 |
std::unique_ptr<llvm::MemoryBuffer> Buffer) { |
| 34 |
return TBTM.lexBuffer(std::move(Buffer)); |
| 35 |
} |
| 36 |
}; |
| 37 |
|
| 38 |
// FIXME: `createLeaf` is based on `syntax::tokenize` internally, as such it |
| 39 |
// doesn't support digraphs or line continuations. |
| 40 |
syntax::Leaf *clang::syntax::createLeaf(syntax::Arena &A, |
| 41 |
TokenBufferTokenManager &TBTM, |
| 42 |
tok::TokenKind K, StringRef Spelling) { |
| 43 |
auto Tokens = |
| 44 |
FactoryImpl::lexBuffer(TBTM, llvm::MemoryBuffer::getMemBufferCopy(Spelling)) |
| 45 |
.second; |
| 46 |
assert(Tokens.size() == 1); |
| 47 |
assert(Tokens.front().kind() == K && |
| 48 |
"spelling is not lexed into the expected kind of token"); |
| 49 |
|
| 50 |
auto *Leaf = new (A.getAllocator()) syntax::Leaf( |
| 51 |
reinterpret_cast<TokenManager::Key>(Tokens.begin())); |
| 52 |
syntax::FactoryImpl::setCanModify(Leaf); |
| 53 |
Leaf->assertInvariants(); |
| 54 |
return Leaf; |
| 55 |
} |
| 56 |
|
| 57 |
syntax::Leaf *clang::syntax::createLeaf(syntax::Arena &A, |
| 58 |
TokenBufferTokenManager &TBTM, |
| 59 |
tok::TokenKind K) { |
| 60 |
const auto *Spelling = tok::getPunctuatorSpelling(K); |
| 61 |
if (!Spelling) |
| 62 |
Spelling = tok::getKeywordSpelling(K); |
| 63 |
assert(Spelling && |
| 64 |
"Cannot infer the spelling of the token from its token kind."); |
| 65 |
return createLeaf(A, TBTM, K, Spelling); |
| 66 |
} |
| 67 |
|
| 68 |
namespace { |
| 69 |
// Allocates the concrete syntax `Tree` according to its `NodeKind`. |
| 70 |
syntax::Tree *allocateTree(syntax::Arena &A, syntax::NodeKind Kind) { |
| 71 |
switch (Kind) { |
| 72 |
case syntax::NodeKind::Leaf: |
| 73 |
assert(false); |
| 74 |
break; |
| 75 |
case syntax::NodeKind::TranslationUnit: |
| 76 |
return new (A.getAllocator()) syntax::TranslationUnit; |
| 77 |
case syntax::NodeKind::UnknownExpression: |
| 78 |
return new (A.getAllocator()) syntax::UnknownExpression; |
| 79 |
case syntax::NodeKind::ParenExpression: |
| 80 |
return new (A.getAllocator()) syntax::ParenExpression; |
| 81 |
case syntax::NodeKind::ThisExpression: |
| 82 |
return new (A.getAllocator()) syntax::ThisExpression; |
| 83 |
case syntax::NodeKind::IntegerLiteralExpression: |
| 84 |
return new (A.getAllocator()) syntax::IntegerLiteralExpression; |
| 85 |
case syntax::NodeKind::CharacterLiteralExpression: |
| 86 |
return new (A.getAllocator()) syntax::CharacterLiteralExpression; |
| 87 |
case syntax::NodeKind::FloatingLiteralExpression: |
| 88 |
return new (A.getAllocator()) syntax::FloatingLiteralExpression; |
| 89 |
case syntax::NodeKind::StringLiteralExpression: |
| 90 |
return new (A.getAllocator()) syntax::StringLiteralExpression; |
| 91 |
case syntax::NodeKind::BoolLiteralExpression: |
| 92 |
return new (A.getAllocator()) syntax::BoolLiteralExpression; |
| 93 |
case syntax::NodeKind::CxxNullPtrExpression: |
| 94 |
return new (A.getAllocator()) syntax::CxxNullPtrExpression; |
| 95 |
case syntax::NodeKind::IntegerUserDefinedLiteralExpression: |
| 96 |
return new (A.getAllocator()) syntax::IntegerUserDefinedLiteralExpression; |
| 97 |
case syntax::NodeKind::FloatUserDefinedLiteralExpression: |
| 98 |
return new (A.getAllocator()) syntax::FloatUserDefinedLiteralExpression; |
| 99 |
case syntax::NodeKind::CharUserDefinedLiteralExpression: |
| 100 |
return new (A.getAllocator()) syntax::CharUserDefinedLiteralExpression; |
| 101 |
case syntax::NodeKind::StringUserDefinedLiteralExpression: |
| 102 |
return new (A.getAllocator()) syntax::StringUserDefinedLiteralExpression; |
| 103 |
case syntax::NodeKind::PrefixUnaryOperatorExpression: |
| 104 |
return new (A.getAllocator()) syntax::PrefixUnaryOperatorExpression; |
| 105 |
case syntax::NodeKind::PostfixUnaryOperatorExpression: |
| 106 |
return new (A.getAllocator()) syntax::PostfixUnaryOperatorExpression; |
| 107 |
case syntax::NodeKind::BinaryOperatorExpression: |
| 108 |
return new (A.getAllocator()) syntax::BinaryOperatorExpression; |
| 109 |
case syntax::NodeKind::UnqualifiedId: |
| 110 |
return new (A.getAllocator()) syntax::UnqualifiedId; |
| 111 |
case syntax::NodeKind::IdExpression: |
| 112 |
return new (A.getAllocator()) syntax::IdExpression; |
| 113 |
case syntax::NodeKind::CallExpression: |
| 114 |
return new (A.getAllocator()) syntax::CallExpression; |
| 115 |
case syntax::NodeKind::UnknownStatement: |
| 116 |
return new (A.getAllocator()) syntax::UnknownStatement; |
| 117 |
case syntax::NodeKind::DeclarationStatement: |
| 118 |
return new (A.getAllocator()) syntax::DeclarationStatement; |
| 119 |
case syntax::NodeKind::EmptyStatement: |
| 120 |
return new (A.getAllocator()) syntax::EmptyStatement; |
| 121 |
case syntax::NodeKind::SwitchStatement: |
| 122 |
return new (A.getAllocator()) syntax::SwitchStatement; |
| 123 |
case syntax::NodeKind::CaseStatement: |
| 124 |
return new (A.getAllocator()) syntax::CaseStatement; |
| 125 |
case syntax::NodeKind::DefaultStatement: |
| 126 |
return new (A.getAllocator()) syntax::DefaultStatement; |
| 127 |
case syntax::NodeKind::IfStatement: |
| 128 |
return new (A.getAllocator()) syntax::IfStatement; |
| 129 |
case syntax::NodeKind::ForStatement: |
| 130 |
return new (A.getAllocator()) syntax::ForStatement; |
| 131 |
case syntax::NodeKind::WhileStatement: |
| 132 |
return new (A.getAllocator()) syntax::WhileStatement; |
| 133 |
case syntax::NodeKind::ContinueStatement: |
| 134 |
return new (A.getAllocator()) syntax::ContinueStatement; |
| 135 |
case syntax::NodeKind::BreakStatement: |
| 136 |
return new (A.getAllocator()) syntax::BreakStatement; |
| 137 |
case syntax::NodeKind::ReturnStatement: |
| 138 |
return new (A.getAllocator()) syntax::ReturnStatement; |
| 139 |
case syntax::NodeKind::RangeBasedForStatement: |
| 140 |
return new (A.getAllocator()) syntax::RangeBasedForStatement; |
| 141 |
case syntax::NodeKind::ExpressionStatement: |
| 142 |
return new (A.getAllocator()) syntax::ExpressionStatement; |
| 143 |
case syntax::NodeKind::CompoundStatement: |
| 144 |
return new (A.getAllocator()) syntax::CompoundStatement; |
| 145 |
case syntax::NodeKind::UnknownDeclaration: |
| 146 |
return new (A.getAllocator()) syntax::UnknownDeclaration; |
| 147 |
case syntax::NodeKind::EmptyDeclaration: |
| 148 |
return new (A.getAllocator()) syntax::EmptyDeclaration; |
| 149 |
case syntax::NodeKind::StaticAssertDeclaration: |
| 150 |
return new (A.getAllocator()) syntax::StaticAssertDeclaration; |
| 151 |
case syntax::NodeKind::LinkageSpecificationDeclaration: |
| 152 |
return new (A.getAllocator()) syntax::LinkageSpecificationDeclaration; |
| 153 |
case syntax::NodeKind::SimpleDeclaration: |
| 154 |
return new (A.getAllocator()) syntax::SimpleDeclaration; |
| 155 |
case syntax::NodeKind::TemplateDeclaration: |
| 156 |
return new (A.getAllocator()) syntax::TemplateDeclaration; |
| 157 |
case syntax::NodeKind::ExplicitTemplateInstantiation: |
| 158 |
return new (A.getAllocator()) syntax::ExplicitTemplateInstantiation; |
| 159 |
case syntax::NodeKind::NamespaceDefinition: |
| 160 |
return new (A.getAllocator()) syntax::NamespaceDefinition; |
| 161 |
case syntax::NodeKind::NamespaceAliasDefinition: |
| 162 |
return new (A.getAllocator()) syntax::NamespaceAliasDefinition; |
| 163 |
case syntax::NodeKind::UsingNamespaceDirective: |
| 164 |
return new (A.getAllocator()) syntax::UsingNamespaceDirective; |
| 165 |
case syntax::NodeKind::UsingDeclaration: |
| 166 |
return new (A.getAllocator()) syntax::UsingDeclaration; |
| 167 |
case syntax::NodeKind::TypeAliasDeclaration: |
| 168 |
return new (A.getAllocator()) syntax::TypeAliasDeclaration; |
| 169 |
case syntax::NodeKind::SimpleDeclarator: |
| 170 |
return new (A.getAllocator()) syntax::SimpleDeclarator; |
| 171 |
case syntax::NodeKind::ParenDeclarator: |
| 172 |
return new (A.getAllocator()) syntax::ParenDeclarator; |
| 173 |
case syntax::NodeKind::ArraySubscript: |
| 174 |
return new (A.getAllocator()) syntax::ArraySubscript; |
| 175 |
case syntax::NodeKind::TrailingReturnType: |
| 176 |
return new (A.getAllocator()) syntax::TrailingReturnType; |
| 177 |
case syntax::NodeKind::ParametersAndQualifiers: |
| 178 |
return new (A.getAllocator()) syntax::ParametersAndQualifiers; |
| 179 |
case syntax::NodeKind::MemberPointer: |
| 180 |
return new (A.getAllocator()) syntax::MemberPointer; |
| 181 |
case syntax::NodeKind::GlobalNameSpecifier: |
| 182 |
return new (A.getAllocator()) syntax::GlobalNameSpecifier; |
| 183 |
case syntax::NodeKind::DecltypeNameSpecifier: |
| 184 |
return new (A.getAllocator()) syntax::DecltypeNameSpecifier; |
| 185 |
case syntax::NodeKind::IdentifierNameSpecifier: |
| 186 |
return new (A.getAllocator()) syntax::IdentifierNameSpecifier; |
| 187 |
case syntax::NodeKind::SimpleTemplateNameSpecifier: |
| 188 |
return new (A.getAllocator()) syntax::SimpleTemplateNameSpecifier; |
| 189 |
case syntax::NodeKind::NestedNameSpecifier: |
| 190 |
return new (A.getAllocator()) syntax::NestedNameSpecifier; |
| 191 |
case syntax::NodeKind::MemberExpression: |
| 192 |
return new (A.getAllocator()) syntax::MemberExpression; |
| 193 |
case syntax::NodeKind::CallArguments: |
| 194 |
return new (A.getAllocator()) syntax::CallArguments; |
| 195 |
case syntax::NodeKind::ParameterDeclarationList: |
| 196 |
return new (A.getAllocator()) syntax::ParameterDeclarationList; |
| 197 |
case syntax::NodeKind::DeclaratorList: |
| 198 |
return new (A.getAllocator()) syntax::DeclaratorList; |
| 199 |
} |
| 200 |
llvm_unreachable("unknown node kind"); |
| 201 |
} |
| 202 |
} // namespace |
| 203 |
|
| 204 |
syntax::Tree *clang::syntax::createTree( |
| 205 |
syntax::Arena &A, |
| 206 |
ArrayRef<std::pair<syntax::Node *, syntax::NodeRole>> Children, |
| 207 |
syntax::NodeKind K) { |
| 208 |
auto *T = allocateTree(A, K); |
| 209 |
FactoryImpl::setCanModify(T); |
| 210 |
for (const auto &Child : Children) |
| 211 |
FactoryImpl::appendChildLowLevel(T, Child.first, Child.second); |
| 212 |
|
| 213 |
T->assertInvariants(); |
| 214 |
return T; |
| 215 |
} |
| 216 |
|
| 217 |
syntax::Node *clang::syntax::deepCopyExpandingMacros(syntax::Arena &A, |
| 218 |
TokenBufferTokenManager &TBTM, |
| 219 |
const syntax::Node *N) { |
| 220 |
if (const auto *L = dyn_cast<syntax::Leaf>(N)) |
| 221 |
// `L->getToken()` gives us the expanded token, thus we implicitly expand |
| 222 |
// any macros here. |
| 223 |
return createLeaf(A, TBTM, TBTM.getToken(L->getTokenKey())->kind(), |
| 224 |
TBTM.getText(L->getTokenKey())); |
| 225 |
|
| 226 |
const auto *T = cast<syntax::Tree>(N); |
| 227 |
std::vector<std::pair<syntax::Node *, syntax::NodeRole>> Children; |
| 228 |
for (const auto *Child = T->getFirstChild(); Child; |
| 229 |
Child = Child->getNextSibling()) |
| 230 |
Children.push_back({deepCopyExpandingMacros(A, TBTM, Child), Child->getRole()}); |
| 231 |
|
| 232 |
return createTree(A, Children, N->getKind()); |
| 233 |
} |
| 234 |
|
| 235 |
syntax::EmptyStatement *clang::syntax::createEmptyStatement(syntax::Arena &A, TokenBufferTokenManager &TBTM) { |
| 236 |
return cast<EmptyStatement>( |
| 237 |
createTree(A, {{createLeaf(A, TBTM, tok::semi), NodeRole::Unknown}}, |
| 238 |
NodeKind::EmptyStatement)); |
| 239 |
} |