Sema.cpp revision ba6a9bd384df475780be636ca45bcef5c5bbd19f
1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// 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 the actions class which performs semantic analysis and 11// builds an AST out of a parse stream. 12// 13//===----------------------------------------------------------------------===// 14 15#include "Sema.h" 16#include "llvm/ADT/DenseMap.h" 17#include "clang/AST/ASTConsumer.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/Expr.h" 21#include "clang/Lex/Preprocessor.h" 22#include "clang/Basic/PartialDiagnostic.h" 23#include "clang/Basic/TargetInfo.h" 24using namespace clang; 25 26/// Determines whether we should have an a.k.a. clause when 27/// pretty-printing a type. There are three main criteria: 28/// 29/// 1) Some types provide very minimal sugar that doesn't impede the 30/// user's understanding --- for example, elaborated type 31/// specifiers. If this is all the sugar we see, we don't want an 32/// a.k.a. clause. 33/// 2) Some types are technically sugared but are much more familiar 34/// when seen in their sugared form --- for example, va_list, 35/// vector types, and the magic Objective C types. We don't 36/// want to desugar these, even if we do produce an a.k.a. clause. 37/// 3) Some types may have already been desugared previously in this diagnostic. 38/// if this is the case, doing another "aka" would just be clutter. 39/// 40static bool ShouldAKA(ASTContext &Context, QualType QT, 41 const Diagnostic::ArgumentValue *PrevArgs, 42 unsigned NumPrevArgs, 43 QualType &DesugaredQT) { 44 QualType InputTy = QT; 45 46 bool AKA = false; 47 QualifierCollector Qc; 48 49 while (true) { 50 const Type *Ty = Qc.strip(QT); 51 52 // Don't aka just because we saw an elaborated type... 53 if (isa<ElaboratedType>(Ty)) { 54 QT = cast<ElaboratedType>(Ty)->desugar(); 55 continue; 56 } 57 58 // ...or a qualified name type... 59 if (isa<QualifiedNameType>(Ty)) { 60 QT = cast<QualifiedNameType>(Ty)->desugar(); 61 continue; 62 } 63 64 // ...or a substituted template type parameter. 65 if (isa<SubstTemplateTypeParmType>(Ty)) { 66 QT = cast<SubstTemplateTypeParmType>(Ty)->desugar(); 67 continue; 68 } 69 70 // Don't desugar template specializations. 71 if (isa<TemplateSpecializationType>(Ty)) 72 break; 73 74 // Don't desugar magic Objective-C types. 75 if (QualType(Ty,0) == Context.getObjCIdType() || 76 QualType(Ty,0) == Context.getObjCClassType() || 77 QualType(Ty,0) == Context.getObjCSelType() || 78 QualType(Ty,0) == Context.getObjCProtoType()) 79 break; 80 81 // Don't desugar va_list. 82 if (QualType(Ty,0) == Context.getBuiltinVaListType()) 83 break; 84 85 // Otherwise, do a single-step desugar. 86 QualType Underlying; 87 bool IsSugar = false; 88 switch (Ty->getTypeClass()) { 89#define ABSTRACT_TYPE(Class, Base) 90#define TYPE(Class, Base) \ 91 case Type::Class: { \ 92 const Class##Type *CTy = cast<Class##Type>(Ty); \ 93 if (CTy->isSugared()) { \ 94 IsSugar = true; \ 95 Underlying = CTy->desugar(); \ 96 } \ 97 break; \ 98 } 99#include "clang/AST/TypeNodes.def" 100 } 101 102 // If it wasn't sugared, we're done. 103 if (!IsSugar) 104 break; 105 106 // If the desugared type is a vector type, we don't want to expand 107 // it, it will turn into an attribute mess. People want their "vec4". 108 if (isa<VectorType>(Underlying)) 109 break; 110 111 // Otherwise, we're tearing through something opaque; note that 112 // we'll eventually need an a.k.a. clause and keep going. 113 AKA = true; 114 QT = Underlying; 115 continue; 116 } 117 118 // If we never tore through opaque sugar, don't print aka. 119 if (!AKA) return false; 120 121 // If we did, check to see if we already desugared this type in this 122 // diagnostic. If so, don't do it again. 123 for (unsigned i = 0; i != NumPrevArgs; ++i) { 124 // TODO: Handle ak_declcontext case. 125 if (PrevArgs[i].first == Diagnostic::ak_qualtype) { 126 void *Ptr = (void*)PrevArgs[i].second; 127 QualType PrevTy(QualType::getFromOpaquePtr(Ptr)); 128 if (PrevTy == InputTy) 129 return false; 130 } 131 } 132 133 DesugaredQT = Qc.apply(QT); 134 return true; 135} 136 137/// \brief Convert the given type to a string suitable for printing as part of 138/// a diagnostic. 139/// 140/// \param Context the context in which the type was allocated 141/// \param Ty the type to print 142static std::string 143ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty, 144 const Diagnostic::ArgumentValue *PrevArgs, 145 unsigned NumPrevArgs) { 146 // FIXME: Playing with std::string is really slow. 147 std::string S = Ty.getAsString(Context.PrintingPolicy); 148 149 // Consider producing an a.k.a. clause if removing all the direct 150 // sugar gives us something "significantly different". 151 152 QualType DesugaredTy; 153 if (ShouldAKA(Context, Ty, PrevArgs, NumPrevArgs, DesugaredTy)) { 154 S = "'"+S+"' (aka '"; 155 S += DesugaredTy.getAsString(Context.PrintingPolicy); 156 S += "')"; 157 return S; 158 } 159 160 S = "'" + S + "'"; 161 return S; 162} 163 164/// ConvertQualTypeToStringFn - This function is used to pretty print the 165/// specified QualType as a string in diagnostics. 166static void ConvertArgToStringFn(Diagnostic::ArgumentKind Kind, intptr_t Val, 167 const char *Modifier, unsigned ModLen, 168 const char *Argument, unsigned ArgLen, 169 const Diagnostic::ArgumentValue *PrevArgs, 170 unsigned NumPrevArgs, 171 llvm::SmallVectorImpl<char> &Output, 172 void *Cookie) { 173 ASTContext &Context = *static_cast<ASTContext*>(Cookie); 174 175 std::string S; 176 bool NeedQuotes = true; 177 178 switch (Kind) { 179 default: assert(0 && "unknown ArgumentKind"); 180 case Diagnostic::ak_qualtype: { 181 assert(ModLen == 0 && ArgLen == 0 && 182 "Invalid modifier for QualType argument"); 183 184 QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val))); 185 S = ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, NumPrevArgs); 186 NeedQuotes = false; 187 break; 188 } 189 case Diagnostic::ak_declarationname: { 190 DeclarationName N = DeclarationName::getFromOpaqueInteger(Val); 191 S = N.getAsString(); 192 193 if (ModLen == 9 && !memcmp(Modifier, "objcclass", 9) && ArgLen == 0) 194 S = '+' + S; 195 else if (ModLen == 12 && !memcmp(Modifier, "objcinstance", 12) && ArgLen==0) 196 S = '-' + S; 197 else 198 assert(ModLen == 0 && ArgLen == 0 && 199 "Invalid modifier for DeclarationName argument"); 200 break; 201 } 202 case Diagnostic::ak_nameddecl: { 203 bool Qualified; 204 if (ModLen == 1 && Modifier[0] == 'q' && ArgLen == 0) 205 Qualified = true; 206 else { 207 assert(ModLen == 0 && ArgLen == 0 && 208 "Invalid modifier for NamedDecl* argument"); 209 Qualified = false; 210 } 211 reinterpret_cast<NamedDecl*>(Val)-> 212 getNameForDiagnostic(S, Context.PrintingPolicy, Qualified); 213 break; 214 } 215 case Diagnostic::ak_nestednamespec: { 216 llvm::raw_string_ostream OS(S); 217 reinterpret_cast<NestedNameSpecifier*>(Val)->print(OS, 218 Context.PrintingPolicy); 219 NeedQuotes = false; 220 break; 221 } 222 case Diagnostic::ak_declcontext: { 223 DeclContext *DC = reinterpret_cast<DeclContext *> (Val); 224 assert(DC && "Should never have a null declaration context"); 225 226 if (DC->isTranslationUnit()) { 227 // FIXME: Get these strings from some localized place 228 if (Context.getLangOptions().CPlusPlus) 229 S = "the global namespace"; 230 else 231 S = "the global scope"; 232 } else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) { 233 S = ConvertTypeToDiagnosticString(Context, Context.getTypeDeclType(Type), 234 PrevArgs, NumPrevArgs); 235 } else { 236 // FIXME: Get these strings from some localized place 237 NamedDecl *ND = cast<NamedDecl>(DC); 238 if (isa<NamespaceDecl>(ND)) 239 S += "namespace "; 240 else if (isa<ObjCMethodDecl>(ND)) 241 S += "method "; 242 else if (isa<FunctionDecl>(ND)) 243 S += "function "; 244 245 S += "'"; 246 ND->getNameForDiagnostic(S, Context.PrintingPolicy, true); 247 S += "'"; 248 } 249 NeedQuotes = false; 250 break; 251 } 252 } 253 254 if (NeedQuotes) 255 Output.push_back('\''); 256 257 Output.append(S.begin(), S.end()); 258 259 if (NeedQuotes) 260 Output.push_back('\''); 261} 262 263 264static inline RecordDecl *CreateStructDecl(ASTContext &C, const char *Name) { 265 if (C.getLangOptions().CPlusPlus) 266 return CXXRecordDecl::Create(C, TagDecl::TK_struct, 267 C.getTranslationUnitDecl(), 268 SourceLocation(), &C.Idents.get(Name)); 269 270 return RecordDecl::Create(C, TagDecl::TK_struct, 271 C.getTranslationUnitDecl(), 272 SourceLocation(), &C.Idents.get(Name)); 273} 274 275void Sema::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) { 276 TUScope = S; 277 PushDeclContext(S, Context.getTranslationUnitDecl()); 278 279 if (PP.getTargetInfo().getPointerWidth(0) >= 64) { 280 DeclaratorInfo *DInfo; 281 282 // Install [u]int128_t for 64-bit targets. 283 DInfo = Context.getTrivialDeclaratorInfo(Context.Int128Ty); 284 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 285 SourceLocation(), 286 &Context.Idents.get("__int128_t"), 287 DInfo), TUScope); 288 289 DInfo = Context.getTrivialDeclaratorInfo(Context.UnsignedInt128Ty); 290 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 291 SourceLocation(), 292 &Context.Idents.get("__uint128_t"), 293 DInfo), TUScope); 294 } 295 296 297 if (!PP.getLangOptions().ObjC1) return; 298 299 // Built-in ObjC types may already be set by PCHReader (hence isNull checks). 300 if (Context.getObjCSelType().isNull()) { 301 // Synthesize "typedef struct objc_selector *SEL;" 302 RecordDecl *SelTag = CreateStructDecl(Context, "objc_selector"); 303 PushOnScopeChains(SelTag, TUScope); 304 305 QualType SelT = Context.getPointerType(Context.getTagDeclType(SelTag)); 306 DeclaratorInfo *SelInfo = Context.getTrivialDeclaratorInfo(SelT); 307 TypedefDecl *SelTypedef 308 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 309 &Context.Idents.get("SEL"), SelInfo); 310 PushOnScopeChains(SelTypedef, TUScope); 311 Context.setObjCSelType(Context.getTypeDeclType(SelTypedef)); 312 } 313 314 // Synthesize "@class Protocol; 315 if (Context.getObjCProtoType().isNull()) { 316 ObjCInterfaceDecl *ProtocolDecl = 317 ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(), 318 &Context.Idents.get("Protocol"), 319 SourceLocation(), true); 320 Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl)); 321 PushOnScopeChains(ProtocolDecl, TUScope); 322 } 323 // Create the built-in typedef for 'id'. 324 if (Context.getObjCIdType().isNull()) { 325 QualType IdT = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy); 326 DeclaratorInfo *IdInfo = Context.getTrivialDeclaratorInfo(IdT); 327 TypedefDecl *IdTypedef 328 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 329 &Context.Idents.get("id"), IdInfo); 330 PushOnScopeChains(IdTypedef, TUScope); 331 Context.setObjCIdType(Context.getTypeDeclType(IdTypedef)); 332 Context.ObjCIdRedefinitionType = Context.getObjCIdType(); 333 } 334 // Create the built-in typedef for 'Class'. 335 if (Context.getObjCClassType().isNull()) { 336 QualType ClassType 337 = Context.getObjCObjectPointerType(Context.ObjCBuiltinClassTy); 338 DeclaratorInfo *ClassInfo = Context.getTrivialDeclaratorInfo(ClassType); 339 TypedefDecl *ClassTypedef 340 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 341 &Context.Idents.get("Class"), ClassInfo); 342 PushOnScopeChains(ClassTypedef, TUScope); 343 Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef)); 344 Context.ObjCClassRedefinitionType = Context.getObjCClassType(); 345 } 346} 347 348Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 349 bool CompleteTranslationUnit) 350 : LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer), 351 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), 352 ExternalSource(0), CodeCompleter(0), CurContext(0), 353 PreDeclaratorDC(0), CurBlock(0), PackContext(0), 354 IdResolver(pp.getLangOptions()), StdNamespace(0), StdBadAlloc(0), 355 GlobalNewDeleteDeclared(false), ExprEvalContext(PotentiallyEvaluated), 356 CompleteTranslationUnit(CompleteTranslationUnit), 357 NumSFINAEErrors(0), CurrentInstantiationScope(0) { 358 359 TUScope = 0; 360 if (getLangOptions().CPlusPlus) 361 FieldCollector.reset(new CXXFieldCollector()); 362 363 // Tell diagnostics how to render things from the AST library. 364 PP.getDiagnostics().SetArgToStringFn(ConvertArgToStringFn, &Context); 365} 366 367/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. 368/// If there is already an implicit cast, merge into the existing one. 369/// If isLvalue, the result of the cast is an lvalue. 370void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty, 371 CastExpr::CastKind Kind, bool isLvalue) { 372 QualType ExprTy = Context.getCanonicalType(Expr->getType()); 373 QualType TypeTy = Context.getCanonicalType(Ty); 374 375 if (ExprTy == TypeTy) 376 return; 377 378 if (Expr->getType().getTypePtr()->isPointerType() && 379 Ty.getTypePtr()->isPointerType()) { 380 QualType ExprBaseType = 381 cast<PointerType>(ExprTy.getUnqualifiedType())->getPointeeType(); 382 QualType BaseType = 383 cast<PointerType>(TypeTy.getUnqualifiedType())->getPointeeType(); 384 if (ExprBaseType.getAddressSpace() != BaseType.getAddressSpace()) { 385 Diag(Expr->getExprLoc(), diag::err_implicit_pointer_address_space_cast) 386 << Expr->getSourceRange(); 387 } 388 } 389 390 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) { 391 if (ImpCast->getCastKind() == Kind) { 392 ImpCast->setType(Ty); 393 ImpCast->setLvalueCast(isLvalue); 394 return; 395 } 396 } 397 398 Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, isLvalue); 399} 400 401void Sema::DeleteExpr(ExprTy *E) { 402 if (E) static_cast<Expr*>(E)->Destroy(Context); 403} 404void Sema::DeleteStmt(StmtTy *S) { 405 if (S) static_cast<Stmt*>(S)->Destroy(Context); 406} 407 408/// ActOnEndOfTranslationUnit - This is called at the very end of the 409/// translation unit when EOF is reached and all but the top-level scope is 410/// popped. 411void Sema::ActOnEndOfTranslationUnit() { 412 // C++: Perform implicit template instantiations. 413 // 414 // FIXME: When we perform these implicit instantiations, we do not carefully 415 // keep track of the point of instantiation (C++ [temp.point]). This means 416 // that name lookup that occurs within the template instantiation will 417 // always happen at the end of the translation unit, so it will find 418 // some names that should not be found. Although this is common behavior 419 // for C++ compilers, it is technically wrong. In the future, we either need 420 // to be able to filter the results of name lookup or we need to perform 421 // template instantiations earlier. 422 PerformPendingImplicitInstantiations(); 423 424 // Check for #pragma weak identifiers that were never declared 425 // FIXME: This will cause diagnostics to be emitted in a non-determinstic 426 // order! Iterating over a densemap like this is bad. 427 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 428 I = WeakUndeclaredIdentifiers.begin(), 429 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { 430 if (I->second.getUsed()) continue; 431 432 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) 433 << I->first; 434 } 435 436 if (!CompleteTranslationUnit) 437 return; 438 439 // C99 6.9.2p2: 440 // A declaration of an identifier for an object that has file 441 // scope without an initializer, and without a storage-class 442 // specifier or with the storage-class specifier static, 443 // constitutes a tentative definition. If a translation unit 444 // contains one or more tentative definitions for an identifier, 445 // and the translation unit contains no external definition for 446 // that identifier, then the behavior is exactly as if the 447 // translation unit contains a file scope declaration of that 448 // identifier, with the composite type as of the end of the 449 // translation unit, with an initializer equal to 0. 450 for (unsigned i = 0, e = TentativeDefinitionList.size(); i != e; ++i) { 451 VarDecl *VD = TentativeDefinitions.lookup(TentativeDefinitionList[i]); 452 453 // If the tentative definition was completed, it will be in the list, but 454 // not the map. 455 if (VD == 0 || VD->isInvalidDecl() || !VD->isTentativeDefinition(Context)) 456 continue; 457 458 if (const IncompleteArrayType *ArrayT 459 = Context.getAsIncompleteArrayType(VD->getType())) { 460 if (RequireCompleteType(VD->getLocation(), 461 ArrayT->getElementType(), 462 diag::err_tentative_def_incomplete_type_arr)) { 463 VD->setInvalidDecl(); 464 continue; 465 } 466 467 // Set the length of the array to 1 (C99 6.9.2p5). 468 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 469 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 470 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), 471 One, ArrayType::Normal, 0); 472 VD->setType(T); 473 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 474 diag::err_tentative_def_incomplete_type)) 475 VD->setInvalidDecl(); 476 477 // Notify the consumer that we've completed a tentative definition. 478 if (!VD->isInvalidDecl()) 479 Consumer.CompleteTentativeDefinition(VD); 480 481 } 482} 483 484 485//===----------------------------------------------------------------------===// 486// Helper functions. 487//===----------------------------------------------------------------------===// 488 489DeclContext *Sema::getFunctionLevelDeclContext() { 490 DeclContext *DC = PreDeclaratorDC ? PreDeclaratorDC : CurContext; 491 492 while (isa<BlockDecl>(DC)) 493 DC = DC->getParent(); 494 495 return DC; 496} 497 498/// getCurFunctionDecl - If inside of a function body, this returns a pointer 499/// to the function decl for the function being parsed. If we're currently 500/// in a 'block', this returns the containing context. 501FunctionDecl *Sema::getCurFunctionDecl() { 502 DeclContext *DC = getFunctionLevelDeclContext(); 503 return dyn_cast<FunctionDecl>(DC); 504} 505 506ObjCMethodDecl *Sema::getCurMethodDecl() { 507 DeclContext *DC = getFunctionLevelDeclContext(); 508 return dyn_cast<ObjCMethodDecl>(DC); 509} 510 511NamedDecl *Sema::getCurFunctionOrMethodDecl() { 512 DeclContext *DC = getFunctionLevelDeclContext(); 513 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 514 return cast<NamedDecl>(DC); 515 return 0; 516} 517 518Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() { 519 if (!this->Emit()) 520 return; 521 522 // If this is not a note, and we're in a template instantiation 523 // that is different from the last template instantiation where 524 // we emitted an error, print a template instantiation 525 // backtrace. 526 if (!SemaRef.Diags.isBuiltinNote(DiagID) && 527 !SemaRef.ActiveTemplateInstantiations.empty() && 528 SemaRef.ActiveTemplateInstantiations.back() 529 != SemaRef.LastTemplateInstantiationErrorContext) { 530 SemaRef.PrintInstantiationStack(); 531 SemaRef.LastTemplateInstantiationErrorContext 532 = SemaRef.ActiveTemplateInstantiations.back(); 533 } 534} 535 536Sema::SemaDiagnosticBuilder 537Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 538 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 539 PD.Emit(Builder); 540 541 return Builder; 542} 543 544void Sema::ActOnComment(SourceRange Comment) { 545 Context.Comments.push_back(Comment); 546} 547 548