ClangDiagnosticsEmitter.cpp source code [clang_source_code/utils/TableGen/ClangDiagnosticsEmitter.cpp]

1	//=- ClangDiagnosticsEmitter.cpp - Generate Clang diagnostics tables -- 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	// These tablegen backends emit Clang diagnostics tables.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#include "llvm/ADT/DenseSet.h"
14	#include "llvm/ADT/Optional.h"
15	#include "llvm/ADT/PointerUnion.h"
16	#include "llvm/ADT/STLExtras.h"
17	#include "llvm/ADT/SmallPtrSet.h"
18	#include "llvm/ADT/SmallString.h"
19	#include "llvm/ADT/SmallVector.h"
20	#include "llvm/ADT/StringMap.h"
21	#include "llvm/ADT/Twine.h"
22	#include "llvm/Support/Casting.h"
23	#include "llvm/TableGen/Error.h"
24	#include "llvm/TableGen/Record.h"
25	#include "llvm/TableGen/StringToOffsetTable.h"
26	#include "llvm/TableGen/TableGenBackend.h"
27	#include <algorithm>
28	#include <cctype>
29	#include <functional>
30	#include <map>
31	#include <set>
32	using namespace llvm;
33
34	//===----------------------------------------------------------------------===//
35	// Diagnostic category computation code.
36	//===----------------------------------------------------------------------===//
37
38	namespace {
39	class DiagGroupParentMap {
40	RecordKeeper &Records;
41	std::map<const Record, std::vector<Record> > Mapping;
42	public:
43	DiagGroupParentMap(RecordKeeper &records) : Records(records) {
44	std::vector<Record*> DiagGroups
45	= Records.getAllDerivedDefinitions("DiagGroup");
46	for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
47	std::vector<Record*> SubGroups =
48	DiagGroups[i]->getValueAsListOfDefs("SubGroups");
49	for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
50	Mapping[SubGroups[j]].push_back(DiagGroups[i]);
51	}
52	}
53
54	const std::vector<Record> &getParents(const Record Group) {
55	return Mapping[Group];
56	}
57	};
58	} // end anonymous namespace.
59
60	static std::string
61	getCategoryFromDiagGroup(const Record *Group,
62	DiagGroupParentMap &DiagGroupParents) {
63	// If the DiagGroup has a category, return it.
64	std::string CatName = Group->getValueAsString("CategoryName");
65	if (!CatName.empty()) return CatName;
66
67	// The diag group may the subgroup of one or more other diagnostic groups,
68	// check these for a category as well.
69	const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
70	for (unsigned i = 0, e = Parents.size(); i != e; ++i) {
71	CatName = getCategoryFromDiagGroup(Parents[i], DiagGroupParents);
72	if (!CatName.empty()) return CatName;
73	}
74	return "";
75	}
76
77	/// getDiagnosticCategory - Return the category that the specified diagnostic
78	/// lives in.
79	static std::string getDiagnosticCategory(const Record *R,
80	DiagGroupParentMap &DiagGroupParents) {
81	// If the diagnostic is in a group, and that group has a category, use it.
82	if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
83	// Check the diagnostic's diag group for a category.
84	std::string CatName = getCategoryFromDiagGroup(Group->getDef(),
85	DiagGroupParents);
86	if (!CatName.empty()) return CatName;
87	}
88
89	// If the diagnostic itself has a category, get it.
90	return R->getValueAsString("CategoryName");
91	}
92
93	namespace {
94	class DiagCategoryIDMap {
95	RecordKeeper &Records;
96	StringMap<unsigned> CategoryIDs;
97	std::vector<std::string> CategoryStrings;
98	public:
99	DiagCategoryIDMap(RecordKeeper &records) : Records(records) {
100	DiagGroupParentMap ParentInfo(Records);
101
102	// The zero'th category is "".
103	CategoryStrings.push_back("");
104	CategoryIDs[""] = 0;
105
106	std::vector<Record*> Diags =
107	Records.getAllDerivedDefinitions("Diagnostic");
108	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
109	std::string Category = getDiagnosticCategory(Diags[i], ParentInfo);
110	if (Category.empty()) continue; // Skip diags with no category.
111
112	unsigned &ID = CategoryIDs[Category];
113	if (ID != 0) continue; // Already seen.
114
115	ID = CategoryStrings.size();
116	CategoryStrings.push_back(Category);
117	}
118	}
119
120	unsigned getID(StringRef CategoryString) {
121	return CategoryIDs[CategoryString];
122	}
123
124	typedef std::vector<std::string>::const_iterator const_iterator;
125	const_iterator begin() const { return CategoryStrings.begin(); }
126	const_iterator end() const { return CategoryStrings.end(); }
127	};
128
129	struct GroupInfo {
130	std::vector<const Record*> DiagsInGroup;
131	std::vector<std::string> SubGroups;
132	unsigned IDNo;
133
134	const Record *ExplicitDef;
135
136	GroupInfo() : ExplicitDef(nullptr) {}
137	};
138	} // end anonymous namespace.
139
140	static bool beforeThanCompare(const Record LHS, const Record RHS) {
141	assert(!LHS->getLoc().empty() && !RHS->getLoc().empty());
142	return
143	LHS->getLoc().front().getPointer() < RHS->getLoc().front().getPointer();
144	}
145
146	static bool diagGroupBeforeByName(const Record LHS, const Record RHS) {
147	return LHS->getValueAsString("GroupName") <
148	RHS->getValueAsString("GroupName");
149	}
150
151	static bool beforeThanCompareGroups(const GroupInfo LHS, const GroupInfo RHS){
152	assert(!LHS->DiagsInGroup.empty() && !RHS->DiagsInGroup.empty());
153	return beforeThanCompare(LHS->DiagsInGroup.front(),
154	RHS->DiagsInGroup.front());
155	}
156
157	/// Invert the 1-[0/1] mapping of diags to group into a one to many
158	/// mapping of groups to diags in the group.
159	static void groupDiagnostics(const std::vector<Record*> &Diags,
160	const std::vector<Record*> &DiagGroups,
161	std::map<std::string, GroupInfo> &DiagsInGroup) {
162
163	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
164	const Record *R = Diags[i];
165	DefInit *DI = dyn_cast<DefInit>(R->getValueInit("Group"));
166	if (!DI)
167	continue;
168	assert(R->getValueAsDef("Class")->getName() != "CLASS_NOTE" &&
169	"Note can't be in a DiagGroup");
170	std::string GroupName = DI->getDef()->getValueAsString("GroupName");
171	DiagsInGroup[GroupName].DiagsInGroup.push_back(R);
172	}
173
174	typedef SmallPtrSet<GroupInfo *, 16> GroupSetTy;
175	GroupSetTy ImplicitGroups;
176
177	// Add all DiagGroup's to the DiagsInGroup list to make sure we pick up empty
178	// groups (these are warnings that GCC supports that clang never produces).
179	for (unsigned i = 0, e = DiagGroups.size(); i != e; ++i) {
180	Record *Group = DiagGroups[i];
181	GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
182	if (Group->isAnonymous()) {
183	if (GI.DiagsInGroup.size() > 1)
184	ImplicitGroups.insert(&GI);
185	} else {
186	if (GI.ExplicitDef)
187	assert(GI.ExplicitDef == Group);
188	else
189	GI.ExplicitDef = Group;
190	}
191
192	std::vector<Record*> SubGroups = Group->getValueAsListOfDefs("SubGroups");
193	for (unsigned j = 0, e = SubGroups.size(); j != e; ++j)
194	GI.SubGroups.push_back(SubGroups[j]->getValueAsString("GroupName"));
195	}
196
197	// Assign unique ID numbers to the groups.
198	unsigned IDNo = 0;
199	for (std::map<std::string, GroupInfo>::iterator
200	I = DiagsInGroup.begin(), E = DiagsInGroup.end(); I != E; ++I, ++IDNo)
201	I->second.IDNo = IDNo;
202
203	// Sort the implicit groups, so we can warn about them deterministically.
204	SmallVector<GroupInfo *, 16> SortedGroups(ImplicitGroups.begin(),
205	ImplicitGroups.end());
206	for (SmallVectorImpl<GroupInfo *>::iterator I = SortedGroups.begin(),
207	E = SortedGroups.end();
208	I != E; ++I) {
209	MutableArrayRef<const Record > GroupDiags = (I)->DiagsInGroup;
210	llvm::sort(GroupDiags, beforeThanCompare);
211	}
212	llvm::sort(SortedGroups, beforeThanCompareGroups);
213
214	// Warn about the same group being used anonymously in multiple places.
215	for (SmallVectorImpl<GroupInfo *>::const_iterator I = SortedGroups.begin(),
216	E = SortedGroups.end();
217	I != E; ++I) {
218	ArrayRef<const Record > GroupDiags = (I)->DiagsInGroup;
219
220	if ((*I)->ExplicitDef) {
221	std::string Name = (*I)->ExplicitDef->getValueAsString("GroupName");
222	for (ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
223	DE = GroupDiags.end();
224	DI != DE; ++DI) {
225	const DefInit GroupInit = cast<DefInit>((DI)->getValueInit("Group"));
226	const Record *NextDiagGroup = GroupInit->getDef();
227	if (NextDiagGroup == (*I)->ExplicitDef)
228	continue;
229
230	SrcMgr.PrintMessage((*DI)->getLoc().front(),
231	SourceMgr::DK_Error,
232	Twine("group '") + Name +
233	"' is referred to anonymously");
234	SrcMgr.PrintMessage((*I)->ExplicitDef->getLoc().front(),
235	SourceMgr::DK_Note, "group defined here");
236	}
237	} else {
238	// If there's no existing named group, we should just warn once and use
239	// notes to list all the other cases.
240	ArrayRef<const Record *>::const_iterator DI = GroupDiags.begin(),
241	DE = GroupDiags.end();
242	assert(DI != DE && "We only care about groups with multiple uses!");
243
244	const DefInit GroupInit = cast<DefInit>((DI)->getValueInit("Group"));
245	const Record *NextDiagGroup = GroupInit->getDef();
246	std::string Name = NextDiagGroup->getValueAsString("GroupName");
247
248	SrcMgr.PrintMessage((*DI)->getLoc().front(),
249	SourceMgr::DK_Error,
250	Twine("group '") + Name +
251	"' is referred to anonymously");
252
253	for (++DI; DI != DE; ++DI) {
254	SrcMgr.PrintMessage((*DI)->getLoc().front(),
255	SourceMgr::DK_Note, "also referenced here");
256	}
257	}
258	}
259	}
260
261	//===----------------------------------------------------------------------===//
262	// Infer members of -Wpedantic.
263	//===----------------------------------------------------------------------===//
264
265	typedef std::vector<const Record *> RecordVec;
266	typedef llvm::DenseSet<const Record *> RecordSet;
267	typedef llvm::PointerUnion<RecordVec, RecordSet> VecOrSet;
268
269	namespace {
270	class InferPedantic {
271	typedef llvm::DenseMap<const Record*,
272	std::pair<unsigned, Optional<unsigned> > > GMap;
273
274	DiagGroupParentMap &DiagGroupParents;
275	const std::vector<Record*> &Diags;
276	const std::vector<Record*> DiagGroups;
277	std::map<std::string, GroupInfo> &DiagsInGroup;
278	llvm::DenseSet<const Record*> DiagsSet;
279	GMap GroupCount;
280	public:
281	InferPedantic(DiagGroupParentMap &DiagGroupParents,
282	const std::vector<Record*> &Diags,
283	const std::vector<Record*> &DiagGroups,
284	std::map<std::string, GroupInfo> &DiagsInGroup)
285	: DiagGroupParents(DiagGroupParents),
286	Diags(Diags),
287	DiagGroups(DiagGroups),
288	DiagsInGroup(DiagsInGroup) {}
289
290	/// Compute the set of diagnostics and groups that are immediately
291	/// in -Wpedantic.
292	void compute(VecOrSet DiagsInPedantic,
293	VecOrSet GroupsInPedantic);
294
295	private:
296	/// Determine whether a group is a subgroup of another group.
297	bool isSubGroupOfGroup(const Record *Group,
298	llvm::StringRef RootGroupName);
299
300	/// Determine if the diagnostic is an extension.
301	bool isExtension(const Record *Diag);
302
303	/// Determine if the diagnostic is off by default.
304	bool isOffByDefault(const Record *Diag);
305
306	/// Increment the count for a group, and transitively marked
307	/// parent groups when appropriate.
308	void markGroup(const Record *Group);
309
310	/// Return true if the diagnostic is in a pedantic group.
311	bool groupInPedantic(const Record *Group, bool increment = false);
312	};
313	} // end anonymous namespace
314
315	bool InferPedantic::isSubGroupOfGroup(const Record *Group,
316	llvm::StringRef GName) {
317
318	const std::string &GroupName = Group->getValueAsString("GroupName");
319	if (GName == GroupName)
320	return true;
321
322	const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
323	for (unsigned i = 0, e = Parents.size(); i != e; ++i)
324	if (isSubGroupOfGroup(Parents[i], GName))
325	return true;
326
327	return false;
328	}
329
330	/// Determine if the diagnostic is an extension.
331	bool InferPedantic::isExtension(const Record *Diag) {
332	const std::string &ClsName = Diag->getValueAsDef("Class")->getName();
333	return ClsName == "CLASS_EXTENSION";
334	}
335
336	bool InferPedantic::isOffByDefault(const Record *Diag) {
337	const std::string &DefSeverity =
338	Diag->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
339	return DefSeverity == "Ignored";
340	}
341
342	bool InferPedantic::groupInPedantic(const Record *Group, bool increment) {
343	GMap::mapped_type &V = GroupCount[Group];
344	// Lazily compute the threshold value for the group count.
345	if (!V.second.hasValue()) {
346	const GroupInfo &GI = DiagsInGroup[Group->getValueAsString("GroupName")];
347	V.second = GI.SubGroups.size() + GI.DiagsInGroup.size();
348	}
349
350	if (increment)
351	++V.first;
352
353	// Consider a group in -Wpendatic IFF if has at least one diagnostic
354	// or subgroup AND all of those diagnostics and subgroups are covered
355	// by -Wpedantic via our computation.
356	return V.first != 0 && V.first == V.second.getValue();
357	}
358
359	void InferPedantic::markGroup(const Record *Group) {
360	// If all the diagnostics and subgroups have been marked as being
361	// covered by -Wpedantic, increment the count of parent groups. Once the
362	// group's count is equal to the number of subgroups and diagnostics in
363	// that group, we can safely add this group to -Wpedantic.
364	if (groupInPedantic(Group, /* increment */ true)) {
365	const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
366	for (unsigned i = 0, e = Parents.size(); i != e; ++i)
367	markGroup(Parents[i]);
368	}
369	}
370
371	void InferPedantic::compute(VecOrSet DiagsInPedantic,
372	VecOrSet GroupsInPedantic) {
373	// All extensions that are not on by default are implicitly in the
374	// "pedantic" group. For those that aren't explicitly included in -Wpedantic,
375	// mark them for consideration to be included in -Wpedantic directly.
376	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
377	Record *R = Diags[i];
378	if (isExtension(R) && isOffByDefault(R)) {
379	DiagsSet.insert(R);
380	if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group"))) {
381	const Record *GroupRec = Group->getDef();
382	if (!isSubGroupOfGroup(GroupRec, "pedantic")) {
383	markGroup(GroupRec);
384	}
385	}
386	}
387	}
388
389	// Compute the set of diagnostics that are directly in -Wpedantic. We
390	// march through Diags a second time to ensure the results are emitted
391	// in deterministic order.
392	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
393	Record *R = Diags[i];
394	if (!DiagsSet.count(R))
395	continue;
396	// Check if the group is implicitly in -Wpedantic. If so,
397	// the diagnostic should not be directly included in the -Wpedantic
398	// diagnostic group.
399	if (DefInit *Group = dyn_cast<DefInit>(R->getValueInit("Group")))
400	if (groupInPedantic(Group->getDef()))
401	continue;
402
403	// The diagnostic is not included in a group that is (transitively) in
404	// -Wpedantic. Include it in -Wpedantic directly.
405	if (RecordVec V = DiagsInPedantic.dyn_cast<RecordVec>())
406	V->push_back(R);
407	else {
408	DiagsInPedantic.get<RecordSet*>()->insert(R);
409	}
410	}
411
412	if (!GroupsInPedantic)
413	return;
414
415	// Compute the set of groups that are directly in -Wpedantic. We
416	// march through the groups to ensure the results are emitted
417	/// in a deterministc order.
418	for (unsigned i = 0, ei = DiagGroups.size(); i != ei; ++i) {
419	Record *Group = DiagGroups[i];
420	if (!groupInPedantic(Group))
421	continue;
422
423	unsigned ParentsInPedantic = 0;
424	const std::vector<Record*> &Parents = DiagGroupParents.getParents(Group);
425	for (unsigned j = 0, ej = Parents.size(); j != ej; ++j) {
426	if (groupInPedantic(Parents[j]))
427	++ParentsInPedantic;
428	}
429	// If all the parents are in -Wpedantic, this means that this diagnostic
430	// group will be indirectly included by -Wpedantic already. In that
431	// case, do not add it directly to -Wpedantic. If the group has no
432	// parents, obviously it should go into -Wpedantic.
433	if (Parents.size() > 0 && ParentsInPedantic == Parents.size())
434	continue;
435
436	if (RecordVec V = GroupsInPedantic.dyn_cast<RecordVec>())
437	V->push_back(Group);
438	else {
439	GroupsInPedantic.get<RecordSet*>()->insert(Group);
440	}
441	}
442	}
443
444	namespace {
445	enum PieceKind {
446	MultiPieceClass,
447	TextPieceClass,
448	PlaceholderPieceClass,
449	SelectPieceClass,
450	PluralPieceClass,
451	DiffPieceClass,
452	SubstitutionPieceClass,
453	};
454
455	enum ModifierType {
456	MT_Unknown,
457	MT_Placeholder,
458	MT_Select,
459	MT_Sub,
460	MT_Plural,
461	MT_Diff,
462	MT_Ordinal,
463	MT_S,
464	MT_Q,
465	MT_ObjCClass,
466	MT_ObjCInstance,
467	};
468
469	static StringRef getModifierName(ModifierType MT) {
470	switch (MT) {
471	case MT_Select:
472	return "select";
473	case MT_Sub:
474	return "sub";
475	case MT_Diff:
476	return "diff";
477	case MT_Plural:
478	return "plural";
479	case MT_Ordinal:
480	return "ordinal";
481	case MT_S:
482	return "s";
483	case MT_Q:
484	return "q";
485	case MT_Placeholder:
486	return "";
487	case MT_ObjCClass:
488	return "objcclass";
489	case MT_ObjCInstance:
490	return "objcinstance";
491	case MT_Unknown:
492	llvm_unreachable("invalid modifier type");
493	}
494	// Unhandled case
495	llvm_unreachable("invalid modifier type");
496	}
497
498	struct Piece {
499	// This type and its derived classes are move-only.
500	Piece(PieceKind Kind) : ClassKind(Kind) {}
501	Piece(Piece const &O) = delete;
502	Piece &operator=(Piece const &) = delete;
503	virtual ~Piece() {}
504
505	PieceKind getPieceClass() const { return ClassKind; }
506	static bool classof(const Piece *) { return true; }
507
508	private:
509	PieceKind ClassKind;
510	};
511
512	struct MultiPiece : Piece {
513	MultiPiece() : Piece(MultiPieceClass) {}
514	MultiPiece(std::vector<Piece *> Pieces)
515	: Piece(MultiPieceClass), Pieces(std::move(Pieces)) {}
516
517	std::vector<Piece *> Pieces;
518
519	static bool classof(const Piece *P) {
520	return P->getPieceClass() == MultiPieceClass;
521	}
522	};
523
524	struct TextPiece : Piece {
525	StringRef Role;
526	std::string Text;
527	TextPiece(StringRef Text, StringRef Role = "")
528	: Piece(TextPieceClass), Role(Role), Text(Text.str()) {}
529
530	static bool classof(const Piece *P) {
531	return P->getPieceClass() == TextPieceClass;
532	}
533	};
534
535	struct PlaceholderPiece : Piece {
536	ModifierType Kind;
537	int Index;
538	PlaceholderPiece(ModifierType Kind, int Index)
539	: Piece(PlaceholderPieceClass), Kind(Kind), Index(Index) {}
540
541	static bool classof(const Piece *P) {
542	return P->getPieceClass() == PlaceholderPieceClass;
543	}
544	};
545
546	struct SelectPiece : Piece {
547	protected:
548	SelectPiece(PieceKind Kind, ModifierType ModKind)
549	: Piece(Kind), ModKind(ModKind) {}
550
551	public:
552	SelectPiece(ModifierType ModKind) : SelectPiece(SelectPieceClass, ModKind) {}
553
554	ModifierType ModKind;
555	std::vector<Piece *> Options;
556	int Index;
557
558	static bool classof(const Piece *P) {
559	return P->getPieceClass() == SelectPieceClass \|\|
560	P->getPieceClass() == PluralPieceClass;
561	}
562	};
563
564	struct PluralPiece : SelectPiece {
565	PluralPiece() : SelectPiece(PluralPieceClass, MT_Plural) {}
566
567	std::vector<Piece *> OptionPrefixes;
568	int Index;
569
570	static bool classof(const Piece *P) {
571	return P->getPieceClass() == PluralPieceClass;
572	}
573	};
574
575	struct DiffPiece : Piece {
576	DiffPiece() : Piece(DiffPieceClass) {}
577
578	Piece *Options[2] = {};
579	int Indexes[2] = {};
580
581	static bool classof(const Piece *P) {
582	return P->getPieceClass() == DiffPieceClass;
583	}
584	};
585
586	struct SubstitutionPiece : Piece {
587	SubstitutionPiece() : Piece(SubstitutionPieceClass) {}
588
589	std::string Name;
590	std::vector<int> Modifiers;
591
592	static bool classof(const Piece *P) {
593	return P->getPieceClass() == SubstitutionPieceClass;
594	}
595	};
596
597	/// Diagnostic text, parsed into pieces.
598
599
600	struct DiagnosticTextBuilder {
601	DiagnosticTextBuilder(DiagnosticTextBuilder const &) = delete;
602	DiagnosticTextBuilder &operator=(DiagnosticTextBuilder const &) = delete;
603
604	DiagnosticTextBuilder(RecordKeeper &Records) {
605	// Build up the list of substitution records.
606	for (auto *S : Records.getAllDerivedDefinitions("TextSubstitution")) {
607	EvaluatingRecordGuard Guard(&EvaluatingRecord, S);
608	Substitutions.try_emplace(
609	S->getName(), DiagText(*this, S->getValueAsString("Substitution")));
610	}
611
612	// Check that no diagnostic definitions have the same name as a
613	// substitution.
614	for (Record *Diag : Records.getAllDerivedDefinitions("Diagnostic")) {
615	StringRef Name = Diag->getName();
616	if (Substitutions.count(Name))
617	llvm::PrintFatalError(
618	Diag->getLoc(),
619	"Diagnostic '" + Name +
620	"' has same name as TextSubstitution definition");
621	}
622	}
623
624	std::vector<std::string> buildForDocumentation(StringRef Role,
625	const Record *R);
626	std::string buildForDefinition(const Record *R);
627
628	Piece getSubstitution(SubstitutionPiece S) const {
629	auto It = Substitutions.find(S->Name);
630	if (It == Substitutions.end())
631	PrintFatalError("Failed to find substitution with name: " + S->Name);
632	return It->second.Root;
633	}
634
635	LLVM_ATTRIBUTE_NORETURN void PrintFatalError(llvm::Twine const &Msg) const {
636	assert(EvaluatingRecord && "not evaluating a record?");
637	llvm::PrintFatalError(EvaluatingRecord->getLoc(), Msg);
638	}
639
640	private:
641	struct DiagText {
642	DiagnosticTextBuilder &Builder;
643	std::vector<Piece *> AllocatedPieces;
644	Piece *Root = nullptr;
645
646	template <class T, class... Args> T *New(Args &&... args) {
647	static_assert(std::is_base_of<Piece, T>::value, "must be piece");
648	T *Mem = new T(std::forward<Args>(args)...);
649	AllocatedPieces.push_back(Mem);
650	return Mem;
651	}
652
653	DiagText(DiagnosticTextBuilder &Builder, StringRef Text)
654	: Builder(Builder), Root(parseDiagText(Text)) {}
655
656	Piece *parseDiagText(StringRef &Text, bool Nested = false);
657	int parseModifier(StringRef &) const;
658
659	public:
660	DiagText(DiagText &&O) noexcept
661	: Builder(O.Builder), AllocatedPieces(std::move(O.AllocatedPieces)),
662	Root(O.Root) {
663	O.Root = nullptr;
664	}
665
666	~DiagText() {
667	for (Piece *P : AllocatedPieces)
668	delete P;
669	}
670	};
671
672	private:
673	const Record *EvaluatingRecord = nullptr;
674	struct EvaluatingRecordGuard {
675	EvaluatingRecordGuard(const Record *Dest, const Record New)
676	: Dest(Dest), Old(*Dest) {
677	*Dest = New;
678	}
679	~EvaluatingRecordGuard() { *Dest = Old; }
680	const Record **Dest;
681	const Record *Old;
682	};
683
684	StringMap<DiagText> Substitutions;
685	};
686
687	template <class Derived> struct DiagTextVisitor {
688	using ModifierMappingsType = Optional<std::vector<int>>;
689
690	private:
691	Derived &getDerived() { return static_cast<Derived &>(*this); }
692
693	public:
694	std::vector<int>
695	getSubstitutionMappings(SubstitutionPiece *P,
696	const ModifierMappingsType &Mappings) const {
697	std::vector<int> NewMappings;
698	for (int Idx : P->Modifiers)
699	NewMappings.push_back(mapIndex(Idx, Mappings));
700	return NewMappings;
701	}
702
703	struct SubstitutionContext {
704	SubstitutionContext(DiagTextVisitor &Visitor, SubstitutionPiece *P)
705	: Visitor(Visitor) {
706	Substitution = Visitor.Builder.getSubstitution(P);
707	OldMappings = std::move(Visitor.ModifierMappings);
708	std::vector<int> NewMappings =
709	Visitor.getSubstitutionMappings(P, OldMappings);
710	Visitor.ModifierMappings = std::move(NewMappings);
711	}
712
713	~SubstitutionContext() {
714	Visitor.ModifierMappings = std::move(OldMappings);
715	}
716
717	private:
718	DiagTextVisitor &Visitor;
719	Optional<std::vector<int>> OldMappings;
720
721	public:
722	Piece *Substitution;
723	};
724
725	public:
726	DiagTextVisitor(DiagnosticTextBuilder &Builder) : Builder(Builder) {}
727
728	void Visit(Piece *P) {
729	switch (P->getPieceClass()) {
730	#define CASE(T) \
731	case T##PieceClass: \
732	return getDerived().Visit##T(static_cast<T##Piece *>(P))
733	CASE(Multi);
734	CASE(Text);
735	CASE(Placeholder);
736	CASE(Select);
737	CASE(Plural);
738	CASE(Diff);
739	CASE(Substitution);
740	#undef CASE
741	}
742	}
743
744	void VisitSubstitution(SubstitutionPiece *P) {
745	SubstitutionContext Guard(*this, P);
746	Visit(Guard.Substitution);
747	}
748
749	int mapIndex(int Idx,
750	ModifierMappingsType const &ModifierMappings) const {
751	if (!ModifierMappings)
752	return Idx;
753	if (ModifierMappings->size() <= static_cast<unsigned>(Idx))
754	Builder.PrintFatalError("Modifier value '" + std::to_string(Idx) +
755	"' is not valid for this mapping (has " +
756	std::to_string(ModifierMappings->size()) +
757	" mappings)");
758	return (*ModifierMappings)[Idx];
759	}
760
761	int mapIndex(int Idx) const {
762	return mapIndex(Idx, ModifierMappings);
763	}
764
765	protected:
766	DiagnosticTextBuilder &Builder;
767	ModifierMappingsType ModifierMappings;
768	};
769
770	void escapeRST(StringRef Str, std::string &Out) {
771	for (auto K : Str) {
772	if (StringRef("`*\|_[]\\").count(K))
773	Out.push_back('\\');
774	Out.push_back(K);
775	}
776	}
777
778	template <typename It> void padToSameLength(It Begin, It End) {
779	size_t Width = 0;
780	for (It I = Begin; I != End; ++I)
781	Width = std::max(Width, I->size());
782	for (It I = Begin; I != End; ++I)
783	(*I) += std::string(Width - I->size(), ' ');
784	}
785
786	template <typename It> void makeTableRows(It Begin, It End) {
787	if (Begin == End)
788	return;
789	padToSameLength(Begin, End);
790	for (It I = Begin; I != End; ++I)
791	I = "\|" + I + "\|";
792	}
793
794	void makeRowSeparator(std::string &Str) {
795	for (char &K : Str)
796	K = (K == '\|' ? '+' : '-');
797	}
798
799	struct DiagTextDocPrinter : DiagTextVisitor<DiagTextDocPrinter> {
800	using BaseTy = DiagTextVisitor<DiagTextDocPrinter>;
801	DiagTextDocPrinter(DiagnosticTextBuilder &Builder,
802	std::vector<std::string> &RST)
803	: BaseTy(Builder), RST(RST) {}
804
805	void gatherNodes(
806	Piece *OrigP, const ModifierMappingsType &CurrentMappings,
807	std::vector<std::pair<Piece *, ModifierMappingsType>> &Pieces) const {
808	if (auto *Sub = dyn_cast<SubstitutionPiece>(OrigP)) {
809	ModifierMappingsType NewMappings =
810	getSubstitutionMappings(Sub, CurrentMappings);
811	return gatherNodes(Builder.getSubstitution(Sub), NewMappings, Pieces);
812	}
813	if (auto *MD = dyn_cast<MultiPiece>(OrigP)) {
814	for (Piece *Node : MD->Pieces)
815	gatherNodes(Node, CurrentMappings, Pieces);
816	return;
817	}
818	Pieces.push_back(std::make_pair(OrigP, CurrentMappings));
819	}
820
821	void VisitMulti(MultiPiece *P) {
822	if (P->Pieces.empty()) {
823	RST.push_back("");
824	return;
825	}
826
827	if (P->Pieces.size() == 1)
828	return Visit(P->Pieces[0]);
829
830	// Flatten the list of nodes, replacing any substitution pieces with the
831	// recursively flattened substituted node.
832	std::vector<std::pair<Piece *, ModifierMappingsType>> Pieces;
833	gatherNodes(P, ModifierMappings, Pieces);
834
835	std::string EmptyLinePrefix;
836	size_t Start = RST.size();
837	bool HasMultipleLines = true;
838	for (const std::pair<Piece *, ModifierMappingsType> &NodePair : Pieces) {
839	std::vector<std::string> Lines;
840	DiagTextDocPrinter Visitor{Builder, Lines};
841	Visitor.ModifierMappings = NodePair.second;
842	Visitor.Visit(NodePair.first);
843
844	if (Lines.empty())
845	continue;
846
847	// We need a vertical separator if either this or the previous piece is a
848	// multi-line piece, or this is the last piece.
849	const char *Separator = (Lines.size() > 1 \|\| HasMultipleLines) ? "\|" : "";
850	HasMultipleLines = Lines.size() > 1;
851
852	if (Start + Lines.size() > RST.size())
853	RST.resize(Start + Lines.size(), EmptyLinePrefix);
854
855	padToSameLength(Lines.begin(), Lines.end());
856	for (size_t I = 0; I != Lines.size(); ++I)
857	RST[Start + I] += Separator + Lines[I];
858	std::string Empty(Lines[0].size(), ' ');
859	for (size_t I = Start + Lines.size(); I != RST.size(); ++I)
860	RST[I] += Separator + Empty;
861	EmptyLinePrefix += Separator + Empty;
862	}
863	for (size_t I = Start; I != RST.size(); ++I)
864	RST[I] += "\|";
865	EmptyLinePrefix += "\|";
866
867	makeRowSeparator(EmptyLinePrefix);
868	RST.insert(RST.begin() + Start, EmptyLinePrefix);
869	RST.insert(RST.end(), EmptyLinePrefix);
870	}
871
872	void VisitText(TextPiece *P) {
873	RST.push_back("");
874	auto &S = RST.back();
875
876	StringRef T = P->Text;
877	while (!T.empty() && T.front() == ' ') {
878	RST.back() += " \|nbsp\| ";
879	T = T.drop_front();
880	}
881
882	std::string Suffix;
883	while (!T.empty() && T.back() == ' ') {
884	Suffix += " \|nbsp\| ";
885	T = T.drop_back();
886	}
887
888	if (!T.empty()) {
889	S += ':';
890	S += P->Role;
891	S += ":`";
892	escapeRST(T, S);
893	S += '`';
894	}
895
896	S += Suffix;
897	}
898
899	void VisitPlaceholder(PlaceholderPiece *P) {
900	RST.push_back(std::string(":placeholder:`") +
901	char('A' + mapIndex(P->Index)) + "`");
902	}
903
904	void VisitSelect(SelectPiece *P) {
905	std::vector<size_t> SeparatorIndexes;
906	SeparatorIndexes.push_back(RST.size());
907	RST.emplace_back();
908	for (auto *O : P->Options) {
909	Visit(O);
910	SeparatorIndexes.push_back(RST.size());
911	RST.emplace_back();
912	}
913
914	makeTableRows(RST.begin() + SeparatorIndexes.front(),
915	RST.begin() + SeparatorIndexes.back() + 1);
916	for (size_t I : SeparatorIndexes)
917	makeRowSeparator(RST[I]);
918	}
919
920	void VisitPlural(PluralPiece *P) { VisitSelect(P); }
921
922	void VisitDiff(DiffPiece *P) { Visit(P->Options[1]); }
923
924	std::vector<std::string> &RST;
925	};
926
927	struct DiagTextPrinter : DiagTextVisitor<DiagTextPrinter> {
928	public:
929	using BaseTy = DiagTextVisitor<DiagTextPrinter>;
930	DiagTextPrinter(DiagnosticTextBuilder &Builder, std::string &Result)
931	: BaseTy(Builder), Result(Result) {}
932
933	void VisitMulti(MultiPiece *P) {
934	for (auto *Child : P->Pieces)
935	Visit(Child);
936	}
937	void VisitText(TextPiece *P) { Result += P->Text; }
938	void VisitPlaceholder(PlaceholderPiece *P) {
939	Result += "%";
940	Result += getModifierName(P->Kind);
941	addInt(mapIndex(P->Index));
942	}
943	void VisitSelect(SelectPiece *P) {
944	Result += "%";
945	Result += getModifierName(P->ModKind);
946	if (P->ModKind == MT_Select) {
947	Result += "{";
948	for (auto *D : P->Options) {
949	Visit(D);
950	Result += '\|';
951	}
952	if (!P->Options.empty())
953	Result.erase(--Result.end());
954	Result += '}';
955	}
956	addInt(mapIndex(P->Index));
957	}
958
959	void VisitPlural(PluralPiece *P) {
960	Result += "%plural{";
961	assert(P->Options.size() == P->OptionPrefixes.size());
962	for (unsigned I = 0, End = P->Options.size(); I < End; ++I) {
963	if (P->OptionPrefixes[I])
964	Visit(P->OptionPrefixes[I]);
965	Visit(P->Options[I]);
966	Result += "\|";
967	}
968	if (!P->Options.empty())
969	Result.erase(--Result.end());
970	Result += '}';
971	addInt(mapIndex(P->Index));
972	}
973
974	void VisitDiff(DiffPiece *P) {
975	Result += "%diff{";
976	Visit(P->Options[0]);
977	Result += "\|";
978	Visit(P->Options[1]);
979	Result += "}";
980	addInt(mapIndex(P->Indexes[0]));
981	Result += ",";
982	addInt(mapIndex(P->Indexes[1]));
983	}
984
985	void addInt(int Val) { Result += std::to_string(Val); }
986
987	std::string &Result;
988	};
989
990	int DiagnosticTextBuilder::DiagText::parseModifier(StringRef &Text) const {
991	if (Text.empty() \|\| !isdigit(Text[0]))
992	Builder.PrintFatalError("expected modifier in diagnostic");
993	int Val = 0;
994	do {
995	Val *= 10;
996	Val += Text[0] - '0';
997	Text = Text.drop_front();
998	} while (!Text.empty() && isdigit(Text[0]));
999	return Val;
1000	}
1001
1002	Piece *DiagnosticTextBuilder::DiagText::parseDiagText(StringRef &Text,
1003	bool Nested) {
1004	std::vector<Piece *> Parsed;
1005
1006	while (!Text.empty()) {
1007	size_t End = (size_t)-2;
1008	do
1009	End = Nested ? Text.find_first_of("%\|}", End + 2)
1010	: Text.find_first_of('%', End + 2);
1011	while (End < Text.size() - 1 && Text[End] == '%' &&
1012	(Text[End + 1] == '%' \|\| Text[End + 1] == '\|'));
1013
1014	if (End) {
1015	Parsed.push_back(New<TextPiece>(Text.slice(0, End), "diagtext"));
1016	Text = Text.slice(End, StringRef::npos);
1017	if (Text.empty())
1018	break;
1019	}
1020
1021	if (Text[0] == '\|' \|\| Text[0] == '}')
1022	break;
1023
1024	// Drop the '%'.
1025	Text = Text.drop_front();
1026
1027	// Extract the (optional) modifier.
1028	size_t ModLength = Text.find_first_of("0123456789{");
1029	StringRef Modifier = Text.slice(0, ModLength);
1030	Text = Text.slice(ModLength, StringRef::npos);
1031	ModifierType ModType = llvm::StringSwitch<ModifierType>{Modifier}
1032	.Case("select", MT_Select)
1033	.Case("sub", MT_Sub)
1034	.Case("diff", MT_Diff)
1035	.Case("plural", MT_Plural)
1036	.Case("s", MT_S)
1037	.Case("ordinal", MT_Ordinal)
1038	.Case("q", MT_Q)
1039	.Case("objcclass", MT_ObjCClass)
1040	.Case("objcinstance", MT_ObjCInstance)
1041	.Case("", MT_Placeholder)
1042	.Default(MT_Unknown);
1043
1044	switch (ModType) {
1045	case MT_Unknown:
1046	Builder.PrintFatalError("Unknown modifier type: " + Modifier);
1047	case MT_Select: {
1048	SelectPiece *Select = New<SelectPiece>(MT_Select);
1049	do {
1050	Text = Text.drop_front(); // '{' or '\|'
1051	Select->Options.push_back(parseDiagText(Text, true));
1052	assert(!Text.empty() && "malformed %select");
1053	} while (Text.front() == '\|');
1054	// Drop the trailing '}'.
1055	Text = Text.drop_front(1);
1056	Select->Index = parseModifier(Text);
1057	Parsed.push_back(Select);
1058	continue;
1059	}
1060	case MT_Plural: {
1061	PluralPiece *Plural = New<PluralPiece>();
1062	do {
1063	Text = Text.drop_front(); // '{' or '\|'
1064	size_t End = Text.find_first_of(":");
1065	if (End == StringRef::npos)
1066	Builder.PrintFatalError("expected ':' while parsing %plural");
1067	++End;
1068	assert(!Text.empty());
1069	Plural->OptionPrefixes.push_back(
1070	New<TextPiece>(Text.slice(0, End), "diagtext"));
1071	Text = Text.slice(End, StringRef::npos);
1072	Plural->Options.push_back(parseDiagText(Text, true));
1073	assert(!Text.empty() && "malformed %select");
1074	} while (Text.front() == '\|');
1075	// Drop the trailing '}'.
1076	Text = Text.drop_front(1);
1077	Plural->Index = parseModifier(Text);
1078	Parsed.push_back(Plural);
1079	continue;
1080	}
1081	case MT_Sub: {
1082	SubstitutionPiece *Sub = New<SubstitutionPiece>();
1083	Text = Text.drop_front(); // '{'
1084	size_t NameSize = Text.find_first_of('}');
1085	assert(NameSize != size_t(-1) && "failed to find the end of the name");
1086	assert(NameSize != 0 && "empty name?");
1087	Sub->Name = Text.substr(0, NameSize).str();
1088	Text = Text.drop_front(NameSize);
1089	Text = Text.drop_front(); // '}'
1090	if (!Text.empty()) {
1091	while (true) {
1092	if (!isdigit(Text[0]))
1093	break;
1094	Sub->Modifiers.push_back(parseModifier(Text));
1095	if (Text.empty() \|\| Text[0] != ',')
1096	break;
1097	Text = Text.drop_front(); // ','
1098	assert(!Text.empty() && isdigit(Text[0]) &&
1099	"expected another modifier");
1100	}
1101	}
1102	Parsed.push_back(Sub);
1103	continue;
1104	}
1105	case MT_Diff: {
1106	DiffPiece *Diff = New<DiffPiece>();
1107	Text = Text.drop_front(); // '{'
1108	Diff->Options[0] = parseDiagText(Text, true);
1109	Text = Text.drop_front(); // '\|'
1110	Diff->Options[1] = parseDiagText(Text, true);
1111
1112	Text = Text.drop_front(); // '}'
1113	Diff->Indexes[0] = parseModifier(Text);
1114	Text = Text.drop_front(); // ','
1115	Diff->Indexes[1] = parseModifier(Text);
1116	Parsed.push_back(Diff);
1117	continue;
1118	}
1119	case MT_S: {
1120	SelectPiece *Select = New<SelectPiece>(ModType);
1121	Select->Options.push_back(New<TextPiece>(""));
1122	Select->Options.push_back(New<TextPiece>("s", "diagtext"));
1123	Select->Index = parseModifier(Text);
1124	Parsed.push_back(Select);
1125	continue;
1126	}
1127	case MT_Q:
1128	case MT_Placeholder:
1129	case MT_ObjCClass:
1130	case MT_ObjCInstance:
1131	case MT_Ordinal: {
1132	Parsed.push_back(New<PlaceholderPiece>(ModType, parseModifier(Text)));
1133	continue;
1134	}
1135	}
1136	}
1137
1138	return New<MultiPiece>(Parsed);
1139	}
1140
1141	std::vector<std::string>
1142	DiagnosticTextBuilder::buildForDocumentation(StringRef Severity,
1143	const Record *R) {
1144	EvaluatingRecordGuard Guard(&EvaluatingRecord, R);
1145	StringRef Text = R->getValueAsString("Text");
1146
1147	DiagText D(*this, Text);
1148	TextPiece *Prefix = D.New<TextPiece>(Severity, Severity);
1149	Prefix->Text += ": ";
1150	auto *MP = dyn_cast<MultiPiece>(D.Root);
1151	if (!MP) {
1152	MP = D.New<MultiPiece>();
1153	MP->Pieces.push_back(D.Root);
1154	D.Root = MP;
1155	}
1156	MP->Pieces.insert(MP->Pieces.begin(), Prefix);
1157	std::vector<std::string> Result;
1158	DiagTextDocPrinter{*this, Result}.Visit(D.Root);
1159	return Result;
1160	}
1161
1162	std::string DiagnosticTextBuilder::buildForDefinition(const Record *R) {
1163	EvaluatingRecordGuard Guard(&EvaluatingRecord, R);
1164	StringRef Text = R->getValueAsString("Text");
1165	DiagText D(*this, Text);
1166	std::string Result;
1167	DiagTextPrinter{*this, Result}.Visit(D.Root);
1168	return Result;
1169	}
1170
1171	} // namespace
1172
1173	//===----------------------------------------------------------------------===//
1174	// Warning Tables (.inc file) generation.
1175	//===----------------------------------------------------------------------===//
1176
1177	static bool isError(const Record &Diag) {
1178	const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
1179	return ClsName == "CLASS_ERROR";
1180	}
1181
1182	static bool isRemark(const Record &Diag) {
1183	const std::string &ClsName = Diag.getValueAsDef("Class")->getName();
1184	return ClsName == "CLASS_REMARK";
1185	}
1186
1187
1188	/// ClangDiagsDefsEmitter - The top-level class emits .def files containing
1189	/// declarations of Clang diagnostics.
1190	namespace clang {
1191	void EmitClangDiagsDefs(RecordKeeper &Records, raw_ostream &OS,
1192	const std::string &Component) {
1193	// Write the #if guard
1194	if (!Component.empty()) {
1195	std::string ComponentName = StringRef(Component).upper();
1196	OS << "#ifdef " << ComponentName << "START\n";
1197	OS << "__" << ComponentName << "START = DIAG_START_" << ComponentName
1198	<< ",\n";
1199	OS << "#undef " << ComponentName << "START\n";
1200	OS << "#endif\n\n";
1201	}
1202
1203	DiagnosticTextBuilder DiagTextBuilder(Records);
1204
1205	std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");
1206
1207	std::vector<Record*> DiagGroups
1208	= Records.getAllDerivedDefinitions("DiagGroup");
1209
1210	std::map<std::string, GroupInfo> DiagsInGroup;
1211	groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
1212
1213	DiagCategoryIDMap CategoryIDs(Records);
1214	DiagGroupParentMap DGParentMap(Records);
1215
1216	// Compute the set of diagnostics that are in -Wpedantic.
1217	RecordSet DiagsInPedantic;
1218	InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
1219	inferPedantic.compute(&DiagsInPedantic, (RecordVec*)nullptr);
1220
1221	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
1222	const Record &R = *Diags[i];
1223
1224	// Check if this is an error that is accidentally in a warning
1225	// group.
1226	if (isError(R)) {
1227	if (DefInit *Group = dyn_cast<DefInit>(R.getValueInit("Group"))) {
1228	const Record *GroupRec = Group->getDef();
1229	const std::string &GroupName = GroupRec->getValueAsString("GroupName");
1230	PrintFatalError(R.getLoc(), "Error " + R.getName() +
1231	" cannot be in a warning group [" + GroupName + "]");
1232	}
1233	}
1234
1235	// Check that all remarks have an associated diagnostic group.
1236	if (isRemark(R)) {
1237	if (!isa<DefInit>(R.getValueInit("Group"))) {
1238	PrintFatalError(R.getLoc(), "Error " + R.getName() +
1239	" not in any diagnostic group");
1240	}
1241	}
1242
1243	// Filter by component.
1244	if (!Component.empty() && Component != R.getValueAsString("Component"))
1245	continue;
1246
1247	OS << "DIAG(" << R.getName() << ", ";
1248	OS << R.getValueAsDef("Class")->getName();
1249	OS << ", (unsigned)diag::Severity::"
1250	<< R.getValueAsDef("DefaultSeverity")->getValueAsString("Name");
1251
1252	// Description string.
1253	OS << ", \"";
1254	OS.write_escaped(DiagTextBuilder.buildForDefinition(&R)) << '"';
1255
1256	// Warning associated with the diagnostic. This is stored as an index into
1257	// the alphabetically sorted warning table.
1258	if (DefInit *DI = dyn_cast<DefInit>(R.getValueInit("Group"))) {
1259	std::map<std::string, GroupInfo>::iterator I =
1260	DiagsInGroup.find(DI->getDef()->getValueAsString("GroupName"));
1261	assert(I != DiagsInGroup.end());
1262	OS << ", " << I->second.IDNo;
1263	} else if (DiagsInPedantic.count(&R)) {
1264	std::map<std::string, GroupInfo>::iterator I =
1265	DiagsInGroup.find("pedantic");
1266	assert(I != DiagsInGroup.end() && "pedantic group not defined");
1267	OS << ", " << I->second.IDNo;
1268	} else {
1269	OS << ", 0";
1270	}
1271
1272	// SFINAE response.
1273	OS << ", " << R.getValueAsDef("SFINAE")->getName();
1274
1275	// Default warning has no Werror bit.
1276	if (R.getValueAsBit("WarningNoWerror"))
1277	OS << ", true";
1278	else
1279	OS << ", false";
1280
1281	if (R.getValueAsBit("ShowInSystemHeader"))
1282	OS << ", true";
1283	else
1284	OS << ", false";
1285
1286	// Category number.
1287	OS << ", " << CategoryIDs.getID(getDiagnosticCategory(&R, DGParentMap));
1288	OS << ")\n";
1289	}
1290	}
1291	} // end namespace clang
1292
1293	//===----------------------------------------------------------------------===//
1294	// Warning Group Tables generation
1295	//===----------------------------------------------------------------------===//
1296
1297	static std::string getDiagCategoryEnum(llvm::StringRef name) {
1298	if (name.empty())
1299	return "DiagCat_None";
1300	SmallString<256> enumName = llvm::StringRef("DiagCat_");
1301	for (llvm::StringRef::iterator I = name.begin(), E = name.end(); I != E; ++I)
1302	enumName += isalnum(I) ? I : '_';
1303	return enumName.str();
1304	}
1305
1306	/// Emit the array of diagnostic subgroups.
1307	///
1308	/// The array of diagnostic subgroups contains for each group a list of its
1309	/// subgroups. The individual lists are separated by '-1'. Groups with no
1310	/// subgroups are skipped.
1311	///
1312	/// \code
1313	/// static const int16_t DiagSubGroups[] = {
1314	/// /* Empty */ -1,
1315	/// /* DiagSubGroup0 */ 142, -1,
1316	/// /* DiagSubGroup13 */ 265, 322, 399, -1
1317	/// }
1318	/// \endcode
1319	///
1320	static void emitDiagSubGroups(std::map<std::string, GroupInfo> &DiagsInGroup,
1321	RecordVec &GroupsInPedantic, raw_ostream &OS) {
1322	OS << "static const int16_t DiagSubGroups[] = {\n"
1323	<< " /* Empty */ -1,\n";
1324	for (auto const &I : DiagsInGroup) {
1325	const bool IsPedantic = I.first == "pedantic";
1326
1327	const std::vector<std::string> &SubGroups = I.second.SubGroups;
1328	if (!SubGroups.empty() \|\| (IsPedantic && !GroupsInPedantic.empty())) {
1329	OS << " /* DiagSubGroup" << I.second.IDNo << " */ ";
1330	for (auto const &SubGroup : SubGroups) {
1331	std::map<std::string, GroupInfo>::const_iterator RI =
1332	DiagsInGroup.find(SubGroup);
1333	assert(RI != DiagsInGroup.end() && "Referenced without existing?");
1334	OS << RI->second.IDNo << ", ";
1335	}
1336	// Emit the groups implicitly in "pedantic".
1337	if (IsPedantic) {
1338	for (auto const &Group : GroupsInPedantic) {
1339	const std::string &GroupName = Group->getValueAsString("GroupName");
1340	std::map<std::string, GroupInfo>::const_iterator RI =
1341	DiagsInGroup.find(GroupName);
1342	assert(RI != DiagsInGroup.end() && "Referenced without existing?");
1343	OS << RI->second.IDNo << ", ";
1344	}
1345	}
1346
1347	OS << "-1,\n";
1348	}
1349	}
1350	OS << "};\n\n";
1351	}
1352
1353	/// Emit the list of diagnostic arrays.
1354	///
1355	/// This data structure is a large array that contains itself arrays of varying
1356	/// size. Each array represents a list of diagnostics. The different arrays are
1357	/// separated by the value '-1'.
1358	///
1359	/// \code
1360	/// static const int16_t DiagArrays[] = {
1361	/// /* Empty */ -1,
1362	/// /* DiagArray1 */ diag::warn_pragma_message,
1363	/// -1,
1364	/// /* DiagArray2 */ diag::warn_abs_too_small,
1365	/// diag::warn_unsigned_abs,
1366	/// diag::warn_wrong_absolute_value_type,
1367	/// -1
1368	/// };
1369	/// \endcode
1370	///
1371	static void emitDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
1372	RecordVec &DiagsInPedantic, raw_ostream &OS) {
1373	OS << "static const int16_t DiagArrays[] = {\n"
1374	<< " /* Empty */ -1,\n";
1375	for (auto const &I : DiagsInGroup) {
1376	const bool IsPedantic = I.first == "pedantic";
1377
1378	const std::vector<const Record *> &V = I.second.DiagsInGroup;
1379	if (!V.empty() \|\| (IsPedantic && !DiagsInPedantic.empty())) {
1380	OS << " /* DiagArray" << I.second.IDNo << " */ ";
1381	for (auto *Record : V)
1382	OS << "diag::" << Record->getName() << ", ";
1383	// Emit the diagnostics implicitly in "pedantic".
1384	if (IsPedantic) {
1385	for (auto const &Diag : DiagsInPedantic)
1386	OS << "diag::" << Diag->getName() << ", ";
1387	}
1388	OS << "-1,\n";
1389	}
1390	}
1391	OS << "};\n\n";
1392	}
1393
1394	/// Emit a list of group names.
1395	///
1396	/// This creates a long string which by itself contains a list of pascal style
1397	/// strings, which consist of a length byte directly followed by the string.
1398	///
1399	/// \code
1400	/// static const char DiagGroupNames[] = {
1401	/// \000\020#pragma-messages\t#warnings\020CFString-literal"
1402	/// };
1403	/// \endcode
1404	static void emitDiagGroupNames(StringToOffsetTable &GroupNames,
1405	raw_ostream &OS) {
1406	OS << "static const char DiagGroupNames[] = {\n";
1407	GroupNames.EmitString(OS);
1408	OS << "};\n\n";
1409	}
1410
1411	/// Emit diagnostic arrays and related data structures.
1412	///
1413	/// This creates the actual diagnostic array, an array of diagnostic subgroups
1414	/// and an array of subgroup names.
1415	///
1416	/// \code
1417	/// #ifdef GET_DIAG_ARRAYS
1418	/// static const int16_t DiagArrays[];
1419	/// static const int16_t DiagSubGroups[];
1420	/// static const char DiagGroupNames[];
1421	/// #endif
1422	/// \endcode
1423	static void emitAllDiagArrays(std::map<std::string, GroupInfo> &DiagsInGroup,
1424	RecordVec &DiagsInPedantic,
1425	RecordVec &GroupsInPedantic,
1426	StringToOffsetTable &GroupNames,
1427	raw_ostream &OS) {
1428	OS << "\n#ifdef GET_DIAG_ARRAYS\n";
1429	emitDiagArrays(DiagsInGroup, DiagsInPedantic, OS);
1430	emitDiagSubGroups(DiagsInGroup, GroupsInPedantic, OS);
1431	emitDiagGroupNames(GroupNames, OS);
1432	OS << "#endif // GET_DIAG_ARRAYS\n\n";
1433	}
1434
1435	/// Emit diagnostic table.
1436	///
1437	/// The table is sorted by the name of the diagnostic group. Each element
1438	/// consists of the name of the diagnostic group (given as offset in the
1439	/// group name table), a reference to a list of diagnostics (optional) and a
1440	/// reference to a set of subgroups (optional).
1441	///
1442	/// \code
1443	/// #ifdef GET_DIAG_TABLE
1444	/// {/* abi / 159, / DiagArray11 / 19, / Empty */ 0},
1445	/// {/* aggregate-return / 180, / Empty / 0, / Empty */ 0},
1446	/// {/* all / 197, / Empty / 0, / DiagSubGroup13 */ 3},
1447	/// {/* deprecated / 1981,/ DiagArray1 / 348, / DiagSubGroup3 */ 9},
1448	/// #endif
1449	/// \endcode
1450	static void emitDiagTable(std::map<std::string, GroupInfo> &DiagsInGroup,
1451	RecordVec &DiagsInPedantic,
1452	RecordVec &GroupsInPedantic,
1453	StringToOffsetTable &GroupNames, raw_ostream &OS) {
1454	unsigned MaxLen = 0;
1455
1456	for (auto const &I: DiagsInGroup)
1457	MaxLen = std::max(MaxLen, (unsigned)I.first.size());
1458
1459	OS << "\n#ifdef GET_DIAG_TABLE\n";
1460	unsigned SubGroupIndex = 1, DiagArrayIndex = 1;
1461	for (auto const &I: DiagsInGroup) {
1462	// Group option string.
1463	OS << " { /* ";
1464	if (I.first.find_first_not_of("abcdefghijklmnopqrstuvwxyz"
1465	"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1466	"0123456789!@#$%^*-+=:?") !=
1467	std::string::npos)
1468	PrintFatalError("Invalid character in diagnostic group '" + I.first +
1469	"'");
1470	OS << I.first << " */ " << std::string(MaxLen - I.first.size(), ' ');
1471	// Store a pascal-style length byte at the beginning of the string.
1472	std::string Name = char(I.first.size()) + I.first;
1473	OS << GroupNames.GetOrAddStringOffset(Name, false) << ", ";
1474
1475	// Special handling for 'pedantic'.
1476	const bool IsPedantic = I.first == "pedantic";
1477
1478	// Diagnostics in the group.
1479	const std::vector<const Record *> &V = I.second.DiagsInGroup;
1480	const bool hasDiags =
1481	!V.empty() \|\| (IsPedantic && !DiagsInPedantic.empty());
1482	if (hasDiags) {
1483	OS << "/* DiagArray" << I.second.IDNo << " */ " << DiagArrayIndex
1484	<< ", ";
1485	if (IsPedantic)
1486	DiagArrayIndex += DiagsInPedantic.size();
1487	DiagArrayIndex += V.size() + 1;
1488	} else {
1489	OS << "/* Empty */ 0, ";
1490	}
1491
1492	// Subgroups.
1493	const std::vector<std::string> &SubGroups = I.second.SubGroups;
1494	const bool hasSubGroups =
1495	!SubGroups.empty() \|\| (IsPedantic && !GroupsInPedantic.empty());
1496	if (hasSubGroups) {
1497	OS << "/* DiagSubGroup" << I.second.IDNo << " */ " << SubGroupIndex;
1498	if (IsPedantic)
1499	SubGroupIndex += GroupsInPedantic.size();
1500	SubGroupIndex += SubGroups.size() + 1;
1501	} else {
1502	OS << "/* Empty */ 0";
1503	}
1504
1505	OS << " },\n";
1506	}
1507	OS << "#endif // GET_DIAG_TABLE\n\n";
1508	}
1509
1510	/// Emit the table of diagnostic categories.
1511	///
1512	/// The table has the form of macro calls that have two parameters. The
1513	/// category's name as well as an enum that represents the category. The
1514	/// table can be used by defining the macro 'CATEGORY' and including this
1515	/// table right after.
1516	///
1517	/// \code
1518	/// #ifdef GET_CATEGORY_TABLE
1519	/// CATEGORY("Semantic Issue", DiagCat_Semantic_Issue)
1520	/// CATEGORY("Lambda Issue", DiagCat_Lambda_Issue)
1521	/// #endif
1522	/// \endcode
1523	static void emitCategoryTable(RecordKeeper &Records, raw_ostream &OS) {
1524	DiagCategoryIDMap CategoriesByID(Records);
1525	OS << "\n#ifdef GET_CATEGORY_TABLE\n";
1526	for (auto const &C : CategoriesByID)
1527	OS << "CATEGORY(\"" << C << "\", " << getDiagCategoryEnum(C) << ")\n";
1528	OS << "#endif // GET_CATEGORY_TABLE\n\n";
1529	}
1530
1531	namespace clang {
1532	void EmitClangDiagGroups(RecordKeeper &Records, raw_ostream &OS) {
1533	// Compute a mapping from a DiagGroup to all of its parents.
1534	DiagGroupParentMap DGParentMap(Records);
1535
1536	std::vector<Record *> Diags = Records.getAllDerivedDefinitions("Diagnostic");
1537
1538	std::vector<Record *> DiagGroups =
1539	Records.getAllDerivedDefinitions("DiagGroup");
1540
1541	std::map<std::string, GroupInfo> DiagsInGroup;
1542	groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
1543
1544	// All extensions are implicitly in the "pedantic" group. Record the
1545	// implicit set of groups in the "pedantic" group, and use this information
1546	// later when emitting the group information for Pedantic.
1547	RecordVec DiagsInPedantic;
1548	RecordVec GroupsInPedantic;
1549	InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
1550	inferPedantic.compute(&DiagsInPedantic, &GroupsInPedantic);
1551
1552	StringToOffsetTable GroupNames;
1553	for (std::map<std::string, GroupInfo>::const_iterator
1554	I = DiagsInGroup.begin(),
1555	E = DiagsInGroup.end();
1556	I != E; ++I) {
1557	// Store a pascal-style length byte at the beginning of the string.
1558	std::string Name = char(I->first.size()) + I->first;
1559	GroupNames.GetOrAddStringOffset(Name, false);
1560	}
1561
1562	emitAllDiagArrays(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
1563	OS);
1564	emitDiagTable(DiagsInGroup, DiagsInPedantic, GroupsInPedantic, GroupNames,
1565	OS);
1566	emitCategoryTable(Records, OS);
1567	}
1568	} // end namespace clang
1569
1570	//===----------------------------------------------------------------------===//
1571	// Diagnostic name index generation
1572	//===----------------------------------------------------------------------===//
1573
1574	namespace {
1575	struct RecordIndexElement
1576	{
1577	RecordIndexElement() {}
1578	explicit RecordIndexElement(Record const &R):
1579	Name(R.getName()) {}
1580
1581	std::string Name;
1582	};
1583	} // end anonymous namespace.
1584
1585	namespace clang {
1586	void EmitClangDiagsIndexName(RecordKeeper &Records, raw_ostream &OS) {
1587	const std::vector<Record*> &Diags =
1588	Records.getAllDerivedDefinitions("Diagnostic");
1589
1590	std::vector<RecordIndexElement> Index;
1591	Index.reserve(Diags.size());
1592	for (unsigned i = 0, e = Diags.size(); i != e; ++i) {
1593	const Record &R = *(Diags[i]);
1594	Index.push_back(RecordIndexElement(R));
1595	}
1596
1597	llvm::sort(Index,
1598	[](const RecordIndexElement &Lhs, const RecordIndexElement &Rhs) {
1599	return Lhs.Name < Rhs.Name;
1600	});
1601
1602	for (unsigned i = 0, e = Index.size(); i != e; ++i) {
1603	const RecordIndexElement &R = Index[i];
1604
1605	OS << "DIAG_NAME_INDEX(" << R.Name << ")\n";
1606	}
1607	}
1608
1609	//===----------------------------------------------------------------------===//
1610	// Diagnostic documentation generation
1611	//===----------------------------------------------------------------------===//
1612
1613	namespace docs {
1614	namespace {
1615
1616	bool isRemarkGroup(const Record *DiagGroup,
1617	const std::map<std::string, GroupInfo> &DiagsInGroup) {
1618	bool AnyRemarks = false, AnyNonRemarks = false;
1619
1620	std::function<void(StringRef)> Visit = [&](StringRef GroupName) {
1621	auto &GroupInfo = DiagsInGroup.find(GroupName)->second;
1622	for (const Record *Diag : GroupInfo.DiagsInGroup)
1623	(isRemark(*Diag) ? AnyRemarks : AnyNonRemarks) = true;
1624	for (const auto &Name : GroupInfo.SubGroups)
1625	Visit(Name);
1626	};
1627	Visit(DiagGroup->getValueAsString("GroupName"));
1628
1629	if (AnyRemarks && AnyNonRemarks)
1630	PrintFatalError(
1631	DiagGroup->getLoc(),
1632	"Diagnostic group contains both remark and non-remark diagnostics");
1633	return AnyRemarks;
1634	}
1635
1636	std::string getDefaultSeverity(const Record *Diag) {
1637	return Diag->getValueAsDef("DefaultSeverity")->getValueAsString("Name");
1638	}
1639
1640	std::set<std::string>
1641	getDefaultSeverities(const Record *DiagGroup,
1642	const std::map<std::string, GroupInfo> &DiagsInGroup) {
1643	std::set<std::string> States;
1644
1645	std::function<void(StringRef)> Visit = [&](StringRef GroupName) {
1646	auto &GroupInfo = DiagsInGroup.find(GroupName)->second;
1647	for (const Record *Diag : GroupInfo.DiagsInGroup)
1648	States.insert(getDefaultSeverity(Diag));
1649	for (const auto &Name : GroupInfo.SubGroups)
1650	Visit(Name);
1651	};
1652	Visit(DiagGroup->getValueAsString("GroupName"));
1653	return States;
1654	}
1655
1656	void writeHeader(StringRef Str, raw_ostream &OS, char Kind = '-') {
1657	OS << Str << "\n" << std::string(Str.size(), Kind) << "\n";
1658	}
1659
1660	void writeDiagnosticText(DiagnosticTextBuilder &Builder, const Record *R,
1661	StringRef Role, raw_ostream &OS) {
1662	StringRef Text = R->getValueAsString("Text");
1663	if (Text == "%0")
1664	OS << "The text of this diagnostic is not controlled by Clang.\n\n";
1665	else {
1666	std::vector<std::string> Out = Builder.buildForDocumentation(Role, R);
1667	for (auto &Line : Out)
1668	OS << Line << "\n";
1669	OS << "\n";
1670	}
1671	}
1672
1673	} // namespace
1674	} // namespace docs
1675
1676	void EmitClangDiagDocs(RecordKeeper &Records, raw_ostream &OS) {
1677	using namespace docs;
1678
1679	// Get the documentation introduction paragraph.
1680	const Record *Documentation = Records.getDef("GlobalDocumentation");
1681	if (!Documentation) {
1682	PrintFatalError("The Documentation top-level definition is missing, "
1683	"no documentation will be generated.");
1684	return;
1685	}
1686
1687	OS << Documentation->getValueAsString("Intro") << "\n";
1688
1689	DiagnosticTextBuilder Builder(Records);
1690
1691	std::vector<Record*> Diags =
1692	Records.getAllDerivedDefinitions("Diagnostic");
1693
1694	std::vector<Record*> DiagGroups =
1695	Records.getAllDerivedDefinitions("DiagGroup");
1696	llvm::sort(DiagGroups, diagGroupBeforeByName);
1697
1698	DiagGroupParentMap DGParentMap(Records);
1699
1700	std::map<std::string, GroupInfo> DiagsInGroup;
1701	groupDiagnostics(Diags, DiagGroups, DiagsInGroup);
1702
1703	// Compute the set of diagnostics that are in -Wpedantic.
1704	{
1705	RecordSet DiagsInPedanticSet;
1706	RecordSet GroupsInPedanticSet;
1707	InferPedantic inferPedantic(DGParentMap, Diags, DiagGroups, DiagsInGroup);
1708	inferPedantic.compute(&DiagsInPedanticSet, &GroupsInPedanticSet);
1709	auto &PedDiags = DiagsInGroup["pedantic"];
1710	// Put the diagnostics into a deterministic order.
1711	RecordVec DiagsInPedantic(DiagsInPedanticSet.begin(),
1712	DiagsInPedanticSet.end());
1713	RecordVec GroupsInPedantic(GroupsInPedanticSet.begin(),
1714	GroupsInPedanticSet.end());
1715	llvm::sort(DiagsInPedantic, beforeThanCompare);
1716	llvm::sort(GroupsInPedantic, beforeThanCompare);
1717	PedDiags.DiagsInGroup.insert(PedDiags.DiagsInGroup.end(),
1718	DiagsInPedantic.begin(),
1719	DiagsInPedantic.end());
1720	for (auto *Group : GroupsInPedantic)
1721	PedDiags.SubGroups.push_back(Group->getValueAsString("GroupName"));
1722	}
1723
1724	// FIXME: Write diagnostic categories and link to diagnostic groups in each.
1725
1726	// Write out the diagnostic groups.
1727	for (const Record *G : DiagGroups) {
1728	bool IsRemarkGroup = isRemarkGroup(G, DiagsInGroup);
1729	auto &GroupInfo = DiagsInGroup[G->getValueAsString("GroupName")];
1730	bool IsSynonym = GroupInfo.DiagsInGroup.empty() &&
1731	GroupInfo.SubGroups.size() == 1;
1732
1733	writeHeader(((IsRemarkGroup ? "-R" : "-W") +
1734	G->getValueAsString("GroupName")).str(),
1735	OS);
1736
1737	if (!IsSynonym) {
1738	// FIXME: Ideally, all the diagnostics in a group should have the same
1739	// default state, but that is not currently the case.
1740	auto DefaultSeverities = getDefaultSeverities(G, DiagsInGroup);
1741	if (!DefaultSeverities.empty() && !DefaultSeverities.count("Ignored")) {
1742	bool AnyNonErrors = DefaultSeverities.count("Warning") \|\|
1743	DefaultSeverities.count("Remark");
1744	if (!AnyNonErrors)
1745	OS << "This diagnostic is an error by default, but the flag ``-Wno-"
1746	<< G->getValueAsString("GroupName") << "`` can be used to disable "
1747	<< "the error.\n\n";
1748	else
1749	OS << "This diagnostic is enabled by default.\n\n";
1750	} else if (DefaultSeverities.size() > 1) {
1751	OS << "Some of the diagnostics controlled by this flag are enabled "
1752	<< "by default.\n\n";
1753	}
1754	}
1755
1756	if (!GroupInfo.SubGroups.empty()) {
1757	if (IsSynonym)
1758	OS << "Synonym for ";
1759	else if (GroupInfo.DiagsInGroup.empty())
1760	OS << "Controls ";
1761	else
1762	OS << "Also controls ";
1763
1764	bool First = true;
1765	llvm::sort(GroupInfo.SubGroups);
1766	for (const auto &Name : GroupInfo.SubGroups) {
1767	if (!First) OS << ", ";
1768	OS << "`" << (IsRemarkGroup ? "-R" : "-W") << Name << "`_";
1769	First = false;
1770	}
1771	OS << ".\n\n";
1772	}
1773
1774	if (!GroupInfo.DiagsInGroup.empty()) {
1775	OS << "Diagnostic text:\n\n";
1776	for (const Record *D : GroupInfo.DiagsInGroup) {
1777	auto Severity = getDefaultSeverity(D);
1778	Severity[0] = tolower(Severity[0]);
1779	if (Severity == "ignored")
1780	Severity = IsRemarkGroup ? "remark" : "warning";
1781
1782	writeDiagnosticText(Builder, D, Severity, OS);
1783	}
1784	}
1785
1786	auto Doc = G->getValueAsString("Documentation");
1787	if (!Doc.empty())
1788	OS << Doc;
1789	else if (GroupInfo.SubGroups.empty() && GroupInfo.DiagsInGroup.empty())
1790	OS << "This diagnostic flag exists for GCC compatibility, and has no "
1791	"effect in Clang.\n";
1792	OS << "\n";
1793	}
1794	}
1795
1796	} // end namespace clang
1797

Clang Project