Coverage Report

Created: 2022-05-14 11:35

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/lib/Frontend/VerifyDiagnosticConsumer.cpp
Line
Count
Source (jump to first uncovered line)
1
//===- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ---------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8
//
9
// This is a concrete diagnostic client, which buffers the diagnostic messages.
10
//
11
//===----------------------------------------------------------------------===//
12
13
#include "clang/Frontend/VerifyDiagnosticConsumer.h"
14
#include "clang/Basic/CharInfo.h"
15
#include "clang/Basic/Diagnostic.h"
16
#include "clang/Basic/DiagnosticOptions.h"
17
#include "clang/Basic/FileManager.h"
18
#include "clang/Basic/LLVM.h"
19
#include "clang/Basic/SourceLocation.h"
20
#include "clang/Basic/SourceManager.h"
21
#include "clang/Basic/TokenKinds.h"
22
#include "clang/Frontend/FrontendDiagnostic.h"
23
#include "clang/Frontend/TextDiagnosticBuffer.h"
24
#include "clang/Lex/HeaderSearch.h"
25
#include "clang/Lex/Lexer.h"
26
#include "clang/Lex/PPCallbacks.h"
27
#include "clang/Lex/Preprocessor.h"
28
#include "clang/Lex/Token.h"
29
#include "llvm/ADT/STLExtras.h"
30
#include "llvm/ADT/SmallPtrSet.h"
31
#include "llvm/ADT/SmallString.h"
32
#include "llvm/ADT/StringRef.h"
33
#include "llvm/ADT/Twine.h"
34
#include "llvm/Support/ErrorHandling.h"
35
#include "llvm/Support/Regex.h"
36
#include "llvm/Support/raw_ostream.h"
37
#include <algorithm>
38
#include <cassert>
39
#include <cstddef>
40
#include <cstring>
41
#include <iterator>
42
#include <memory>
43
#include <string>
44
#include <utility>
45
#include <vector>
46
47
using namespace clang;
48
49
using Directive = VerifyDiagnosticConsumer::Directive;
50
using DirectiveList = VerifyDiagnosticConsumer::DirectiveList;
51
using ExpectedData = VerifyDiagnosticConsumer::ExpectedData;
52
53
#ifndef NDEBUG
54
55
namespace {
56
57
class VerifyFileTracker : public PPCallbacks {
58
  VerifyDiagnosticConsumer &Verify;
59
  SourceManager &SM;
60
61
public:
62
  VerifyFileTracker(VerifyDiagnosticConsumer &Verify, SourceManager &SM)
63
17.6k
      : Verify(Verify), SM(SM) {}
64
65
  /// Hook into the preprocessor and update the list of parsed
66
  /// files when the preprocessor indicates a new file is entered.
67
  void FileChanged(SourceLocation Loc, FileChangeReason Reason,
68
                   SrcMgr::CharacteristicKind FileType,
69
105k
                   FileID PrevFID) override {
70
105k
    Verify.UpdateParsedFileStatus(SM, SM.getFileID(Loc),
71
105k
                                  VerifyDiagnosticConsumer::IsParsed);
72
105k
  }
73
};
74
75
} // namespace
76
77
#endif
78
79
//===----------------------------------------------------------------------===//
80
// Checking diagnostics implementation.
81
//===----------------------------------------------------------------------===//
82
83
using DiagList = TextDiagnosticBuffer::DiagList;
84
using const_diag_iterator = TextDiagnosticBuffer::const_iterator;
85
86
namespace {
87
88
/// StandardDirective - Directive with string matching.
89
class StandardDirective : public Directive {
90
public:
91
  StandardDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
92
                    bool MatchAnyFileAndLine, bool MatchAnyLine, StringRef Text,
93
                    unsigned Min, unsigned Max)
94
      : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyFileAndLine,
95
318k
                  MatchAnyLine, Text, Min, Max) {}
96
97
318k
  bool isValid(std::string &Error) override {
98
    // all strings are considered valid; even empty ones
99
318k
    return true;
100
318k
  }
101
102
424k
  bool match(StringRef S) override { return S.contains(Text); }
103
};
104
105
/// RegexDirective - Directive with regular-expression matching.
106
class RegexDirective : public Directive {
107
public:
108
  RegexDirective(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
109
                 bool MatchAnyFileAndLine, bool MatchAnyLine, StringRef Text,
110
                 unsigned Min, unsigned Max, StringRef RegexStr)
111
      : Directive(DirectiveLoc, DiagnosticLoc, MatchAnyFileAndLine,
112
                  MatchAnyLine, Text, Min, Max),
113
4.53k
        Regex(RegexStr) {}
114
115
4.53k
  bool isValid(std::string &Error) override {
116
4.53k
    return Regex.isValid(Error);
117
4.53k
  }
118
119
4.68k
  bool match(StringRef S) override {
120
4.68k
    return Regex.match(S);
121
4.68k
  }
122
123
private:
124
  llvm::Regex Regex;
125
};
126
127
class ParseHelper
128
{
129
public:
130
  ParseHelper(StringRef S)
131
43.2M
      : Begin(S.begin()), End(S.end()), C(Begin), P(Begin) {}
132
133
  // Return true if string literal is next.
134
1.71M
  bool Next(StringRef S) {
135
1.71M
    P = C;
136
1.71M
    PEnd = C + S.size();
137
1.71M
    if (PEnd > End)
138
0
      return false;
139
1.71M
    return memcmp(P, S.data(), S.size()) == 0;
140
1.71M
  }
141
142
  // Return true if number is next.
143
  // Output N only if number is next.
144
390k
  bool Next(unsigned &N) {
145
390k
    unsigned TMP = 0;
146
390k
    P = C;
147
390k
    PEnd = P;
148
492k
    for (; PEnd < End && *PEnd >= '0' && 
*PEnd <= '9'400k
;
++PEnd102k
) {
149
102k
      TMP *= 10;
150
102k
      TMP += *PEnd - '0';
151
102k
    }
152
390k
    if (PEnd == C)
153
289k
      return false;
154
100k
    N = TMP;
155
100k
    return true;
156
390k
  }
157
158
  // Return true if a marker is next.
159
  // A marker is the longest match for /#[A-Za-z0-9_-]+/.
160
636k
  bool NextMarker() {
161
636k
    P = C;
162
636k
    if (P == End || *P != '#')
163
1.76k
      return false;
164
634k
    PEnd = P;
165
634k
    ++PEnd;
166
693k
    while ((isAlphanumeric(*PEnd) || 
*PEnd == '-'634k
||
*PEnd == '_'634k
) &&
167
693k
           
PEnd < End58.7k
)
168
58.7k
      ++PEnd;
169
634k
    return PEnd > P + 1;
170
636k
  }
171
172
  // Return true if string literal S is matched in content.
173
  // When true, P marks begin-position of the match, and calling Advance sets C
174
  // to end-position of the match.
175
  // If S is the empty string, then search for any letter instead (makes sense
176
  // with FinishDirectiveToken=true).
177
  // If EnsureStartOfWord, then skip matches that don't start a new word.
178
  // If FinishDirectiveToken, then assume the match is the start of a comment
179
  // directive for -verify, and extend the match to include the entire first
180
  // token of that directive.
181
  bool Search(StringRef S, bool EnsureStartOfWord = false,
182
44.1M
              bool FinishDirectiveToken = false) {
183
45.2M
    do {
184
45.2M
      if (!S.empty()) {
185
43.8M
        P = std::search(C, End, S.begin(), S.end());
186
43.8M
        PEnd = P + S.size();
187
43.8M
      }
188
1.38M
      else {
189
1.38M
        P = C;
190
2.61M
        while (P != End && 
!isLetter(*P)2.59M
)
191
1.23M
          ++P;
192
1.38M
        PEnd = P + 1;
193
1.38M
      }
194
45.2M
      if (P == End)
195
42.9M
        break;
196
      // If not start of word but required, skip and search again.
197
2.21M
      if (EnsureStartOfWord
198
               // Check if string literal starts a new word.
199
2.21M
          && 
!(2.21M
P == Begin2.21M
||
isWhitespace(P[-1])2.21M
200
               // Or it could be preceded by the start of a comment.
201
2.21M
               || 
(1.06M
P > (Begin + 1)1.06M
&&
(1.06M
P[-1] == '/'1.06M
||
P[-1] == '*'1.06M
)
202
1.06M
                                   &&  
P[-2] == '/'5.28k
)))
203
1.06M
        continue;
204
1.14M
      if (FinishDirectiveToken) {
205
4.38M
        while (PEnd != End && 
(4.36M
isAlphanumeric(*PEnd)4.36M
206
4.36M
                               || 
*PEnd == '-'863k
||
*PEnd == '_'499k
))
207
3.86M
          ++PEnd;
208
        // Put back trailing digits and hyphens to be parsed later as a count
209
        // or count range.  Because -verify prefixes must start with letters,
210
        // we know the actual directive we found starts with a letter, so
211
        // we won't put back the entire directive word and thus record an empty
212
        // string.
213
512k
        assert(isLetter(*P) && "-verify prefix must start with a letter");
214
517k
        while (isDigit(PEnd[-1]) || 
PEnd[-1] == '-'513k
)
215
4.21k
          --PEnd;
216
512k
      }
217
0
      return true;
218
2.21M
    } while (
Advance()1.06M
);
219
43.0M
    return false;
220
44.1M
  }
221
222
  // Return true if a CloseBrace that closes the OpenBrace at the current nest
223
  // level is found. When true, P marks begin-position of CloseBrace.
224
323k
  bool SearchClosingBrace(StringRef OpenBrace, StringRef CloseBrace) {
225
323k
    unsigned Depth = 1;
226
323k
    P = C;
227
14.7M
    while (P < End) {
228
14.7M
      StringRef S(P, End - P);
229
14.7M
      if (S.startswith(OpenBrace)) {
230
5.72k
        ++Depth;
231
5.72k
        P += OpenBrace.size();
232
14.7M
      } else if (S.startswith(CloseBrace)) {
233
329k
        --Depth;
234
329k
        if (Depth == 0) {
235
323k
          PEnd = P + CloseBrace.size();
236
323k
          return true;
237
323k
        }
238
5.72k
        P += CloseBrace.size();
239
14.4M
      } else {
240
14.4M
        ++P;
241
14.4M
      }
242
14.7M
    }
243
0
    return false;
244
323k
  }
245
246
  // Advance 1-past previous next/search.
247
  // Behavior is undefined if previous next/search failed.
248
3.09M
  bool Advance() {
249
3.09M
    C = PEnd;
250
3.09M
    return C < End;
251
3.09M
  }
252
253
  // Return the text matched by the previous next/search.
254
  // Behavior is undefined if previous next/search failed.
255
524k
  StringRef Match() { return StringRef(P, PEnd - P); }
256
257
  // Skip zero or more whitespace.
258
646k
  void SkipWhitespace() {
259
954k
    for (; C < End && isWhitespace(*C); 
++C307k
)
260
307k
      ;
261
646k
  }
262
263
  // Return true if EOF reached.
264
44.4M
  bool Done() {
265
44.4M
    return !(C < End);
266
44.4M
  }
267
268
  // Beginning of expected content.
269
  const char * const Begin;
270
271
  // End of expected content (1-past).
272
  const char * const End;
273
274
  // Position of next char in content.
275
  const char *C;
276
277
  // Previous next/search subject start.
278
  const char *P;
279
280
private:
281
  // Previous next/search subject end (1-past).
282
  const char *PEnd = nullptr;
283
};
284
285
// The information necessary to create a directive.
286
struct UnattachedDirective {
287
  DirectiveList *DL = nullptr;
288
  bool RegexKind = false;
289
  SourceLocation DirectivePos, ContentBegin;
290
  std::string Text;
291
  unsigned Min = 1, Max = 1;
292
};
293
294
// Attach the specified directive to the line of code indicated by
295
// \p ExpectedLoc.
296
void attachDirective(DiagnosticsEngine &Diags, const UnattachedDirective &UD,
297
                     SourceLocation ExpectedLoc,
298
                     bool MatchAnyFileAndLine = false,
299
323k
                     bool MatchAnyLine = false) {
300
  // Construct new directive.
301
323k
  std::unique_ptr<Directive> D = Directive::create(
302
323k
      UD.RegexKind, UD.DirectivePos, ExpectedLoc, MatchAnyFileAndLine,
303
323k
      MatchAnyLine, UD.Text, UD.Min, UD.Max);
304
305
323k
  std::string Error;
306
323k
  if (!D->isValid(Error)) {
307
0
    Diags.Report(UD.ContentBegin, diag::err_verify_invalid_content)
308
0
      << (UD.RegexKind ? "regex" : "string") << Error;
309
0
  }
310
311
323k
  UD.DL->push_back(std::move(D));
312
323k
}
313
314
} // anonymous
315
316
// Tracker for markers in the input files. A marker is a comment of the form
317
//
318
//   n = 123; // #123
319
//
320
// ... that can be referred to by a later expected-* directive:
321
//
322
//   // expected-error@#123 {{undeclared identifier 'n'}}
323
//
324
// Marker declarations must be at the start of a comment or preceded by
325
// whitespace to distinguish them from uses of markers in directives.
326
class VerifyDiagnosticConsumer::MarkerTracker {
327
  DiagnosticsEngine &Diags;
328
329
  struct Marker {
330
    SourceLocation DefLoc;
331
    SourceLocation RedefLoc;
332
    SourceLocation UseLoc;
333
  };
334
  llvm::StringMap<Marker> Markers;
335
336
  // Directives that couldn't be created yet because they name an unknown
337
  // marker.
338
  llvm::StringMap<llvm::SmallVector<UnattachedDirective, 2>> DeferredDirectives;
339
340
public:
341
18.2k
  MarkerTracker(DiagnosticsEngine &Diags) : Diags(Diags) {}
342
343
  // Register a marker.
344
11.3k
  void addMarker(StringRef MarkerName, SourceLocation Pos) {
345
11.3k
    auto InsertResult = Markers.insert(
346
11.3k
        {MarkerName, Marker{Pos, SourceLocation(), SourceLocation()}});
347
348
11.3k
    Marker &M = InsertResult.first->second;
349
11.3k
    if (!InsertResult.second) {
350
      // Marker was redefined.
351
9.66k
      M.RedefLoc = Pos;
352
9.66k
    } else {
353
      // First definition: build any deferred directives.
354
1.66k
      auto Deferred = DeferredDirectives.find(MarkerName);
355
1.66k
      if (Deferred != DeferredDirectives.end()) {
356
37
        for (auto &UD : Deferred->second) {
357
37
          if (M.UseLoc.isInvalid())
358
21
            M.UseLoc = UD.DirectivePos;
359
37
          attachDirective(Diags, UD, Pos);
360
37
        }
361
21
        DeferredDirectives.erase(Deferred);
362
21
      }
363
1.66k
    }
364
11.3k
  }
365
366
  // Register a directive at the specified marker.
367
417
  void addDirective(StringRef MarkerName, const UnattachedDirective &UD) {
368
417
    auto MarkerIt = Markers.find(MarkerName);
369
417
    if (MarkerIt != Markers.end()) {
370
379
      Marker &M = MarkerIt->second;
371
379
      if (M.UseLoc.isInvalid())
372
242
        M.UseLoc = UD.DirectivePos;
373
379
      return attachDirective(Diags, UD, M.DefLoc);
374
379
    }
375
38
    DeferredDirectives[MarkerName].push_back(UD);
376
38
  }
377
378
  // Ensure we have no remaining deferred directives, and no
379
  // multiply-defined-and-used markers.
380
17.6k
  void finalize() {
381
17.6k
    for (auto &MarkerInfo : Markers) {
382
1.65k
      StringRef Name = MarkerInfo.first();
383
1.65k
      Marker &M = MarkerInfo.second;
384
1.65k
      if (M.RedefLoc.isValid() && 
M.UseLoc.isValid()523
) {
385
1
        Diags.Report(M.UseLoc, diag::err_verify_ambiguous_marker) << Name;
386
1
        Diags.Report(M.DefLoc, diag::note_verify_ambiguous_marker) << Name;
387
1
        Diags.Report(M.RedefLoc, diag::note_verify_ambiguous_marker) << Name;
388
1
      }
389
1.65k
    }
390
391
17.6k
    for (auto &DeferredPair : DeferredDirectives) {
392
1
      Diags.Report(DeferredPair.second.front().DirectivePos,
393
1
                   diag::err_verify_no_such_marker)
394
1
          << DeferredPair.first();
395
1
    }
396
17.6k
  }
397
};
398
399
/// ParseDirective - Go through the comment and see if it indicates expected
400
/// diagnostics. If so, then put them in the appropriate directive list.
401
///
402
/// Returns true if any valid directives were found.
403
static bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM,
404
                           Preprocessor *PP, SourceLocation Pos,
405
                           VerifyDiagnosticConsumer::DirectiveStatus &Status,
406
21.6M
                           VerifyDiagnosticConsumer::MarkerTracker &Markers) {
407
21.6M
  DiagnosticsEngine &Diags = PP ? 
PP->getDiagnostics()21.6M
:
SM.getDiagnostics()623
;
408
409
  // First, scan the comment looking for markers.
410
22.2M
  for (ParseHelper PH(S); !PH.Done();) {
411
22.2M
    if (!PH.Search("#", true))
412
21.6M
      break;
413
634k
    PH.C = PH.P;
414
634k
    if (!PH.NextMarker()) {
415
622k
      PH.Next("#");
416
622k
      PH.Advance();
417
622k
      continue;
418
622k
    }
419
11.3k
    PH.Advance();
420
11.3k
    Markers.addMarker(PH.Match(), Pos);
421
11.3k
  }
422
423
  // A single comment may contain multiple directives.
424
21.6M
  bool FoundDirective = false;
425
22.1M
  for (ParseHelper PH(S); !PH.Done();) {
426
    // Search for the initial directive token.
427
    // If one prefix, save time by searching only for its directives.
428
    // Otherwise, search for any potential directive token and check it later.
429
21.8M
    const auto &Prefixes = Diags.getDiagnosticOptions().VerifyPrefixes;
430
21.8M
    if (!(Prefixes.size() == 1 ? 
PH.Search(*Prefixes.begin(), true, true)21.5M
431
21.8M
                               : 
PH.Search("", true, true)344k
))
432
21.3M
      break;
433
434
512k
    StringRef DToken = PH.Match();
435
512k
    PH.Advance();
436
437
    // Default directive kind.
438
512k
    UnattachedDirective D;
439
512k
    const char *KindStr = "string";
440
441
    // Parse the initial directive token in reverse so we can easily determine
442
    // its exact actual prefix.  If we were to parse it from the front instead,
443
    // it would be harder to determine where the prefix ends because there
444
    // might be multiple matching -verify prefixes because some might prefix
445
    // others.
446
447
    // Regex in initial directive token: -re
448
512k
    if (DToken.endswith("-re")) {
449
4.56k
      D.RegexKind = true;
450
4.56k
      KindStr = "regex";
451
4.56k
      DToken = DToken.substr(0, DToken.size()-3);
452
4.56k
    }
453
454
    // Type in initial directive token: -{error|warning|note|no-diagnostics}
455
512k
    bool NoDiag = false;
456
512k
    StringRef DType;
457
512k
    if (DToken.endswith(DType="-error"))
458
186k
      D.DL = ED ? 
&ED->Errors186k
:
nullptr34
;
459
326k
    else if (DToken.endswith(DType="-warning"))
460
61.8k
      D.DL = ED ? 
&ED->Warnings61.8k
:
nullptr7
;
461
264k
    else if (DToken.endswith(DType="-remark"))
462
87
      D.DL = ED ? &ED->Remarks : 
nullptr0
;
463
264k
    else if (DToken.endswith(DType="-note"))
464
89.4k
      D.DL = ED ? 
&ED->Notes89.4k
:
nullptr10
;
465
175k
    else if (DToken.endswith(DType="-no-diagnostics")) {
466
8.57k
      NoDiag = true;
467
8.57k
      if (D.RegexKind)
468
0
        continue;
469
8.57k
    }
470
166k
    else
471
166k
      continue;
472
346k
    DToken = DToken.substr(0, DToken.size()-DType.size());
473
474
    // What's left in DToken is the actual prefix.  That might not be a -verify
475
    // prefix even if there is only one -verify prefix (for example, the full
476
    // DToken is foo-bar-warning, but foo is the only -verify prefix).
477
346k
    if (!std::binary_search(Prefixes.begin(), Prefixes.end(), DToken))
478
14.5k
      continue;
479
480
331k
    if (NoDiag) {
481
8.46k
      if (Status == VerifyDiagnosticConsumer::HasOtherExpectedDirectives)
482
1
        Diags.Report(Pos, diag::err_verify_invalid_no_diags)
483
1
          << /*IsExpectedNoDiagnostics=*/true;
484
8.46k
      else
485
8.46k
        Status = VerifyDiagnosticConsumer::HasExpectedNoDiagnostics;
486
8.46k
      continue;
487
8.46k
    }
488
323k
    if (Status == VerifyDiagnosticConsumer::HasExpectedNoDiagnostics) {
489
1
      Diags.Report(Pos, diag::err_verify_invalid_no_diags)
490
1
        << /*IsExpectedNoDiagnostics=*/false;
491
1
      continue;
492
1
    }
493
323k
    Status = VerifyDiagnosticConsumer::HasOtherExpectedDirectives;
494
495
    // If a directive has been found but we're not interested
496
    // in storing the directive information, return now.
497
323k
    if (!D.DL)
498
51
      return true;
499
500
    // Next optional token: @
501
323k
    SourceLocation ExpectedLoc;
502
323k
    StringRef Marker;
503
323k
    bool MatchAnyFileAndLine = false;
504
323k
    bool MatchAnyLine = false;
505
323k
    if (!PH.Next("@")) {
506
259k
      ExpectedLoc = Pos;
507
259k
    } else {
508
64.2k
      PH.Advance();
509
64.2k
      unsigned Line = 0;
510
64.2k
      bool FoundPlus = PH.Next("+");
511
64.2k
      if (FoundPlus || 
PH.Next("-")19.8k
) {
512
        // Relative to current line.
513
61.4k
        PH.Advance();
514
61.4k
        bool Invalid = false;
515
61.4k
        unsigned ExpectedLine = SM.getSpellingLineNumber(Pos, &Invalid);
516
61.4k
        if (!Invalid && PH.Next(Line) && (FoundPlus || 
Line < ExpectedLine17.0k
)) {
517
61.4k
          if (FoundPlus) 
ExpectedLine += Line44.4k
;
518
17.0k
          else ExpectedLine -= Line;
519
61.4k
          ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), ExpectedLine, 1);
520
61.4k
        }
521
61.4k
      } else 
if (2.78k
PH.Next(Line)2.78k
) {
522
        // Absolute line number.
523
595
        if (Line > 0)
524
589
          ExpectedLoc = SM.translateLineCol(SM.getFileID(Pos), Line, 1);
525
2.18k
      } else if (PH.NextMarker()) {
526
417
        Marker = PH.Match();
527
1.76k
      } else if (PP && PH.Search(":")) {
528
        // Specific source file.
529
1.30k
        StringRef Filename(PH.C, PH.P-PH.C);
530
1.30k
        PH.Advance();
531
532
1.30k
        if (Filename == "*") {
533
4
          MatchAnyFileAndLine = true;
534
4
          if (!PH.Next("*")) {
535
1
            Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin),
536
1
                         diag::err_verify_missing_line)
537
1
                << "'*'";
538
1
            continue;
539
1
          }
540
3
          MatchAnyLine = true;
541
3
          ExpectedLoc = SourceLocation();
542
1.30k
        } else {
543
          // Lookup file via Preprocessor, like a #include.
544
1.30k
          Optional<FileEntryRef> File =
545
1.30k
              PP->LookupFile(Pos, Filename, false, nullptr, nullptr, nullptr,
546
1.30k
                             nullptr, nullptr, nullptr, nullptr, nullptr);
547
1.30k
          if (!File) {
548
1
            Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin),
549
1
                         diag::err_verify_missing_file)
550
1
                << Filename << KindStr;
551
1
            continue;
552
1
          }
553
554
1.30k
          FileID FID = SM.translateFile(*File);
555
1.30k
          if (FID.isInvalid())
556
50
            FID = SM.createFileID(*File, Pos, SrcMgr::C_User);
557
558
1.30k
          if (PH.Next(Line) && 
Line > 0621
)
559
619
            ExpectedLoc = SM.translateLineCol(FID, Line, 1);
560
681
          else if (PH.Next("*")) {
561
678
            MatchAnyLine = true;
562
678
            ExpectedLoc = SM.translateLineCol(FID, 1, 1);
563
678
          }
564
1.30k
        }
565
1.30k
      } else 
if (463
PH.Next("*")463
) {
566
457
        MatchAnyLine = true;
567
457
        ExpectedLoc = SourceLocation();
568
457
      }
569
570
64.2k
      if (ExpectedLoc.isInvalid() && 
!MatchAnyLine898
&&
Marker.empty()438
) {
571
21
        Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
572
21
                     diag::err_verify_missing_line) << KindStr;
573
21
        continue;
574
21
      }
575
64.2k
      PH.Advance();
576
64.2k
    }
577
578
    // Skip optional whitespace.
579
323k
    PH.SkipWhitespace();
580
581
    // Next optional token: positive integer or a '+'.
582
323k
    if (PH.Next(D.Min)) {
583
36.5k
      PH.Advance();
584
      // A positive integer can be followed by a '+' meaning min
585
      // or more, or by a '-' meaning a range from min to max.
586
36.5k
      if (PH.Next("+")) {
587
2.46k
        D.Max = Directive::MaxCount;
588
2.46k
        PH.Advance();
589
34.0k
      } else if (PH.Next("-")) {
590
1.28k
        PH.Advance();
591
1.28k
        if (!PH.Next(D.Max) || D.Max < D.Min) {
592
0
          Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
593
0
                       diag::err_verify_invalid_range) << KindStr;
594
0
          continue;
595
0
        }
596
1.28k
        PH.Advance();
597
32.7k
      } else {
598
32.7k
        D.Max = D.Min;
599
32.7k
      }
600
286k
    } else if (PH.Next("+")) {
601
      // '+' on its own means "1 or more".
602
703
      D.Max = Directive::MaxCount;
603
703
      PH.Advance();
604
703
    }
605
606
    // Skip optional whitespace.
607
323k
    PH.SkipWhitespace();
608
609
    // Next token: {{
610
323k
    if (!PH.Next("{{")) {
611
7
      Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
612
7
                   diag::err_verify_missing_start) << KindStr;
613
7
      continue;
614
7
    }
615
323k
    PH.Advance();
616
323k
    const char* const ContentBegin = PH.C; // mark content begin
617
    // Search for token: }}
618
323k
    if (!PH.SearchClosingBrace("{{", "}}")) {
619
0
      Diags.Report(Pos.getLocWithOffset(PH.C-PH.Begin),
620
0
                   diag::err_verify_missing_end) << KindStr;
621
0
      continue;
622
0
    }
623
323k
    const char* const ContentEnd = PH.P; // mark content end
624
323k
    PH.Advance();
625
626
323k
    D.DirectivePos = Pos;
627
323k
    D.ContentBegin = Pos.getLocWithOffset(ContentBegin - PH.Begin);
628
629
    // Build directive text; convert \n to newlines.
630
323k
    StringRef NewlineStr = "\\n";
631
323k
    StringRef Content(ContentBegin, ContentEnd-ContentBegin);
632
323k
    size_t CPos = 0;
633
323k
    size_t FPos;
634
323k
    while ((FPos = Content.find(NewlineStr, CPos)) != StringRef::npos) {
635
86
      D.Text += Content.substr(CPos, FPos-CPos);
636
86
      D.Text += '\n';
637
86
      CPos = FPos + NewlineStr.size();
638
86
    }
639
323k
    if (D.Text.empty())
640
323k
      D.Text.assign(ContentBegin, ContentEnd);
641
642
    // Check that regex directives contain at least one regex.
643
323k
    if (D.RegexKind && 
D.Text.find("{{") == StringRef::npos4.53k
) {
644
0
      Diags.Report(D.ContentBegin, diag::err_verify_missing_regex) << D.Text;
645
0
      return false;
646
0
    }
647
648
323k
    if (Marker.empty())
649
322k
      attachDirective(Diags, D, ExpectedLoc, MatchAnyFileAndLine, MatchAnyLine);
650
417
    else
651
417
      Markers.addDirective(Marker, D);
652
323k
    FoundDirective = true;
653
323k
  }
654
655
21.6M
  return FoundDirective;
656
21.6M
}
657
658
VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &Diags_)
659
    : Diags(Diags_), PrimaryClient(Diags.getClient()),
660
      PrimaryClientOwner(Diags.takeClient()),
661
      Buffer(new TextDiagnosticBuffer()), Markers(new MarkerTracker(Diags)),
662
17.6k
      Status(HasNoDirectives) {
663
17.6k
  if (Diags.hasSourceManager())
664
0
    setSourceManager(Diags.getSourceManager());
665
17.6k
}
666
667
17.5k
VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
668
17.5k
  assert(!ActiveSourceFiles && "Incomplete parsing of source files!");
669
0
  assert(!CurrentPreprocessor && "CurrentPreprocessor should be invalid!");
670
0
  SrcManager = nullptr;
671
17.5k
  CheckDiagnostics();
672
17.5k
  assert(!Diags.ownsClient() &&
673
17.5k
         "The VerifyDiagnosticConsumer takes over ownership of the client!");
674
17.5k
}
675
676
// DiagnosticConsumer interface.
677
678
void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
679
17.6k
                                               const Preprocessor *PP) {
680
  // Attach comment handler on first invocation.
681
17.6k
  if (++ActiveSourceFiles == 1) {
682
17.6k
    if (PP) {
683
17.6k
      CurrentPreprocessor = PP;
684
17.6k
      this->LangOpts = &LangOpts;
685
17.6k
      setSourceManager(PP->getSourceManager());
686
17.6k
      const_cast<Preprocessor *>(PP)->addCommentHandler(this);
687
17.6k
#ifndef NDEBUG
688
      // Debug build tracks parsed files.
689
17.6k
      const_cast<Preprocessor *>(PP)->addPPCallbacks(
690
17.6k
                      std::make_unique<VerifyFileTracker>(*this, *SrcManager));
691
17.6k
#endif
692
17.6k
    }
693
17.6k
  }
694
695
17.6k
  assert((!PP || CurrentPreprocessor == PP) && "Preprocessor changed!");
696
0
  PrimaryClient->BeginSourceFile(LangOpts, PP);
697
17.6k
}
698
699
17.6k
void VerifyDiagnosticConsumer::EndSourceFile() {
700
17.6k
  assert(ActiveSourceFiles && "No active source files!");
701
0
  PrimaryClient->EndSourceFile();
702
703
  // Detach comment handler once last active source file completed.
704
17.6k
  if (--ActiveSourceFiles == 0) {
705
17.6k
    if (CurrentPreprocessor)
706
17.6k
      const_cast<Preprocessor *>(CurrentPreprocessor)->
707
17.6k
          removeCommentHandler(this);
708
709
    // Diagnose any used-but-not-defined markers.
710
17.6k
    Markers->finalize();
711
712
    // Check diagnostics once last file completed.
713
17.6k
    CheckDiagnostics();
714
17.6k
    CurrentPreprocessor = nullptr;
715
17.6k
    LangOpts = nullptr;
716
17.6k
  }
717
17.6k
}
718
719
void VerifyDiagnosticConsumer::HandleDiagnostic(
720
372k
      DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
721
372k
  if (Info.hasSourceManager()) {
722
    // If this diagnostic is for a different source manager, ignore it.
723
372k
    if (SrcManager && &Info.getSourceManager() != SrcManager)
724
278
      return;
725
726
371k
    setSourceManager(Info.getSourceManager());
727
371k
  }
728
729
371k
#ifndef NDEBUG
730
  // Debug build tracks unparsed files for possible
731
  // unparsed expected-* directives.
732
371k
  if (SrcManager) {
733
371k
    SourceLocation Loc = Info.getLocation();
734
371k
    if (Loc.isValid()) {
735
371k
      ParsedStatus PS = IsUnparsed;
736
737
371k
      Loc = SrcManager->getExpansionLoc(Loc);
738
371k
      FileID FID = SrcManager->getFileID(Loc);
739
740
371k
      const FileEntry *FE = SrcManager->getFileEntryForID(FID);
741
371k
      if (FE && 
CurrentPreprocessor371k
&&
SrcManager->isLoadedFileID(FID)371k
) {
742
        // If the file is a modules header file it shall not be parsed
743
        // for expected-* directives.
744
1.54k
        HeaderSearch &HS = CurrentPreprocessor->getHeaderSearchInfo();
745
1.54k
        if (HS.findModuleForHeader(FE))
746
1.16k
          PS = IsUnparsedNoDirectives;
747
1.54k
      }
748
749
371k
      UpdateParsedFileStatus(*SrcManager, FID, PS);
750
371k
    }
751
371k
  }
752
371k
#endif
753
754
  // Send the diagnostic to the buffer, we will check it once we reach the end
755
  // of the source file (or are destructed).
756
371k
  Buffer->HandleDiagnostic(DiagLevel, Info);
757
371k
}
758
759
/// HandleComment - Hook into the preprocessor and extract comments containing
760
///  expected errors and warnings.
761
bool VerifyDiagnosticConsumer::HandleComment(Preprocessor &PP,
762
21.6M
                                             SourceRange Comment) {
763
21.6M
  SourceManager &SM = PP.getSourceManager();
764
765
  // If this comment is for a different source manager, ignore it.
766
21.6M
  if (SrcManager && &SM != SrcManager)
767
0
    return false;
768
769
21.6M
  SourceLocation CommentBegin = Comment.getBegin();
770
771
21.6M
  const char *CommentRaw = SM.getCharacterData(CommentBegin);
772
21.6M
  StringRef C(CommentRaw, SM.getCharacterData(Comment.getEnd()) - CommentRaw);
773
774
21.6M
  if (C.empty())
775
2
    return false;
776
777
  // Fold any "\<EOL>" sequences
778
21.6M
  size_t loc = C.find('\\');
779
21.6M
  if (loc == StringRef::npos) {
780
21.4M
    ParseDirective(C, &ED, SM, &PP, CommentBegin, Status, *Markers);
781
21.4M
    return false;
782
21.4M
  }
783
784
144k
  std::string C2;
785
144k
  C2.reserve(C.size());
786
787
305k
  for (size_t last = 0;; 
loc = C.find('\\', last)161k
) {
788
305k
    if (loc == StringRef::npos || 
loc == C.size()161k
) {
789
144k
      C2 += C.substr(last);
790
144k
      break;
791
144k
    }
792
161k
    C2 += C.substr(last, loc-last);
793
161k
    last = loc + 1;
794
795
161k
    if (C[last] == '\n' || 
C[last] == '\r'146k
) {
796
14.3k
      ++last;
797
798
      // Escape \r\n  or \n\r, but not \n\n.
799
14.3k
      if (last < C.size())
800
14.3k
        if (C[last] == '\n' || C[last] == '\r')
801
0
          if (C[last] != C[last-1])
802
0
            ++last;
803
146k
    } else {
804
      // This was just a normal backslash.
805
146k
      C2 += '\\';
806
146k
    }
807
161k
  }
808
809
144k
  if (!C2.empty())
810
144k
    ParseDirective(C2, &ED, SM, &PP, CommentBegin, Status, *Markers);
811
144k
  return false;
812
21.6M
}
813
814
#ifndef NDEBUG
815
/// Lex the specified source file to determine whether it contains
816
/// any expected-* directives.  As a Lexer is used rather than a full-blown
817
/// Preprocessor, directives inside skipped #if blocks will still be found.
818
///
819
/// \return true if any directives were found.
820
static bool findDirectives(SourceManager &SM, FileID FID,
821
124
                           const LangOptions &LangOpts) {
822
  // Create a raw lexer to pull all the comments out of FID.
823
124
  if (FID.isInvalid())
824
0
    return false;
825
826
  // Create a lexer to lex all the tokens of the main file in raw mode.
827
124
  llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID);
828
124
  Lexer RawLex(FID, FromFile, SM, LangOpts);
829
830
  // Return comments as tokens, this is how we find expected diagnostics.
831
124
  RawLex.SetCommentRetentionState(true);
832
833
124
  Token Tok;
834
124
  Tok.setKind(tok::comment);
835
124
  VerifyDiagnosticConsumer::DirectiveStatus Status =
836
124
    VerifyDiagnosticConsumer::HasNoDirectives;
837
27.2k
  while (Tok.isNot(tok::eof)) {
838
27.1k
    RawLex.LexFromRawLexer(Tok);
839
27.1k
    if (!Tok.is(tok::comment)) 
continue26.5k
;
840
841
623
    std::string Comment = RawLex.getSpelling(Tok, SM, LangOpts);
842
623
    if (Comment.empty()) 
continue0
;
843
844
    // We don't care about tracking markers for this phase.
845
623
    VerifyDiagnosticConsumer::MarkerTracker Markers(SM.getDiagnostics());
846
847
    // Find first directive.
848
623
    if (ParseDirective(Comment, nullptr, SM, nullptr, Tok.getLocation(),
849
623
                       Status, Markers))
850
51
      return true;
851
623
  }
852
73
  return false;
853
124
}
854
#endif // !NDEBUG
855
856
/// Takes a list of diagnostics that have been generated but not matched
857
/// by an expected-* directive and produces a diagnostic to the user from this.
858
static unsigned PrintUnexpected(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
859
                                const_diag_iterator diag_begin,
860
                                const_diag_iterator diag_end,
861
140k
                                const char *Kind) {
862
140k
  if (diag_begin == diag_end) 
return 0140k
;
863
864
108
  SmallString<256> Fmt;
865
108
  llvm::raw_svector_ostream OS(Fmt);
866
281
  for (const_diag_iterator I = diag_begin, E = diag_end; I != E; 
++I173
) {
867
173
    if (I->first.isInvalid() || 
!SourceMgr108
)
868
65
      OS << "\n  (frontend)";
869
108
    else {
870
108
      OS << "\n ";
871
108
      if (const FileEntry *File = SourceMgr->getFileEntryForID(
872
108
                                                SourceMgr->getFileID(I->first)))
873
108
        OS << " File " << File->getName();
874
108
      OS << " Line " << SourceMgr->getPresumedLineNumber(I->first);
875
108
    }
876
173
    OS << ": " << I->second;
877
173
  }
878
879
108
  Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit()
880
108
    << Kind << /*Unexpected=*/true << OS.str();
881
108
  return std::distance(diag_begin, diag_end);
882
140k
}
883
884
/// Takes a list of diagnostics that were expected to have been generated
885
/// but were not and produces a diagnostic to the user from this.
886
static unsigned PrintExpected(DiagnosticsEngine &Diags,
887
                              SourceManager &SourceMgr,
888
70.4k
                              std::vector<Directive *> &DL, const char *Kind) {
889
70.4k
  if (DL.empty())
890
70.4k
    return 0;
891
892
25
  SmallString<256> Fmt;
893
25
  llvm::raw_svector_ostream OS(Fmt);
894
127
  for (const auto *D : DL) {
895
127
    if (D->DiagnosticLoc.isInvalid() || 
D->MatchAnyFileAndLine126
)
896
1
      OS << "\n  File *";
897
126
    else
898
126
      OS << "\n  File " << SourceMgr.getFilename(D->DiagnosticLoc);
899
127
    if (D->MatchAnyLine)
900
2
      OS << " Line *";
901
125
    else
902
125
      OS << " Line " << SourceMgr.getPresumedLineNumber(D->DiagnosticLoc);
903
127
    if (D->DirectiveLoc != D->DiagnosticLoc)
904
20
      OS << " (directive at "
905
20
         << SourceMgr.getFilename(D->DirectiveLoc) << ':'
906
20
         << SourceMgr.getPresumedLineNumber(D->DirectiveLoc) << ')';
907
127
    OS << ": " << D->Text;
908
127
  }
909
910
25
  Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit()
911
25
    << Kind << /*Unexpected=*/false << OS.str();
912
25
  return DL.size();
913
70.4k
}
914
915
/// Determine whether two source locations come from the same file.
916
static bool IsFromSameFile(SourceManager &SM, SourceLocation DirectiveLoc,
917
397k
                           SourceLocation DiagnosticLoc) {
918
409k
  while (DiagnosticLoc.isMacroID())
919
11.8k
    DiagnosticLoc = SM.getImmediateMacroCallerLoc(DiagnosticLoc);
920
921
397k
  if (SM.isWrittenInSameFile(DirectiveLoc, DiagnosticLoc))
922
394k
    return true;
923
924
2.62k
  const FileEntry *DiagFile = SM.getFileEntryForID(SM.getFileID(DiagnosticLoc));
925
2.62k
  if (!DiagFile && 
SM.isWrittenInMainFile(DirectiveLoc)13
)
926
13
    return true;
927
928
2.61k
  return (DiagFile == SM.getFileEntryForID(SM.getFileID(DirectiveLoc)));
929
2.62k
}
930
931
/// CheckLists - Compare expected to seen diagnostic lists and return the
932
/// the difference between them.
933
static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
934
                           const char *Label,
935
                           DirectiveList &Left,
936
                           const_diag_iterator d2_begin,
937
                           const_diag_iterator d2_end,
938
70.4k
                           bool IgnoreUnexpected) {
939
70.4k
  std::vector<Directive *> LeftOnly;
940
70.4k
  DiagList Right(d2_begin, d2_end);
941
942
323k
  for (auto &Owner : Left) {
943
323k
    Directive &D = *Owner;
944
323k
    unsigned LineNo1 = SourceMgr.getPresumedLineNumber(D.DiagnosticLoc);
945
946
694k
    for (unsigned i = 0; i < D.Max; 
++i371k
) {
947
375k
      DiagList::iterator II, IE;
948
2.33M
      for (II = Right.begin(), IE = Right.end(); II != IE; 
++II1.95M
) {
949
2.32M
        if (!D.MatchAnyLine) {
950
2.28M
          unsigned LineNo2 = SourceMgr.getPresumedLineNumber(II->first);
951
2.28M
          if (LineNo1 != LineNo2)
952
1.89M
            continue;
953
2.28M
        }
954
955
431k
        if (!D.DiagnosticLoc.isInvalid() && 
!D.MatchAnyFileAndLine397k
&&
956
431k
            
!IsFromSameFile(SourceMgr, D.DiagnosticLoc, II->first)397k
)
957
2.31k
          continue;
958
959
429k
        const std::string &RightText = II->second;
960
429k
        if (D.match(RightText))
961
371k
          break;
962
429k
      }
963
375k
      if (II == IE) {
964
        // Not found.
965
4.10k
        if (i >= D.Min) 
break3.98k
;
966
127
        LeftOnly.push_back(&D);
967
371k
      } else {
968
        // Found. The same cannot be found twice.
969
371k
        Right.erase(II);
970
371k
      }
971
375k
    }
972
323k
  }
973
  // Now all that's left in Right are those that were not matched.
974
70.4k
  unsigned num = PrintExpected(Diags, SourceMgr, LeftOnly, Label);
975
70.4k
  if (!IgnoreUnexpected)
976
70.3k
    num += PrintUnexpected(Diags, &SourceMgr, Right.begin(), Right.end(), Label);
977
70.4k
  return num;
978
70.4k
}
979
980
/// CheckResults - This compares the expected results to those that
981
/// were actually reported. It emits any discrepencies. Return "true" if there
982
/// were problems. Return "false" otherwise.
983
static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
984
                             const TextDiagnosticBuffer &Buffer,
985
17.6k
                             ExpectedData &ED) {
986
  // We want to capture the delta between what was expected and what was
987
  // seen.
988
  //
989
  //   Expected \ Seen - set expected but not seen
990
  //   Seen \ Expected - set seen but not expected
991
17.6k
  unsigned NumProblems = 0;
992
993
17.6k
  const DiagnosticLevelMask DiagMask =
994
17.6k
    Diags.getDiagnosticOptions().getVerifyIgnoreUnexpected();
995
996
  // See if there are error mismatches.
997
17.6k
  NumProblems += CheckLists(Diags, SourceMgr, "error", ED.Errors,
998
17.6k
                            Buffer.err_begin(), Buffer.err_end(),
999
17.6k
                            bool(DiagnosticLevelMask::Error & DiagMask));
1000
1001
  // See if there are warning mismatches.
1002
17.6k
  NumProblems += CheckLists(Diags, SourceMgr, "warning", ED.Warnings,
1003
17.6k
                            Buffer.warn_begin(), Buffer.warn_end(),
1004
17.6k
                            bool(DiagnosticLevelMask::Warning & DiagMask));
1005
1006
  // See if there are remark mismatches.
1007
17.6k
  NumProblems += CheckLists(Diags, SourceMgr, "remark", ED.Remarks,
1008
17.6k
                            Buffer.remark_begin(), Buffer.remark_end(),
1009
17.6k
                            bool(DiagnosticLevelMask::Remark & DiagMask));
1010
1011
  // See if there are note mismatches.
1012
17.6k
  NumProblems += CheckLists(Diags, SourceMgr, "note", ED.Notes,
1013
17.6k
                            Buffer.note_begin(), Buffer.note_end(),
1014
17.6k
                            bool(DiagnosticLevelMask::Note & DiagMask));
1015
1016
17.6k
  return NumProblems;
1017
17.6k
}
1018
1019
void VerifyDiagnosticConsumer::UpdateParsedFileStatus(SourceManager &SM,
1020
                                                      FileID FID,
1021
477k
                                                      ParsedStatus PS) {
1022
  // Check SourceManager hasn't changed.
1023
477k
  setSourceManager(SM);
1024
1025
477k
#ifndef NDEBUG
1026
477k
  if (FID.isInvalid())
1027
0
    return;
1028
1029
477k
  const FileEntry *FE = SM.getFileEntryForID(FID);
1030
1031
477k
  if (PS == IsParsed) {
1032
    // Move the FileID from the unparsed set to the parsed set.
1033
105k
    UnparsedFiles.erase(FID);
1034
105k
    ParsedFiles.insert(std::make_pair(FID, FE));
1035
371k
  } else if (!ParsedFiles.count(FID) && 
!UnparsedFiles.count(FID)1.60k
) {
1036
    // Add the FileID to the unparsed set if we haven't seen it before.
1037
1038
    // Check for directives.
1039
328
    bool FoundDirectives;
1040
328
    if (PS == IsUnparsedNoDirectives)
1041
204
      FoundDirectives = false;
1042
124
    else
1043
124
      FoundDirectives = !LangOpts || findDirectives(SM, FID, *LangOpts);
1044
1045
    // Add the FileID to the unparsed set.
1046
328
    UnparsedFiles.insert(std::make_pair(FID,
1047
328
                                      UnparsedFileStatus(FE, FoundDirectives)));
1048
328
  }
1049
477k
#endif
1050
477k
}
1051
1052
35.1k
void VerifyDiagnosticConsumer::CheckDiagnostics() {
1053
  // Ensure any diagnostics go to the primary client.
1054
35.1k
  DiagnosticConsumer *CurClient = Diags.getClient();
1055
35.1k
  std::unique_ptr<DiagnosticConsumer> Owner = Diags.takeClient();
1056
35.1k
  Diags.setClient(PrimaryClient, false);
1057
1058
35.1k
#ifndef NDEBUG
1059
  // In a debug build, scan through any files that may have been missed
1060
  // during parsing and issue a fatal error if directives are contained
1061
  // within these files.  If a fatal error occurs, this suggests that
1062
  // this file is being parsed separately from the main file, in which
1063
  // case consider moving the directives to the correct place, if this
1064
  // is applicable.
1065
35.1k
  if (!UnparsedFiles.empty()) {
1066
    // Generate a cache of parsed FileEntry pointers for alias lookups.
1067
235
    llvm::SmallPtrSet<const FileEntry *, 8> ParsedFileCache;
1068
235
    for (const auto &I : ParsedFiles)
1069
495
      if (const FileEntry *FE = I.second)
1070
260
        ParsedFileCache.insert(FE);
1071
1072
    // Iterate through list of unparsed files.
1073
325
    for (const auto &I : UnparsedFiles) {
1074
325
      const UnparsedFileStatus &Status = I.second;
1075
325
      const FileEntry *FE = Status.getFile();
1076
1077
      // Skip files that have been parsed via an alias.
1078
325
      if (FE && 
ParsedFileCache.count(FE)321
)
1079
56
        continue;
1080
1081
      // Report a fatal error if this file contained directives.
1082
269
      if (Status.foundDirectives()) {
1083
0
        llvm::report_fatal_error(Twine("-verify directives found after rather"
1084
0
                                       " than during normal parsing of ",
1085
0
                                 StringRef(FE ? FE->getName() : "(unknown)")));
1086
0
      }
1087
269
    }
1088
1089
    // UnparsedFiles has been processed now, so clear it.
1090
235
    UnparsedFiles.clear();
1091
235
  }
1092
35.1k
#endif // !NDEBUG
1093
1094
35.1k
  if (SrcManager) {
1095
    // Produce an error if no expected-* directives could be found in the
1096
    // source file(s) processed.
1097
17.6k
    if (Status == HasNoDirectives) {
1098
29
      Diags.Report(diag::err_verify_no_directives).setForceEmit();
1099
29
      ++NumErrors;
1100
29
      Status = HasNoDirectivesReported;
1101
29
    }
1102
1103
    // Check that the expected diagnostics occurred.
1104
17.6k
    NumErrors += CheckResults(Diags, *SrcManager, *Buffer, ED);
1105
17.6k
  } else {
1106
17.5k
    const DiagnosticLevelMask DiagMask =
1107
17.5k
        ~Diags.getDiagnosticOptions().getVerifyIgnoreUnexpected();
1108
17.5k
    if (bool(DiagnosticLevelMask::Error & DiagMask))
1109
17.5k
      NumErrors += PrintUnexpected(Diags, nullptr, Buffer->err_begin(),
1110
17.5k
                                   Buffer->err_end(), "error");
1111
17.5k
    if (bool(DiagnosticLevelMask::Warning & DiagMask))
1112
17.5k
      NumErrors += PrintUnexpected(Diags, nullptr, Buffer->warn_begin(),
1113
17.5k
                                   Buffer->warn_end(), "warn");
1114
17.5k
    if (bool(DiagnosticLevelMask::Remark & DiagMask))
1115
17.5k
      NumErrors += PrintUnexpected(Diags, nullptr, Buffer->remark_begin(),
1116
17.5k
                                   Buffer->remark_end(), "remark");
1117
17.5k
    if (bool(DiagnosticLevelMask::Note & DiagMask))
1118
17.5k
      NumErrors += PrintUnexpected(Diags, nullptr, Buffer->note_begin(),
1119
17.5k
                                   Buffer->note_end(), "note");
1120
17.5k
  }
1121
1122
35.1k
  Diags.setClient(CurClient, Owner.release() != nullptr);
1123
1124
  // Reset the buffer, we have processed all the diagnostics in it.
1125
35.1k
  Buffer.reset(new TextDiagnosticBuffer());
1126
35.1k
  ED.Reset();
1127
35.1k
}
1128
1129
std::unique_ptr<Directive> Directive::create(bool RegexKind,
1130
                                             SourceLocation DirectiveLoc,
1131
                                             SourceLocation DiagnosticLoc,
1132
                                             bool MatchAnyFileAndLine,
1133
                                             bool MatchAnyLine, StringRef Text,
1134
323k
                                             unsigned Min, unsigned Max) {
1135
323k
  if (!RegexKind)
1136
318k
    return std::make_unique<StandardDirective>(DirectiveLoc, DiagnosticLoc,
1137
318k
                                               MatchAnyFileAndLine,
1138
318k
                                               MatchAnyLine, Text, Min, Max);
1139
1140
  // Parse the directive into a regular expression.
1141
4.53k
  std::string RegexStr;
1142
4.53k
  StringRef S = Text;
1143
17.6k
  while (!S.empty()) {
1144
13.1k
    if (S.startswith("{{")) {
1145
5.72k
      S = S.drop_front(2);
1146
5.72k
      size_t RegexMatchLength = S.find("}}");
1147
5.72k
      assert(RegexMatchLength != StringRef::npos);
1148
      // Append the regex, enclosed in parentheses.
1149
0
      RegexStr += "(";
1150
5.72k
      RegexStr.append(S.data(), RegexMatchLength);
1151
5.72k
      RegexStr += ")";
1152
5.72k
      S = S.drop_front(RegexMatchLength + 2);
1153
7.41k
    } else {
1154
7.41k
      size_t VerbatimMatchLength = S.find("{{");
1155
7.41k
      if (VerbatimMatchLength == StringRef::npos)
1156
2.48k
        VerbatimMatchLength = S.size();
1157
      // Escape and append the fixed string.
1158
7.41k
      RegexStr += llvm::Regex::escape(S.substr(0, VerbatimMatchLength));
1159
7.41k
      S = S.drop_front(VerbatimMatchLength);
1160
7.41k
    }
1161
13.1k
  }
1162
1163
4.53k
  return std::make_unique<RegexDirective>(DirectiveLoc, DiagnosticLoc,
1164
4.53k
                                          MatchAnyFileAndLine, MatchAnyLine,
1165
4.53k
                                          Text, Min, Max, RegexStr);
1166
323k
}