VerifyDiagnosticConsumer.h

Go to the documentation of this file.

//===- VerifyDiagnosticConsumer.h - Verifying Diagnostic Client -*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICCONSUMER_H
#define LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICCONSUMER_H
 
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Lex/Preprocessor.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/PointerIntPair.h"
#include "llvm/ADT/StringRef.h"
#include <cassert>
#include <limits>
#include <memory>
#include <string>
#include <vector>
 
namespace clang {
 
class FileEntry;
class LangOptions;
class SourceManager;
class TextDiagnosticBuffer;
 
enum class DiagnosticMatchResult {
  None,
  OnlyPartial,    /// Match, but not a full match.
  AtLeastPartial, /// Match, but we didn't check for full match.
  Full,
};
 
/// VerifyDiagnosticConsumer - Create a diagnostic client which will use
/// markers in the input source to check that all the emitted diagnostics match
/// those expected. See clang/docs/InternalsManual.rst for details about how to
/// write tests to verify diagnostics.
///
class VerifyDiagnosticConsumer: public DiagnosticConsumer,
                                public CommentHandler {
public:
  /// Directive - Abstract class representing a parsed verify directive.
  ///
  class Directive {
  public:
    static std::unique_ptr<Directive>
    create(bool RegexKind, SourceLocation DirectiveLoc,
           SourceLocation DiagnosticLoc, StringRef Spelling,
           bool MatchAnyFileAndLine, bool MatchAnyLine, StringRef Text,
           unsigned Min, unsigned Max, bool FullMatchRequired);
 
  public:
    /// Constant representing n or more matches.
    static const unsigned MaxCount = std::numeric_limits<unsigned>::max();
 
    SourceLocation DirectiveLoc;
    SourceLocation DiagnosticLoc;
    const std::string Spelling;
    const std::string Text;
    unsigned Min, Max;
    bool MatchAnyLine;
    bool MatchAnyFileAndLine; // `MatchAnyFileAndLine` implies `MatchAnyLine`.
    bool FullMatchRequired;
 
    Directive(const Directive &) = delete;
    Directive &operator=(const Directive &) = delete;
    virtual ~Directive() = default;
 
    // Returns true if directive text is valid.
    // Otherwise returns false and populates E.
    virtual bool isValid(std::string &Error) = 0;
 
    // Returns true on match.
    virtual DiagnosticMatchResult match(StringRef S) const = 0;
 
  protected:
    Directive(SourceLocation DirectiveLoc, SourceLocation DiagnosticLoc,
              StringRef Spelling, bool MatchAnyFileAndLine, bool MatchAnyLine,
              StringRef Text, unsigned Min, unsigned Max,
              bool FullMatchRequired)
        : DirectiveLoc(DirectiveLoc), DiagnosticLoc(DiagnosticLoc),
          Spelling(Spelling), Text(Text), Min(Min), Max(Max),
          MatchAnyLine(MatchAnyLine || MatchAnyFileAndLine),
          MatchAnyFileAndLine(MatchAnyFileAndLine),
          FullMatchRequired(FullMatchRequired) {
      assert(!DirectiveLoc.isInvalid() && "DirectiveLoc is invalid!");
      assert((!DiagnosticLoc.isInvalid() || MatchAnyLine) &&
             "DiagnosticLoc is invalid!");
    }
  };
 
  using DirectiveList = std::vector<std::unique_ptr<Directive>>;
 
  /// ExpectedData - owns directive objects and deletes on destructor.
  struct ExpectedData {
    DirectiveList Errors;
    DirectiveList Warnings;
    DirectiveList Remarks;
    DirectiveList Notes;
 
    void Reset() {
      Errors.clear();
      Warnings.clear();
      Remarks.clear();
      Notes.clear();
    }
  };
 
  enum DirectiveStatus {
    HasNoDirectives,
    HasNoDirectivesReported,
    HasExpectedNoDiagnostics,
    HasOtherExpectedDirectives
  };
 
  struct ParsingState {
    DirectiveStatus Status;
    std::string FirstNoDiagnosticsDirective;
    bool AllDirectivesMatchExactlyOneDiag = true;
    bool WildcardsAreErroneouslyPresent = false;
  };
 
  class MarkerTracker;
 
private:
  DiagnosticsEngine &Diags;
  DiagnosticConsumer *PrimaryClient;
  std::unique_ptr<DiagnosticConsumer> PrimaryClientOwner;
  std::unique_ptr<TextDiagnosticBuffer> Buffer;
  std::unique_ptr<MarkerTracker> Markers;
  const Preprocessor *CurrentPreprocessor = nullptr;
  const LangOptions *LangOpts = nullptr;
  SourceManager *SrcManager = nullptr;
  unsigned ActiveSourceFiles = 0;
  ParsingState State;
  ExpectedData ED;
  bool CheckOrderOfDirectives;
  bool OneDiagPerDirective;
  bool DisableWildcardInDiagLoc;
 
  void CheckDiagnostics();
 
  void setSourceManager(SourceManager &SM) {
    assert((!SrcManager || SrcManager == &SM) && "SourceManager changed!");
    SrcManager = &SM;
  }
 
  // These facilities are used for validation in debug builds.
  class UnparsedFileStatus {
    OptionalFileEntryRef File;
    bool FoundDirectives;
 
  public:
    UnparsedFileStatus(OptionalFileEntryRef File, bool FoundDirectives)
        : File(File), FoundDirectives(FoundDirectives) {}
 
    OptionalFileEntryRef getFile() const { return File; }
    bool foundDirectives() const { return FoundDirectives; }
  };
 
  using ParsedFilesMap = llvm::DenseMap<FileID, const FileEntry *>;
  using UnparsedFilesMap = llvm::DenseMap<FileID, UnparsedFileStatus>;
 
  ParsedFilesMap ParsedFiles;
  UnparsedFilesMap UnparsedFiles;
 
public:
  /// Create a new verifying diagnostic client, which will issue errors to
  /// the currently-attached diagnostic client when a diagnostic does not match
  /// what is expected (as indicated in the source file).
  VerifyDiagnosticConsumer(DiagnosticsEngine &Diags);
  ~VerifyDiagnosticConsumer() override;
 
  void BeginSourceFile(const LangOptions &LangOpts,
                       const Preprocessor *PP) override;
 
  void EndSourceFile() override;
 
  enum ParsedStatus {
    /// File has been processed via HandleComment.
    IsParsed,
 
    /// File has diagnostics and may have directives.
    IsUnparsed,
 
    /// File has diagnostics but guaranteed no directives.
    IsUnparsedNoDirectives
  };
 
  /// Update lists of parsed and unparsed files.
  void UpdateParsedFileStatus(SourceManager &SM, FileID FID, ParsedStatus PS);
 
  bool HandleComment(Preprocessor &PP, SourceRange Comment) override;
 
  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
                        const Diagnostic &Info) override;
};
 
} // namespace clang
 
#endif // LLVM_CLANG_FRONTEND_VERIFYDIAGNOSTICCONSUMER_H