Home | History | Annotate | Download | only in Frontend 
      1 //===---- VerifyDiagnosticConsumer.cpp - Verifying Diagnostic Client ------===//
      2 //
      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 
     14 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
     15 #include "clang/Frontend/FrontendDiagnostic.h"
     16 #include "clang/Frontend/TextDiagnosticBuffer.h"
     17 #include "clang/Lex/Preprocessor.h"
     18 #include "llvm/ADT/SmallString.h"
     19 #include "llvm/Support/Regex.h"
     20 #include "llvm/Support/raw_ostream.h"
     21 using namespace clang;
     22 
     23 VerifyDiagnosticConsumer::VerifyDiagnosticConsumer(DiagnosticsEngine &_Diags)
     24   : Diags(_Diags), PrimaryClient(Diags.getClient()),
     25     OwnsPrimaryClient(Diags.ownsClient()),
     26     Buffer(new TextDiagnosticBuffer()), CurrentPreprocessor(0)
     27 {
     28   Diags.takeClient();
     29 }
     30 
     31 VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
     32   CheckDiagnostics();
     33   Diags.takeClient();
     34   if (OwnsPrimaryClient)
     35     delete PrimaryClient;
     36 }
     37 
     38 // DiagnosticConsumer interface.
     39 
     40 void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
     41                                              const Preprocessor *PP) {
     42   // FIXME: Const hack, we screw up the preprocessor but in practice its ok
     43   // because it doesn't get reused. It would be better if we could make a copy
     44   // though.
     45   CurrentPreprocessor = const_cast<Preprocessor*>(PP);
     46 
     47   PrimaryClient->BeginSourceFile(LangOpts, PP);
     48 }
     49 
     50 void VerifyDiagnosticConsumer::EndSourceFile() {
     51   CheckDiagnostics();
     52 
     53   PrimaryClient->EndSourceFile();
     54 
     55   CurrentPreprocessor = 0;
     56 }
     57 
     58 void VerifyDiagnosticConsumer::HandleDiagnostic(
     59       DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
     60   if (FirstErrorFID.isInvalid() && Info.hasSourceManager()) {
     61     const SourceManager &SM = Info.getSourceManager();
     62     FirstErrorFID = SM.getFileID(Info.getLocation());
     63   }
     64   // Send the diagnostic to the buffer, we will check it once we reach the end
     65   // of the source file (or are destructed).
     66   Buffer->HandleDiagnostic(DiagLevel, Info);
     67 }
     68 
     69 //===----------------------------------------------------------------------===//
     70 // Checking diagnostics implementation.
     71 //===----------------------------------------------------------------------===//
     72 
     73 typedef TextDiagnosticBuffer::DiagList DiagList;
     74 typedef TextDiagnosticBuffer::const_iterator const_diag_iterator;
     75 
     76 namespace {
     77 
     78 /// Directive - Abstract class representing a parsed verify directive.
     79 ///
     80 class Directive {
     81 public:
     82   static Directive* Create(bool RegexKind, const SourceLocation &Location,
     83                            const std::string &Text, unsigned Count);
     84 public:
     85   SourceLocation Location;
     86   const std::string Text;
     87   unsigned Count;
     88 
     89   virtual ~Directive() { }
     90 
     91   // Returns true if directive text is valid.
     92   // Otherwise returns false and populates E.
     93   virtual bool isValid(std::string &Error) = 0;
     94 
     95   // Returns true on match.
     96   virtual bool Match(const std::string &S) = 0;
     97 
     98 protected:
     99   Directive(const SourceLocation &Location, const std::string &Text,
    100             unsigned Count)
    101     : Location(Location), Text(Text), Count(Count) { }
    102 
    103 private:
    104   Directive(const Directive&); // DO NOT IMPLEMENT
    105   void operator=(const Directive&); // DO NOT IMPLEMENT
    106 };
    107 
    108 /// StandardDirective - Directive with string matching.
    109 ///
    110 class StandardDirective : public Directive {
    111 public:
    112   StandardDirective(const SourceLocation &Location, const std::string &Text,
    113                     unsigned Count)
    114     : Directive(Location, Text, Count) { }
    115 
    116   virtual bool isValid(std::string &Error) {
    117     // all strings are considered valid; even empty ones
    118     return true;
    119   }
    120 
    121   virtual bool Match(const std::string &S) {
    122     return S.find(Text) != std::string::npos ||
    123            Text.find(S) != std::string::npos;
    124   }
    125 };
    126 
    127 /// RegexDirective - Directive with regular-expression matching.
    128 ///
    129 class RegexDirective : public Directive {
    130 public:
    131   RegexDirective(const SourceLocation &Location, const std::string &Text,
    132                  unsigned Count)
    133     : Directive(Location, Text, Count), Regex(Text) { }
    134 
    135   virtual bool isValid(std::string &Error) {
    136     if (Regex.isValid(Error))
    137       return true;
    138     return false;
    139   }
    140 
    141   virtual bool Match(const std::string &S) {
    142     return Regex.match(S);
    143   }
    144 
    145 private:
    146   llvm::Regex Regex;
    147 };
    148 
    149 typedef std::vector<Directive*> DirectiveList;
    150 
    151 /// ExpectedData - owns directive objects and deletes on destructor.
    152 ///
    153 struct ExpectedData {
    154   DirectiveList Errors;
    155   DirectiveList Warnings;
    156   DirectiveList Notes;
    157 
    158   ~ExpectedData() {
    159     DirectiveList* Lists[] = { &Errors, &Warnings, &Notes, 0 };
    160     for (DirectiveList **PL = Lists; *PL; ++PL) {
    161       DirectiveList * const L = *PL;
    162       for (DirectiveList::iterator I = L->begin(), E = L->end(); I != E; ++I)
    163         delete *I;
    164     }
    165   }
    166 };
    167 
    168 class ParseHelper
    169 {
    170 public:
    171   ParseHelper(const char *Begin, const char *End)
    172     : Begin(Begin), End(End), C(Begin), P(Begin), PEnd(NULL) { }
    173 
    174   // Return true if string literal is next.
    175   bool Next(StringRef S) {
    176     P = C;
    177     PEnd = C + S.size();
    178     if (PEnd > End)
    179       return false;
    180     return !memcmp(P, S.data(), S.size());
    181   }
    182 
    183   // Return true if number is next.
    184   // Output N only if number is next.
    185   bool Next(unsigned &N) {
    186     unsigned TMP = 0;
    187     P = C;
    188     for (; P < End && P[0] >= '0' && P[0] <= '9'; ++P) {
    189       TMP *= 10;
    190       TMP += P[0] - '0';
    191     }
    192     if (P == C)
    193       return false;
    194     PEnd = P;
    195     N = TMP;
    196     return true;
    197   }
    198 
    199   // Return true if string literal is found.
    200   // When true, P marks begin-position of S in content.
    201   bool Search(StringRef S) {
    202     P = std::search(C, End, S.begin(), S.end());
    203     PEnd = P + S.size();
    204     return P != End;
    205   }
    206 
    207   // Advance 1-past previous next/search.
    208   // Behavior is undefined if previous next/search failed.
    209   bool Advance() {
    210     C = PEnd;
    211     return C < End;
    212   }
    213 
    214   // Skip zero or more whitespace.
    215   void SkipWhitespace() {
    216     for (; C < End && isspace(*C); ++C)
    217       ;
    218   }
    219 
    220   // Return true if EOF reached.
    221   bool Done() {
    222     return !(C < End);
    223   }
    224 
    225   const char * const Begin; // beginning of expected content
    226   const char * const End;   // end of expected content (1-past)
    227   const char *C;            // position of next char in content
    228   const char *P;
    229 
    230 private:
    231   const char *PEnd; // previous next/search subject end (1-past)
    232 };
    233 
    234 } // namespace anonymous
    235 
    236 /// ParseDirective - Go through the comment and see if it indicates expected
    237 /// diagnostics. If so, then put them in the appropriate directive list.
    238 ///
    239 static void ParseDirective(const char *CommentStart, unsigned CommentLen,
    240                            ExpectedData &ED, Preprocessor &PP,
    241                            SourceLocation Pos) {
    242   // A single comment may contain multiple directives.
    243   for (ParseHelper PH(CommentStart, CommentStart+CommentLen); !PH.Done();) {
    244     // search for token: expected
    245     if (!PH.Search("expected"))
    246       break;
    247     PH.Advance();
    248 
    249     // next token: -
    250     if (!PH.Next("-"))
    251       continue;
    252     PH.Advance();
    253 
    254     // next token: { error | warning | note }
    255     DirectiveList* DL = NULL;
    256     if (PH.Next("error"))
    257       DL = &ED.Errors;
    258     else if (PH.Next("warning"))
    259       DL = &ED.Warnings;
    260     else if (PH.Next("note"))
    261       DL = &ED.Notes;
    262     else
    263       continue;
    264     PH.Advance();
    265 
    266     // default directive kind
    267     bool RegexKind = false;
    268     const char* KindStr = "string";
    269 
    270     // next optional token: -
    271     if (PH.Next("-re")) {
    272       PH.Advance();
    273       RegexKind = true;
    274       KindStr = "regex";
    275     }
    276 
    277     // skip optional whitespace
    278     PH.SkipWhitespace();
    279 
    280     // next optional token: positive integer
    281     unsigned Count = 1;
    282     if (PH.Next(Count))
    283       PH.Advance();
    284 
    285     // skip optional whitespace
    286     PH.SkipWhitespace();
    287 
    288     // next token: {{
    289     if (!PH.Next("{{")) {
    290       PP.Diag(Pos.getLocWithOffset(PH.C-PH.Begin),
    291               diag::err_verify_missing_start) << KindStr;
    292       continue;
    293     }
    294     PH.Advance();
    295     const char* const ContentBegin = PH.C; // mark content begin
    296 
    297     // search for token: }}
    298     if (!PH.Search("}}")) {
    299       PP.Diag(Pos.getLocWithOffset(PH.C-PH.Begin),
    300               diag::err_verify_missing_end) << KindStr;
    301       continue;
    302     }
    303     const char* const ContentEnd = PH.P; // mark content end
    304     PH.Advance();
    305 
    306     // build directive text; convert \n to newlines
    307     std::string Text;
    308     StringRef NewlineStr = "\\n";
    309     StringRef Content(ContentBegin, ContentEnd-ContentBegin);
    310     size_t CPos = 0;
    311     size_t FPos;
    312     while ((FPos = Content.find(NewlineStr, CPos)) != StringRef::npos) {
    313       Text += Content.substr(CPos, FPos-CPos);
    314       Text += '\n';
    315       CPos = FPos + NewlineStr.size();
    316     }
    317     if (Text.empty())
    318       Text.assign(ContentBegin, ContentEnd);
    319 
    320     // construct new directive
    321     Directive *D = Directive::Create(RegexKind, Pos, Text, Count);
    322     std::string Error;
    323     if (D->isValid(Error))
    324       DL->push_back(D);
    325     else {
    326       PP.Diag(Pos.getLocWithOffset(ContentBegin-PH.Begin),
    327               diag::err_verify_invalid_content)
    328         << KindStr << Error;
    329     }
    330   }
    331 }
    332 
    333 /// FindExpectedDiags - Lex the main source file to find all of the
    334 //   expected errors and warnings.
    335 static void FindExpectedDiags(Preprocessor &PP, ExpectedData &ED, FileID FID) {
    336   // Create a raw lexer to pull all the comments out of FID.
    337   if (FID.isInvalid())
    338     return;
    339 
    340   SourceManager& SM = PP.getSourceManager();
    341   // Create a lexer to lex all the tokens of the main file in raw mode.
    342   const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
    343   Lexer RawLex(FID, FromFile, SM, PP.getLangOptions());
    344 
    345   // Return comments as tokens, this is how we find expected diagnostics.
    346   RawLex.SetCommentRetentionState(true);
    347 
    348   Token Tok;
    349   Tok.setKind(tok::comment);
    350   while (Tok.isNot(tok::eof)) {
    351     RawLex.Lex(Tok);
    352     if (!Tok.is(tok::comment)) continue;
    353 
    354     std::string Comment = PP.getSpelling(Tok);
    355     if (Comment.empty()) continue;
    356 
    357     // Find all expected errors/warnings/notes.
    358     ParseDirective(&Comment[0], Comment.size(), ED, PP, Tok.getLocation());
    359   };
    360 }
    361 
    362 /// PrintProblem - This takes a diagnostic map of the delta between expected and
    363 /// seen diagnostics. If there's anything in it, then something unexpected
    364 /// happened. Print the map out in a nice format and return "true". If the map
    365 /// is empty and we're not going to print things, then return "false".
    366 ///
    367 static unsigned PrintProblem(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
    368                              const_diag_iterator diag_begin,
    369                              const_diag_iterator diag_end,
    370                              const char *Kind, bool Expected) {
    371   if (diag_begin == diag_end) return 0;
    372 
    373   llvm::SmallString<256> Fmt;
    374   llvm::raw_svector_ostream OS(Fmt);
    375   for (const_diag_iterator I = diag_begin, E = diag_end; I != E; ++I) {
    376     if (I->first.isInvalid() || !SourceMgr)
    377       OS << "\n  (frontend)";
    378     else
    379       OS << "\n  Line " << SourceMgr->getPresumedLineNumber(I->first);
    380     OS << ": " << I->second;
    381   }
    382 
    383   Diags.Report(diag::err_verify_inconsistent_diags)
    384     << Kind << !Expected << OS.str();
    385   return std::distance(diag_begin, diag_end);
    386 }
    387 
    388 static unsigned PrintProblem(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
    389                              DirectiveList &DL, const char *Kind,
    390                              bool Expected) {
    391   if (DL.empty())
    392     return 0;
    393 
    394   llvm::SmallString<256> Fmt;
    395   llvm::raw_svector_ostream OS(Fmt);
    396   for (DirectiveList::iterator I = DL.begin(), E = DL.end(); I != E; ++I) {
    397     Directive& D = **I;
    398     if (D.Location.isInvalid() || !SourceMgr)
    399       OS << "\n  (frontend)";
    400     else
    401       OS << "\n  Line " << SourceMgr->getPresumedLineNumber(D.Location);
    402     OS << ": " << D.Text;
    403   }
    404 
    405   Diags.Report(diag::err_verify_inconsistent_diags)
    406     << Kind << !Expected << OS.str();
    407   return DL.size();
    408 }
    409 
    410 /// CheckLists - Compare expected to seen diagnostic lists and return the
    411 /// the difference between them.
    412 ///
    413 static unsigned CheckLists(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
    414                            const char *Label,
    415                            DirectiveList &Left,
    416                            const_diag_iterator d2_begin,
    417                            const_diag_iterator d2_end) {
    418   DirectiveList LeftOnly;
    419   DiagList Right(d2_begin, d2_end);
    420 
    421   for (DirectiveList::iterator I = Left.begin(), E = Left.end(); I != E; ++I) {
    422     Directive& D = **I;
    423     unsigned LineNo1 = SourceMgr.getPresumedLineNumber(D.Location);
    424 
    425     for (unsigned i = 0; i < D.Count; ++i) {
    426       DiagList::iterator II, IE;
    427       for (II = Right.begin(), IE = Right.end(); II != IE; ++II) {
    428         unsigned LineNo2 = SourceMgr.getPresumedLineNumber(II->first);
    429         if (LineNo1 != LineNo2)
    430           continue;
    431 
    432         const std::string &RightText = II->second;
    433         if (D.Match(RightText))
    434           break;
    435       }
    436       if (II == IE) {
    437         // Not found.
    438         LeftOnly.push_back(*I);
    439       } else {
    440         // Found. The same cannot be found twice.
    441         Right.erase(II);
    442       }
    443     }
    444   }
    445   // Now all that's left in Right are those that were not matched.
    446 
    447   return (PrintProblem(Diags, &SourceMgr, LeftOnly, Label, true) +
    448           PrintProblem(Diags, &SourceMgr, Right.begin(), Right.end(),
    449                        Label, false));
    450 }
    451 
    452 /// CheckResults - This compares the expected results to those that
    453 /// were actually reported. It emits any discrepencies. Return "true" if there
    454 /// were problems. Return "false" otherwise.
    455 ///
    456 static unsigned CheckResults(DiagnosticsEngine &Diags, SourceManager &SourceMgr,
    457                              const TextDiagnosticBuffer &Buffer,
    458                              ExpectedData &ED) {
    459   // We want to capture the delta between what was expected and what was
    460   // seen.
    461   //
    462   //   Expected \ Seen - set expected but not seen
    463   //   Seen \ Expected - set seen but not expected
    464   unsigned NumProblems = 0;
    465 
    466   // See if there are error mismatches.
    467   NumProblems += CheckLists(Diags, SourceMgr, "error", ED.Errors,
    468                             Buffer.err_begin(), Buffer.err_end());
    469 
    470   // See if there are warning mismatches.
    471   NumProblems += CheckLists(Diags, SourceMgr, "warning", ED.Warnings,
    472                             Buffer.warn_begin(), Buffer.warn_end());
    473 
    474   // See if there are note mismatches.
    475   NumProblems += CheckLists(Diags, SourceMgr, "note", ED.Notes,
    476                             Buffer.note_begin(), Buffer.note_end());
    477 
    478   return NumProblems;
    479 }
    480 
    481 void VerifyDiagnosticConsumer::CheckDiagnostics() {
    482   ExpectedData ED;
    483 
    484   // Ensure any diagnostics go to the primary client.
    485   bool OwnsCurClient = Diags.ownsClient();
    486   DiagnosticConsumer *CurClient = Diags.takeClient();
    487   Diags.setClient(PrimaryClient, false);
    488 
    489   // If we have a preprocessor, scan the source for expected diagnostic
    490   // markers. If not then any diagnostics are unexpected.
    491   if (CurrentPreprocessor) {
    492     SourceManager &SM = CurrentPreprocessor->getSourceManager();
    493     // Extract expected-error strings from main file.
    494     FindExpectedDiags(*CurrentPreprocessor, ED, SM.getMainFileID());
    495     // Only check for expectations in other diagnostic locations
    496     // if they are not the main file (via ID or FileEntry) - the main
    497     // file has already been looked at, and its expectations must not
    498     // be added twice.
    499     if (!FirstErrorFID.isInvalid() && FirstErrorFID != SM.getMainFileID()
    500         && (!SM.getFileEntryForID(FirstErrorFID)
    501             || (SM.getFileEntryForID(FirstErrorFID) !=
    502                 SM.getFileEntryForID(SM.getMainFileID())))) {
    503       FindExpectedDiags(*CurrentPreprocessor, ED, FirstErrorFID);
    504       FirstErrorFID = FileID();
    505     }
    506 
    507     // Check that the expected diagnostics occurred.
    508     NumErrors += CheckResults(Diags, SM, *Buffer, ED);
    509   } else {
    510     NumErrors += (PrintProblem(Diags, 0,
    511                                Buffer->err_begin(), Buffer->err_end(),
    512                                "error", false) +
    513                   PrintProblem(Diags, 0,
    514                                Buffer->warn_begin(), Buffer->warn_end(),
    515                                "warn", false) +
    516                   PrintProblem(Diags, 0,
    517                                Buffer->note_begin(), Buffer->note_end(),
    518                                "note", false));
    519   }
    520 
    521   Diags.takeClient();
    522   Diags.setClient(CurClient, OwnsCurClient);
    523 
    524   // Reset the buffer, we have processed all the diagnostics in it.
    525   Buffer.reset(new TextDiagnosticBuffer());
    526 }
    527 
    528 DiagnosticConsumer *
    529 VerifyDiagnosticConsumer::clone(DiagnosticsEngine &Diags) const {
    530   if (!Diags.getClient())
    531     Diags.setClient(PrimaryClient->clone(Diags));
    532 
    533   return new VerifyDiagnosticConsumer(Diags);
    534 }
    535 
    536 Directive* Directive::Create(bool RegexKind, const SourceLocation &Location,
    537                              const std::string &Text, unsigned Count) {
    538   if (RegexKind)
    539     return new RegexDirective(Location, Text, Count);
    540   return new StandardDirective(Location, Text, Count);
    541 }
    542