contrib/llvm-project/clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h

   1 //===--- Diagnostics.h - Helper class for error diagnostics -----*- C++ -*-===//
   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 /// \file
  10 /// Diagnostics class to manage error messages.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_CLANG_ASTMATCHERS_DYNAMIC_DIAGNOSTICS_H
  15 #define LLVM_CLANG_ASTMATCHERS_DYNAMIC_DIAGNOSTICS_H
  16
  17 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
  18 #include "clang/Basic/LLVM.h"
  19 #include "llvm/ADT/ArrayRef.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/ADT/Twine.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include <string>
  24 #include <vector>
  25
  26 namespace clang {
  27 namespace ast_matchers {
  28 namespace dynamic {
  29
  30 struct SourceLocation {
  31   SourceLocation() : Line(), Column() {}
  32   unsigned Line;
  33   unsigned Column;
  34 };
  35
  36 struct SourceRange {
  37   SourceLocation Start;
  38   SourceLocation End;
  39 };
  40
  41 /// A VariantValue instance annotated with its parser context.
  42 struct ParserValue {
  43   ParserValue() : Text(), Range(), Value() {}
  44   StringRef Text;
  45   SourceRange Range;
  46   VariantValue Value;
  47 };
  48
  49 /// Helper class to manage error messages.
  50 class Diagnostics {
  51 public:
  52   /// Parser context types.
  53   enum ContextType {
  54     CT_MatcherArg = 0,
  55     CT_MatcherConstruct = 1
  56   };
  57
  58   /// All errors from the system.
  59   enum ErrorType {
  60     ET_None = 0,
  61
  62     ET_RegistryMatcherNotFound = 1,
  63     ET_RegistryWrongArgCount = 2,
  64     ET_RegistryWrongArgType = 3,
  65     ET_RegistryNotBindable = 4,
  66     ET_RegistryAmbiguousOverload = 5,
  67     ET_RegistryValueNotFound = 6,
  68
  69     ET_ParserStringError = 100,
  70     ET_ParserNoOpenParen = 101,
  71     ET_ParserNoCloseParen = 102,
  72     ET_ParserNoComma = 103,
  73     ET_ParserNoCode = 104,
  74     ET_ParserNotAMatcher = 105,
  75     ET_ParserInvalidToken = 106,
  76     ET_ParserMalformedBindExpr = 107,
  77     ET_ParserTrailingCode = 108,
  78     ET_ParserNumberError = 109,
  79     ET_ParserOverloadedType = 110
  80   };
  81
  82   /// Helper stream class.
  83   class ArgStream {
  84   public:
  85     ArgStream(std::vector<std::string> *Out) : Out(Out) {}
  86     template <class T> ArgStream &operator<<(const T &Arg) {
  87       return operator<<(Twine(Arg));
  88     }
  89     ArgStream &operator<<(const Twine &Arg);
  90
  91   private:
  92     std::vector<std::string> *Out;
  93   };
  94
  95   /// Class defining a parser context.
  96   ///
  97   /// Used by the parser to specify (possibly recursive) contexts where the
  98   /// parsing/construction can fail. Any error triggered within a context will
  99   /// keep information about the context chain.
 100   /// This class should be used as a RAII instance in the stack.
 101   struct Context {
 102   public:
 103     /// About to call the constructor for a matcher.
 104     enum ConstructMatcherEnum { ConstructMatcher };
 105     Context(ConstructMatcherEnum, Diagnostics *Error, StringRef MatcherName,
 106             SourceRange MatcherRange);
 107     /// About to recurse into parsing one argument for a matcher.
 108     enum MatcherArgEnum { MatcherArg };
 109     Context(MatcherArgEnum, Diagnostics *Error, StringRef MatcherName,
 110             SourceRange MatcherRange, unsigned ArgNumber);
 111     ~Context();
 112
 113   private:
 114     Diagnostics *const Error;
 115   };
 116
 117   /// Context for overloaded matcher construction.
 118   ///
 119   /// This context will take care of merging all errors that happen within it
 120   /// as "candidate" overloads for the same matcher.
 121   struct OverloadContext {
 122   public:
 123    OverloadContext(Diagnostics* Error);
 124    ~OverloadContext();
 125
 126    /// Revert all errors that happened within this context.
 127    void revertErrors();
 128
 129   private:
 130     Diagnostics *const Error;
 131     unsigned BeginIndex;
 132   };
 133
 134   /// Add an error to the diagnostics.
 135   ///
 136   /// All the context information will be kept on the error message.
 137   /// \return a helper class to allow the caller to pass the arguments for the
 138   /// error message, using the << operator.
 139   ArgStream addError(SourceRange Range, ErrorType Error);
 140
 141   /// Information stored for one frame of the context.
 142   struct ContextFrame {
 143     ContextType Type;
 144     SourceRange Range;
 145     std::vector<std::string> Args;
 146   };
 147
 148   /// Information stored for each error found.
 149   struct ErrorContent {
 150     std::vector<ContextFrame> ContextStack;
 151     struct Message {
 152       SourceRange Range;
 153       ErrorType Type;
 154       std::vector<std::string> Args;
 155     };
 156     std::vector<Message> Messages;
 157   };
 158   ArrayRef<ErrorContent> errors() const { return Errors; }
 159
 160   /// Returns a simple string representation of each error.
 161   ///
 162   /// Each error only shows the error message without any context.
 163   void printToStream(llvm::raw_ostream &OS) const;
 164   std::string toString() const;
 165
 166   /// Returns the full string representation of each error.
 167   ///
 168   /// Each error message contains the full context.
 169   void printToStreamFull(llvm::raw_ostream &OS) const;
 170   std::string toStringFull() const;
 171
 172 private:
 173   /// Helper function used by the constructors of ContextFrame.
 174   ArgStream pushContextFrame(ContextType Type, SourceRange Range);
 175
 176   std::vector<ContextFrame> ContextStack;
 177   std::vector<ErrorContent> Errors;
 178 };
 179
 180 }  // namespace dynamic
 181 }  // namespace ast_matchers
 182 }  // namespace clang
 183
 184 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_DIAGNOSTICS_H