ASTDiagnostic.cpp revision 36f5cfe4df32af6c5fe01228102512996f566f9d 
1//===--- ASTDiagnostic.cpp - Diagnostic Printing Hooks for AST Nodes ------===//
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 file implements a diagnostic formatting hook for AST elements.
11//
12//===----------------------------------------------------------------------===//
13#include "clang/AST/ASTDiagnostic.h"
14
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclObjC.h"
17#include "clang/AST/Type.h"
18#include "llvm/Support/raw_ostream.h"
19
20using namespace clang;
21
22// Returns a desugared version of the QualType, and marks ShouldAKA as true
23// whenever we remove significant sugar from the type.
24static QualType Desugar(ASTContext &Context, QualType QT, bool &ShouldAKA) {
25  QualifierCollector QC;
26
27  while (true) {
28    const Type *Ty = QC.strip(QT);
29
30    // Don't aka just because we saw an elaborated type...
31    if (const ElaboratedType *ET = dyn_cast<ElaboratedType>(Ty)) {
32      QT = ET->desugar();
33      continue;
34    }
35    // ... or a paren type ...
36    if (const ParenType *PT = dyn_cast<ParenType>(Ty)) {
37      QT = PT->desugar();
38      continue;
39    }
40    // ...or a substituted template type parameter ...
41    if (const SubstTemplateTypeParmType *ST =
42          dyn_cast<SubstTemplateTypeParmType>(Ty)) {
43      QT = ST->desugar();
44      continue;
45    }
46    // ...or an attributed type...
47    if (const AttributedType *AT = dyn_cast<AttributedType>(Ty)) {
48      QT = AT->desugar();
49      continue;
50    }
51    // ... or an auto type.
52    if (const AutoType *AT = dyn_cast<AutoType>(Ty)) {
53      if (!AT->isSugared())
54        break;
55      QT = AT->desugar();
56      continue;
57    }
58
59    // Don't desugar template specializations, unless it's an alias template.
60    if (const TemplateSpecializationType *TST
61          = dyn_cast<TemplateSpecializationType>(Ty))
62      if (!TST->isTypeAlias())
63        break;
64
65    // Don't desugar magic Objective-C types.
66    if (QualType(Ty,0) == Context.getObjCIdType() ||
67        QualType(Ty,0) == Context.getObjCClassType() ||
68        QualType(Ty,0) == Context.getObjCSelType() ||
69        QualType(Ty,0) == Context.getObjCProtoType())
70      break;
71
72    // Don't desugar va_list.
73    if (QualType(Ty,0) == Context.getBuiltinVaListType())
74      break;
75
76    // Otherwise, do a single-step desugar.
77    QualType Underlying;
78    bool IsSugar = false;
79    switch (Ty->getTypeClass()) {
80#define ABSTRACT_TYPE(Class, Base)
81#define TYPE(Class, Base) \
82case Type::Class: { \
83const Class##Type *CTy = cast<Class##Type>(Ty); \
84if (CTy->isSugared()) { \
85IsSugar = true; \
86Underlying = CTy->desugar(); \
87} \
88break; \
89}
90#include "clang/AST/TypeNodes.def"
91    }
92
93    // If it wasn't sugared, we're done.
94    if (!IsSugar)
95      break;
96
97    // If the desugared type is a vector type, we don't want to expand
98    // it, it will turn into an attribute mess. People want their "vec4".
99    if (isa<VectorType>(Underlying))
100      break;
101
102    // Don't desugar through the primary typedef of an anonymous type.
103    if (const TagType *UTT = Underlying->getAs<TagType>())
104      if (const TypedefType *QTT = dyn_cast<TypedefType>(QT))
105        if (UTT->getDecl()->getTypedefNameForAnonDecl() == QTT->getDecl())
106          break;
107
108    // Record that we actually looked through an opaque type here.
109    ShouldAKA = true;
110    QT = Underlying;
111  }
112
113  // If we have a pointer-like type, desugar the pointee as well.
114  // FIXME: Handle other pointer-like types.
115  if (const PointerType *Ty = QT->getAs<PointerType>()) {
116    QT = Context.getPointerType(Desugar(Context, Ty->getPointeeType(),
117                                        ShouldAKA));
118  } else if (const LValueReferenceType *Ty = QT->getAs<LValueReferenceType>()) {
119    QT = Context.getLValueReferenceType(Desugar(Context, Ty->getPointeeType(),
120                                                ShouldAKA));
121  } else if (const RValueReferenceType *Ty = QT->getAs<RValueReferenceType>()) {
122    QT = Context.getRValueReferenceType(Desugar(Context, Ty->getPointeeType(),
123                                                ShouldAKA));
124  }
125
126  return QC.apply(Context, QT);
127}
128
129/// \brief Convert the given type to a string suitable for printing as part of
130/// a diagnostic.
131///
132/// There are four main criteria when determining whether we should have an
133/// a.k.a. clause when pretty-printing a type:
134///
135/// 1) Some types provide very minimal sugar that doesn't impede the
136///    user's understanding --- for example, elaborated type
137///    specifiers.  If this is all the sugar we see, we don't want an
138///    a.k.a. clause.
139/// 2) Some types are technically sugared but are much more familiar
140///    when seen in their sugared form --- for example, va_list,
141///    vector types, and the magic Objective C types.  We don't
142///    want to desugar these, even if we do produce an a.k.a. clause.
143/// 3) Some types may have already been desugared previously in this diagnostic.
144///    if this is the case, doing another "aka" would just be clutter.
145/// 4) Two different types within the same diagnostic have the same output
146///    string.  In this case, force an a.k.a with the desugared type when
147///    doing so will provide additional information.
148///
149/// \param Context the context in which the type was allocated
150/// \param Ty the type to print
151/// \param QualTypeVals pointer values to QualTypes which are used in the
152/// diagnostic message
153static std::string
154ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty,
155                              const DiagnosticsEngine::ArgumentValue *PrevArgs,
156                              unsigned NumPrevArgs,
157                              ArrayRef<intptr_t> QualTypeVals) {
158  // FIXME: Playing with std::string is really slow.
159  bool ForceAKA = false;
160  QualType CanTy = Ty.getCanonicalType();
161  std::string S = Ty.getAsString(Context.getPrintingPolicy());
162  std::string CanS = CanTy.getAsString(Context.getPrintingPolicy());
163
164  for (unsigned I = 0, E = QualTypeVals.size(); I != E; ++I) {
165    QualType CompareTy =
166        QualType::getFromOpaquePtr(reinterpret_cast<void*>(QualTypeVals[I]));
167    if (CompareTy.isNull())
168      continue;
169    if (CompareTy == Ty)
170      continue;  // Same types
171    QualType CompareCanTy = CompareTy.getCanonicalType();
172    if (CompareCanTy == CanTy)
173      continue;  // Same canonical types
174    std::string CompareS = CompareTy.getAsString(Context.getPrintingPolicy());
175    bool aka;
176    QualType CompareDesugar = Desugar(Context, CompareTy, aka);
177    std::string CompareDesugarStr =
178        CompareDesugar.getAsString(Context.getPrintingPolicy());
179    if (CompareS != S && CompareDesugarStr != S)
180      continue;  // The type string is different than the comparison string
181                 // and the desugared comparison string.
182    std::string CompareCanS =
183        CompareCanTy.getAsString(Context.getPrintingPolicy());
184
185    if (CompareCanS == CanS)
186      continue;  // No new info from canonical type
187
188    ForceAKA = true;
189    break;
190  }
191
192  // Check to see if we already desugared this type in this
193  // diagnostic.  If so, don't do it again.
194  bool Repeated = false;
195  for (unsigned i = 0; i != NumPrevArgs; ++i) {
196    // TODO: Handle ak_declcontext case.
197    if (PrevArgs[i].first == DiagnosticsEngine::ak_qualtype) {
198      void *Ptr = (void*)PrevArgs[i].second;
199      QualType PrevTy(QualType::getFromOpaquePtr(Ptr));
200      if (PrevTy == Ty) {
201        Repeated = true;
202        break;
203      }
204    }
205  }
206
207  // Consider producing an a.k.a. clause if removing all the direct
208  // sugar gives us something "significantly different".
209  if (!Repeated) {
210    bool ShouldAKA = false;
211    QualType DesugaredTy = Desugar(Context, Ty, ShouldAKA);
212    if (ShouldAKA || ForceAKA) {
213      if (DesugaredTy == Ty) {
214        DesugaredTy = Ty.getCanonicalType();
215      }
216      std::string akaStr = DesugaredTy.getAsString(Context.getPrintingPolicy());
217      if (akaStr != S) {
218        S = "'" + S + "' (aka '" + akaStr + "')";
219        return S;
220      }
221    }
222  }
223
224  S = "'" + S + "'";
225  return S;
226}
227
228void clang::FormatASTNodeDiagnosticArgument(
229    DiagnosticsEngine::ArgumentKind Kind,
230    intptr_t Val,
231    const char *Modifier,
232    unsigned ModLen,
233    const char *Argument,
234    unsigned ArgLen,
235    const DiagnosticsEngine::ArgumentValue *PrevArgs,
236    unsigned NumPrevArgs,
237    SmallVectorImpl<char> &Output,
238    void *Cookie,
239    ArrayRef<intptr_t> QualTypeVals) {
240  ASTContext &Context = *static_cast<ASTContext*>(Cookie);
241
242  std::string S;
243  bool NeedQuotes = true;
244
245  switch (Kind) {
246    default: llvm_unreachable("unknown ArgumentKind");
247    case DiagnosticsEngine::ak_qualtype: {
248      assert(ModLen == 0 && ArgLen == 0 &&
249             "Invalid modifier for QualType argument");
250
251      QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val)));
252      S = ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, NumPrevArgs,
253                                        QualTypeVals);
254      NeedQuotes = false;
255      break;
256    }
257    case DiagnosticsEngine::ak_declarationname: {
258      DeclarationName N = DeclarationName::getFromOpaqueInteger(Val);
259      S = N.getAsString();
260
261      if (ModLen == 9 && !memcmp(Modifier, "objcclass", 9) && ArgLen == 0)
262        S = '+' + S;
263      else if (ModLen == 12 && !memcmp(Modifier, "objcinstance", 12)
264                && ArgLen==0)
265        S = '-' + S;
266      else
267        assert(ModLen == 0 && ArgLen == 0 &&
268               "Invalid modifier for DeclarationName argument");
269      break;
270    }
271    case DiagnosticsEngine::ak_nameddecl: {
272      bool Qualified;
273      if (ModLen == 1 && Modifier[0] == 'q' && ArgLen == 0)
274        Qualified = true;
275      else {
276        assert(ModLen == 0 && ArgLen == 0 &&
277               "Invalid modifier for NamedDecl* argument");
278        Qualified = false;
279      }
280      const NamedDecl *ND = reinterpret_cast<const NamedDecl*>(Val);
281      ND->getNameForDiagnostic(S, Context.getPrintingPolicy(), Qualified);
282      break;
283    }
284    case DiagnosticsEngine::ak_nestednamespec: {
285      llvm::raw_string_ostream OS(S);
286      reinterpret_cast<NestedNameSpecifier*>(Val)->print(OS,
287                                                        Context.getPrintingPolicy());
288      NeedQuotes = false;
289      break;
290    }
291    case DiagnosticsEngine::ak_declcontext: {
292      DeclContext *DC = reinterpret_cast<DeclContext *> (Val);
293      assert(DC && "Should never have a null declaration context");
294
295      if (DC->isTranslationUnit()) {
296        // FIXME: Get these strings from some localized place
297        if (Context.getLangOptions().CPlusPlus)
298          S = "the global namespace";
299        else
300          S = "the global scope";
301      } else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) {
302        S = ConvertTypeToDiagnosticString(Context,
303                                          Context.getTypeDeclType(Type),
304                                          PrevArgs, NumPrevArgs, QualTypeVals);
305      } else {
306        // FIXME: Get these strings from some localized place
307        NamedDecl *ND = cast<NamedDecl>(DC);
308        if (isa<NamespaceDecl>(ND))
309          S += "namespace ";
310        else if (isa<ObjCMethodDecl>(ND))
311          S += "method ";
312        else if (isa<FunctionDecl>(ND))
313          S += "function ";
314
315        S += "'";
316        ND->getNameForDiagnostic(S, Context.getPrintingPolicy(), true);
317        S += "'";
318      }
319      NeedQuotes = false;
320      break;
321    }
322  }
323
324  if (NeedQuotes)
325    Output.push_back('\'');
326
327  Output.append(S.begin(), S.end());
328
329  if (NeedQuotes)
330    Output.push_back('\'');
331}
332