nils.hoelscher
/
llvm-for-llvmta
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
llvm-for-llvmta/tools/clang/utils/TableGen/ClangASTPropertiesEmitter.cpp

866 lines
30 KiB
C++
Raw Permalink Normal View History

added clang
2022-04-25 13:02:35 +02:00
//=== ClangASTPropsEmitter.cpp - Generate Clang AST properties --*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This tablegen backend emits code for working with Clang AST properties.
//
//===----------------------------------------------------------------------===//
#include "ASTTableGen.h"
#include "TableGenBackends.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Twine.h"
#include "llvm/TableGen/Error.h"
#include "llvm/TableGen/Record.h"
#include "llvm/TableGen/TableGenBackend.h"
#include <cctype>
#include <map>
#include <set>
#include <string>
using namespace llvm;
using namespace clang;
using namespace clang::tblgen;
static StringRef getReaderResultType(TypeNode _) { return "QualType"; }
namespace {
struct ReaderWriterInfo {
bool IsReader;
/// The name of the node hierarchy. Not actually sensitive to IsReader,
/// but useful to cache here anyway.
StringRef HierarchyName;
/// The suffix on classes: Reader/Writer
StringRef ClassSuffix;
/// The base name of methods: read/write
StringRef MethodPrefix;
/// The name of the property helper member: R/W
StringRef HelperVariable;
/// The result type of methods on the class.
StringRef ResultType;
template <class NodeClass>
static ReaderWriterInfo forReader() {
return ReaderWriterInfo{
true,
NodeClass::getASTHierarchyName(),
"Reader",
"read",
"R",
getReaderResultType(NodeClass())
};
}
template <class NodeClass>
static ReaderWriterInfo forWriter() {
return ReaderWriterInfo{
false,
NodeClass::getASTHierarchyName(),
"Writer",
"write",
"W",
"void"
};
}
};
struct NodeInfo {
std::vector<Property> Properties;
CreationRule Creator = nullptr;
OverrideRule Override = nullptr;
ReadHelperRule ReadHelper = nullptr;
};
struct CasedTypeInfo {
TypeKindRule KindRule;
std::vector<TypeCase> Cases;
};
class ASTPropsEmitter {
raw_ostream &Out;
RecordKeeper &Records;
std::map<HasProperties, NodeInfo> NodeInfos;
std::vector<PropertyType> AllPropertyTypes;
std::map<PropertyType, CasedTypeInfo> CasedTypeInfos;
public:
ASTPropsEmitter(RecordKeeper &records, raw_ostream &out)
: Out(out), Records(records) {
// Find all the properties.
for (Property property :
records.getAllDerivedDefinitions(PropertyClassName)) {
HasProperties node = property.getClass();
NodeInfos[node].Properties.push_back(property);
}
// Find all the creation rules.
for (CreationRule creationRule :
records.getAllDerivedDefinitions(CreationRuleClassName)) {
HasProperties node = creationRule.getClass();
auto &info = NodeInfos[node];
if (info.Creator) {
PrintFatalError(creationRule.getLoc(),
"multiple creator rules for \"" + node.getName()
+ "\"");
}
info.Creator = creationRule;
}
// Find all the override rules.
for (OverrideRule overrideRule :
records.getAllDerivedDefinitions(OverrideRuleClassName)) {
HasProperties node = overrideRule.getClass();
auto &info = NodeInfos[node];
if (info.Override) {
PrintFatalError(overrideRule.getLoc(),
"multiple override rules for \"" + node.getName()
+ "\"");
}
info.Override = overrideRule;
}
// Find all the write helper rules.
for (ReadHelperRule helperRule :
records.getAllDerivedDefinitions(ReadHelperRuleClassName)) {
HasProperties node = helperRule.getClass();
auto &info = NodeInfos[node];
if (info.ReadHelper) {
PrintFatalError(helperRule.getLoc(),
"multiple write helper rules for \"" + node.getName()
+ "\"");
}
info.ReadHelper = helperRule;
}
// Find all the concrete property types.
for (PropertyType type :
records.getAllDerivedDefinitions(PropertyTypeClassName)) {
// Ignore generic specializations; they're generally not useful when
// emitting basic emitters etc.
if (type.isGenericSpecialization()) continue;
AllPropertyTypes.push_back(type);
}
// Find all the type kind rules.
for (TypeKindRule kindRule :
records.getAllDerivedDefinitions(TypeKindClassName)) {
PropertyType type = kindRule.getParentType();
auto &info = CasedTypeInfos[type];
if (info.KindRule) {
PrintFatalError(kindRule.getLoc(),
"multiple kind rules for \""
+ type.getCXXTypeName() + "\"");
}
info.KindRule = kindRule;
}
// Find all the type cases.
for (TypeCase typeCase :
records.getAllDerivedDefinitions(TypeCaseClassName)) {
CasedTypeInfos[typeCase.getParentType()].Cases.push_back(typeCase);
}
Validator(*this).validate();
}
void visitAllProperties(HasProperties derived, const NodeInfo &derivedInfo,
function_ref<void (Property)> visit) {
std::set<StringRef> ignoredProperties;
auto overrideRule = derivedInfo.Override;
if (overrideRule) {
auto list = overrideRule.getIgnoredProperties();
ignoredProperties.insert(list.begin(), list.end());
}
// TODO: we should sort the properties in various ways
// - put arrays at the end to enable abbreviations
// - put conditional properties after properties used in the condition
visitAllNodesWithInfo(derived, derivedInfo,
[&](HasProperties node, const NodeInfo &info) {
for (Property prop : info.Properties) {
if (ignoredProperties.count(prop.getName()))
continue;
visit(prop);
}
});
}
void visitAllNodesWithInfo(HasProperties derivedNode,
const NodeInfo &derivedNodeInfo,
llvm::function_ref<void (HasProperties node,
const NodeInfo &info)>
visit) {
visit(derivedNode, derivedNodeInfo);
// Also walk the bases if appropriate.
if (ASTNode base = derivedNode.getAs<ASTNode>()) {
for (base = base.getBase(); base; base = base.getBase()) {
auto it = NodeInfos.find(base);
// Ignore intermediate nodes that don't add interesting properties.
if (it == NodeInfos.end()) continue;
auto &baseInfo = it->second;
visit(base, baseInfo);
}
}
}
template <class NodeClass>
void emitNodeReaderClass() {
auto info = ReaderWriterInfo::forReader<NodeClass>();
emitNodeReaderWriterClass<NodeClass>(info);
}
template <class NodeClass>
void emitNodeWriterClass() {
auto info = ReaderWriterInfo::forWriter<NodeClass>();
emitNodeReaderWriterClass<NodeClass>(info);
}
template <class NodeClass>
void emitNodeReaderWriterClass(const ReaderWriterInfo &info);
template <class NodeClass>
void emitNodeReaderWriterMethod(NodeClass node,
const ReaderWriterInfo &info);
void emitPropertiedReaderWriterBody(HasProperties node,
const ReaderWriterInfo &info);
void emitReadOfProperty(StringRef readerName, Property property);
void emitReadOfProperty(StringRef readerName, StringRef name,
PropertyType type, StringRef condition = "");
void emitWriteOfProperty(StringRef writerName, Property property);
void emitWriteOfProperty(StringRef writerName, StringRef name,
PropertyType type, StringRef readCode,
StringRef condition = "");
void emitBasicReaderWriterFile(const ReaderWriterInfo &info);
void emitDispatcherTemplate(const ReaderWriterInfo &info);
void emitPackUnpackOptionalTemplate(const ReaderWriterInfo &info);
void emitBasicReaderWriterTemplate(const ReaderWriterInfo &info);
void emitCasedReaderWriterMethodBody(PropertyType type,
const CasedTypeInfo &typeCases,
const ReaderWriterInfo &info);
private:
class Validator {
ASTPropsEmitter &Emitter;
std::set<HasProperties> ValidatedNodes;
public:
Validator(ASTPropsEmitter &emitter) : Emitter(emitter) {}
void validate();
private:
void validateNode(HasProperties node, const NodeInfo &nodeInfo);
void validateType(PropertyType type, WrappedRecord context);
};
};
} // end anonymous namespace
void ASTPropsEmitter::Validator::validate() {
for (auto &entry : Emitter.NodeInfos) {
validateNode(entry.first, entry.second);
}
if (ErrorsPrinted > 0) {
PrintFatalError("property validation failed");
}
}
void ASTPropsEmitter::Validator::validateNode(HasProperties derivedNode,
const NodeInfo &derivedNodeInfo) {
if (!ValidatedNodes.insert(derivedNode).second) return;
// A map from property name to property.
std::map<StringRef, Property> allProperties;
Emitter.visitAllNodesWithInfo(derivedNode, derivedNodeInfo,
[&](HasProperties node,
const NodeInfo &nodeInfo) {
for (Property property : nodeInfo.Properties) {
validateType(property.getType(), property);
auto result = allProperties.insert(
std::make_pair(property.getName(), property));
// Diagnose non-unique properties.
if (!result.second) {
// The existing property is more likely to be associated with a
// derived node, so use it as the error.
Property existingProperty = result.first->second;
PrintError(existingProperty.getLoc(),
"multiple properties named \"" + property.getName()
+ "\" in hierarchy of " + derivedNode.getName());
PrintNote(property.getLoc(), "existing property");
}
}
});
}
void ASTPropsEmitter::Validator::validateType(PropertyType type,
WrappedRecord context) {
if (!type.isGenericSpecialization()) {
if (type.getCXXTypeName() == "") {
PrintError(type.getLoc(),
"type is not generic but has no C++ type name");
if (context) PrintNote(context.getLoc(), "type used here");
}
} else if (auto eltType = type.getArrayElementType()) {
validateType(eltType, context);
} else if (auto valueType = type.getOptionalElementType()) {
validateType(valueType, context);
if (valueType.getPackOptionalCode().empty()) {
PrintError(valueType.getLoc(),
"type doesn't provide optional-packing code");
if (context) PrintNote(context.getLoc(), "type used here");
} else if (valueType.getUnpackOptionalCode().empty()) {
PrintError(valueType.getLoc(),
"type doesn't provide optional-unpacking code");
if (context) PrintNote(context.getLoc(), "type used here");
}
} else {
PrintError(type.getLoc(), "unknown generic property type");
if (context) PrintNote(context.getLoc(), "type used here");
}
}
/****************************************************************************/
/**************************** AST READER/WRITERS ****************************/
/****************************************************************************/
template <class NodeClass>
void ASTPropsEmitter::emitNodeReaderWriterClass(const ReaderWriterInfo &info) {
StringRef suffix = info.ClassSuffix;
StringRef var = info.HelperVariable;
// Enter the class declaration.
Out << "template <class Property" << suffix << ">\n"
"class Abstract" << info.HierarchyName << suffix << " {\n"
"public:\n"
" Property" << suffix << " &" << var << ";\n\n";
// Emit the constructor.
Out << " Abstract" << info.HierarchyName << suffix
<< "(Property" << suffix << " &" << var << ") : "
<< var << "(" << var << ") {}\n\n";
// Emit a method that dispatches on a kind to the appropriate node-specific
// method.
Out << " " << info.ResultType << " " << info.MethodPrefix << "(";
if (info.IsReader)
Out << NodeClass::getASTIdTypeName() << " kind";
else
Out << "const " << info.HierarchyName << " *node";
Out << ") {\n"
" switch (";
if (info.IsReader)
Out << "kind";
else
Out << "node->" << NodeClass::getASTIdAccessorName() << "()";
Out << ") {\n";
visitASTNodeHierarchy<NodeClass>(Records, [&](NodeClass node, NodeClass _) {
if (node.isAbstract()) return;
Out << " case " << info.HierarchyName << "::" << node.getId() << ":\n"
" return " << info.MethodPrefix << node.getClassName() << "(";
if (!info.IsReader)
Out << "static_cast<const " << node.getClassName()
<< " *>(node)";
Out << ");\n";
});
Out << " }\n"
" llvm_unreachable(\"bad kind\");\n"
" }\n\n";
// Emit node-specific methods for all the concrete nodes.
visitASTNodeHierarchy<NodeClass>(Records,
[&](NodeClass node, NodeClass base) {
if (node.isAbstract()) return;
emitNodeReaderWriterMethod(node, info);
});
// Finish the class.
Out << "};\n\n";
}
/// Emit a reader method for the given concrete AST node class.
template <class NodeClass>
void ASTPropsEmitter::emitNodeReaderWriterMethod(NodeClass node,
const ReaderWriterInfo &info) {
// Declare and start the method.
Out << " " << info.ResultType << " "
<< info.MethodPrefix << node.getClassName() << "(";
if (!info.IsReader)
Out << "const " << node.getClassName() << " *node";
Out << ") {\n";
if (info.IsReader)
Out << " auto &ctx = " << info.HelperVariable << ".getASTContext();\n";
emitPropertiedReaderWriterBody(node, info);
// Finish the method declaration.
Out << " }\n\n";
}
void ASTPropsEmitter::emitPropertiedReaderWriterBody(HasProperties node,
const ReaderWriterInfo &info) {
// Find the information for this node.
auto it = NodeInfos.find(node);
if (it == NodeInfos.end())
PrintFatalError(node.getLoc(),
"no information about how to deserialize \""
+ node.getName() + "\"");
auto &nodeInfo = it->second;
StringRef creationCode;
if (info.IsReader) {
// We should have a creation rule.
if (!nodeInfo.Creator)
PrintFatalError(node.getLoc(),
"no " CreationRuleClassName " for \""
+ node.getName() + "\"");
creationCode = nodeInfo.Creator.getCreationCode();
}
// Emit the ReadHelper code, if present.
if (!info.IsReader && nodeInfo.ReadHelper) {
Out << " " << nodeInfo.ReadHelper.getHelperCode() << "\n";
}
// Emit code to read all the properties.
visitAllProperties(node, nodeInfo, [&](Property prop) {
// Verify that the creation code refers to this property.
if (info.IsReader && creationCode.find(prop.getName()) == StringRef::npos)
PrintFatalError(nodeInfo.Creator.getLoc(),
"creation code for " + node.getName()
+ " doesn't refer to property \""
+ prop.getName() + "\"");
// Emit code to read or write this property.
if (info.IsReader)
emitReadOfProperty(info.HelperVariable, prop);
else
emitWriteOfProperty(info.HelperVariable, prop);
});
// Emit the final creation code.
if (info.IsReader)
Out << " " << creationCode << "\n";
}
static void emitBasicReaderWriterMethodSuffix(raw_ostream &out,
PropertyType type,
bool isForRead) {
if (!type.isGenericSpecialization()) {
out << type.getAbstractTypeName();
} else if (auto eltType = type.getArrayElementType()) {
out << "Array";
// We only include an explicit template argument for reads so that
// we don't cause spurious const mismatches.
if (isForRead) {
out << "<";
eltType.emitCXXValueTypeName(isForRead, out);
out << ">";
}
} else if (auto valueType = type.getOptionalElementType()) {
out << "Optional";
// We only include an explicit template argument for reads so that
// we don't cause spurious const mismatches.
if (isForRead) {
out << "<";
valueType.emitCXXValueTypeName(isForRead, out);
out << ">";
}
} else {
PrintFatalError(type.getLoc(), "unexpected generic property type");
}
}
/// Emit code to read the given property in a node-reader method.
void ASTPropsEmitter::emitReadOfProperty(StringRef readerName,
Property property) {
emitReadOfProperty(readerName, property.getName(), property.getType(),
property.getCondition());
}
void ASTPropsEmitter::emitReadOfProperty(StringRef readerName,
StringRef name,
PropertyType type,
StringRef condition) {
// Declare all the necessary buffers.
auto bufferTypes = type.getBufferElementTypes();
for (size_t i = 0, e = bufferTypes.size(); i != e; ++i) {
Out << " llvm::SmallVector<";
PropertyType(bufferTypes[i]).emitCXXValueTypeName(/*for read*/ true, Out);
Out << ", 8> " << name << "_buffer_" << i << ";\n";
}
// T prop = R.find("prop").read##ValueType(buffers...);
// We intentionally ignore shouldPassByReference here: we're going to
// get a pr-value back from read(), and we should be able to forward
// that in the creation rule.
Out << " ";
if (!condition.empty()) Out << "llvm::Optional<";
type.emitCXXValueTypeName(true, Out);
if (!condition.empty()) Out << ">";
Out << " " << name;
if (condition.empty()) {
Out << " = ";
} else {
Out << ";\n"
" if (" << condition << ") {\n"
" " << name << ".emplace(";
}
Out << readerName << ".find(\"" << name << "\")."
<< (type.isGenericSpecialization() ? "template " : "") << "read";
emitBasicReaderWriterMethodSuffix(Out, type, /*for read*/ true);
Out << "(";
for (size_t i = 0, e = bufferTypes.size(); i != e; ++i) {
Out << (i > 0 ? ", " : "") << name << "_buffer_" << i;
}
Out << ")";
if (condition.empty()) {
Out << ";\n";
} else {
Out << ");\n"
" }\n";
}
}
/// Emit code to write the given property in a node-writer method.
void ASTPropsEmitter::emitWriteOfProperty(StringRef writerName,
Property property) {
emitWriteOfProperty(writerName, property.getName(), property.getType(),
property.getReadCode(), property.getCondition());
}
void ASTPropsEmitter::emitWriteOfProperty(StringRef writerName,
StringRef name,
PropertyType type,
StringRef readCode,
StringRef condition) {
if (!condition.empty()) {
Out << " if (" << condition << ") {\n";
}
// Focus down to the property:
// T prop = <READ>;
// W.find("prop").write##ValueType(prop);
Out << " ";
type.emitCXXValueTypeName(false, Out);
Out << " " << name << " = (" << readCode << ");\n"
" " << writerName << ".find(\"" << name << "\").write";
emitBasicReaderWriterMethodSuffix(Out, type, /*for read*/ false);
Out << "(" << name << ");\n";
if (!condition.empty()) {
Out << " }\n";
}
}
/// Emit an .inc file that defines the AbstractFooReader class
/// for the given AST class hierarchy.
template <class NodeClass>
static void emitASTReader(RecordKeeper &records, raw_ostream &out,
StringRef description) {
emitSourceFileHeader(description, out);
ASTPropsEmitter(records, out).emitNodeReaderClass<NodeClass>();
}
void clang::EmitClangTypeReader(RecordKeeper &records, raw_ostream &out) {
emitASTReader<TypeNode>(records, out, "A CRTP reader for Clang Type nodes");
}
/// Emit an .inc file that defines the AbstractFooWriter class
/// for the given AST class hierarchy.
template <class NodeClass>
static void emitASTWriter(RecordKeeper &records, raw_ostream &out,
StringRef description) {
emitSourceFileHeader(description, out);
ASTPropsEmitter(records, out).emitNodeWriterClass<NodeClass>();
}
void clang::EmitClangTypeWriter(RecordKeeper &records, raw_ostream &out) {
emitASTWriter<TypeNode>(records, out, "A CRTP writer for Clang Type nodes");
}
/****************************************************************************/
/*************************** BASIC READER/WRITERS ***************************/
/****************************************************************************/
void
ASTPropsEmitter::emitDispatcherTemplate(const ReaderWriterInfo &info) {
// Declare the {Read,Write}Dispatcher template.
StringRef dispatcherPrefix = (info.IsReader ? "Read" : "Write");
Out << "template <class ValueType>\n"
"struct " << dispatcherPrefix << "Dispatcher;\n";
// Declare a specific specialization of the dispatcher template.
auto declareSpecialization =
[&](StringRef specializationParameters,
const Twine &cxxTypeName,
StringRef methodSuffix) {
StringRef var = info.HelperVariable;
Out << "template " << specializationParameters << "\n"
"struct " << dispatcherPrefix << "Dispatcher<"
<< cxxTypeName << "> {\n";
Out << " template <class Basic" << info.ClassSuffix << ", class... Args>\n"
" static " << (info.IsReader ? cxxTypeName : "void") << " "
<< info.MethodPrefix
<< "(Basic" << info.ClassSuffix << " &" << var
<< ", Args &&... args) {\n"
" return " << var << "."
<< info.MethodPrefix << methodSuffix
<< "(std::forward<Args>(args)...);\n"
" }\n"
"};\n";
};
// Declare explicit specializations for each of the concrete types.
for (PropertyType type : AllPropertyTypes) {
declareSpecialization("<>",
type.getCXXTypeName(),
type.getAbstractTypeName());
// Also declare a specialization for the const type when appropriate.
if (!info.IsReader && type.isConstWhenWriting()) {
declareSpecialization("<>",
"const " + type.getCXXTypeName(),
type.getAbstractTypeName());
}
}
// Declare partial specializations for ArrayRef and Optional.
declareSpecialization("<class T>",
"llvm::ArrayRef<T>",
"Array");
declareSpecialization("<class T>",
"llvm::Optional<T>",
"Optional");
Out << "\n";
}
void
ASTPropsEmitter::emitPackUnpackOptionalTemplate(const ReaderWriterInfo &info) {
StringRef classPrefix = (info.IsReader ? "Unpack" : "Pack");
StringRef methodName = (info.IsReader ? "unpack" : "pack");
// Declare the {Pack,Unpack}OptionalValue template.
Out << "template <class ValueType>\n"
"struct " << classPrefix << "OptionalValue;\n";
auto declareSpecialization = [&](const Twine &typeName,
StringRef code) {
Out << "template <>\n"
"struct " << classPrefix << "OptionalValue<" << typeName << "> {\n"
" static " << (info.IsReader ? "Optional<" : "") << typeName
<< (info.IsReader ? "> " : " ") << methodName << "("
<< (info.IsReader ? "" : "Optional<") << typeName
<< (info.IsReader ? "" : ">") << " value) {\n"
" return " << code << ";\n"
" }\n"
"};\n";
};
for (PropertyType type : AllPropertyTypes) {
StringRef code = (info.IsReader ? type.getUnpackOptionalCode()
: type.getPackOptionalCode());
if (code.empty()) continue;
StringRef typeName = type.getCXXTypeName();
declareSpecialization(typeName, code);
if (type.isConstWhenWriting() && !info.IsReader)
declareSpecialization("const " + typeName, code);
}
Out << "\n";
}
void
ASTPropsEmitter::emitBasicReaderWriterTemplate(const ReaderWriterInfo &info) {
// Emit the Basic{Reader,Writer}Base template.
Out << "template <class Impl>\n"
"class Basic" << info.ClassSuffix << "Base {\n";
Out << " ASTContext &C;\n";
Out << "protected:\n"
" Basic"
<< info.ClassSuffix << "Base" << ("(ASTContext &ctx) : C(ctx)")
<< " {}\n"
"public:\n";
Out << " ASTContext &getASTContext() { return C; }\n";
Out << " Impl &asImpl() { return static_cast<Impl&>(*this); }\n";
auto enterReaderWriterMethod = [&](StringRef cxxTypeName,
StringRef abstractTypeName,
bool shouldPassByReference,
bool constWhenWriting,
StringRef paramName) {
Out << " " << (info.IsReader ? cxxTypeName : "void")
<< " " << info.MethodPrefix << abstractTypeName << "(";
if (!info.IsReader)
Out << (shouldPassByReference || constWhenWriting ? "const " : "")
<< cxxTypeName
<< (shouldPassByReference ? " &" : "") << " " << paramName;
Out << ") {\n";
};
// Emit {read,write}ValueType methods for all the enum and subclass types
// that default to using the integer/base-class implementations.
for (PropertyType type : AllPropertyTypes) {
auto enterMethod = [&](StringRef paramName) {
enterReaderWriterMethod(type.getCXXTypeName(),
type.getAbstractTypeName(),
type.shouldPassByReference(),
type.isConstWhenWriting(),
paramName);
};
auto exitMethod = [&] {
Out << " }\n";
};
// Handled cased types.
auto casedIter = CasedTypeInfos.find(type);
if (casedIter != CasedTypeInfos.end()) {
enterMethod("node");
emitCasedReaderWriterMethodBody(type, casedIter->second, info);
exitMethod();
} else if (type.isEnum()) {
enterMethod("value");
if (info.IsReader)
Out << " return asImpl().template readEnum<"
<< type.getCXXTypeName() << ">();\n";
else
Out << " asImpl().writeEnum(value);\n";
exitMethod();
} else if (PropertyType superclass = type.getSuperclassType()) {
enterMethod("value");
if (info.IsReader)
Out << " return cast_or_null<" << type.getSubclassClassName()
<< ">(asImpl().read"
<< superclass.getAbstractTypeName()
<< "());\n";
else
Out << " asImpl().write" << superclass.getAbstractTypeName()
<< "(value);\n";
exitMethod();
} else {
// The other types can't be handled as trivially.
}
}
Out << "};\n\n";
}
void ASTPropsEmitter::emitCasedReaderWriterMethodBody(PropertyType type,
const CasedTypeInfo &typeCases,
const ReaderWriterInfo &info) {
if (typeCases.Cases.empty()) {
assert(typeCases.KindRule);
PrintFatalError(typeCases.KindRule.getLoc(),
"no cases found for \"" + type.getCXXTypeName() + "\"");
}
if (!typeCases.KindRule) {
assert(!typeCases.Cases.empty());
PrintFatalError(typeCases.Cases.front().getLoc(),
"no kind rule for \"" + type.getCXXTypeName() + "\"");
}
auto var = info.HelperVariable;
std::string subvar = ("sub" + var).str();
// Bind `ctx` for readers.
if (info.IsReader)
Out << " auto &ctx = asImpl().getASTContext();\n";
// Start an object.
Out << " auto &&" << subvar << " = asImpl()."
<< info.MethodPrefix << "Object();\n";
// Read/write the kind property;
TypeKindRule kindRule = typeCases.KindRule;
StringRef kindProperty = kindRule.getKindPropertyName();
PropertyType kindType = kindRule.getKindType();
if (info.IsReader) {
emitReadOfProperty(subvar, kindProperty, kindType);
} else {
// Write the property. Note that this will implicitly read the
// kind into a local variable with the right name.
emitWriteOfProperty(subvar, kindProperty, kindType,
kindRule.getReadCode());
}
// Prepare a ReaderWriterInfo with a helper variable that will use
// the sub-reader/writer.
ReaderWriterInfo subInfo = info;
subInfo.HelperVariable = subvar;
// Switch on the kind.
Out << " switch (" << kindProperty << ") {\n";
for (TypeCase typeCase : typeCases.Cases) {
Out << " case " << type.getCXXTypeName() << "::"
<< typeCase.getCaseName() << ": {\n";
emitPropertiedReaderWriterBody(typeCase, subInfo);
if (!info.IsReader)
Out << " return;\n";
Out << " }\n\n";
}
Out << " }\n"
" llvm_unreachable(\"bad " << kindType.getCXXTypeName()
<< "\");\n";
}
void ASTPropsEmitter::emitBasicReaderWriterFile(const ReaderWriterInfo &info) {
emitDispatcherTemplate(info);
emitPackUnpackOptionalTemplate(info);
emitBasicReaderWriterTemplate(info);
}
/// Emit an .inc file that defines some helper classes for reading
/// basic values.
void clang::EmitClangBasicReader(RecordKeeper &records, raw_ostream &out) {
emitSourceFileHeader("Helper classes for BasicReaders", out);
// Use any property, we won't be using those properties.
auto info = ReaderWriterInfo::forReader<TypeNode>();
ASTPropsEmitter(records, out).emitBasicReaderWriterFile(info);
}
/// Emit an .inc file that defines some helper classes for writing
/// basic values.
void clang::EmitClangBasicWriter(RecordKeeper &records, raw_ostream &out) {
emitSourceFileHeader("Helper classes for BasicWriters", out);
// Use any property, we won't be using those properties.
auto info = ReaderWriterInfo::forWriter<TypeNode>();
ASTPropsEmitter(records, out).emitBasicReaderWriterFile(info);
}