]> CyberLeo.Net >> Repos - FreeBSD/stable/9.git/blob - contrib/llvm/tools/clang/lib/AST/ASTDiagnostic.cpp
MFC r234353:
[FreeBSD/stable/9.git] / contrib / llvm / tools / clang / lib / AST / ASTDiagnostic.cpp
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
20 using 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.
24 static 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) \
82 case Type::Class: { \
83 const Class##Type *CTy = cast<Class##Type>(Ty); \
84 if (CTy->isSugared()) { \
85 IsSugar = true; \
86 Underlying = CTy->desugar(); \
87 } \
88 break; \
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
153 static std::string
154 ConvertTypeToDiagnosticString(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
228 void 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.getLangOpts().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 }