1 | //===-- ClangASTPropsEmitter.cpp - Generate Clang AST properties ----------===// |
---|---|
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 | // This tablegen backend emits code for working with Clang AST properties. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "ASTTableGen.h" |
14 | #include "TableGenBackends.h" |
15 | |
16 | #include "llvm/ADT/Twine.h" |
17 | #include "llvm/TableGen/Error.h" |
18 | #include "llvm/TableGen/Record.h" |
19 | #include "llvm/TableGen/TableGenBackend.h" |
20 | #include <cctype> |
21 | #include <map> |
22 | #include <set> |
23 | #include <string> |
24 | using namespace llvm; |
25 | using namespace clang; |
26 | using namespace clang::tblgen; |
27 | |
28 | static StringRef getReaderResultType(TypeNode _) { return "QualType"; } |
29 | |
30 | namespace { |
31 | |
32 | struct ReaderWriterInfo { |
33 | bool IsReader; |
34 | |
35 | /// The name of the node hierarchy. Not actually sensitive to IsReader, |
36 | /// but useful to cache here anyway. |
37 | StringRef HierarchyName; |
38 | |
39 | /// The suffix on classes: Reader/Writer |
40 | StringRef ClassSuffix; |
41 | |
42 | /// The base name of methods: read/write |
43 | StringRef MethodPrefix; |
44 | |
45 | /// The name of the property helper member: R/W |
46 | StringRef HelperVariable; |
47 | |
48 | /// The result type of methods on the class. |
49 | StringRef ResultType; |
50 | |
51 | template <class NodeClass> |
52 | static ReaderWriterInfo forReader() { |
53 | return ReaderWriterInfo{ |
54 | true, |
55 | NodeClass::getASTHierarchyName(), |
56 | "Reader", |
57 | "read", |
58 | "R", |
59 | getReaderResultType(NodeClass()) |
60 | }; |
61 | } |
62 | |
63 | template <class NodeClass> |
64 | static ReaderWriterInfo forWriter() { |
65 | return ReaderWriterInfo{ |
66 | false, |
67 | NodeClass::getASTHierarchyName(), |
68 | "Writer", |
69 | "write", |
70 | "W", |
71 | "void" |
72 | }; |
73 | } |
74 | }; |
75 | |
76 | struct NodeInfo { |
77 | std::vector<Property> Properties; |
78 | CreationRule Creator = nullptr; |
79 | OverrideRule Override = nullptr; |
80 | ReadHelperRule ReadHelper = nullptr; |
81 | }; |
82 | |
83 | struct CasedTypeInfo { |
84 | TypeKindRule KindRule; |
85 | std::vector<TypeCase> Cases; |
86 | }; |
87 | |
88 | class ASTPropsEmitter { |
89 | raw_ostream &Out; |
90 | const RecordKeeper &Records; |
91 | std::map<HasProperties, NodeInfo> NodeInfos; |
92 | std::vector<PropertyType> AllPropertyTypes; |
93 | std::map<PropertyType, CasedTypeInfo> CasedTypeInfos; |
94 | |
95 | public: |
96 | ASTPropsEmitter(const RecordKeeper &records, raw_ostream &out) |
97 | : Out(out), Records(records) { |
98 | |
99 | // Find all the properties. |
100 | for (Property property : |
101 | records.getAllDerivedDefinitions(PropertyClassName)) { |
102 | HasProperties node = property.getClass(); |
103 | NodeInfos[node].Properties.push_back(x: property); |
104 | } |
105 | |
106 | // Find all the creation rules. |
107 | for (CreationRule creationRule : |
108 | records.getAllDerivedDefinitions(CreationRuleClassName)) { |
109 | HasProperties node = creationRule.getClass(); |
110 | |
111 | auto &info = NodeInfos[node]; |
112 | if (info.Creator) { |
113 | PrintFatalError(ErrorLoc: creationRule.getLoc(), Msg: "multiple creator rules for \""+ |
114 | node.getName() + "\""); |
115 | } |
116 | info.Creator = creationRule; |
117 | } |
118 | |
119 | // Find all the override rules. |
120 | for (OverrideRule overrideRule : |
121 | records.getAllDerivedDefinitions(OverrideRuleClassName)) { |
122 | HasProperties node = overrideRule.getClass(); |
123 | |
124 | auto &info = NodeInfos[node]; |
125 | if (info.Override) { |
126 | PrintFatalError(ErrorLoc: overrideRule.getLoc(), |
127 | Msg: "multiple override rules for \""+ node.getName() + |
128 | "\""); |
129 | } |
130 | info.Override = overrideRule; |
131 | } |
132 | |
133 | // Find all the write helper rules. |
134 | for (ReadHelperRule helperRule : |
135 | records.getAllDerivedDefinitions(ReadHelperRuleClassName)) { |
136 | HasProperties node = helperRule.getClass(); |
137 | |
138 | auto &info = NodeInfos[node]; |
139 | if (info.ReadHelper) { |
140 | PrintFatalError(ErrorLoc: helperRule.getLoc(), |
141 | Msg: "multiple write helper rules for \""+ node.getName() + |
142 | "\""); |
143 | } |
144 | info.ReadHelper = helperRule; |
145 | } |
146 | |
147 | // Find all the concrete property types. |
148 | for (PropertyType type : |
149 | records.getAllDerivedDefinitions(PropertyTypeClassName)) { |
150 | // Ignore generic specializations; they're generally not useful when |
151 | // emitting basic emitters etc. |
152 | if (type.isGenericSpecialization()) |
153 | continue; |
154 | |
155 | AllPropertyTypes.push_back(x: type); |
156 | } |
157 | |
158 | // Find all the type kind rules. |
159 | for (TypeKindRule kindRule : |
160 | records.getAllDerivedDefinitions(TypeKindClassName)) { |
161 | PropertyType type = kindRule.getParentType(); |
162 | auto &info = CasedTypeInfos[type]; |
163 | if (info.KindRule) { |
164 | PrintFatalError(ErrorLoc: kindRule.getLoc(), Msg: "multiple kind rules for \""+ |
165 | type.getCXXTypeName() + "\""); |
166 | } |
167 | info.KindRule = kindRule; |
168 | } |
169 | |
170 | // Find all the type cases. |
171 | for (TypeCase typeCase : |
172 | records.getAllDerivedDefinitions(TypeCaseClassName)) { |
173 | CasedTypeInfos[typeCase.getParentType()].Cases.push_back(x: typeCase); |
174 | } |
175 | |
176 | Validator(*this).validate(); |
177 | } |
178 | |
179 | void visitAllProperties(HasProperties derived, const NodeInfo &derivedInfo, |
180 | function_ref<void(Property)> visit) { |
181 | std::set<StringRef> ignoredProperties; |
182 | |
183 | auto overrideRule = derivedInfo.Override; |
184 | if (overrideRule) { |
185 | auto list = overrideRule.getIgnoredProperties(); |
186 | ignoredProperties.insert(first: list.begin(), last: list.end()); |
187 | } |
188 | |
189 | // TODO: we should sort the properties in various ways |
190 | // - put arrays at the end to enable abbreviations |
191 | // - put conditional properties after properties used in the condition |
192 | |
193 | visitAllNodesWithInfo(derivedNode: derived, derivedNodeInfo: derivedInfo, |
194 | visit: [&](HasProperties node, const NodeInfo &info) { |
195 | for (Property prop : info.Properties) { |
196 | if (ignoredProperties.count(x: prop.getName())) |
197 | continue; |
198 | |
199 | visit(prop); |
200 | } |
201 | }); |
202 | } |
203 | |
204 | void visitAllNodesWithInfo( |
205 | HasProperties derivedNode, const NodeInfo &derivedNodeInfo, |
206 | function_ref<void(HasProperties node, const NodeInfo &info)> visit) { |
207 | visit(derivedNode, derivedNodeInfo); |
208 | |
209 | // Also walk the bases if appropriate. |
210 | if (ASTNode base = derivedNode.getAs<ASTNode>()) { |
211 | for (base = base.getBase(); base; base = base.getBase()) { |
212 | auto it = NodeInfos.find(x: base); |
213 | |
214 | // Ignore intermediate nodes that don't add interesting properties. |
215 | if (it == NodeInfos.end()) |
216 | continue; |
217 | auto &baseInfo = it->second; |
218 | |
219 | visit(base, baseInfo); |
220 | } |
221 | } |
222 | } |
223 | |
224 | template <class NodeClass> void emitNodeReaderClass() { |
225 | auto info = ReaderWriterInfo::forReader<NodeClass>(); |
226 | emitNodeReaderWriterClass<NodeClass>(info); |
227 | } |
228 | |
229 | template <class NodeClass> void emitNodeWriterClass() { |
230 | auto info = ReaderWriterInfo::forWriter<NodeClass>(); |
231 | emitNodeReaderWriterClass<NodeClass>(info); |
232 | } |
233 | |
234 | template <class NodeClass> |
235 | void emitNodeReaderWriterClass(const ReaderWriterInfo &info); |
236 | |
237 | template <class NodeClass> |
238 | void emitNodeReaderWriterMethod(NodeClass node, const ReaderWriterInfo &info); |
239 | |
240 | void emitPropertiedReaderWriterBody(HasProperties node, |
241 | const ReaderWriterInfo &info); |
242 | |
243 | void emitReadOfProperty(StringRef readerName, Property property); |
244 | void emitReadOfProperty(StringRef readerName, StringRef name, |
245 | PropertyType type, StringRef condition = ""); |
246 | |
247 | void emitWriteOfProperty(StringRef writerName, Property property); |
248 | void emitWriteOfProperty(StringRef writerName, StringRef name, |
249 | PropertyType type, StringRef readCode, |
250 | StringRef condition = ""); |
251 | |
252 | void emitBasicReaderWriterFile(const ReaderWriterInfo &info); |
253 | void emitDispatcherTemplate(const ReaderWriterInfo &info); |
254 | void emitPackUnpackOptionalTemplate(const ReaderWriterInfo &info); |
255 | void emitBasicReaderWriterTemplate(const ReaderWriterInfo &info); |
256 | |
257 | void emitCasedReaderWriterMethodBody(PropertyType type, |
258 | const CasedTypeInfo &typeCases, |
259 | const ReaderWriterInfo &info); |
260 | |
261 | private: |
262 | class Validator { |
263 | ASTPropsEmitter &Emitter; |
264 | std::set<HasProperties> ValidatedNodes; |
265 | |
266 | public: |
267 | Validator(ASTPropsEmitter &emitter) : Emitter(emitter) {} |
268 | void validate(); |
269 | |
270 | private: |
271 | void validateNode(HasProperties node, const NodeInfo &nodeInfo); |
272 | void validateType(PropertyType type, WrappedRecord context); |
273 | }; |
274 | }; |
275 | |
276 | } // end anonymous namespace |
277 | |
278 | void ASTPropsEmitter::Validator::validate() { |
279 | for (auto &entry : Emitter.NodeInfos) { |
280 | validateNode(node: entry.first, nodeInfo: entry.second); |
281 | } |
282 | |
283 | if (ErrorsPrinted > 0) { |
284 | PrintFatalError(Msg: "property validation failed"); |
285 | } |
286 | } |
287 | |
288 | void ASTPropsEmitter::Validator::validateNode(HasProperties derivedNode, |
289 | const NodeInfo &derivedNodeInfo) { |
290 | if (!ValidatedNodes.insert(x: derivedNode).second) return; |
291 | |
292 | // A map from property name to property. |
293 | std::map<StringRef, Property> allProperties; |
294 | |
295 | Emitter.visitAllNodesWithInfo(derivedNode, derivedNodeInfo, |
296 | visit: [&](HasProperties node, |
297 | const NodeInfo &nodeInfo) { |
298 | for (Property property : nodeInfo.Properties) { |
299 | validateType(type: property.getType(), context: property); |
300 | |
301 | auto result = allProperties.insert( |
302 | x: std::make_pair(x: property.getName(), y&: property)); |
303 | |
304 | // Diagnose non-unique properties. |
305 | if (!result.second) { |
306 | // The existing property is more likely to be associated with a |
307 | // derived node, so use it as the error. |
308 | Property existingProperty = result.first->second; |
309 | PrintError(ErrorLoc: existingProperty.getLoc(), |
310 | Msg: "multiple properties named \""+ property.getName() |
311 | + "\" in hierarchy of "+ derivedNode.getName()); |
312 | PrintNote(NoteLoc: property.getLoc(), Msg: "existing property"); |
313 | } |
314 | } |
315 | }); |
316 | } |
317 | |
318 | void ASTPropsEmitter::Validator::validateType(PropertyType type, |
319 | WrappedRecord context) { |
320 | if (!type.isGenericSpecialization()) { |
321 | if (type.getCXXTypeName() == "") { |
322 | PrintError(ErrorLoc: type.getLoc(), |
323 | Msg: "type is not generic but has no C++ type name"); |
324 | if (context) PrintNote(NoteLoc: context.getLoc(), Msg: "type used here"); |
325 | } |
326 | } else if (auto eltType = type.getArrayElementType()) { |
327 | validateType(type: eltType, context); |
328 | } else if (auto valueType = type.getOptionalElementType()) { |
329 | validateType(type: valueType, context); |
330 | |
331 | if (valueType.getPackOptionalCode().empty()) { |
332 | PrintError(ErrorLoc: valueType.getLoc(), |
333 | Msg: "type doesn't provide optional-packing code"); |
334 | if (context) PrintNote(NoteLoc: context.getLoc(), Msg: "type used here"); |
335 | } else if (valueType.getUnpackOptionalCode().empty()) { |
336 | PrintError(ErrorLoc: valueType.getLoc(), |
337 | Msg: "type doesn't provide optional-unpacking code"); |
338 | if (context) PrintNote(NoteLoc: context.getLoc(), Msg: "type used here"); |
339 | } |
340 | } else { |
341 | PrintError(ErrorLoc: type.getLoc(), Msg: "unknown generic property type"); |
342 | if (context) PrintNote(NoteLoc: context.getLoc(), Msg: "type used here"); |
343 | } |
344 | } |
345 | |
346 | /****************************************************************************/ |
347 | /**************************** AST READER/WRITERS ****************************/ |
348 | /****************************************************************************/ |
349 | |
350 | template <class NodeClass> |
351 | void ASTPropsEmitter::emitNodeReaderWriterClass(const ReaderWriterInfo &info) { |
352 | StringRef suffix = info.ClassSuffix; |
353 | StringRef var = info.HelperVariable; |
354 | |
355 | // Enter the class declaration. |
356 | Out << "template <class Property"<< suffix << ">\n" |
357 | "class Abstract"<< info.HierarchyName << suffix << " {\n" |
358 | "public:\n" |
359 | " Property"<< suffix << " &"<< var << ";\n\n"; |
360 | |
361 | // Emit the constructor. |
362 | Out << " Abstract"<< info.HierarchyName << suffix |
363 | << "(Property"<< suffix << " &"<< var << ") : " |
364 | << var << "("<< var << ") {}\n\n"; |
365 | |
366 | // Emit a method that dispatches on a kind to the appropriate node-specific |
367 | // method. |
368 | Out << " "<< info.ResultType << " "<< info.MethodPrefix << "("; |
369 | if (info.IsReader) |
370 | Out << NodeClass::getASTIdTypeName() << " kind"; |
371 | else |
372 | Out << "const "<< info.HierarchyName << " *node"; |
373 | Out << ") {\n" |
374 | " switch ("; |
375 | if (info.IsReader) |
376 | Out << "kind"; |
377 | else |
378 | Out << "node->"<< NodeClass::getASTIdAccessorName() << "()"; |
379 | Out << ") {\n"; |
380 | visitASTNodeHierarchy<NodeClass>(Records, [&](NodeClass node, NodeClass _) { |
381 | if (node.isAbstract()) return; |
382 | Out << " case "<< info.HierarchyName << "::"<< node.getId() << ":\n" |
383 | " return "<< info.MethodPrefix << node.getClassName() << "("; |
384 | if (!info.IsReader) |
385 | Out << "static_cast<const "<< node.getClassName() |
386 | << " *>(node)"; |
387 | Out << ");\n"; |
388 | }); |
389 | Out << " }\n" |
390 | " llvm_unreachable(\"bad kind\");\n" |
391 | " }\n\n"; |
392 | |
393 | // Emit node-specific methods for all the concrete nodes. |
394 | visitASTNodeHierarchy<NodeClass>(Records, |
395 | [&](NodeClass node, NodeClass base) { |
396 | if (node.isAbstract()) return; |
397 | emitNodeReaderWriterMethod(node, info); |
398 | }); |
399 | |
400 | // Finish the class. |
401 | Out << "};\n\n"; |
402 | } |
403 | |
404 | /// Emit a reader method for the given concrete AST node class. |
405 | template <class NodeClass> |
406 | void ASTPropsEmitter::emitNodeReaderWriterMethod(NodeClass node, |
407 | const ReaderWriterInfo &info) { |
408 | // Declare and start the method. |
409 | Out << " "<< info.ResultType << " " |
410 | << info.MethodPrefix << node.getClassName() << "("; |
411 | if (!info.IsReader) |
412 | Out << "const "<< node.getClassName() << " *node"; |
413 | Out << ") {\n"; |
414 | if (info.IsReader) |
415 | Out << " auto &ctx = "<< info.HelperVariable << ".getASTContext();\n"; |
416 | |
417 | emitPropertiedReaderWriterBody(node, info); |
418 | |
419 | // Finish the method declaration. |
420 | Out << " }\n\n"; |
421 | } |
422 | |
423 | void ASTPropsEmitter::emitPropertiedReaderWriterBody(HasProperties node, |
424 | const ReaderWriterInfo &info) { |
425 | // Find the information for this node. |
426 | auto it = NodeInfos.find(x: node); |
427 | if (it == NodeInfos.end()) |
428 | PrintFatalError(ErrorLoc: node.getLoc(), |
429 | Msg: "no information about how to deserialize \"" |
430 | + node.getName() + "\""); |
431 | auto &nodeInfo = it->second; |
432 | |
433 | StringRef creationCode; |
434 | if (info.IsReader) { |
435 | // We should have a creation rule. |
436 | if (!nodeInfo.Creator) |
437 | PrintFatalError(ErrorLoc: node.getLoc(), |
438 | Msg: "no "CreationRuleClassName " for \"" |
439 | + node.getName() + "\""); |
440 | |
441 | creationCode = nodeInfo.Creator.getCreationCode(); |
442 | } |
443 | |
444 | // Emit the ReadHelper code, if present. |
445 | if (!info.IsReader && nodeInfo.ReadHelper) { |
446 | Out << " "<< nodeInfo.ReadHelper.getHelperCode() << "\n"; |
447 | } |
448 | |
449 | // Emit code to read all the properties. |
450 | visitAllProperties(derived: node, derivedInfo: nodeInfo, visit: [&](Property prop) { |
451 | // Verify that the creation code refers to this property. |
452 | if (info.IsReader && !creationCode.contains(Other: prop.getName())) |
453 | PrintFatalError(ErrorLoc: nodeInfo.Creator.getLoc(), |
454 | Msg: "creation code for "+ node.getName() |
455 | + " doesn't refer to property \"" |
456 | + prop.getName() + "\""); |
457 | |
458 | // Emit code to read or write this property. |
459 | if (info.IsReader) |
460 | emitReadOfProperty(readerName: info.HelperVariable, property: prop); |
461 | else |
462 | emitWriteOfProperty(writerName: info.HelperVariable, property: prop); |
463 | }); |
464 | |
465 | // Emit the final creation code. |
466 | if (info.IsReader) |
467 | Out << " "<< creationCode << "\n"; |
468 | } |
469 | |
470 | static void emitBasicReaderWriterMethodSuffix(raw_ostream &out, |
471 | PropertyType type, |
472 | bool isForRead) { |
473 | if (!type.isGenericSpecialization()) { |
474 | out << type.getAbstractTypeName(); |
475 | } else if (auto eltType = type.getArrayElementType()) { |
476 | out << "Array"; |
477 | // We only include an explicit template argument for reads so that |
478 | // we don't cause spurious const mismatches. |
479 | if (isForRead) { |
480 | out << "<"; |
481 | eltType.emitCXXValueTypeName(forRead: isForRead, out); |
482 | out << ">"; |
483 | } |
484 | } else if (auto valueType = type.getOptionalElementType()) { |
485 | out << "Optional"; |
486 | // We only include an explicit template argument for reads so that |
487 | // we don't cause spurious const mismatches. |
488 | if (isForRead) { |
489 | out << "<"; |
490 | valueType.emitCXXValueTypeName(forRead: isForRead, out); |
491 | out << ">"; |
492 | } |
493 | } else { |
494 | PrintFatalError(ErrorLoc: type.getLoc(), Msg: "unexpected generic property type"); |
495 | } |
496 | } |
497 | |
498 | /// Emit code to read the given property in a node-reader method. |
499 | void ASTPropsEmitter::emitReadOfProperty(StringRef readerName, |
500 | Property property) { |
501 | emitReadOfProperty(readerName, name: property.getName(), type: property.getType(), |
502 | condition: property.getCondition()); |
503 | } |
504 | |
505 | void ASTPropsEmitter::emitReadOfProperty(StringRef readerName, |
506 | StringRef name, |
507 | PropertyType type, |
508 | StringRef condition) { |
509 | // Declare all the necessary buffers. |
510 | auto bufferTypes = type.getBufferElementTypes(); |
511 | for (size_t i = 0, e = bufferTypes.size(); i != e; ++i) { |
512 | Out << " llvm::SmallVector<"; |
513 | PropertyType(bufferTypes[i]).emitCXXValueTypeName(/*for read*/ forRead: true, out&: Out); |
514 | Out << ", 8> "<< name << "_buffer_"<< i << ";\n"; |
515 | } |
516 | |
517 | // T prop = R.find("prop").read##ValueType(buffers...); |
518 | // We intentionally ignore shouldPassByReference here: we're going to |
519 | // get a pr-value back from read(), and we should be able to forward |
520 | // that in the creation rule. |
521 | Out << " "; |
522 | if (!condition.empty()) |
523 | Out << "std::optional<"; |
524 | type.emitCXXValueTypeName(forRead: true, out&: Out); |
525 | if (!condition.empty()) Out << ">"; |
526 | Out << " "<< name; |
527 | |
528 | if (condition.empty()) { |
529 | Out << " = "; |
530 | } else { |
531 | Out << ";\n" |
532 | " if ("<< condition << ") {\n" |
533 | " "<< name << ".emplace("; |
534 | } |
535 | |
536 | Out << readerName << ".find(\""<< name << "\")." |
537 | << (type.isGenericSpecialization() ? "template ": "") << "read"; |
538 | emitBasicReaderWriterMethodSuffix(out&: Out, type, /*for read*/ isForRead: true); |
539 | Out << "("; |
540 | for (size_t i = 0, e = bufferTypes.size(); i != e; ++i) { |
541 | Out << (i > 0 ? ", ": "") << name << "_buffer_"<< i; |
542 | } |
543 | Out << ")"; |
544 | |
545 | if (condition.empty()) { |
546 | Out << ";\n"; |
547 | } else { |
548 | Out << ");\n" |
549 | " }\n"; |
550 | } |
551 | } |
552 | |
553 | /// Emit code to write the given property in a node-writer method. |
554 | void ASTPropsEmitter::emitWriteOfProperty(StringRef writerName, |
555 | Property property) { |
556 | emitWriteOfProperty(writerName, name: property.getName(), type: property.getType(), |
557 | readCode: property.getReadCode(), condition: property.getCondition()); |
558 | } |
559 | |
560 | void ASTPropsEmitter::emitWriteOfProperty(StringRef writerName, |
561 | StringRef name, |
562 | PropertyType type, |
563 | StringRef readCode, |
564 | StringRef condition) { |
565 | if (!condition.empty()) { |
566 | Out << " if ("<< condition << ") {\n"; |
567 | } |
568 | |
569 | // Focus down to the property: |
570 | // T prop = <READ>; |
571 | // W.find("prop").write##ValueType(prop); |
572 | Out << " "; |
573 | type.emitCXXValueTypeName(forRead: false, out&: Out); |
574 | Out << " "<< name << " = ("<< readCode << ");\n" |
575 | " "<< writerName << ".find(\""<< name << "\").write"; |
576 | emitBasicReaderWriterMethodSuffix(out&: Out, type, /*for read*/ isForRead: false); |
577 | Out << "("<< name << ");\n"; |
578 | |
579 | if (!condition.empty()) { |
580 | Out << " }\n"; |
581 | } |
582 | } |
583 | |
584 | /// Emit an .inc file that defines the AbstractFooReader class |
585 | /// for the given AST class hierarchy. |
586 | template <class NodeClass> |
587 | static void emitASTReader(const RecordKeeper &records, raw_ostream &out, |
588 | StringRef description) { |
589 | emitSourceFileHeader(Desc: description, OS&: out, Record: records); |
590 | |
591 | ASTPropsEmitter(records, out).emitNodeReaderClass<NodeClass>(); |
592 | } |
593 | |
594 | void clang::EmitClangTypeReader(const RecordKeeper &records, raw_ostream &out) { |
595 | emitASTReader<TypeNode>(records, out, description: "A CRTP reader for Clang Type nodes"); |
596 | } |
597 | |
598 | /// Emit an .inc file that defines the AbstractFooWriter class |
599 | /// for the given AST class hierarchy. |
600 | template <class NodeClass> |
601 | static void emitASTWriter(const RecordKeeper &records, raw_ostream &out, |
602 | StringRef description) { |
603 | emitSourceFileHeader(Desc: description, OS&: out, Record: records); |
604 | |
605 | ASTPropsEmitter(records, out).emitNodeWriterClass<NodeClass>(); |
606 | } |
607 | |
608 | void clang::EmitClangTypeWriter(const RecordKeeper &records, raw_ostream &out) { |
609 | emitASTWriter<TypeNode>(records, out, description: "A CRTP writer for Clang Type nodes"); |
610 | } |
611 | |
612 | /****************************************************************************/ |
613 | /*************************** BASIC READER/WRITERS ***************************/ |
614 | /****************************************************************************/ |
615 | |
616 | void |
617 | ASTPropsEmitter::emitDispatcherTemplate(const ReaderWriterInfo &info) { |
618 | // Declare the {Read,Write}Dispatcher template. |
619 | StringRef dispatcherPrefix = (info.IsReader ? "Read": "Write"); |
620 | Out << "template <class ValueType>\n" |
621 | "struct "<< dispatcherPrefix << "Dispatcher;\n"; |
622 | |
623 | // Declare a specific specialization of the dispatcher template. |
624 | auto declareSpecialization = |
625 | [&](StringRef specializationParameters, |
626 | const Twine &cxxTypeName, |
627 | StringRef methodSuffix) { |
628 | StringRef var = info.HelperVariable; |
629 | Out << "template "<< specializationParameters << "\n" |
630 | "struct "<< dispatcherPrefix << "Dispatcher<" |
631 | << cxxTypeName << "> {\n"; |
632 | Out << " template <class Basic"<< info.ClassSuffix << ", class... Args>\n" |
633 | " static "<< (info.IsReader ? cxxTypeName : "void") << " " |
634 | << info.MethodPrefix |
635 | << "(Basic"<< info.ClassSuffix << " &"<< var |
636 | << ", Args &&... args) {\n" |
637 | " return "<< var << "." |
638 | << info.MethodPrefix << methodSuffix |
639 | << "(std::forward<Args>(args)...);\n" |
640 | " }\n" |
641 | "};\n"; |
642 | }; |
643 | |
644 | // Declare explicit specializations for each of the concrete types. |
645 | for (PropertyType type : AllPropertyTypes) { |
646 | declareSpecialization("<>", |
647 | type.getCXXTypeName(), |
648 | type.getAbstractTypeName()); |
649 | // Also declare a specialization for the const type when appropriate. |
650 | if (!info.IsReader && type.isConstWhenWriting()) { |
651 | declareSpecialization("<>", |
652 | "const "+ type.getCXXTypeName(), |
653 | type.getAbstractTypeName()); |
654 | } |
655 | } |
656 | // Declare partial specializations for ArrayRef and Optional. |
657 | declareSpecialization("<class T>", |
658 | "llvm::ArrayRef<T>", |
659 | "Array"); |
660 | declareSpecialization("<class T>", "std::optional<T>", "Optional"); |
661 | Out << "\n"; |
662 | } |
663 | |
664 | void |
665 | ASTPropsEmitter::emitPackUnpackOptionalTemplate(const ReaderWriterInfo &info) { |
666 | StringRef classPrefix = (info.IsReader ? "Unpack": "Pack"); |
667 | StringRef methodName = (info.IsReader ? "unpack": "pack"); |
668 | |
669 | // Declare the {Pack,Unpack}OptionalValue template. |
670 | Out << "template <class ValueType>\n" |
671 | "struct "<< classPrefix << "OptionalValue;\n"; |
672 | |
673 | auto declareSpecialization = [&](const Twine &typeName, StringRef code) { |
674 | Out << "template <>\n" |
675 | "struct " |
676 | << classPrefix << "OptionalValue<"<< typeName |
677 | << "> {\n" |
678 | " static " |
679 | << (info.IsReader ? "std::optional<": "") << typeName |
680 | << (info.IsReader ? "> ": " ") << methodName << "(" |
681 | << (info.IsReader ? "": "std::optional<") << typeName |
682 | << (info.IsReader ? "": ">") |
683 | << " value) {\n" |
684 | " return " |
685 | << code |
686 | << ";\n" |
687 | " }\n" |
688 | "};\n"; |
689 | }; |
690 | |
691 | for (PropertyType type : AllPropertyTypes) { |
692 | StringRef code = (info.IsReader ? type.getUnpackOptionalCode() |
693 | : type.getPackOptionalCode()); |
694 | if (code.empty()) continue; |
695 | |
696 | StringRef typeName = type.getCXXTypeName(); |
697 | declareSpecialization(typeName, code); |
698 | if (type.isConstWhenWriting() && !info.IsReader) |
699 | declareSpecialization("const "+ typeName, code); |
700 | } |
701 | Out << "\n"; |
702 | } |
703 | |
704 | void |
705 | ASTPropsEmitter::emitBasicReaderWriterTemplate(const ReaderWriterInfo &info) { |
706 | // Emit the Basic{Reader,Writer}Base template. |
707 | Out << "template <class Impl>\n" |
708 | "class Basic"<< info.ClassSuffix << "Base {\n"; |
709 | Out << " ASTContext &C;\n"; |
710 | Out << "protected:\n" |
711 | " Basic" |
712 | << info.ClassSuffix << "Base"<< ( "(ASTContext &ctx) : C(ctx)") |
713 | << " {}\n" |
714 | "public:\n"; |
715 | Out << " ASTContext &getASTContext() { return C; }\n"; |
716 | Out << " Impl &asImpl() { return static_cast<Impl&>(*this); }\n"; |
717 | |
718 | auto enterReaderWriterMethod = [&](StringRef cxxTypeName, |
719 | StringRef abstractTypeName, |
720 | bool shouldPassByReference, |
721 | bool constWhenWriting, |
722 | StringRef paramName) { |
723 | Out << " "<< (info.IsReader ? cxxTypeName : "void") |
724 | << " "<< info.MethodPrefix << abstractTypeName << "("; |
725 | if (!info.IsReader) |
726 | Out << (shouldPassByReference || constWhenWriting ? "const ": "") |
727 | << cxxTypeName |
728 | << (shouldPassByReference ? " &": "") << " "<< paramName; |
729 | Out << ") {\n"; |
730 | }; |
731 | |
732 | // Emit {read,write}ValueType methods for all the enum and subclass types |
733 | // that default to using the integer/base-class implementations. |
734 | for (PropertyType type : AllPropertyTypes) { |
735 | auto enterMethod = [&](StringRef paramName) { |
736 | enterReaderWriterMethod(type.getCXXTypeName(), |
737 | type.getAbstractTypeName(), |
738 | type.shouldPassByReference(), |
739 | type.isConstWhenWriting(), |
740 | paramName); |
741 | }; |
742 | auto exitMethod = [&] { |
743 | Out << " }\n"; |
744 | }; |
745 | |
746 | // Handled cased types. |
747 | auto casedIter = CasedTypeInfos.find(x: type); |
748 | if (casedIter != CasedTypeInfos.end()) { |
749 | enterMethod("node"); |
750 | emitCasedReaderWriterMethodBody(type, typeCases: casedIter->second, info); |
751 | exitMethod(); |
752 | |
753 | } else if (type.isEnum()) { |
754 | enterMethod("value"); |
755 | if (info.IsReader) |
756 | Out << " return asImpl().template readEnum<" |
757 | << type.getCXXTypeName() << ">();\n"; |
758 | else |
759 | Out << " asImpl().writeEnum(value);\n"; |
760 | exitMethod(); |
761 | |
762 | } else if (PropertyType superclass = type.getSuperclassType()) { |
763 | enterMethod("value"); |
764 | if (info.IsReader) |
765 | Out << " return cast_or_null<"<< type.getSubclassClassName() |
766 | << ">(asImpl().read" |
767 | << superclass.getAbstractTypeName() |
768 | << "());\n"; |
769 | else |
770 | Out << " asImpl().write"<< superclass.getAbstractTypeName() |
771 | << "(value);\n"; |
772 | exitMethod(); |
773 | |
774 | } else { |
775 | // The other types can't be handled as trivially. |
776 | } |
777 | } |
778 | Out << "};\n\n"; |
779 | } |
780 | |
781 | void ASTPropsEmitter::emitCasedReaderWriterMethodBody(PropertyType type, |
782 | const CasedTypeInfo &typeCases, |
783 | const ReaderWriterInfo &info) { |
784 | if (typeCases.Cases.empty()) { |
785 | assert(typeCases.KindRule); |
786 | PrintFatalError(ErrorLoc: typeCases.KindRule.getLoc(), |
787 | Msg: "no cases found for \""+ type.getCXXTypeName() + "\""); |
788 | } |
789 | if (!typeCases.KindRule) { |
790 | assert(!typeCases.Cases.empty()); |
791 | PrintFatalError(ErrorLoc: typeCases.Cases.front().getLoc(), |
792 | Msg: "no kind rule for \""+ type.getCXXTypeName() + "\""); |
793 | } |
794 | |
795 | auto var = info.HelperVariable; |
796 | std::string subvar = ("sub"+ var).str(); |
797 | |
798 | // Bind `ctx` for readers. |
799 | if (info.IsReader) |
800 | Out << " auto &ctx = asImpl().getASTContext();\n"; |
801 | |
802 | // Start an object. |
803 | Out << " auto &&"<< subvar << " = asImpl()." |
804 | << info.MethodPrefix << "Object();\n"; |
805 | |
806 | // Read/write the kind property; |
807 | TypeKindRule kindRule = typeCases.KindRule; |
808 | StringRef kindProperty = kindRule.getKindPropertyName(); |
809 | PropertyType kindType = kindRule.getKindType(); |
810 | if (info.IsReader) { |
811 | emitReadOfProperty(readerName: subvar, name: kindProperty, type: kindType); |
812 | } else { |
813 | // Write the property. Note that this will implicitly read the |
814 | // kind into a local variable with the right name. |
815 | emitWriteOfProperty(writerName: subvar, name: kindProperty, type: kindType, |
816 | readCode: kindRule.getReadCode()); |
817 | } |
818 | |
819 | // Prepare a ReaderWriterInfo with a helper variable that will use |
820 | // the sub-reader/writer. |
821 | ReaderWriterInfo subInfo = info; |
822 | subInfo.HelperVariable = subvar; |
823 | |
824 | // Switch on the kind. |
825 | Out << " switch ("<< kindProperty << ") {\n"; |
826 | for (TypeCase typeCase : typeCases.Cases) { |
827 | Out << " case "<< type.getCXXTypeName() << "::" |
828 | << typeCase.getCaseName() << ": {\n"; |
829 | emitPropertiedReaderWriterBody(node: typeCase, info: subInfo); |
830 | if (!info.IsReader) |
831 | Out << " return;\n"; |
832 | Out << " }\n\n"; |
833 | } |
834 | Out << " }\n" |
835 | " llvm_unreachable(\"bad "<< kindType.getCXXTypeName() |
836 | << "\");\n"; |
837 | } |
838 | |
839 | void ASTPropsEmitter::emitBasicReaderWriterFile(const ReaderWriterInfo &info) { |
840 | emitDispatcherTemplate(info); |
841 | emitPackUnpackOptionalTemplate(info); |
842 | emitBasicReaderWriterTemplate(info); |
843 | } |
844 | |
845 | /// Emit an .inc file that defines some helper classes for reading |
846 | /// basic values. |
847 | void clang::EmitClangBasicReader(const RecordKeeper &records, |
848 | raw_ostream &out) { |
849 | emitSourceFileHeader(Desc: "Helper classes for BasicReaders", OS&: out, Record: records); |
850 | |
851 | // Use any property, we won't be using those properties. |
852 | auto info = ReaderWriterInfo::forReader<TypeNode>(); |
853 | ASTPropsEmitter(records, out).emitBasicReaderWriterFile(info); |
854 | } |
855 | |
856 | /// Emit an .inc file that defines some helper classes for writing |
857 | /// basic values. |
858 | void clang::EmitClangBasicWriter(const RecordKeeper &records, |
859 | raw_ostream &out) { |
860 | emitSourceFileHeader(Desc: "Helper classes for BasicWriters", OS&: out, Record: records); |
861 | |
862 | // Use any property, we won't be using those properties. |
863 | auto info = ReaderWriterInfo::forWriter<TypeNode>(); |
864 | ASTPropsEmitter(records, out).emitBasicReaderWriterFile(info); |
865 | } |
866 |
Definitions
- getReaderResultType
- ReaderWriterInfo
- forReader
- forWriter
- NodeInfo
- CasedTypeInfo
- ASTPropsEmitter
- ASTPropsEmitter
- visitAllProperties
- visitAllNodesWithInfo
- emitNodeReaderClass
- emitNodeWriterClass
- Validator
- Validator
- validate
- validateNode
- validateType
- emitNodeReaderWriterClass
- emitNodeReaderWriterMethod
- emitPropertiedReaderWriterBody
- emitBasicReaderWriterMethodSuffix
- emitReadOfProperty
- emitReadOfProperty
- emitWriteOfProperty
- emitWriteOfProperty
- emitASTReader
- EmitClangTypeReader
- emitASTWriter
- EmitClangTypeWriter
- emitDispatcherTemplate
- emitPackUnpackOptionalTemplate
- emitBasicReaderWriterTemplate
- emitCasedReaderWriterMethodBody
- emitBasicReaderWriterFile
- EmitClangBasicReader
Learn to use CMake with our Intro Training
Find out more