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 } 332
