-
Notifications
You must be signed in to change notification settings - Fork 11.1k
/
Diagnostic.h
1856 lines (1533 loc) · 63.6 KB
/
Diagnostic.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//===- Diagnostic.h - C Language Family Diagnostic Handling -----*- C++ -*-===https://
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===https://
//
/// \file
/// Defines the Diagnostic-related interfaces.
//
//===----------------------------------------------------------------------===https://
#ifndef LLVM_CLANG_BASIC_DIAGNOSTIC_H
#define LLVM_CLANG_BASIC_DIAGNOSTIC_H
#include "clang/Basic/DiagnosticIDs.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/Specifiers.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/IntrusiveRefCntPtr.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/iterator_range.h"
#include "llvm/Support/Compiler.h"
#include <cassert>
#include <cstdint>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
namespace llvm {
class Error;
class raw_ostream;
} // namespace llvm
namespace clang {
class DeclContext;
class DiagnosticBuilder;
class DiagnosticConsumer;
class IdentifierInfo;
class LangOptions;
class Preprocessor;
class SourceManager;
class StoredDiagnostic;
namespace tok {
enum TokenKind : unsigned short;
} // namespace tok
/// Annotates a diagnostic with some code that should be
/// inserted, removed, or replaced to fix the problem.
///
/// This kind of hint should be used when we are certain that the
/// introduction, removal, or modification of a particular (small!)
/// amount of code will correct a compilation error. The compiler
/// should also provide full recovery from such errors, such that
/// suppressing the diagnostic output can still result in successful
/// compilation.
class FixItHint {
public:
/// Code that should be replaced to correct the error. Empty for an
/// insertion hint.
CharSourceRange RemoveRange;
/// Code in the specific range that should be inserted in the insertion
/// location.
CharSourceRange InsertFromRange;
/// The actual code to insert at the insertion location, as a
/// string.
std::string CodeToInsert;
bool BeforePreviousInsertions = false;
/// Empty code modification hint, indicating that no code
/// modification is known.
FixItHint() = default;
bool isNull() const {
return !RemoveRange.isValid();
}
/// Create a code modification hint that inserts the given
/// code string at a specific location.
static FixItHint CreateInsertion(SourceLocation InsertionLoc,
StringRef Code,
bool BeforePreviousInsertions = false) {
FixItHint Hint;
Hint.RemoveRange =
CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);
Hint.CodeToInsert = std::string(Code);
Hint.BeforePreviousInsertions = BeforePreviousInsertions;
return Hint;
}
/// Create a code modification hint that inserts the given
/// code from \p FromRange at a specific location.
static FixItHint CreateInsertionFromRange(SourceLocation InsertionLoc,
CharSourceRange FromRange,
bool BeforePreviousInsertions = false) {
FixItHint Hint;
Hint.RemoveRange =
CharSourceRange::getCharRange(InsertionLoc, InsertionLoc);
Hint.InsertFromRange = FromRange;
Hint.BeforePreviousInsertions = BeforePreviousInsertions;
return Hint;
}
/// Create a code modification hint that removes the given
/// source range.
static FixItHint CreateRemoval(CharSourceRange RemoveRange) {
FixItHint Hint;
Hint.RemoveRange = RemoveRange;
return Hint;
}
static FixItHint CreateRemoval(SourceRange RemoveRange) {
return CreateRemoval(CharSourceRange::getTokenRange(RemoveRange));
}
/// Create a code modification hint that replaces the given
/// source range with the given code string.
static FixItHint CreateReplacement(CharSourceRange RemoveRange,
StringRef Code) {
FixItHint Hint;
Hint.RemoveRange = RemoveRange;
Hint.CodeToInsert = std::string(Code);
return Hint;
}
static FixItHint CreateReplacement(SourceRange RemoveRange,
StringRef Code) {
return CreateReplacement(CharSourceRange::getTokenRange(RemoveRange), Code);
}
};
struct DiagnosticStorage {
enum {
/// The maximum number of arguments we can hold. We
/// currently only support up to 10 arguments (%0-%9).
///
/// A single diagnostic with more than that almost certainly has to
/// be simplified anyway.
MaxArguments = 10
};
/// The number of entries in Arguments.
unsigned char NumDiagArgs = 0;
/// Specifies for each argument whether it is in DiagArgumentsStr
/// or in DiagArguments.
unsigned char DiagArgumentsKind[MaxArguments];
/// The values for the various substitution positions.
///
/// This is used when the argument is not an std::string. The specific value
/// is mangled into an uint64_t and the interpretation depends on exactly
/// what sort of argument kind it is.
uint64_t DiagArgumentsVal[MaxArguments];
/// The values for the various substitution positions that have
/// string arguments.
std::string DiagArgumentsStr[MaxArguments];
/// The list of ranges added to this diagnostic.
SmallVector<CharSourceRange, 8> DiagRanges;
/// If valid, provides a hint with some code to insert, remove, or
/// modify at a particular position.
SmallVector<FixItHint, 6> FixItHints;
DiagnosticStorage() = default;
};
/// Concrete class used by the front-end to report problems and issues.
///
/// This massages the diagnostics (e.g. handling things like "report warnings
/// as errors" and passes them off to the DiagnosticConsumer for reporting to
/// the user. DiagnosticsEngine is tied to one translation unit and one
/// SourceManager.
class DiagnosticsEngine : public RefCountedBase<DiagnosticsEngine> {
public:
/// The level of the diagnostic, after it has been through mapping.
enum Level {
Ignored = DiagnosticIDs::Ignored,
Note = DiagnosticIDs::Note,
Remark = DiagnosticIDs::Remark,
Warning = DiagnosticIDs::Warning,
Error = DiagnosticIDs::Error,
Fatal = DiagnosticIDs::Fatal
};
enum ArgumentKind {
/// std::string
ak_std_string,
/// const char *
ak_c_string,
/// int
ak_sint,
/// unsigned
ak_uint,
/// enum TokenKind : unsigned
ak_tokenkind,
/// IdentifierInfo
ak_identifierinfo,
/// address space
ak_addrspace,
/// Qualifiers
ak_qual,
/// QualType
ak_qualtype,
/// DeclarationName
ak_declarationname,
/// NamedDecl *
ak_nameddecl,
/// NestedNameSpecifier *
ak_nestednamespec,
/// DeclContext *
ak_declcontext,
/// pair<QualType, QualType>
ak_qualtype_pair,
/// Attr *
ak_attr
};
/// Represents on argument value, which is a union discriminated
/// by ArgumentKind, with a value.
using ArgumentValue = std::pair<ArgumentKind, intptr_t>;
private:
// Used by __extension__
unsigned char AllExtensionsSilenced = 0;
// Treat fatal errors like errors.
bool FatalsAsError = false;
// Suppress all diagnostics.
bool SuppressAllDiagnostics = false;
// Elide common types of templates.
bool ElideType = true;
// Print a tree when comparing templates.
bool PrintTemplateTree = false;
// Color printing is enabled.
bool ShowColors = false;
// Which overload candidates to show.
OverloadsShown ShowOverloads = Ovl_All;
// With Ovl_Best, the number of overload candidates to show when we encounter
// an error.
//
// The value here is the number of candidates to show in the first nontrivial
// error. Future errors may show a different number of candidates.
unsigned NumOverloadsToShow = 32;
// Cap of # errors emitted, 0 -> no limit.
unsigned ErrorLimit = 0;
// Cap on depth of template backtrace stack, 0 -> no limit.
unsigned TemplateBacktraceLimit = 0;
// Cap on depth of constexpr evaluation backtrace stack, 0 -> no limit.
unsigned ConstexprBacktraceLimit = 0;
IntrusiveRefCntPtr<DiagnosticIDs> Diags;
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
DiagnosticConsumer *Client = nullptr;
std::unique_ptr<DiagnosticConsumer> Owner;
SourceManager *SourceMgr = nullptr;
/// Mapping information for diagnostics.
///
/// Mapping info is packed into four bits per diagnostic. The low three
/// bits are the mapping (an instance of diag::Severity), or zero if unset.
/// The high bit is set when the mapping was established as a user mapping.
/// If the high bit is clear, then the low bits are set to the default
/// value, and should be mapped with -pedantic, -Werror, etc.
///
/// A new DiagState is created and kept around when diagnostic pragmas modify
/// the state so that we know what is the diagnostic state at any given
/// source location.
class DiagState {
llvm::DenseMap<unsigned, DiagnosticMapping> DiagMap;
public:
// "Global" configuration state that can actually vary between modules.
// Ignore all warnings: -w
LLVM_PREFERRED_TYPE(bool)
unsigned IgnoreAllWarnings : 1;
// Enable all warnings.
LLVM_PREFERRED_TYPE(bool)
unsigned EnableAllWarnings : 1;
// Treat warnings like errors.
LLVM_PREFERRED_TYPE(bool)
unsigned WarningsAsErrors : 1;
// Treat errors like fatal errors.
LLVM_PREFERRED_TYPE(bool)
unsigned ErrorsAsFatal : 1;
// Suppress warnings in system headers.
LLVM_PREFERRED_TYPE(bool)
unsigned SuppressSystemWarnings : 1;
// Map extensions to warnings or errors?
diag::Severity ExtBehavior = diag::Severity::Ignored;
DiagState()
: IgnoreAllWarnings(false), EnableAllWarnings(false),
WarningsAsErrors(false), ErrorsAsFatal(false),
SuppressSystemWarnings(false) {}
using iterator = llvm::DenseMap<unsigned, DiagnosticMapping>::iterator;
using const_iterator =
llvm::DenseMap<unsigned, DiagnosticMapping>::const_iterator;
void setMapping(diag::kind Diag, DiagnosticMapping Info) {
DiagMap[Diag] = Info;
}
DiagnosticMapping lookupMapping(diag::kind Diag) const {
return DiagMap.lookup(Diag);
}
DiagnosticMapping &getOrAddMapping(diag::kind Diag);
const_iterator begin() const { return DiagMap.begin(); }
const_iterator end() const { return DiagMap.end(); }
};
/// Keeps and automatically disposes all DiagStates that we create.
std::list<DiagState> DiagStates;
/// A mapping from files to the diagnostic states for those files. Lazily
/// built on demand for files in which the diagnostic state has not changed.
class DiagStateMap {
public:
/// Add an initial diagnostic state.
void appendFirst(DiagState *State);
/// Add a new latest state point.
void append(SourceManager &SrcMgr, SourceLocation Loc, DiagState *State);
/// Look up the diagnostic state at a given source location.
DiagState *lookup(SourceManager &SrcMgr, SourceLocation Loc) const;
/// Determine whether this map is empty.
bool empty() const { return Files.empty(); }
/// Clear out this map.
void clear() {
Files.clear();
FirstDiagState = CurDiagState = nullptr;
CurDiagStateLoc = SourceLocation();
}
/// Produce a debugging dump of the diagnostic state.
LLVM_DUMP_METHOD void dump(SourceManager &SrcMgr,
StringRef DiagName = StringRef()) const;
/// Grab the most-recently-added state point.
DiagState *getCurDiagState() const { return CurDiagState; }
/// Get the location at which a diagnostic state was last added.
SourceLocation getCurDiagStateLoc() const { return CurDiagStateLoc; }
private:
friend class ASTReader;
friend class ASTWriter;
/// Represents a point in source where the diagnostic state was
/// modified because of a pragma.
///
/// 'Loc' can be null if the point represents the diagnostic state
/// modifications done through the command-line.
struct DiagStatePoint {
DiagState *State;
unsigned Offset;
DiagStatePoint(DiagState *State, unsigned Offset)
: State(State), Offset(Offset) {}
};
/// Description of the diagnostic states and state transitions for a
/// particular FileID.
struct File {
/// The diagnostic state for the parent file. This is strictly redundant,
/// as looking up the DecomposedIncludedLoc for the FileID in the Files
/// map would give us this, but we cache it here for performance.
File *Parent = nullptr;
/// The offset of this file within its parent.
unsigned ParentOffset = 0;
/// Whether this file has any local (not imported from an AST file)
/// diagnostic state transitions.
bool HasLocalTransitions = false;
/// The points within the file where the state changes. There will always
/// be at least one of these (the state on entry to the file).
llvm::SmallVector<DiagStatePoint, 4> StateTransitions;
DiagState *lookup(unsigned Offset) const;
};
/// The diagnostic states for each file.
mutable std::map<FileID, File> Files;
/// The initial diagnostic state.
DiagState *FirstDiagState;
/// The current diagnostic state.
DiagState *CurDiagState;
/// The location at which the current diagnostic state was established.
SourceLocation CurDiagStateLoc;
/// Get the diagnostic state information for a file.
File *getFile(SourceManager &SrcMgr, FileID ID) const;
};
DiagStateMap DiagStatesByLoc;
/// Keeps the DiagState that was active during each diagnostic 'push'
/// so we can get back at it when we 'pop'.
std::vector<DiagState *> DiagStateOnPushStack;
DiagState *GetCurDiagState() const {
return DiagStatesByLoc.getCurDiagState();
}
void PushDiagStatePoint(DiagState *State, SourceLocation L);
/// Finds the DiagStatePoint that contains the diagnostic state of
/// the given source location.
DiagState *GetDiagStateForLoc(SourceLocation Loc) const {
return SourceMgr ? DiagStatesByLoc.lookup(*SourceMgr, Loc)
: DiagStatesByLoc.getCurDiagState();
}
/// Sticky flag set to \c true when an error is emitted.
bool ErrorOccurred;
/// Sticky flag set to \c true when an "uncompilable error" occurs.
/// I.e. an error that was not upgraded from a warning by -Werror.
bool UncompilableErrorOccurred;
/// Sticky flag set to \c true when a fatal error is emitted.
bool FatalErrorOccurred;
/// Indicates that an unrecoverable error has occurred.
bool UnrecoverableErrorOccurred;
/// Counts for DiagnosticErrorTrap to check whether an error occurred
/// during a parsing section, e.g. during parsing a function.
unsigned TrapNumErrorsOccurred;
unsigned TrapNumUnrecoverableErrorsOccurred;
/// The level of the last diagnostic emitted.
///
/// This is used to emit continuation diagnostics with the same level as the
/// diagnostic that they follow.
DiagnosticIDs::Level LastDiagLevel;
/// Number of warnings reported
unsigned NumWarnings;
/// Number of errors reported
unsigned NumErrors;
/// A function pointer that converts an opaque diagnostic
/// argument to a strings.
///
/// This takes the modifiers and argument that was present in the diagnostic.
///
/// The PrevArgs array indicates the previous arguments formatted for this
/// diagnostic. Implementations of this function can use this information to
/// avoid redundancy across arguments.
///
/// This is a hack to avoid a layering violation between libbasic and libsema.
using ArgToStringFnTy = void (*)(
ArgumentKind Kind, intptr_t Val,
StringRef Modifier, StringRef Argument,
ArrayRef<ArgumentValue> PrevArgs,
SmallVectorImpl<char> &Output,
void *Cookie,
ArrayRef<intptr_t> QualTypeVals);
void *ArgToStringCookie = nullptr;
ArgToStringFnTy ArgToStringFn;
/// ID of the "delayed" diagnostic, which is a (typically
/// fatal) diagnostic that had to be delayed because it was found
/// while emitting another diagnostic.
unsigned DelayedDiagID;
/// First string argument for the delayed diagnostic.
std::string DelayedDiagArg1;
/// Second string argument for the delayed diagnostic.
std::string DelayedDiagArg2;
/// Third string argument for the delayed diagnostic.
std::string DelayedDiagArg3;
/// Optional flag value.
///
/// Some flags accept values, for instance: -Wframe-larger-than=<value> and
/// -Rpass=<value>. The content of this string is emitted after the flag name
/// and '='.
std::string FlagValue;
public:
explicit DiagnosticsEngine(IntrusiveRefCntPtr<DiagnosticIDs> Diags,
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
DiagnosticConsumer *client = nullptr,
bool ShouldOwnClient = true);
DiagnosticsEngine(const DiagnosticsEngine &) = delete;
DiagnosticsEngine &operator=(const DiagnosticsEngine &) = delete;
~DiagnosticsEngine();
friend void DiagnosticsTestHelper(DiagnosticsEngine &);
LLVM_DUMP_METHOD void dump() const;
LLVM_DUMP_METHOD void dump(StringRef DiagName) const;
const IntrusiveRefCntPtr<DiagnosticIDs> &getDiagnosticIDs() const {
return Diags;
}
/// Retrieve the diagnostic options.
DiagnosticOptions &getDiagnosticOptions() const { return *DiagOpts; }
using diag_mapping_range = llvm::iterator_range<DiagState::const_iterator>;
/// Get the current set of diagnostic mappings.
diag_mapping_range getDiagnosticMappings() const {
const DiagState &DS = *GetCurDiagState();
return diag_mapping_range(DS.begin(), DS.end());
}
DiagnosticConsumer *getClient() { return Client; }
const DiagnosticConsumer *getClient() const { return Client; }
/// Determine whether this \c DiagnosticsEngine object own its client.
bool ownsClient() const { return Owner != nullptr; }
/// Return the current diagnostic client along with ownership of that
/// client.
std::unique_ptr<DiagnosticConsumer> takeClient() { return std::move(Owner); }
bool hasSourceManager() const { return SourceMgr != nullptr; }
SourceManager &getSourceManager() const {
assert(SourceMgr && "SourceManager not set!");
return *SourceMgr;
}
void setSourceManager(SourceManager *SrcMgr) {
assert(DiagStatesByLoc.empty() &&
"Leftover diag state from a different SourceManager.");
SourceMgr = SrcMgr;
}
//===--------------------------------------------------------------------===https://
// DiagnosticsEngine characterization methods, used by a client to customize
// how diagnostics are emitted.
//
/// Copies the current DiagMappings and pushes the new copy
/// onto the top of the stack.
void pushMappings(SourceLocation Loc);
/// Pops the current DiagMappings off the top of the stack,
/// causing the new top of the stack to be the active mappings.
///
/// \returns \c true if the pop happens, \c false if there is only one
/// DiagMapping on the stack.
bool popMappings(SourceLocation Loc);
/// Set the diagnostic client associated with this diagnostic object.
///
/// \param ShouldOwnClient true if the diagnostic object should take
/// ownership of \c client.
void setClient(DiagnosticConsumer *client, bool ShouldOwnClient = true);
/// Specify a limit for the number of errors we should
/// emit before giving up.
///
/// Zero disables the limit.
void setErrorLimit(unsigned Limit) { ErrorLimit = Limit; }
/// Specify the maximum number of template instantiation
/// notes to emit along with a given diagnostic.
void setTemplateBacktraceLimit(unsigned Limit) {
TemplateBacktraceLimit = Limit;
}
/// Retrieve the maximum number of template instantiation
/// notes to emit along with a given diagnostic.
unsigned getTemplateBacktraceLimit() const {
return TemplateBacktraceLimit;
}
/// Specify the maximum number of constexpr evaluation
/// notes to emit along with a given diagnostic.
void setConstexprBacktraceLimit(unsigned Limit) {
ConstexprBacktraceLimit = Limit;
}
/// Retrieve the maximum number of constexpr evaluation
/// notes to emit along with a given diagnostic.
unsigned getConstexprBacktraceLimit() const {
return ConstexprBacktraceLimit;
}
/// When set to true, any unmapped warnings are ignored.
///
/// If this and WarningsAsErrors are both set, then this one wins.
void setIgnoreAllWarnings(bool Val) {
GetCurDiagState()->IgnoreAllWarnings = Val;
}
bool getIgnoreAllWarnings() const {
return GetCurDiagState()->IgnoreAllWarnings;
}
/// When set to true, any unmapped ignored warnings are no longer
/// ignored.
///
/// If this and IgnoreAllWarnings are both set, then that one wins.
void setEnableAllWarnings(bool Val) {
GetCurDiagState()->EnableAllWarnings = Val;
}
bool getEnableAllWarnings() const {
return GetCurDiagState()->EnableAllWarnings;
}
/// When set to true, any warnings reported are issued as errors.
void setWarningsAsErrors(bool Val) {
GetCurDiagState()->WarningsAsErrors = Val;
}
bool getWarningsAsErrors() const {
return GetCurDiagState()->WarningsAsErrors;
}
/// When set to true, any error reported is made a fatal error.
void setErrorsAsFatal(bool Val) { GetCurDiagState()->ErrorsAsFatal = Val; }
bool getErrorsAsFatal() const { return GetCurDiagState()->ErrorsAsFatal; }
/// \brief When set to true, any fatal error reported is made an error.
///
/// This setting takes precedence over the setErrorsAsFatal setting above.
void setFatalsAsError(bool Val) { FatalsAsError = Val; }
bool getFatalsAsError() const { return FatalsAsError; }
/// When set to true mask warnings that come from system headers.
void setSuppressSystemWarnings(bool Val) {
GetCurDiagState()->SuppressSystemWarnings = Val;
}
bool getSuppressSystemWarnings() const {
return GetCurDiagState()->SuppressSystemWarnings;
}
/// Suppress all diagnostics, to silence the front end when we
/// know that we don't want any more diagnostics to be passed along to the
/// client
void setSuppressAllDiagnostics(bool Val) { SuppressAllDiagnostics = Val; }
bool getSuppressAllDiagnostics() const { return SuppressAllDiagnostics; }
/// Set type eliding, to skip outputting same types occurring in
/// template types.
void setElideType(bool Val) { ElideType = Val; }
bool getElideType() { return ElideType; }
/// Set tree printing, to outputting the template difference in a
/// tree format.
void setPrintTemplateTree(bool Val) { PrintTemplateTree = Val; }
bool getPrintTemplateTree() { return PrintTemplateTree; }
/// Set color printing, so the type diffing will inject color markers
/// into the output.
void setShowColors(bool Val) { ShowColors = Val; }
bool getShowColors() { return ShowColors; }
/// Specify which overload candidates to show when overload resolution
/// fails.
///
/// By default, we show all candidates.
void setShowOverloads(OverloadsShown Val) {
ShowOverloads = Val;
}
OverloadsShown getShowOverloads() const { return ShowOverloads; }
/// When a call or operator fails, print out up to this many candidate
/// overloads as suggestions.
///
/// With Ovl_Best, we set a high limit for the first nontrivial overload set
/// we print, and a lower limit for later sets. This way the user has a
/// chance of diagnosing at least one callsite in their program without
/// having to recompile with -fshow-overloads=all.
unsigned getNumOverloadCandidatesToShow() const {
switch (getShowOverloads()) {
case Ovl_All:
// INT_MAX rather than UINT_MAX so that we don't have to think about the
// effect of implicit conversions on this value. In practice we'll never
// hit 2^31 candidates anyway.
return std::numeric_limits<int>::max();
case Ovl_Best:
return NumOverloadsToShow;
}
llvm_unreachable("invalid OverloadsShown kind");
}
/// Call this after showing N overload candidates. This influences the value
/// returned by later calls to getNumOverloadCandidatesToShow().
void overloadCandidatesShown(unsigned N) {
// Current heuristic: Start out with a large value for NumOverloadsToShow,
// and then once we print one nontrivially-large overload set, decrease it
// for future calls.
if (N > 4) {
NumOverloadsToShow = 4;
}
}
/// Pretend that the last diagnostic issued was ignored, so any
/// subsequent notes will be suppressed, or restore a prior ignoring
/// state after ignoring some diagnostics and their notes, possibly in
/// the middle of another diagnostic.
///
/// This can be used by clients who suppress diagnostics themselves.
void setLastDiagnosticIgnored(bool Ignored) {
if (LastDiagLevel == DiagnosticIDs::Fatal)
FatalErrorOccurred = true;
LastDiagLevel = Ignored ? DiagnosticIDs::Ignored : DiagnosticIDs::Warning;
}
/// Determine whether the previous diagnostic was ignored. This can
/// be used by clients that want to determine whether notes attached to a
/// diagnostic will be suppressed.
bool isLastDiagnosticIgnored() const {
return LastDiagLevel == DiagnosticIDs::Ignored;
}
/// Controls whether otherwise-unmapped extension diagnostics are
/// mapped onto ignore/warning/error.
///
/// This corresponds to the GCC -pedantic and -pedantic-errors option.
void setExtensionHandlingBehavior(diag::Severity H) {
GetCurDiagState()->ExtBehavior = H;
}
diag::Severity getExtensionHandlingBehavior() const {
return GetCurDiagState()->ExtBehavior;
}
/// Counter bumped when an __extension__ block is/ encountered.
///
/// When non-zero, all extension diagnostics are entirely silenced, no
/// matter how they are mapped.
void IncrementAllExtensionsSilenced() { ++AllExtensionsSilenced; }
void DecrementAllExtensionsSilenced() { --AllExtensionsSilenced; }
bool hasAllExtensionsSilenced() { return AllExtensionsSilenced != 0; }
/// This allows the client to specify that certain warnings are
/// ignored.
///
/// Notes can never be mapped, errors can only be mapped to fatal, and
/// WARNINGs and EXTENSIONs can be mapped arbitrarily.
///
/// \param Loc The source location that this change of diagnostic state should
/// take affect. It can be null if we are setting the latest state.
void setSeverity(diag::kind Diag, diag::Severity Map, SourceLocation Loc);
/// Change an entire diagnostic group (e.g. "unknown-pragmas") to
/// have the specified mapping.
///
/// \returns true (and ignores the request) if "Group" was unknown, false
/// otherwise.
///
/// \param Flavor The flavor of group to affect. -Rfoo does not affect the
/// state of the -Wfoo group and vice versa.
///
/// \param Loc The source location that this change of diagnostic state should
/// take affect. It can be null if we are setting the state from command-line.
bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group,
diag::Severity Map,
SourceLocation Loc = SourceLocation());
bool setSeverityForGroup(diag::Flavor Flavor, diag::Group Group,
diag::Severity Map,
SourceLocation Loc = SourceLocation());
/// Set the warning-as-error flag for the given diagnostic group.
///
/// This function always only operates on the current diagnostic state.
///
/// \returns True if the given group is unknown, false otherwise.
bool setDiagnosticGroupWarningAsError(StringRef Group, bool Enabled);
/// Set the error-as-fatal flag for the given diagnostic group.
///
/// This function always only operates on the current diagnostic state.
///
/// \returns True if the given group is unknown, false otherwise.
bool setDiagnosticGroupErrorAsFatal(StringRef Group, bool Enabled);
/// Add the specified mapping to all diagnostics of the specified
/// flavor.
///
/// Mainly to be used by -Wno-everything to disable all warnings but allow
/// subsequent -W options to enable specific warnings.
void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map,
SourceLocation Loc = SourceLocation());
bool hasErrorOccurred() const { return ErrorOccurred; }
/// Errors that actually prevent compilation, not those that are
/// upgraded from a warning by -Werror.
bool hasUncompilableErrorOccurred() const {
return UncompilableErrorOccurred;
}
bool hasFatalErrorOccurred() const { return FatalErrorOccurred; }
/// Determine whether any kind of unrecoverable error has occurred.
bool hasUnrecoverableErrorOccurred() const {
return FatalErrorOccurred || UnrecoverableErrorOccurred;
}
unsigned getNumErrors() const { return NumErrors; }
unsigned getNumWarnings() const { return NumWarnings; }
void setNumWarnings(unsigned NumWarnings) {
this->NumWarnings = NumWarnings;
}
/// Return an ID for a diagnostic with the specified format string and
/// level.
///
/// If this is the first request for this diagnostic, it is registered and
/// created, otherwise the existing ID is returned.
///
/// \param FormatString A fixed diagnostic format string that will be hashed
/// and mapped to a unique DiagID.
template <unsigned N>
unsigned getCustomDiagID(Level L, const char (&FormatString)[N]) {
return Diags->getCustomDiagID((DiagnosticIDs::Level)L,
StringRef(FormatString, N - 1));
}
/// Converts a diagnostic argument (as an intptr_t) into the string
/// that represents it.
void ConvertArgToString(ArgumentKind Kind, intptr_t Val,
StringRef Modifier, StringRef Argument,
ArrayRef<ArgumentValue> PrevArgs,
SmallVectorImpl<char> &Output,
ArrayRef<intptr_t> QualTypeVals) const {
ArgToStringFn(Kind, Val, Modifier, Argument, PrevArgs, Output,
ArgToStringCookie, QualTypeVals);
}
void SetArgToStringFn(ArgToStringFnTy Fn, void *Cookie) {
ArgToStringFn = Fn;
ArgToStringCookie = Cookie;
}
/// Note that the prior diagnostic was emitted by some other
/// \c DiagnosticsEngine, and we may be attaching a note to that diagnostic.
void notePriorDiagnosticFrom(const DiagnosticsEngine &Other) {
LastDiagLevel = Other.LastDiagLevel;
}
/// Reset the state of the diagnostic object to its initial configuration.
/// \param[in] soft - if true, doesn't reset the diagnostic mappings and state
void Reset(bool soft = false);
//===--------------------------------------------------------------------===https://
// DiagnosticsEngine classification and reporting interfaces.
//
/// Determine whether the diagnostic is known to be ignored.
///
/// This can be used to opportunistically avoid expensive checks when it's
/// known for certain that the diagnostic has been suppressed at the
/// specified location \p Loc.
///
/// \param Loc The source location we are interested in finding out the
/// diagnostic state. Can be null in order to query the latest state.
bool isIgnored(unsigned DiagID, SourceLocation Loc) const {
return Diags->getDiagnosticSeverity(DiagID, Loc, *this) ==
diag::Severity::Ignored;
}
/// Based on the way the client configured the DiagnosticsEngine
/// object, classify the specified diagnostic ID into a Level, consumable by
/// the DiagnosticConsumer.
///
/// To preserve invariant assumptions, this function should not be used to
/// influence parse or semantic analysis actions. Instead consider using
/// \c isIgnored().
///
/// \param Loc The source location we are interested in finding out the
/// diagnostic state. Can be null in order to query the latest state.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const {
return (Level)Diags->getDiagnosticLevel(DiagID, Loc, *this);
}
/// Issue the message to the client.
///
/// This actually returns an instance of DiagnosticBuilder which emits the
/// diagnostics (through @c ProcessDiag) when it is destroyed.
///
/// \param DiagID A member of the @c diag::kind enum.
/// \param Loc Represents the source location associated with the diagnostic,
/// which can be an invalid location if no position information is available.
inline DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID);
inline DiagnosticBuilder Report(unsigned DiagID);
void Report(const StoredDiagnostic &storedDiag);
/// Determine whethere there is already a diagnostic in flight.
bool isDiagnosticInFlight() const {
return CurDiagID != std::numeric_limits<unsigned>::max();
}
/// Set the "delayed" diagnostic that will be emitted once
/// the current diagnostic completes.
///
/// If a diagnostic is already in-flight but the front end must
/// report a problem (e.g., with an inconsistent file system
/// state), this routine sets a "delayed" diagnostic that will be
/// emitted after the current diagnostic completes. This should
/// only be used for fatal errors detected at inconvenient
/// times. If emitting a delayed diagnostic causes a second delayed
/// diagnostic to be introduced, that second delayed diagnostic
/// will be ignored.
///
/// \param DiagID The ID of the diagnostic being delayed.
///
/// \param Arg1 A string argument that will be provided to the
/// diagnostic. A copy of this string will be stored in the
/// DiagnosticsEngine object itself.
///
/// \param Arg2 A string argument that will be provided to the
/// diagnostic. A copy of this string will be stored in the
/// DiagnosticsEngine object itself.
///
/// \param Arg3 A string argument that will be provided to the
/// diagnostic. A copy of this string will be stored in the
/// DiagnosticsEngine object itself.
void SetDelayedDiagnostic(unsigned DiagID, StringRef Arg1 = "",
StringRef Arg2 = "", StringRef Arg3 = "");
/// Clear out the current diagnostic.
void Clear() { CurDiagID = std::numeric_limits<unsigned>::max(); }
/// Return the value associated with this diagnostic flag.
StringRef getFlagValue() const { return FlagValue; }
private:
// This is private state used by DiagnosticBuilder. We put it here instead of
// in DiagnosticBuilder in order to keep DiagnosticBuilder a small lightweight
// object. This implementation choice means that we can only have one
// diagnostic "in flight" at a time, but this seems to be a reasonable
// tradeoff to keep these objects small. Assertions verify that only one
// diagnostic is in flight at a time.
friend class Diagnostic;
friend class DiagnosticBuilder;
friend class DiagnosticErrorTrap;
friend class DiagnosticIDs;
friend class PartialDiagnostic;
/// Report the delayed diagnostic.