blob: e55e75556108394b85a94bc8a9add63e0ca8aa8c [file] [log] [blame]
David Blaikie621bc692011-09-26 00:38:03 +00001//===---- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ------===//
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This is a concrete diagnostic client, which buffers the diagnostic messages.
11//
12//===----------------------------------------------------------------------===//
13
David Blaikie621bc692011-09-26 00:38:03 +000014#include "clang/Frontend/VerifyDiagnosticConsumer.h"
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000015#include "clang/Frontend/FrontendDiagnostic.h"
16#include "clang/Frontend/TextDiagnosticBuffer.h"
17#include "clang/Lex/Preprocessor.h"
18#include "llvm/ADT/SmallString.h"
Chris Lattner60909e12010-04-28 20:02:30 +000019#include "llvm/Support/Regex.h"
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000020#include "llvm/Support/raw_ostream.h"
Anna Zaksc035e092011-12-15 02:58:00 +000021
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000022using namespace clang;
Jordan Rose4313c012012-07-10 02:56:15 +000023typedef VerifyDiagnosticConsumer::Directive Directive;
24typedef VerifyDiagnosticConsumer::DirectiveList DirectiveList;
25typedef VerifyDiagnosticConsumer::ExpectedData ExpectedData;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000026
David Blaikie621bc692011-09-26 00:38:03 +000027VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &_Diags)
Douglas Gregor78243652011-09-13 01:26:44 +000028 : Diags(_Diags), PrimaryClient(Diags.getClient()),
29 OwnsPrimaryClient(Diags.ownsClient()),
30 Buffer(new TextDiagnosticBuffer()), CurrentPreprocessor(0)
31{
32 Diags.takeClient();
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000033}
34
David Blaikie621bc692011-09-26 00:38:03 +000035VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
Douglas Gregor78243652011-09-13 01:26:44 +000036 CheckDiagnostics();
37 Diags.takeClient();
38 if (OwnsPrimaryClient)
39 delete PrimaryClient;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000040}
41
David Blaikie78ad0b92011-09-25 23:39:51 +000042// DiagnosticConsumer interface.
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000043
David Blaikie621bc692011-09-26 00:38:03 +000044void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
Douglas Gregor1f6b2b52012-01-20 16:28:04 +000045 const Preprocessor *PP) {
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000046 // FIXME: Const hack, we screw up the preprocessor but in practice its ok
47 // because it doesn't get reused. It would be better if we could make a copy
48 // though.
49 CurrentPreprocessor = const_cast<Preprocessor*>(PP);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000050
51 PrimaryClient->BeginSourceFile(LangOpts, PP);
52}
53
David Blaikie621bc692011-09-26 00:38:03 +000054void VerifyDiagnosticConsumer::EndSourceFile() {
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000055 CheckDiagnostics();
56
57 PrimaryClient->EndSourceFile();
58
59 CurrentPreprocessor = 0;
60}
Daniel Dunbar221c7212009-11-14 07:53:24 +000061
David Blaikie621bc692011-09-26 00:38:03 +000062void VerifyDiagnosticConsumer::HandleDiagnostic(
David Blaikie40847cf2011-09-26 01:18:08 +000063 DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
Axel Naumann01231612011-07-25 19:18:12 +000064 if (FirstErrorFID.isInvalid() && Info.hasSourceManager()) {
65 const SourceManager &SM = Info.getSourceManager();
66 FirstErrorFID = SM.getFileID(Info.getLocation());
67 }
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000068 // Send the diagnostic to the buffer, we will check it once we reach the end
69 // of the source file (or are destructed).
70 Buffer->HandleDiagnostic(DiagLevel, Info);
71}
72
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +000073//===----------------------------------------------------------------------===//
74// Checking diagnostics implementation.
75//===----------------------------------------------------------------------===//
76
77typedef TextDiagnosticBuffer::DiagList DiagList;
78typedef TextDiagnosticBuffer::const_iterator const_diag_iterator;
79
Chris Lattner60909e12010-04-28 20:02:30 +000080namespace {
81
Chris Lattner60909e12010-04-28 20:02:30 +000082/// StandardDirective - Directive with string matching.
83///
84class StandardDirective : public Directive {
85public:
Jordan Roseaa48fe82012-07-10 02:57:03 +000086 StandardDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
Jordan Rose3b81b7d2012-07-10 02:57:26 +000087 StringRef Text, unsigned Min, unsigned Max)
88 : Directive(DirectiveLoc, DiagnosticLoc, Text, Min, Max) { }
Chris Lattner60909e12010-04-28 20:02:30 +000089
90 virtual bool isValid(std::string &Error) {
91 // all strings are considered valid; even empty ones
92 return true;
93 }
94
Jordan Rose4313c012012-07-10 02:56:15 +000095 virtual bool match(StringRef S) {
96 return S.find(Text) != StringRef::npos;
Chris Lattner60909e12010-04-28 20:02:30 +000097 }
98};
99
100/// RegexDirective - Directive with regular-expression matching.
101///
102class RegexDirective : public Directive {
103public:
Jordan Roseaa48fe82012-07-10 02:57:03 +0000104 RegexDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000105 StringRef Text, unsigned Min, unsigned Max)
106 : Directive(DirectiveLoc, DiagnosticLoc, Text, Min, Max), Regex(Text) { }
Chris Lattner60909e12010-04-28 20:02:30 +0000107
108 virtual bool isValid(std::string &Error) {
109 if (Regex.isValid(Error))
110 return true;
111 return false;
112 }
113
Jordan Rose4313c012012-07-10 02:56:15 +0000114 virtual bool match(StringRef S) {
Chris Lattner60909e12010-04-28 20:02:30 +0000115 return Regex.match(S);
116 }
117
118private:
119 llvm::Regex Regex;
120};
121
Chris Lattner60909e12010-04-28 20:02:30 +0000122class ParseHelper
123{
124public:
125 ParseHelper(const char *Begin, const char *End)
126 : Begin(Begin), End(End), C(Begin), P(Begin), PEnd(NULL) { }
127
128 // Return true if string literal is next.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000129 bool Next(StringRef S) {
Chris Lattner60909e12010-04-28 20:02:30 +0000130 P = C;
Benjamin Kramer0080f0c2010-09-01 17:28:48 +0000131 PEnd = C + S.size();
Chris Lattner60909e12010-04-28 20:02:30 +0000132 if (PEnd > End)
133 return false;
Benjamin Kramer0080f0c2010-09-01 17:28:48 +0000134 return !memcmp(P, S.data(), S.size());
Chris Lattner60909e12010-04-28 20:02:30 +0000135 }
136
137 // Return true if number is next.
138 // Output N only if number is next.
139 bool Next(unsigned &N) {
140 unsigned TMP = 0;
141 P = C;
142 for (; P < End && P[0] >= '0' && P[0] <= '9'; ++P) {
143 TMP *= 10;
144 TMP += P[0] - '0';
145 }
146 if (P == C)
147 return false;
148 PEnd = P;
149 N = TMP;
150 return true;
151 }
152
153 // Return true if string literal is found.
154 // When true, P marks begin-position of S in content.
Chris Lattner5f9e2722011-07-23 10:55:15 +0000155 bool Search(StringRef S) {
Chris Lattner60909e12010-04-28 20:02:30 +0000156 P = std::search(C, End, S.begin(), S.end());
Benjamin Kramer0080f0c2010-09-01 17:28:48 +0000157 PEnd = P + S.size();
Chris Lattner60909e12010-04-28 20:02:30 +0000158 return P != End;
159 }
160
161 // Advance 1-past previous next/search.
162 // Behavior is undefined if previous next/search failed.
163 bool Advance() {
164 C = PEnd;
165 return C < End;
166 }
167
168 // Skip zero or more whitespace.
169 void SkipWhitespace() {
170 for (; C < End && isspace(*C); ++C)
171 ;
172 }
173
174 // Return true if EOF reached.
175 bool Done() {
176 return !(C < End);
177 }
178
179 const char * const Begin; // beginning of expected content
180 const char * const End; // end of expected content (1-past)
181 const char *C; // position of next char in content
182 const char *P;
183
184private:
185 const char *PEnd; // previous next/search subject end (1-past)
186};
187
188} // namespace anonymous
189
190/// ParseDirective - Go through the comment and see if it indicates expected
191/// diagnostics. If so, then put them in the appropriate directive list.
192///
193static void ParseDirective(const char *CommentStart, unsigned CommentLen,
Jordan Rose4313c012012-07-10 02:56:15 +0000194 ExpectedData &ED, SourceManager &SM,
195 SourceLocation Pos, DiagnosticsEngine &Diags) {
Chris Lattner60909e12010-04-28 20:02:30 +0000196 // A single comment may contain multiple directives.
197 for (ParseHelper PH(CommentStart, CommentStart+CommentLen); !PH.Done();) {
Jordan Roseaa48fe82012-07-10 02:57:03 +0000198 // Search for token: expected
Chris Lattner60909e12010-04-28 20:02:30 +0000199 if (!PH.Search("expected"))
200 break;
201 PH.Advance();
202
Jordan Roseaa48fe82012-07-10 02:57:03 +0000203 // Next token: -
Chris Lattner60909e12010-04-28 20:02:30 +0000204 if (!PH.Next("-"))
205 continue;
206 PH.Advance();
207
Jordan Roseaa48fe82012-07-10 02:57:03 +0000208 // Next token: { error | warning | note }
Chris Lattner60909e12010-04-28 20:02:30 +0000209 DirectiveList* DL = NULL;
210 if (PH.Next("error"))
211 DL = &ED.Errors;
212 else if (PH.Next("warning"))
213 DL = &ED.Warnings;
214 else if (PH.Next("note"))
215 DL = &ED.Notes;
216 else
217 continue;
218 PH.Advance();
219
Jordan Roseaa48fe82012-07-10 02:57:03 +0000220 // Default directive kind.
Chris Lattner60909e12010-04-28 20:02:30 +0000221 bool RegexKind = false;
222 const char* KindStr = "string";
223
Jordan Roseaa48fe82012-07-10 02:57:03 +0000224 // Next optional token: -
Chris Lattner60909e12010-04-28 20:02:30 +0000225 if (PH.Next("-re")) {
226 PH.Advance();
227 RegexKind = true;
228 KindStr = "regex";
229 }
230
Jordan Roseaa48fe82012-07-10 02:57:03 +0000231 // Next optional token: @
232 SourceLocation ExpectedLoc;
233 if (!PH.Next("@")) {
234 ExpectedLoc = Pos;
235 } else {
236 PH.Advance();
237 unsigned Line = 0;
238 bool FoundPlus = PH.Next("+");
239 if (FoundPlus || PH.Next("-")) {
240 // Relative to current line.
241 PH.Advance();
242 bool Invalid = false;
243 unsigned ExpectedLine = SM.getSpellingLineNumber(Pos, &Invalid);
244 if (!Invalid && PH.Next(Line) && (FoundPlus || Line < ExpectedLine)) {
245 if (FoundPlus) ExpectedLine += Line;
246 else ExpectedLine -= Line;
247 ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), ExpectedLine, 1);
248 }
249 } else {
250 // Absolute line number.
251 if (PH.Next(Line) && Line > 0)
252 ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), Line, 1);
253 }
254
255 if (ExpectedLoc.isInvalid()) {
256 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
257 diag::err_verify_missing_line) << KindStr;
258 continue;
259 }
260 PH.Advance();
261 }
262
263 // Skip optional whitespace.
Chris Lattner60909e12010-04-28 20:02:30 +0000264 PH.SkipWhitespace();
265
Jordan Roseaa48fe82012-07-10 02:57:03 +0000266 // Next optional token: positive integer or a '+'.
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000267 unsigned Min = 1;
268 unsigned Max = 1;
269 if (PH.Next(Min)) {
Chris Lattner60909e12010-04-28 20:02:30 +0000270 PH.Advance();
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000271 // A positive integer can be followed by a '+' meaning min
272 // or more, or by a '-' meaning a range from min to max.
273 if (PH.Next("+")) {
274 Max = Directive::MaxCount;
275 PH.Advance();
276 } else if (PH.Next("-")) {
277 PH.Advance();
278 if (!PH.Next(Max) || Max < Min) {
279 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
280 diag::err_verify_invalid_range) << KindStr;
281 continue;
282 }
283 PH.Advance();
284 } else {
285 Max = Min;
286 }
287 } else if (PH.Next("+")) {
288 // '+' on its own means "1 or more".
289 Max = Directive::MaxCount;
Anna Zaks2135ebb2011-12-15 02:28:16 +0000290 PH.Advance();
291 }
Chris Lattner60909e12010-04-28 20:02:30 +0000292
Jordan Roseaa48fe82012-07-10 02:57:03 +0000293 // Skip optional whitespace.
Chris Lattner60909e12010-04-28 20:02:30 +0000294 PH.SkipWhitespace();
295
Jordan Roseaa48fe82012-07-10 02:57:03 +0000296 // Next token: {{
Chris Lattner60909e12010-04-28 20:02:30 +0000297 if (!PH.Next("{{")) {
Jordan Rose4313c012012-07-10 02:56:15 +0000298 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
299 diag::err_verify_missing_start) << KindStr;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000300 continue;
301 }
Chris Lattner60909e12010-04-28 20:02:30 +0000302 PH.Advance();
303 const char* const ContentBegin = PH.C; // mark content begin
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000304
Jordan Roseaa48fe82012-07-10 02:57:03 +0000305 // Search for token: }}
Chris Lattner60909e12010-04-28 20:02:30 +0000306 if (!PH.Search("}}")) {
Jordan Rose4313c012012-07-10 02:56:15 +0000307 Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
308 diag::err_verify_missing_end) << KindStr;
Chris Lattner60909e12010-04-28 20:02:30 +0000309 continue;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000310 }
Chris Lattner60909e12010-04-28 20:02:30 +0000311 const char* const ContentEnd = PH.P; // mark content end
312 PH.Advance();
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000313
Jordan Roseaa48fe82012-07-10 02:57:03 +0000314 // Build directive text; convert \n to newlines.
Chris Lattner60909e12010-04-28 20:02:30 +0000315 std::string Text;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000316 StringRef NewlineStr = "\\n";
317 StringRef Content(ContentBegin, ContentEnd-ContentBegin);
Chris Lattner60909e12010-04-28 20:02:30 +0000318 size_t CPos = 0;
319 size_t FPos;
Chris Lattner5f9e2722011-07-23 10:55:15 +0000320 while ((FPos = Content.find(NewlineStr, CPos)) != StringRef::npos) {
Chris Lattner60909e12010-04-28 20:02:30 +0000321 Text += Content.substr(CPos, FPos-CPos);
322 Text += '\n';
323 CPos = FPos + NewlineStr.size();
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000324 }
Chris Lattner60909e12010-04-28 20:02:30 +0000325 if (Text.empty())
326 Text.assign(ContentBegin, ContentEnd);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000327
Jordan Roseaa48fe82012-07-10 02:57:03 +0000328 // Construct new directive.
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000329 Directive *D = Directive::create(RegexKind, Pos, ExpectedLoc, Text,
330 Min, Max);
Chris Lattner60909e12010-04-28 20:02:30 +0000331 std::string Error;
332 if (D->isValid(Error))
333 DL->push_back(D);
334 else {
Jordan Rose4313c012012-07-10 02:56:15 +0000335 Diags.Report(Pos.getLocWithOffset(ContentBegin-PH.Begin),
336 diag::err_verify_invalid_content)
Chris Lattner60909e12010-04-28 20:02:30 +0000337 << KindStr << Error;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000338 }
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000339 }
340}
341
342/// FindExpectedDiags - Lex the main source file to find all of the
343// expected errors and warnings.
Axel Naumann01231612011-07-25 19:18:12 +0000344static void FindExpectedDiags(Preprocessor &PP, ExpectedData &ED, FileID FID) {
345 // Create a raw lexer to pull all the comments out of FID.
346 if (FID.isInvalid())
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000347 return;
348
Axel Naumann01231612011-07-25 19:18:12 +0000349 SourceManager& SM = PP.getSourceManager();
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000350 // Create a lexer to lex all the tokens of the main file in raw mode.
Chris Lattner6e290142009-11-30 04:18:44 +0000351 const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
David Blaikie4e4d0842012-03-11 07:00:24 +0000352 Lexer RawLex(FID, FromFile, SM, PP.getLangOpts());
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000353
354 // Return comments as tokens, this is how we find expected diagnostics.
355 RawLex.SetCommentRetentionState(true);
356
357 Token Tok;
358 Tok.setKind(tok::comment);
359 while (Tok.isNot(tok::eof)) {
360 RawLex.Lex(Tok);
361 if (!Tok.is(tok::comment)) continue;
362
363 std::string Comment = PP.getSpelling(Tok);
364 if (Comment.empty()) continue;
365
Chris Lattner60909e12010-04-28 20:02:30 +0000366 // Find all expected errors/warnings/notes.
Jordan Rose4313c012012-07-10 02:56:15 +0000367 ParseDirective(&Comment[0], Comment.size(), ED, SM, Tok.getLocation(),
368 PP.getDiagnostics());
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000369 };
370}
371
Jordan Roseaa48fe82012-07-10 02:57:03 +0000372/// \brief Takes a list of diagnostics that have been generated but not matched
373/// by an expected-* directive and produces a diagnostic to the user from this.
374static unsigned PrintUnexpected(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
375 const_diag_iterator diag_begin,
376 const_diag_iterator diag_end,
377 const char *Kind) {
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000378 if (diag_begin == diag_end) return 0;
379
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000380 SmallString<256> Fmt;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000381 llvm::raw_svector_ostream OS(Fmt);
382 for (const_diag_iterator I = diag_begin, E = diag_end; I != E; ++I) {
Daniel Dunbar221c7212009-11-14 07:53:24 +0000383 if (I->first.isInvalid() || !SourceMgr)
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000384 OS << "\n (frontend)";
385 else
Chandler Carruth5ef04ee2011-02-23 00:47:48 +0000386 OS << "\n Line " << SourceMgr->getPresumedLineNumber(I->first);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000387 OS << ": " << I->second;
388 }
389
390 Diags.Report(diag::err_verify_inconsistent_diags)
Jordan Roseaa48fe82012-07-10 02:57:03 +0000391 << Kind << /*Unexpected=*/true << OS.str();
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000392 return std::distance(diag_begin, diag_end);
393}
394
Jordan Roseaa48fe82012-07-10 02:57:03 +0000395/// \brief Takes a list of diagnostics that were expected to have been generated
396/// but were not and produces a diagnostic to the user from this.
397static unsigned PrintExpected(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
398 DirectiveList &DL, const char *Kind) {
Chris Lattner60909e12010-04-28 20:02:30 +0000399 if (DL.empty())
400 return 0;
401
Dylan Noblesmithf7ccbad2012-02-05 02:13:05 +0000402 SmallString<256> Fmt;
Chris Lattner60909e12010-04-28 20:02:30 +0000403 llvm::raw_svector_ostream OS(Fmt);
404 for (DirectiveList::iterator I = DL.begin(), E = DL.end(); I != E; ++I) {
Jordan Roseaa48fe82012-07-10 02:57:03 +0000405 Directive &D = **I;
406 OS << "\n Line " << SourceMgr.getPresumedLineNumber(D.DiagnosticLoc);
407 if (D.DirectiveLoc != D.DiagnosticLoc)
408 OS << " (directive at "
409 << SourceMgr.getFilename(D.DirectiveLoc) << ":"
410 << SourceMgr.getPresumedLineNumber(D.DirectiveLoc) << ")";
Chris Lattner60909e12010-04-28 20:02:30 +0000411 OS << ": " << D.Text;
412 }
413
414 Diags.Report(diag::err_verify_inconsistent_diags)
Jordan Roseaa48fe82012-07-10 02:57:03 +0000415 << Kind << /*Unexpected=*/false << OS.str();
Chris Lattner60909e12010-04-28 20:02:30 +0000416 return DL.size();
417}
418
419/// CheckLists - Compare expected to seen diagnostic lists and return the
420/// the difference between them.
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000421///
David Blaikied6471f72011-09-25 23:23:43 +0000422static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
Chris Lattner60909e12010-04-28 20:02:30 +0000423 const char *Label,
424 DirectiveList &Left,
425 const_diag_iterator d2_begin,
426 const_diag_iterator d2_end) {
427 DirectiveList LeftOnly;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000428 DiagList Right(d2_begin, d2_end);
429
Chris Lattner60909e12010-04-28 20:02:30 +0000430 for (DirectiveList::iterator I = Left.begin(), E = Left.end(); I != E; ++I) {
431 Directive& D = **I;
Jordan Roseaa48fe82012-07-10 02:57:03 +0000432 unsigned LineNo1 = SourceMgr.getPresumedLineNumber(D.DiagnosticLoc);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000433
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000434 for (unsigned i = 0; i < D.Max; ++i) {
Chris Lattner60909e12010-04-28 20:02:30 +0000435 DiagList::iterator II, IE;
436 for (II = Right.begin(), IE = Right.end(); II != IE; ++II) {
Chandler Carruth5ef04ee2011-02-23 00:47:48 +0000437 unsigned LineNo2 = SourceMgr.getPresumedLineNumber(II->first);
Chris Lattner60909e12010-04-28 20:02:30 +0000438 if (LineNo1 != LineNo2)
439 continue;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000440
Chris Lattner60909e12010-04-28 20:02:30 +0000441 const std::string &RightText = II->second;
Jordan Rose4313c012012-07-10 02:56:15 +0000442 if (D.match(RightText))
Chris Lattner60909e12010-04-28 20:02:30 +0000443 break;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000444 }
Chris Lattner60909e12010-04-28 20:02:30 +0000445 if (II == IE) {
446 // Not found.
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000447 if (i >= D.Min) break;
Chris Lattner60909e12010-04-28 20:02:30 +0000448 LeftOnly.push_back(*I);
449 } else {
450 // Found. The same cannot be found twice.
451 Right.erase(II);
452 }
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000453 }
454 }
455 // Now all that's left in Right are those that were not matched.
Jordan Roseaa48fe82012-07-10 02:57:03 +0000456 unsigned num = PrintExpected(Diags, SourceMgr, LeftOnly, Label);
457 num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label);
NAKAMURA Takumiad646842011-12-17 13:00:31 +0000458 return num;
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000459}
460
461/// CheckResults - This compares the expected results to those that
462/// were actually reported. It emits any discrepencies. Return "true" if there
463/// were problems. Return "false" otherwise.
464///
David Blaikied6471f72011-09-25 23:23:43 +0000465static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000466 const TextDiagnosticBuffer &Buffer,
Chris Lattner60909e12010-04-28 20:02:30 +0000467 ExpectedData &ED) {
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000468 // We want to capture the delta between what was expected and what was
469 // seen.
470 //
471 // Expected \ Seen - set expected but not seen
472 // Seen \ Expected - set seen but not expected
473 unsigned NumProblems = 0;
474
475 // See if there are error mismatches.
Chris Lattner60909e12010-04-28 20:02:30 +0000476 NumProblems += CheckLists(Diags, SourceMgr, "error", ED.Errors,
477 Buffer.err_begin(), Buffer.err_end());
Daniel Dunbar221c7212009-11-14 07:53:24 +0000478
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000479 // See if there are warning mismatches.
Chris Lattner60909e12010-04-28 20:02:30 +0000480 NumProblems += CheckLists(Diags, SourceMgr, "warning", ED.Warnings,
481 Buffer.warn_begin(), Buffer.warn_end());
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000482
483 // See if there are note mismatches.
Chris Lattner60909e12010-04-28 20:02:30 +0000484 NumProblems += CheckLists(Diags, SourceMgr, "note", ED.Notes,
485 Buffer.note_begin(), Buffer.note_end());
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000486
487 return NumProblems;
488}
489
David Blaikie621bc692011-09-26 00:38:03 +0000490void VerifyDiagnosticConsumer::CheckDiagnostics() {
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000491 // Ensure any diagnostics go to the primary client.
Douglas Gregor78243652011-09-13 01:26:44 +0000492 bool OwnsCurClient = Diags.ownsClient();
David Blaikie78ad0b92011-09-25 23:39:51 +0000493 DiagnosticConsumer *CurClient = Diags.takeClient();
Douglas Gregor78243652011-09-13 01:26:44 +0000494 Diags.setClient(PrimaryClient, false);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000495
496 // If we have a preprocessor, scan the source for expected diagnostic
497 // markers. If not then any diagnostics are unexpected.
498 if (CurrentPreprocessor) {
Axel Naumann01231612011-07-25 19:18:12 +0000499 SourceManager &SM = CurrentPreprocessor->getSourceManager();
500 // Extract expected-error strings from main file.
501 FindExpectedDiags(*CurrentPreprocessor, ED, SM.getMainFileID());
502 // Only check for expectations in other diagnostic locations
503 // if they are not the main file (via ID or FileEntry) - the main
504 // file has already been looked at, and its expectations must not
505 // be added twice.
506 if (!FirstErrorFID.isInvalid() && FirstErrorFID != SM.getMainFileID()
507 && (!SM.getFileEntryForID(FirstErrorFID)
508 || (SM.getFileEntryForID(FirstErrorFID) !=
Axel Naumann84c05e32011-08-24 13:36:19 +0000509 SM.getFileEntryForID(SM.getMainFileID())))) {
Axel Naumann01231612011-07-25 19:18:12 +0000510 FindExpectedDiags(*CurrentPreprocessor, ED, FirstErrorFID);
Axel Naumann84c05e32011-08-24 13:36:19 +0000511 FirstErrorFID = FileID();
512 }
Daniel Dunbar221c7212009-11-14 07:53:24 +0000513
514 // Check that the expected diagnostics occurred.
Axel Naumann01231612011-07-25 19:18:12 +0000515 NumErrors += CheckResults(Diags, SM, *Buffer, ED);
Daniel Dunbar221c7212009-11-14 07:53:24 +0000516 } else {
Jordan Roseaa48fe82012-07-10 02:57:03 +0000517 NumErrors += (PrintUnexpected(Diags, 0, Buffer->err_begin(),
518 Buffer->err_end(), "error") +
519 PrintUnexpected(Diags, 0, Buffer->warn_begin(),
520 Buffer->warn_end(), "warn") +
521 PrintUnexpected(Diags, 0, Buffer->note_begin(),
522 Buffer->note_end(), "note"));
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000523 }
524
Douglas Gregorbdbb0042010-08-18 22:29:43 +0000525 Diags.takeClient();
Douglas Gregor78243652011-09-13 01:26:44 +0000526 Diags.setClient(CurClient, OwnsCurClient);
Daniel Dunbar81f5a1e2009-11-14 03:23:19 +0000527
528 // Reset the buffer, we have processed all the diagnostics in it.
529 Buffer.reset(new TextDiagnosticBuffer());
530}
Chris Lattner60909e12010-04-28 20:02:30 +0000531
Douglas Gregoraee526e2011-09-29 00:38:00 +0000532DiagnosticConsumer *
533VerifyDiagnosticConsumer::clone(DiagnosticsEngine &Diags) const {
534 if (!Diags.getClient())
535 Diags.setClient(PrimaryClient->clone(Diags));
536
537 return new VerifyDiagnosticConsumer(Diags);
538}
539
Jordan Roseaa48fe82012-07-10 02:57:03 +0000540Directive *Directive::create(bool RegexKind, SourceLocation DirectiveLoc,
541 SourceLocation DiagnosticLoc, StringRef Text,
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000542 unsigned Min, unsigned Max) {
Chris Lattner60909e12010-04-28 20:02:30 +0000543 if (RegexKind)
Jordan Rose3b81b7d2012-07-10 02:57:26 +0000544 return new RegexDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);
545 return new StandardDirective(DirectiveLoc, DiagnosticLoc, Text, Min, Max);
Chris Lattner60909e12010-04-28 20:02:30 +0000546}