1 //===---- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This is a concrete diagnostic client, which buffers the diagnostic messages.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/FileManager.h"
17 #include "clang/Frontend/FrontendDiagnostic.h"
18 #include "clang/Frontend/TextDiagnosticBuffer.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/Preprocessor.h"
21 #include "llvm/ADT/SmallString.h"
22 #include "llvm/Support/Regex.h"
23 #include "llvm/Support/raw_ostream.h"
25 using namespace clang;
26 typedef VerifyDiagnosticConsumer::Directive Directive;
27 typedef VerifyDiagnosticConsumer::DirectiveList DirectiveList;
28 typedef VerifyDiagnosticConsumer::ExpectedData ExpectedData;
30 VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &_Diags)
32 PrimaryClient(Diags.getClient()), OwnsPrimaryClient(Diags.ownsClient()),
33 Buffer(new TextDiagnosticBuffer()), CurrentPreprocessor(0),
34 LangOpts(0), SrcManager(0), ActiveSourceFiles(0), Status(HasNoDirectives)
37 if (Diags.hasSourceManager())
38 setSourceManager(Diags.getSourceManager());
41 VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
42 assert(!ActiveSourceFiles && "Incomplete parsing of source files!");
43 assert(!CurrentPreprocessor && "CurrentPreprocessor should be invalid!");
47 if (OwnsPrimaryClient)
53 class VerifyFileTracker : public PPCallbacks {
54 VerifyDiagnosticConsumer &Verify;
58 VerifyFileTracker(VerifyDiagnosticConsumer &Verify, SourceManager &SM)
59 : Verify(Verify), SM(SM) { }
61 /// \brief Hook into the preprocessor and update the list of parsed
62 /// files when the preprocessor indicates a new file is entered.
63 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
64 SrcMgr::CharacteristicKind FileType,
66 Verify.UpdateParsedFileStatus(SM, SM.getFileID(Loc),
67 VerifyDiagnosticConsumer::IsParsed);
70 } // End anonymous namespace.
73 // DiagnosticConsumer interface.
75 void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
76 const Preprocessor *PP) {
77 // Attach comment handler on first invocation.
78 if (++ActiveSourceFiles == 1) {
80 CurrentPreprocessor = PP;
81 this->LangOpts = &LangOpts;
82 setSourceManager(PP->getSourceManager());
83 const_cast<Preprocessor*>(PP)->addCommentHandler(this);
85 // Debug build tracks parsed files.
86 VerifyFileTracker *V = new VerifyFileTracker(*this, *SrcManager);
87 const_cast<Preprocessor*>(PP)->addPPCallbacks(V);
92 assert((!PP || CurrentPreprocessor == PP) && "Preprocessor changed!");
93 PrimaryClient->BeginSourceFile(LangOpts, PP);
96 void VerifyDiagnosticConsumer::EndSourceFile() {
97 assert(ActiveSourceFiles && "No active source files!");
98 PrimaryClient->EndSourceFile();
100 // Detach comment handler once last active source file completed.
101 if (--ActiveSourceFiles == 0) {
102 if (CurrentPreprocessor)
103 const_cast<Preprocessor*>(CurrentPreprocessor)->removeCommentHandler(this);
105 // Check diagnostics once last file completed.
107 CurrentPreprocessor = 0;
112 void VerifyDiagnosticConsumer::HandleDiagnostic(
113 DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
114 if (Info.hasSourceManager()) {
115 // If this diagnostic is for a different source manager, ignore it.
116 if (SrcManager && &Info.getSourceManager() != SrcManager)
119 setSourceManager(Info.getSourceManager());
123 // Debug build tracks unparsed files for possible
124 // unparsed expected-* directives.
126 SourceLocation Loc = Info.getLocation();
128 ParsedStatus PS = IsUnparsed;
130 Loc = SrcManager->getExpansionLoc(Loc);
131 FileID FID = SrcManager->getFileID(Loc);
133 const FileEntry *FE = SrcManager->getFileEntryForID(FID);
134 if (FE && CurrentPreprocessor && SrcManager->isLoadedFileID(FID)) {
135 // If the file is a modules header file it shall not be parsed
136 // for expected-* directives.
137 HeaderSearch &HS = CurrentPreprocessor->getHeaderSearchInfo();
138 if (HS.findModuleForHeader(FE))
139 PS = IsUnparsedNoDirectives;
142 UpdateParsedFileStatus(*SrcManager, FID, PS);
147 // Send the diagnostic to the buffer, we will check it once we reach the end
148 // of the source file (or are destructed).
149 Buffer->HandleDiagnostic(DiagLevel, Info);
152 //===----------------------------------------------------------------------===//
153 // Checking diagnostics implementation.
154 //===----------------------------------------------------------------------===//
156 typedef TextDiagnosticBuffer::DiagList DiagList;
157 typedef TextDiagnosticBuffer::const_iterator const_diag_iterator;
161 /// StandardDirective - Directive with string matching.
163 class StandardDirective : public Directive {
165 StandardDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
166 StringRef Text, unsigned Min, unsigned Max)
167 : Directive(DirectiveLoc, DiagnosticLoc, Text, Min, Max) { }
169 virtual bool isValid(std::string &Error) {
170 // all strings are considered valid; even empty ones
174 virtual bool match(StringRef S) {
175 return S.find(Text) != StringRef::npos;
179 /// RegexDirective - Directive with regular-expression matching.
181 class RegexDirective : public Directive {
183 RegexDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
184 StringRef Text, unsigned Min, unsigned Max)
185 : Directive(DirectiveLoc, DiagnosticLoc, Text, Min, Max), Regex(Text) { }
187 virtual bool isValid(std::string &Error) {
188 if (Regex.isValid(Error))
193 virtual bool match(StringRef S) {
194 return Regex.match(S);
204 ParseHelper(StringRef S)
205 : Begin(S.begin()), End(S.end()), C(Begin), P(Begin), PEnd(NULL) { }
207 // Return true if string literal is next.
208 bool Next(StringRef S) {
213 return !memcmp(P, S.data(), S.size());
216 // Return true if number is next.
217 // Output N only if number is next.
218 bool Next(unsigned &N) {
221 for (; P < End && P[0] >= '0' && P[0] <= '9'; ++P) {
232 // Return true if string literal is found.
233 // When true, P marks begin-position of S in content.
234 bool Search(StringRef S, bool EnsureStartOfWord = false) {
236 P = std::search(C, End, S.begin(), S.end());
240 if (!EnsureStartOfWord
241 // Check if string literal starts a new word.
242 || P == Begin || isWhitespace(P[-1])
243 // Or it could be preceeded by the start of a comment.
244 || (P > (Begin + 1) && (P[-1] == '/' || P[-1] == '*')
247 // Otherwise, skip and search again.
252 // Advance 1-past previous next/search.
253 // Behavior is undefined if previous next/search failed.
259 // Skip zero or more whitespace.
260 void SkipWhitespace() {
261 for (; C < End && isWhitespace(*C); ++C)
265 // Return true if EOF reached.
270 const char * const Begin; // beginning of expected content
271 const char * const End; // end of expected content (1-past)
272 const char *C; // position of next char in content
276 const char *PEnd; // previous next/search subject end (1-past)
279 } // namespace anonymous
281 /// ParseDirective - Go through the comment and see if it indicates expected
282 /// diagnostics. If so, then put them in the appropriate directive list.
284 /// Returns true if any valid directives were found.
285 static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
286 Preprocessor *PP, SourceLocation Pos,
287 VerifyDiagnosticConsumer::DirectiveStatus &Status) {
288 DiagnosticsEngine &Diags = PP ? PP->getDiagnostics() : SM.getDiagnostics();
290 // A single comment may contain multiple directives.
291 bool FoundDirective = false;
292 for (ParseHelper PH(S); !PH.Done();) {
293 // Search for token: expected
294 if (!PH.Search("expected", true))
303 // Next token: { error | warning | note }
304 DirectiveList* DL = NULL;
305 if (PH.Next("error"))
306 DL = ED ? &ED->Errors : NULL;
307 else if (PH.Next("warning"))
308 DL = ED ? &ED->Warnings : NULL;
309 else if (PH.Next("note"))
310 DL = ED ? &ED->Notes : NULL;
311 else if (PH.Next("no-diagnostics")) {
312 if (Status == VerifyDiagnosticConsumer::HasOtherExpectedDirectives)
313 Diags.Report(Pos, diag::err_verify_invalid_no_diags)
314 << /*IsExpectedNoDiagnostics=*/true;
316 Status = VerifyDiagnosticConsumer::HasExpectedNoDiagnostics;
322 if (Status == VerifyDiagnosticConsumer::HasExpectedNoDiagnostics) {
323 Diags.Report(Pos, diag::err_verify_invalid_no_diags)
324 << /*IsExpectedNoDiagnostics=*/false;
327 Status = VerifyDiagnosticConsumer::HasOtherExpectedDirectives;
329 // If a directive has been found but we're not interested
330 // in storing the directive information, return now.
334 // Default directive kind.
335 bool RegexKind = false;
336 const char* KindStr = "string";
338 // Next optional token: -
339 if (PH.Next("-re")) {
345 // Next optional token: @
346 SourceLocation ExpectedLoc;
352 bool FoundPlus = PH.Next("+");
353 if (FoundPlus || PH.Next("-")) {
354 // Relative to current line.
356 bool Invalid = false;
357 unsigned ExpectedLine = SM.getSpellingLineNumber(Pos, &Invalid);
358 if (!Invalid && PH.Next(Line) && (FoundPlus || Line < ExpectedLine)) {
359 if (FoundPlus) ExpectedLine += Line;
360 else ExpectedLine -= Line;
361 ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), ExpectedLine, 1);
363 } else if (PH.Next(Line)) {
364 // Absolute line number.
366 ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), Line, 1);
367 } else if (PP && PH.Search(":")) {
368 // Specific source file.
369 StringRef Filename(PH.C, PH.P-PH.C);
372 // Lookup file via Preprocessor, like a #include.
373 const DirectoryLookup *CurDir;
374 const FileEntry *FE = PP->LookupFile(Filename, false, NULL, CurDir,
377 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
378 diag::err_verify_missing_file) << Filename << KindStr;
382 if (SM.translateFile(FE).isInvalid())
383 SM.createFileID(FE, Pos, SrcMgr::C_User);
385 if (PH.Next(Line) && Line > 0)
386 ExpectedLoc = SM.translateFileLineCol(FE, Line, 1);
389 if (ExpectedLoc.isInvalid()) {
390 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
391 diag::err_verify_missing_line) << KindStr;
397 // Skip optional whitespace.
400 // Next optional token: positive integer or a '+'.
405 // A positive integer can be followed by a '+' meaning min
406 // or more, or by a '-' meaning a range from min to max.
408 Max = Directive::MaxCount;
410 } else if (PH.Next("-")) {
412 if (!PH.Next(Max) || Max < Min) {
413 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
414 diag::err_verify_invalid_range) << KindStr;
421 } else if (PH.Next("+")) {
422 // '+' on its own means "1 or more".
423 Max = Directive::MaxCount;
427 // Skip optional whitespace.
431 if (!PH.Next("{{")) {
432 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
433 diag::err_verify_missing_start) << KindStr;
437 const char* const ContentBegin = PH.C; // mark content begin
439 // Search for token: }}
440 if (!PH.Search("}}")) {
441 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
442 diag::err_verify_missing_end) << KindStr;
445 const char* const ContentEnd = PH.P; // mark content end
448 // Build directive text; convert \n to newlines.
450 StringRef NewlineStr = "\\n";
451 StringRef Content(ContentBegin, ContentEnd-ContentBegin);
454 while ((FPos = Content.find(NewlineStr, CPos)) != StringRef::npos) {
455 Text += Content.substr(CPos, FPos-CPos);
457 CPos = FPos + NewlineStr.size();
460 Text.assign(ContentBegin, ContentEnd);
462 // Construct new directive.
463 Directive *D = Directive::create(RegexKind, Pos, ExpectedLoc, Text,
466 if (D->isValid(Error)) {
468 FoundDirective = true;
470 Diags.Report(Pos.getLocWithOffset(ContentBegin-PH.Begin),
471 diag::err_verify_invalid_content)
476 return FoundDirective;
479 /// HandleComment - Hook into the preprocessor and extract comments containing
480 /// expected errors and warnings.
481 bool VerifyDiagnosticConsumer::HandleComment(Preprocessor &PP,
482 SourceRange Comment) {
483 SourceManager &SM = PP.getSourceManager();
485 // If this comment is for a different source manager, ignore it.
486 if (SrcManager && &SM != SrcManager)
489 SourceLocation CommentBegin = Comment.getBegin();
491 const char *CommentRaw = SM.getCharacterData(CommentBegin);
492 StringRef C(CommentRaw, SM.getCharacterData(Comment.getEnd()) - CommentRaw);
497 // Fold any "\<EOL>" sequences
498 size_t loc = C.find('\\');
499 if (loc == StringRef::npos) {
500 ParseDirective(C, &ED, SM, &PP, CommentBegin, Status);
505 C2.reserve(C.size());
507 for (size_t last = 0;; loc = C.find('\\', last)) {
508 if (loc == StringRef::npos || loc == C.size()) {
509 C2 += C.substr(last);
512 C2 += C.substr(last, loc-last);
515 if (C[last] == '\n' || C[last] == '\r') {
518 // Escape \r\n or \n\r, but not \n\n.
520 if (C[last] == '\n' || C[last] == '\r')
521 if (C[last] != C[last-1])
524 // This was just a normal backslash.
530 ParseDirective(C2, &ED, SM, &PP, CommentBegin, Status);
535 /// \brief Lex the specified source file to determine whether it contains
536 /// any expected-* directives. As a Lexer is used rather than a full-blown
537 /// Preprocessor, directives inside skipped #if blocks will still be found.
539 /// \return true if any directives were found.
540 static bool findDirectives(SourceManager &SM, FileID FID,
541 const LangOptions &LangOpts) {
542 // Create a raw lexer to pull all the comments out of FID.
546 // Create a lexer to lex all the tokens of the main file in raw mode.
547 const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
548 Lexer RawLex(FID, FromFile, SM, LangOpts);
550 // Return comments as tokens, this is how we find expected diagnostics.
551 RawLex.SetCommentRetentionState(true);
554 Tok.setKind(tok::comment);
555 VerifyDiagnosticConsumer::DirectiveStatus Status =
556 VerifyDiagnosticConsumer::HasNoDirectives;
557 while (Tok.isNot(tok::eof)) {
559 if (!Tok.is(tok::comment)) continue;
561 std::string Comment = RawLex.getSpelling(Tok, SM, LangOpts);
562 if (Comment.empty()) continue;
564 // Find first directive.
565 if (ParseDirective(Comment, 0, SM, 0, Tok.getLocation(), Status))
572 /// \brief Takes a list of diagnostics that have been generated but not matched
573 /// by an expected-* directive and produces a diagnostic to the user from this.
574 static unsigned PrintUnexpected(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
575 const_diag_iterator diag_begin,
576 const_diag_iterator diag_end,
578 if (diag_begin == diag_end) return 0;
580 SmallString<256> Fmt;
581 llvm::raw_svector_ostream OS(Fmt);
582 for (const_diag_iterator I = diag_begin, E = diag_end; I != E; ++I) {
583 if (I->first.isInvalid() || !SourceMgr)
584 OS << "\n (frontend)";
587 if (const FileEntry *File = SourceMgr->getFileEntryForID(
588 SourceMgr->getFileID(I->first)))
589 OS << " File " << File->getName();
590 OS << " Line " << SourceMgr->getPresumedLineNumber(I->first);
592 OS << ": " << I->second;
595 Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit()
596 << Kind << /*Unexpected=*/true << OS.str();
597 return std::distance(diag_begin, diag_end);
600 /// \brief Takes a list of diagnostics that were expected to have been generated
601 /// but were not and produces a diagnostic to the user from this.
602 static unsigned PrintExpected(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
603 DirectiveList &DL, const char *Kind) {
607 SmallString<256> Fmt;
608 llvm::raw_svector_ostream OS(Fmt);
609 for (DirectiveList::iterator I = DL.begin(), E = DL.end(); I != E; ++I) {
611 OS << "\n File " << SourceMgr.getFilename(D.DiagnosticLoc)
612 << " Line " << SourceMgr.getPresumedLineNumber(D.DiagnosticLoc);
613 if (D.DirectiveLoc != D.DiagnosticLoc)
614 OS << " (directive at "
615 << SourceMgr.getFilename(D.DirectiveLoc) << ':'
616 << SourceMgr.getPresumedLineNumber(D.DirectiveLoc) << ')';
617 OS << ": " << D.Text;
620 Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit()
621 << Kind << /*Unexpected=*/false << OS.str();
625 /// \brief Determine whether two source locations come from the same file.
626 static bool IsFromSameFile(SourceManager &SM, SourceLocation DirectiveLoc,
627 SourceLocation DiagnosticLoc) {
628 while (DiagnosticLoc.isMacroID())
629 DiagnosticLoc = SM.getImmediateMacroCallerLoc(DiagnosticLoc);
631 if (SM.isFromSameFile(DirectiveLoc, DiagnosticLoc))
634 const FileEntry *DiagFile = SM.getFileEntryForID(SM.getFileID(DiagnosticLoc));
635 if (!DiagFile && SM.isFromMainFile(DirectiveLoc))
638 return (DiagFile == SM.getFileEntryForID(SM.getFileID(DirectiveLoc)));
641 /// CheckLists - Compare expected to seen diagnostic lists and return the
642 /// the difference between them.
644 static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
647 const_diag_iterator d2_begin,
648 const_diag_iterator d2_end) {
649 DirectiveList LeftOnly;
650 DiagList Right(d2_begin, d2_end);
652 for (DirectiveList::iterator I = Left.begin(), E = Left.end(); I != E; ++I) {
654 unsigned LineNo1 = SourceMgr.getPresumedLineNumber(D.DiagnosticLoc);
656 for (unsigned i = 0; i < D.Max; ++i) {
657 DiagList::iterator II, IE;
658 for (II = Right.begin(), IE = Right.end(); II != IE; ++II) {
659 unsigned LineNo2 = SourceMgr.getPresumedLineNumber(II->first);
660 if (LineNo1 != LineNo2)
663 if (!IsFromSameFile(SourceMgr, D.DiagnosticLoc, II->first))
666 const std::string &RightText = II->second;
667 if (D.match(RightText))
672 if (i >= D.Min) break;
673 LeftOnly.push_back(*I);
675 // Found. The same cannot be found twice.
680 // Now all that's left in Right are those that were not matched.
681 unsigned num = PrintExpected(Diags, SourceMgr, LeftOnly, Label);
682 num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label);
686 /// CheckResults - This compares the expected results to those that
687 /// were actually reported. It emits any discrepencies. Return "true" if there
688 /// were problems. Return "false" otherwise.
690 static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
691 const TextDiagnosticBuffer &Buffer,
693 // We want to capture the delta between what was expected and what was
696 // Expected \ Seen - set expected but not seen
697 // Seen \ Expected - set seen but not expected
698 unsigned NumProblems = 0;
700 // See if there are error mismatches.
701 NumProblems += CheckLists(Diags, SourceMgr, "error", ED.Errors,
702 Buffer.err_begin(), Buffer.err_end());
704 // See if there are warning mismatches.
705 NumProblems += CheckLists(Diags, SourceMgr, "warning", ED.Warnings,
706 Buffer.warn_begin(), Buffer.warn_end());
708 // See if there are note mismatches.
709 NumProblems += CheckLists(Diags, SourceMgr, "note", ED.Notes,
710 Buffer.note_begin(), Buffer.note_end());
715 void VerifyDiagnosticConsumer::UpdateParsedFileStatus(SourceManager &SM,
718 // Check SourceManager hasn't changed.
719 setSourceManager(SM);
725 const FileEntry *FE = SM.getFileEntryForID(FID);
727 if (PS == IsParsed) {
728 // Move the FileID from the unparsed set to the parsed set.
729 UnparsedFiles.erase(FID);
730 ParsedFiles.insert(std::make_pair(FID, FE));
731 } else if (!ParsedFiles.count(FID) && !UnparsedFiles.count(FID)) {
732 // Add the FileID to the unparsed set if we haven't seen it before.
734 // Check for directives.
735 bool FoundDirectives;
736 if (PS == IsUnparsedNoDirectives)
737 FoundDirectives = false;
739 FoundDirectives = !LangOpts || findDirectives(SM, FID, *LangOpts);
741 // Add the FileID to the unparsed set.
742 UnparsedFiles.insert(std::make_pair(FID,
743 UnparsedFileStatus(FE, FoundDirectives)));
748 void VerifyDiagnosticConsumer::CheckDiagnostics() {
749 // Ensure any diagnostics go to the primary client.
750 bool OwnsCurClient = Diags.ownsClient();
751 DiagnosticConsumer *CurClient = Diags.takeClient();
752 Diags.setClient(PrimaryClient, false);
755 // In a debug build, scan through any files that may have been missed
756 // during parsing and issue a fatal error if directives are contained
757 // within these files. If a fatal error occurs, this suggests that
758 // this file is being parsed separately from the main file, in which
759 // case consider moving the directives to the correct place, if this
761 if (UnparsedFiles.size() > 0) {
762 // Generate a cache of parsed FileEntry pointers for alias lookups.
763 llvm::SmallPtrSet<const FileEntry *, 8> ParsedFileCache;
764 for (ParsedFilesMap::iterator I = ParsedFiles.begin(),
765 End = ParsedFiles.end(); I != End; ++I) {
766 if (const FileEntry *FE = I->second)
767 ParsedFileCache.insert(FE);
770 // Iterate through list of unparsed files.
771 for (UnparsedFilesMap::iterator I = UnparsedFiles.begin(),
772 End = UnparsedFiles.end(); I != End; ++I) {
773 const UnparsedFileStatus &Status = I->second;
774 const FileEntry *FE = Status.getFile();
776 // Skip files that have been parsed via an alias.
777 if (FE && ParsedFileCache.count(FE))
780 // Report a fatal error if this file contained directives.
781 if (Status.foundDirectives()) {
782 llvm::report_fatal_error(Twine("-verify directives found after rather"
783 " than during normal parsing of ",
784 StringRef(FE ? FE->getName() : "(unknown)")));
788 // UnparsedFiles has been processed now, so clear it.
789 UnparsedFiles.clear();
794 // Produce an error if no expected-* directives could be found in the
795 // source file(s) processed.
796 if (Status == HasNoDirectives) {
797 Diags.Report(diag::err_verify_no_directives).setForceEmit();
799 Status = HasNoDirectivesReported;
802 // Check that the expected diagnostics occurred.
803 NumErrors += CheckResults(Diags, *SrcManager, *Buffer, ED);
805 NumErrors += (PrintUnexpected(Diags, 0, Buffer->err_begin(),
806 Buffer->err_end(), "error") +
807 PrintUnexpected(Diags, 0, Buffer->warn_begin(),
808 Buffer->warn_end(), "warn") +
809 PrintUnexpected(Diags, 0, Buffer->note_begin(),
810 Buffer->note_end(), "note"));
814 Diags.setClient(CurClient, OwnsCurClient);
816 // Reset the buffer, we have processed all the diagnostics in it.
817 Buffer.reset(new TextDiagnosticBuffer());
823 Directive *Directive::create(bool RegexKind, SourceLocation DirectiveLoc,
824 SourceLocation DiagnosticLoc, StringRef Text,
825 unsigned Min, unsigned Max) {
827 return new RegexDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);
828 return new StandardDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);