Clang Project

clang_source_code/lib/ASTMatchers/Dynamic/Diagnostics.cpp
1//===--- Diagnostics.cpp - 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#include "clang/ASTMatchers/Dynamic/Diagnostics.h"
10
11namespace clang {
12namespace ast_matchers {
13namespace dynamic {
14Diagnostics::ArgStream Diagnostics::pushContextFrame(ContextType Type,
15                                                     SourceRange Range) {
16  ContextStack.emplace_back();
17  ContextFrame& data = ContextStack.back();
18  data.Type = Type;
19  data.Range = Range;
20  return ArgStream(&data.Args);
21}
22
23Diagnostics::Context::Context(ConstructMatcherEnum, Diagnostics *Error,
24                              StringRef MatcherName,
25                              SourceRange MatcherRange)
26    : Error(Error) {
27  Error->pushContextFrame(CT_MatcherConstruct, MatcherRange) << MatcherName;
28}
29
30Diagnostics::Context::Context(MatcherArgEnum, Diagnostics *Error,
31                              StringRef MatcherName,
32                              SourceRange MatcherRange,
33                              unsigned ArgNumber)
34    : Error(Error) {
35  Error->pushContextFrame(CT_MatcherArg, MatcherRange) << ArgNumber
36                                                       << MatcherName;
37}
38
39Diagnostics::Context::~Context() { Error->ContextStack.pop_back(); }
40
41Diagnostics::OverloadContext::OverloadContext(Diagnostics *Error)
42    : Error(Error), BeginIndex(Error->Errors.size()) {}
43
44Diagnostics::OverloadContext::~OverloadContext() {
45  // Merge all errors that happened while in this context.
46  if (BeginIndex < Error->Errors.size()) {
47    Diagnostics::ErrorContent &Dest = Error->Errors[BeginIndex];
48    for (size_t i = BeginIndex + 1, e = Error->Errors.size(); i < e; ++i) {
49      Dest.Messages.push_back(Error->Errors[i].Messages[0]);
50    }
51    Error->Errors.resize(BeginIndex + 1);
52  }
53}
54
55void Diagnostics::OverloadContext::revertErrors() {
56  // Revert the errors.
57  Error->Errors.resize(BeginIndex);
58}
59
60Diagnostics::ArgStream &Diagnostics::ArgStream::operator<<(const Twine &Arg) {
61  Out->push_back(Arg.str());
62  return *this;
63}
64
65Diagnostics::ArgStream Diagnostics::addError(SourceRange Range,
66                                             ErrorType Error) {
67  Errors.emplace_back();
68  ErrorContent &Last = Errors.back();
69  Last.ContextStack = ContextStack;
70  Last.Messages.emplace_back();
71  Last.Messages.back().Range = Range;
72  Last.Messages.back().Type = Error;
73  return ArgStream(&Last.Messages.back().Args);
74}
75
76static StringRef contextTypeToFormatString(Diagnostics::ContextType Type) {
77  switch (Type) {
78    case Diagnostics::CT_MatcherConstruct:
79      return "Error building matcher $0.";
80    case Diagnostics::CT_MatcherArg:
81      return "Error parsing argument $0 for matcher $1.";
82  }
83  llvm_unreachable("Unknown ContextType value.");
84}
85
86static StringRef errorTypeToFormatString(Diagnostics::ErrorType Type) {
87  switch (Type) {
88  case Diagnostics::ET_RegistryMatcherNotFound:
89    return "Matcher not found: $0";
90  case Diagnostics::ET_RegistryWrongArgCount:
91    return "Incorrect argument count. (Expected = $0) != (Actual = $1)";
92  case Diagnostics::ET_RegistryWrongArgType:
93    return "Incorrect type for arg $0. (Expected = $1) != (Actual = $2)";
94  case Diagnostics::ET_RegistryNotBindable:
95    return "Matcher does not support binding.";
96  case Diagnostics::ET_RegistryAmbiguousOverload:
97    // TODO: Add type info about the overload error.
98    return "Ambiguous matcher overload.";
99  case Diagnostics::ET_RegistryValueNotFound:
100    return "Value not found: $0";
101
102  case Diagnostics::ET_ParserStringError:
103    return "Error parsing string token: <$0>";
104  case Diagnostics::ET_ParserNoOpenParen:
105    return "Error parsing matcher. Found token <$0> while looking for '('.";
106  case Diagnostics::ET_ParserNoCloseParen:
107    return "Error parsing matcher. Found end-of-code while looking for ')'.";
108  case Diagnostics::ET_ParserNoComma:
109    return "Error parsing matcher. Found token <$0> while looking for ','.";
110  case Diagnostics::ET_ParserNoCode:
111    return "End of code found while looking for token.";
112  case Diagnostics::ET_ParserNotAMatcher:
113    return "Input value is not a matcher expression.";
114  case Diagnostics::ET_ParserInvalidToken:
115    return "Invalid token <$0> found when looking for a value.";
116  case Diagnostics::ET_ParserMalformedBindExpr:
117    return "Malformed bind() expression.";
118  case Diagnostics::ET_ParserTrailingCode:
119    return "Expected end of code.";
120  case Diagnostics::ET_ParserNumberError:
121    return "Error parsing numeric literal: <$0>";
122  case Diagnostics::ET_ParserOverloadedType:
123    return "Input value has unresolved overloaded type: $0";
124
125  case Diagnostics::ET_None:
126    return "<N/A>";
127  }
128  llvm_unreachable("Unknown ErrorType value.");
129}
130
131static void formatErrorString(StringRef FormatString,
132                              ArrayRef<std::string> Args,
133                              llvm::raw_ostream &OS) {
134  while (!FormatString.empty()) {
135    std::pair<StringRef, StringRef> Pieces = FormatString.split("$");
136    OS << Pieces.first.str();
137    if (Pieces.second.empty()) break;
138
139    const char Next = Pieces.second.front();
140    FormatString = Pieces.second.drop_front();
141    if (Next >= '0' && Next <= '9') {
142      const unsigned Index = Next - '0';
143      if (Index < Args.size()) {
144        OS << Args[Index];
145      } else {
146        OS << "<Argument_Not_Provided>";
147      }
148    }
149  }
150}
151
152static void maybeAddLineAndColumn(SourceRange Range,
153                                  llvm::raw_ostream &OS) {
154  if (Range.Start.Line > 0 && Range.Start.Column > 0) {
155    OS << Range.Start.Line << ":" << Range.Start.Column << ": ";
156  }
157}
158
159static void printContextFrameToStream(const Diagnostics::ContextFrame &Frame,
160                                      llvm::raw_ostream &OS) {
161  maybeAddLineAndColumn(Frame.Range, OS);
162  formatErrorString(contextTypeToFormatString(Frame.Type), Frame.Args, OS);
163}
164
165static void
166printMessageToStream(const Diagnostics::ErrorContent::Message &Message,
167                     const Twine Prefix, llvm::raw_ostream &OS) {
168  maybeAddLineAndColumn(Message.Range, OS);
169  OS << Prefix;
170  formatErrorString(errorTypeToFormatString(Message.Type), Message.Args, OS);
171}
172
173static void printErrorContentToStream(const Diagnostics::ErrorContent &Content,
174                                      llvm::raw_ostream &OS) {
175  if (Content.Messages.size() == 1) {
176    printMessageToStream(Content.Messages[0], "", OS);
177  } else {
178    for (size_t i = 0, e = Content.Messages.size(); i != e; ++i) {
179      if (i != 0) OS << "\n";
180      printMessageToStream(Content.Messages[i],
181                           "Candidate " + Twine(i + 1) + ": ", OS);
182    }
183  }
184}
185
186void Diagnostics::printToStream(llvm::raw_ostream &OS) const {
187  for (size_t i = 0, e = Errors.size(); i != e; ++i) {
188    if (i != 0) OS << "\n";
189    printErrorContentToStream(Errors[i], OS);
190  }
191}
192
193std::string Diagnostics::toString() const {
194  std::string S;
195  llvm::raw_string_ostream OS(S);
196  printToStream(OS);
197  return OS.str();
198}
199
200void Diagnostics::printToStreamFull(llvm::raw_ostream &OS) const {
201  for (size_t i = 0, e = Errors.size(); i != e; ++i) {
202    if (i != 0) OS << "\n";
203    const ErrorContent &Error = Errors[i];
204    for (size_t i = 0, e = Error.ContextStack.size(); i != e; ++i) {
205      printContextFrameToStream(Error.ContextStack[i], OS);
206      OS << "\n";
207    }
208    printErrorContentToStream(Error, OS);
209  }
210}
211
212std::string Diagnostics::toStringFull() const {
213  std::string S;
214  llvm::raw_string_ostream OS(S);
215  printToStreamFull(OS);
216  return OS.str();
217}
218
219}  // namespace dynamic
220}  // namespace ast_matchers
221}  // namespace clang
222
clang::ast_matchers::dynamic::Diagnostics::pushContextFrame
clang::ast_matchers::dynamic::Diagnostics::OverloadContext::revertErrors
clang::ast_matchers::dynamic::Diagnostics::addError
clang::ast_matchers::dynamic::Diagnostics::printToStream
clang::ast_matchers::dynamic::Diagnostics::toString
clang::ast_matchers::dynamic::Diagnostics::printToStreamFull
clang::ast_matchers::dynamic::Diagnostics::toStringFull
CodeThinker, Enjoy your reading code