SemaExprCXX.cpp revision 6ed40e351a7c1fb3084434f1db19216b79623cf0
1//===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===// 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 semantic analysis for C++ expressions. 11// 12//===----------------------------------------------------------------------===// 13 14#include "Sema.h" 15#include "clang/AST/ExprCXX.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/Parse/DeclSpec.h" 18#include "clang/Lex/Preprocessor.h" 19#include "clang/Basic/Diagnostic.h" 20#include "clang/Basic/TargetInfo.h" 21#include "llvm/ADT/STLExtras.h" 22using namespace clang; 23 24/// ActOnCXXConversionFunctionExpr - Parse a C++ conversion function 25/// name (e.g., operator void const *) as an expression. This is 26/// very similar to ActOnIdentifierExpr, except that instead of 27/// providing an identifier the parser provides the type of the 28/// conversion function. 29Sema::ExprResult 30Sema::ActOnCXXConversionFunctionExpr(Scope *S, SourceLocation OperatorLoc, 31 TypeTy *Ty, bool HasTrailingLParen, 32 const CXXScopeSpec &SS) { 33 QualType ConvType = QualType::getFromOpaquePtr(Ty); 34 QualType ConvTypeCanon = Context.getCanonicalType(ConvType); 35 DeclarationName ConvName 36 = Context.DeclarationNames.getCXXConversionFunctionName(ConvTypeCanon); 37 return ActOnDeclarationNameExpr(S, OperatorLoc, ConvName, HasTrailingLParen, 38 &SS); 39} 40 41/// ActOnCXXOperatorFunctionIdExpr - Parse a C++ overloaded operator 42/// name (e.g., @c operator+ ) as an expression. This is very 43/// similar to ActOnIdentifierExpr, except that instead of providing 44/// an identifier the parser provides the kind of overloaded 45/// operator that was parsed. 46Sema::ExprResult 47Sema::ActOnCXXOperatorFunctionIdExpr(Scope *S, SourceLocation OperatorLoc, 48 OverloadedOperatorKind Op, 49 bool HasTrailingLParen, 50 const CXXScopeSpec &SS) { 51 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(Op); 52 return ActOnDeclarationNameExpr(S, OperatorLoc, Name, HasTrailingLParen, &SS); 53} 54 55/// ActOnCXXTypeidOfType - Parse typeid( type-id ). 56Action::ExprResult 57Sema::ActOnCXXTypeid(SourceLocation OpLoc, SourceLocation LParenLoc, 58 bool isType, void *TyOrExpr, SourceLocation RParenLoc) { 59 const NamespaceDecl *StdNs = GetStdNamespace(); 60 if (!StdNs) 61 return Diag(OpLoc, diag::err_need_header_before_typeid); 62 63 IdentifierInfo *TypeInfoII = &PP.getIdentifierTable().get("type_info"); 64 Decl *TypeInfoDecl = LookupDecl(TypeInfoII, 65 Decl::IDNS_Tag | Decl::IDNS_Ordinary, 66 0, StdNs, /*createBuiltins=*/false); 67 RecordDecl *TypeInfoRecordDecl = dyn_cast_or_null<RecordDecl>(TypeInfoDecl); 68 if (!TypeInfoRecordDecl) 69 return Diag(OpLoc, diag::err_need_header_before_typeid); 70 71 QualType TypeInfoType = Context.getTypeDeclType(TypeInfoRecordDecl); 72 73 return new CXXTypeidExpr(isType, TyOrExpr, TypeInfoType.withConst(), 74 SourceRange(OpLoc, RParenLoc)); 75} 76 77/// ActOnCXXBoolLiteral - Parse {true,false} literals. 78Action::ExprResult 79Sema::ActOnCXXBoolLiteral(SourceLocation OpLoc, tok::TokenKind Kind) { 80 assert((Kind == tok::kw_true || Kind == tok::kw_false) && 81 "Unknown C++ Boolean value!"); 82 return new CXXBoolLiteralExpr(Kind == tok::kw_true, Context.BoolTy, OpLoc); 83} 84 85/// ActOnCXXThrow - Parse throw expressions. 86Action::ExprResult 87Sema::ActOnCXXThrow(SourceLocation OpLoc, ExprTy *E) { 88 return new CXXThrowExpr((Expr*)E, Context.VoidTy, OpLoc); 89} 90 91Action::ExprResult Sema::ActOnCXXThis(SourceLocation ThisLoc) { 92 /// C++ 9.3.2: In the body of a non-static member function, the keyword this 93 /// is a non-lvalue expression whose value is the address of the object for 94 /// which the function is called. 95 96 if (!isa<FunctionDecl>(CurContext)) { 97 Diag(ThisLoc, diag::err_invalid_this_use); 98 return ExprResult(true); 99 } 100 101 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) 102 if (MD->isInstance()) 103 return new CXXThisExpr(ThisLoc, MD->getThisType(Context)); 104 105 return Diag(ThisLoc, diag::err_invalid_this_use); 106} 107 108/// ActOnCXXTypeConstructExpr - Parse construction of a specified type. 109/// Can be interpreted either as function-style casting ("int(x)") 110/// or class type construction ("ClassType(x,y,z)") 111/// or creation of a value-initialized type ("int()"). 112Action::ExprResult 113Sema::ActOnCXXTypeConstructExpr(SourceRange TypeRange, TypeTy *TypeRep, 114 SourceLocation LParenLoc, 115 ExprTy **ExprTys, unsigned NumExprs, 116 SourceLocation *CommaLocs, 117 SourceLocation RParenLoc) { 118 assert(TypeRep && "Missing type!"); 119 QualType Ty = QualType::getFromOpaquePtr(TypeRep); 120 Expr **Exprs = (Expr**)ExprTys; 121 SourceLocation TyBeginLoc = TypeRange.getBegin(); 122 SourceRange FullRange = SourceRange(TyBeginLoc, RParenLoc); 123 124 if (const RecordType *RT = Ty->getAsRecordType()) { 125 // C++ 5.2.3p1: 126 // If the simple-type-specifier specifies a class type, the class type shall 127 // be complete. 128 // 129 if (!RT->getDecl()->isDefinition()) 130 return Diag(TyBeginLoc, diag::err_invalid_incomplete_type_use) 131 << Ty << FullRange; 132 133 unsigned DiagID = PP.getDiagnostics().getCustomDiagID(Diagnostic::Error, 134 "class constructors are not supported yet"); 135 return Diag(TyBeginLoc, DiagID); 136 } 137 138 // C++ 5.2.3p1: 139 // If the expression list is a single expression, the type conversion 140 // expression is equivalent (in definedness, and if defined in meaning) to the 141 // corresponding cast expression. 142 // 143 if (NumExprs == 1) { 144 if (CheckCastTypes(TypeRange, Ty, Exprs[0])) 145 return true; 146 return new CXXFunctionalCastExpr(Ty.getNonReferenceType(), Ty, TyBeginLoc, 147 Exprs[0], RParenLoc); 148 } 149 150 // C++ 5.2.3p1: 151 // If the expression list specifies more than a single value, the type shall 152 // be a class with a suitably declared constructor. 153 // 154 if (NumExprs > 1) 155 return Diag(CommaLocs[0], diag::err_builtin_func_cast_more_than_one_arg) 156 << FullRange; 157 158 assert(NumExprs == 0 && "Expected 0 expressions"); 159 160 // C++ 5.2.3p2: 161 // The expression T(), where T is a simple-type-specifier for a non-array 162 // complete object type or the (possibly cv-qualified) void type, creates an 163 // rvalue of the specified type, which is value-initialized. 164 // 165 if (Ty->isArrayType()) 166 return Diag(TyBeginLoc, diag::err_value_init_for_array_type) << FullRange; 167 if (!Ty->isDependentType() && Ty->isIncompleteType() && !Ty->isVoidType()) 168 return Diag(TyBeginLoc, diag::err_invalid_incomplete_type_use) 169 << Ty << FullRange; 170 171 return new CXXZeroInitValueExpr(Ty, TyBeginLoc, RParenLoc); 172} 173 174 175/// ActOnCXXNew - Parsed a C++ 'new' expression (C++ 5.3.4), as in e.g.: 176/// @code new (memory) int[size][4] @endcode 177/// or 178/// @code ::new Foo(23, "hello") @endcode 179/// For the interpretation of this heap of arguments, consult the base version. 180Action::ExprResult 181Sema::ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal, 182 SourceLocation PlacementLParen, 183 ExprTy **PlacementArgs, unsigned NumPlaceArgs, 184 SourceLocation PlacementRParen, bool ParenTypeId, 185 Declarator &D, SourceLocation ConstructorLParen, 186 ExprTy **ConstructorArgs, unsigned NumConsArgs, 187 SourceLocation ConstructorRParen) 188{ 189 // FIXME: Throughout this function, we have rather bad location information. 190 // Implementing Declarator::getSourceRange() would go a long way toward 191 // fixing that. 192 193 Expr *ArraySize = 0; 194 unsigned Skip = 0; 195 // If the specified type is an array, unwrap it and save the expression. 196 if (D.getNumTypeObjects() > 0 && 197 D.getTypeObject(0).Kind == DeclaratorChunk::Array) { 198 DeclaratorChunk &Chunk = D.getTypeObject(0); 199 if (Chunk.Arr.hasStatic) 200 return Diag(Chunk.Loc, diag::err_static_illegal_in_new); 201 if (!Chunk.Arr.NumElts) 202 return Diag(Chunk.Loc, diag::err_array_new_needs_size); 203 ArraySize = static_cast<Expr*>(Chunk.Arr.NumElts); 204 Skip = 1; 205 } 206 207 QualType AllocType = GetTypeForDeclarator(D, /*Scope=*/0, Skip); 208 if (D.getInvalidType()) 209 return true; 210 211 if (CheckAllocatedType(AllocType, D)) 212 return true; 213 214 QualType ResultType = Context.getPointerType(AllocType); 215 216 // That every array dimension except the first is constant was already 217 // checked by the type check above. 218 219 // C++ 5.3.4p6: "The expression in a direct-new-declarator shall have integral 220 // or enumeration type with a non-negative value." 221 if (ArraySize) { 222 QualType SizeType = ArraySize->getType(); 223 if (!SizeType->isIntegralType() && !SizeType->isEnumeralType()) 224 return Diag(ArraySize->getSourceRange().getBegin(), 225 diag::err_array_size_not_integral) 226 << SizeType << ArraySize->getSourceRange(); 227 // Let's see if this is a constant < 0. If so, we reject it out of hand. 228 // We don't care about special rules, so we tell the machinery it's not 229 // evaluated - it gives us a result in more cases. 230 llvm::APSInt Value; 231 if (ArraySize->isIntegerConstantExpr(Value, Context, 0, false)) { 232 if (Value < llvm::APSInt( 233 llvm::APInt::getNullValue(Value.getBitWidth()), false)) 234 return Diag(ArraySize->getSourceRange().getBegin(), 235 diag::err_typecheck_negative_array_size) 236 << ArraySize->getSourceRange(); 237 } 238 } 239 240 FunctionDecl *OperatorNew = 0; 241 FunctionDecl *OperatorDelete = 0; 242 Expr **PlaceArgs = (Expr**)PlacementArgs; 243 if (FindAllocationFunctions(StartLoc, UseGlobal, AllocType, ArraySize, 244 PlaceArgs, NumPlaceArgs, OperatorNew, 245 OperatorDelete)) 246 return true; 247 248 bool Init = ConstructorLParen.isValid(); 249 // --- Choosing a constructor --- 250 // C++ 5.3.4p15 251 // 1) If T is a POD and there's no initializer (ConstructorLParen is invalid) 252 // the object is not initialized. If the object, or any part of it, is 253 // const-qualified, it's an error. 254 // 2) If T is a POD and there's an empty initializer, the object is value- 255 // initialized. 256 // 3) If T is a POD and there's one initializer argument, the object is copy- 257 // constructed. 258 // 4) If T is a POD and there's more initializer arguments, it's an error. 259 // 5) If T is not a POD, the initializer arguments are used as constructor 260 // arguments. 261 // 262 // Or by the C++0x formulation: 263 // 1) If there's no initializer, the object is default-initialized according 264 // to C++0x rules. 265 // 2) Otherwise, the object is direct-initialized. 266 CXXConstructorDecl *Constructor = 0; 267 Expr **ConsArgs = (Expr**)ConstructorArgs; 268 if (const RecordType *RT = AllocType->getAsRecordType()) { 269 // FIXME: This is incorrect for when there is an empty initializer and 270 // no user-defined constructor. Must zero-initialize, not default-construct. 271 Constructor = PerformInitializationByConstructor( 272 AllocType, ConsArgs, NumConsArgs, 273 D.getDeclSpec().getSourceRange().getBegin(), 274 SourceRange(D.getDeclSpec().getSourceRange().getBegin(), 275 ConstructorRParen), 276 RT->getDecl()->getDeclName(), 277 NumConsArgs != 0 ? IK_Direct : IK_Default); 278 if (!Constructor) 279 return true; 280 } else { 281 if (!Init) { 282 // FIXME: Check that no subpart is const. 283 if (AllocType.isConstQualified()) { 284 Diag(StartLoc, diag::err_new_uninitialized_const) 285 << D.getSourceRange(); 286 return true; 287 } 288 } else if (NumConsArgs == 0) { 289 // Object is value-initialized. Do nothing. 290 } else if (NumConsArgs == 1) { 291 // Object is direct-initialized. 292 // FIXME: WHAT DeclarationName do we pass in here? 293 if (CheckInitializerTypes(ConsArgs[0], AllocType, StartLoc, 294 DeclarationName() /*AllocType.getAsString()*/)) 295 return true; 296 } else { 297 Diag(StartLoc, diag::err_builtin_direct_init_more_than_one_arg) 298 << SourceRange(ConstructorLParen, ConstructorRParen); 299 } 300 } 301 302 // FIXME: Also check that the destructor is accessible. (C++ 5.3.4p16) 303 304 return new CXXNewExpr(UseGlobal, OperatorNew, PlaceArgs, NumPlaceArgs, 305 ParenTypeId, ArraySize, Constructor, Init, 306 ConsArgs, NumConsArgs, OperatorDelete, ResultType, 307 StartLoc, Init ? ConstructorRParen : SourceLocation()); 308} 309 310/// CheckAllocatedType - Checks that a type is suitable as the allocated type 311/// in a new-expression. 312/// dimension off and stores the size expression in ArraySize. 313bool Sema::CheckAllocatedType(QualType AllocType, const Declarator &D) 314{ 315 // C++ 5.3.4p1: "[The] type shall be a complete object type, but not an 316 // abstract class type or array thereof. 317 // FIXME: We don't have abstract types yet. 318 // FIXME: Under C++ semantics, an incomplete object type is still an object 319 // type. This code assumes the C semantics, where it's not. 320 if (!AllocType->isObjectType()) { 321 unsigned type; // For the select in the message. 322 if (AllocType->isFunctionType()) { 323 type = 0; 324 } else if(AllocType->isIncompleteType()) { 325 type = 1; 326 } else { 327 assert(AllocType->isReferenceType() && "What else could it be?"); 328 type = 2; 329 } 330 SourceRange TyR = D.getDeclSpec().getSourceRange(); 331 // FIXME: This is very much a guess and won't work for, e.g., pointers. 332 if (D.getNumTypeObjects() > 0) 333 TyR.setEnd(D.getTypeObject(0).Loc); 334 Diag(TyR.getBegin(), diag::err_bad_new_type) 335 << AllocType.getAsString() << type << TyR; 336 return true; 337 } 338 339 // Every dimension shall be of constant size. 340 unsigned i = 1; 341 while (const ArrayType *Array = Context.getAsArrayType(AllocType)) { 342 if (!Array->isConstantArrayType()) { 343 Diag(D.getTypeObject(i).Loc, diag::err_new_array_nonconst) 344 << static_cast<Expr*>(D.getTypeObject(i).Arr.NumElts)->getSourceRange(); 345 return true; 346 } 347 AllocType = Array->getElementType(); 348 ++i; 349 } 350 351 return false; 352} 353 354/// FindAllocationFunctions - Finds the overloads of operator new and delete 355/// that are appropriate for the allocation. 356bool Sema::FindAllocationFunctions(SourceLocation StartLoc, bool UseGlobal, 357 QualType AllocType, bool IsArray, 358 Expr **PlaceArgs, unsigned NumPlaceArgs, 359 FunctionDecl *&OperatorNew, 360 FunctionDecl *&OperatorDelete) 361{ 362 // --- Choosing an allocation function --- 363 // C++ 5.3.4p8 - 14 & 18 364 // 1) If UseGlobal is true, only look in the global scope. Else, also look 365 // in the scope of the allocated class. 366 // 2) If an array size is given, look for operator new[], else look for 367 // operator new. 368 // 3) The first argument is always size_t. Append the arguments from the 369 // placement form. 370 // FIXME: Also find the appropriate delete operator. 371 372 llvm::SmallVector<Expr*, 8> AllocArgs(1 + NumPlaceArgs); 373 // We don't care about the actual value of this argument. 374 // FIXME: Should the Sema create the expression and embed it in the syntax 375 // tree? Or should the consumer just recalculate the value? 376 AllocArgs[0] = new IntegerLiteral(llvm::APInt::getNullValue( 377 Context.Target.getPointerWidth(0)), 378 Context.getSizeType(), 379 SourceLocation()); 380 std::copy(PlaceArgs, PlaceArgs + NumPlaceArgs, AllocArgs.begin() + 1); 381 382 DeclarationName NewName = Context.DeclarationNames.getCXXOperatorName( 383 IsArray ? OO_Array_New : OO_New); 384 if (AllocType->isRecordType() && !UseGlobal) { 385 CXXRecordDecl *Record = cast<CXXRecordType>(AllocType->getAsRecordType()) 386 ->getDecl(); 387 // FIXME: We fail to find inherited overloads. 388 if (FindAllocationOverload(StartLoc, NewName, &AllocArgs[0], 389 AllocArgs.size(), Record, /*AllowMissing=*/true, 390 OperatorNew)) 391 return true; 392 } 393 if (!OperatorNew) { 394 // Didn't find a member overload. Look for a global one. 395 DeclareGlobalNewDelete(); 396 DeclContext *TUDecl = Context.getTranslationUnitDecl(); 397 if (FindAllocationOverload(StartLoc, NewName, &AllocArgs[0], 398 AllocArgs.size(), TUDecl, /*AllowMissing=*/false, 399 OperatorNew)) 400 return true; 401 } 402 403 // FIXME: This is leaked on error. But so much is currently in Sema that it's 404 // easier to clean it in one go. 405 AllocArgs[0]->Destroy(Context); 406 return false; 407} 408 409/// FindAllocationOverload - Find an fitting overload for the allocation 410/// function in the specified scope. 411bool Sema::FindAllocationOverload(SourceLocation StartLoc, DeclarationName Name, 412 Expr** Args, unsigned NumArgs, 413 DeclContext *Ctx, bool AllowMissing, 414 FunctionDecl *&Operator) 415{ 416 DeclContext::lookup_iterator Alloc, AllocEnd; 417 llvm::tie(Alloc, AllocEnd) = Ctx->lookup(Context, Name); 418 if (Alloc == AllocEnd) { 419 if (AllowMissing) 420 return false; 421 // FIXME: Bad location information. 422 return Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 423 << Name << 0; 424 } 425 426 OverloadCandidateSet Candidates; 427 for (; Alloc != AllocEnd; ++Alloc) { 428 // Even member operator new/delete are implicitly treated as 429 // static, so don't use AddMemberCandidate. 430 if (FunctionDecl *Fn = dyn_cast<FunctionDecl>(*Alloc)) 431 AddOverloadCandidate(Fn, Args, NumArgs, Candidates, 432 /*SuppressUserConversions=*/false); 433 } 434 435 // Do the resolution. 436 OverloadCandidateSet::iterator Best; 437 switch(BestViableFunction(Candidates, Best)) { 438 case OR_Success: { 439 // Got one! 440 FunctionDecl *FnDecl = Best->Function; 441 // The first argument is size_t, and the first parameter must be size_t, 442 // too. This is checked on declaration and can be assumed. (It can't be 443 // asserted on, though, since invalid decls are left in there.) 444 for (unsigned i = 1; i < NumArgs; ++i) { 445 // FIXME: Passing word to diagnostic. 446 if (PerformCopyInitialization(Args[i-1], 447 FnDecl->getParamDecl(i)->getType(), 448 "passing")) 449 return true; 450 } 451 Operator = FnDecl; 452 return false; 453 } 454 455 case OR_No_Viable_Function: 456 if (AllowMissing) 457 return false; 458 // FIXME: Bad location information. 459 Diag(StartLoc, diag::err_ovl_no_viable_function_in_call) 460 << Name << (unsigned)Candidates.size(); 461 PrintOverloadCandidates(Candidates, /*OnlyViable=*/false); 462 return true; 463 464 case OR_Ambiguous: 465 // FIXME: Bad location information. 466 Diag(StartLoc, diag::err_ovl_ambiguous_call) 467 << Name; 468 PrintOverloadCandidates(Candidates, /*OnlyViable=*/true); 469 return true; 470 } 471 assert(false && "Unreachable, bad result from BestViableFunction"); 472 return true; 473} 474 475 476/// DeclareGlobalNewDelete - Declare the global forms of operator new and 477/// delete. These are: 478/// @code 479/// void* operator new(std::size_t) throw(std::bad_alloc); 480/// void* operator new[](std::size_t) throw(std::bad_alloc); 481/// void operator delete(void *) throw(); 482/// void operator delete[](void *) throw(); 483/// @endcode 484/// Note that the placement and nothrow forms of new are *not* implicitly 485/// declared. Their use requires including \<new\>. 486void Sema::DeclareGlobalNewDelete() 487{ 488 if (GlobalNewDeleteDeclared) 489 return; 490 GlobalNewDeleteDeclared = true; 491 492 QualType VoidPtr = Context.getPointerType(Context.VoidTy); 493 QualType SizeT = Context.getSizeType(); 494 495 // FIXME: Exception specifications are not added. 496 DeclareGlobalAllocationFunction( 497 Context.DeclarationNames.getCXXOperatorName(OO_New), 498 VoidPtr, SizeT); 499 DeclareGlobalAllocationFunction( 500 Context.DeclarationNames.getCXXOperatorName(OO_Array_New), 501 VoidPtr, SizeT); 502 DeclareGlobalAllocationFunction( 503 Context.DeclarationNames.getCXXOperatorName(OO_Delete), 504 Context.VoidTy, VoidPtr); 505 DeclareGlobalAllocationFunction( 506 Context.DeclarationNames.getCXXOperatorName(OO_Array_Delete), 507 Context.VoidTy, VoidPtr); 508} 509 510/// DeclareGlobalAllocationFunction - Declares a single implicit global 511/// allocation function if it doesn't already exist. 512void Sema::DeclareGlobalAllocationFunction(DeclarationName Name, 513 QualType Return, QualType Argument) 514{ 515 DeclContext *GlobalCtx = Context.getTranslationUnitDecl(); 516 517 // Check if this function is already declared. 518 { 519 DeclContext::decl_iterator Alloc, AllocEnd; 520 for (llvm::tie(Alloc, AllocEnd) = GlobalCtx->lookup(Context, Name); 521 Alloc != AllocEnd; ++Alloc) { 522 // FIXME: Do we need to check for default arguments here? 523 FunctionDecl *Func = cast<FunctionDecl>(*Alloc); 524 if (Func->getNumParams() == 1 && 525 Context.getCanonicalType(Func->getParamDecl(0)->getType()) == Argument) 526 return; 527 } 528 } 529 530 QualType FnType = Context.getFunctionType(Return, &Argument, 1, false, 0); 531 FunctionDecl *Alloc = 532 FunctionDecl::Create(Context, GlobalCtx, SourceLocation(), Name, 533 FnType, FunctionDecl::None, false, 0, 534 SourceLocation()); 535 Alloc->setImplicit(); 536 ParmVarDecl *Param = ParmVarDecl::Create(Context, Alloc, SourceLocation(), 537 0, Argument, VarDecl::None, 0, 0); 538 Alloc->setParams(&Param, 1); 539 540 // FIXME: Also add this declaration to the IdentifierResolver, but 541 // make sure it is at the end of the chain to coincide with the 542 // global scope. 543 ((DeclContext *)TUScope->getEntity())->addDecl(Context, Alloc); 544} 545 546/// ActOnCXXDelete - Parsed a C++ 'delete' expression (C++ 5.3.5), as in: 547/// @code ::delete ptr; @endcode 548/// or 549/// @code delete [] ptr; @endcode 550Action::ExprResult 551Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, 552 bool ArrayForm, ExprTy *Operand) 553{ 554 // C++ 5.3.5p1: "The operand shall have a pointer type, or a class type 555 // having a single conversion function to a pointer type. The result has 556 // type void." 557 // DR599 amends "pointer type" to "pointer to object type" in both cases. 558 559 Expr *Ex = (Expr *)Operand; 560 QualType Type = Ex->getType(); 561 562 if (Type->isRecordType()) { 563 // FIXME: Find that one conversion function and amend the type. 564 } 565 566 if (!Type->isPointerType()) { 567 Diag(StartLoc, diag::err_delete_operand) << Type << Ex->getSourceRange(); 568 return true; 569 } 570 571 QualType Pointee = Type->getAsPointerType()->getPointeeType(); 572 if (Pointee->isIncompleteType() && !Pointee->isVoidType()) 573 Diag(StartLoc, diag::warn_delete_incomplete) 574 << Pointee << Ex->getSourceRange(); 575 else if (!Pointee->isObjectType()) { 576 Diag(StartLoc, diag::err_delete_operand) 577 << Type << Ex->getSourceRange(); 578 return true; 579 } 580 581 // FIXME: Look up the correct operator delete overload and pass a pointer 582 // along. 583 // FIXME: Check access and ambiguity of operator delete and destructor. 584 585 return new CXXDeleteExpr(Context.VoidTy, UseGlobal, ArrayForm, 0, Ex, 586 StartLoc); 587} 588 589 590/// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a 591/// C++ if/switch/while/for statement. 592/// e.g: "if (int x = f()) {...}" 593Action::ExprResult 594Sema::ActOnCXXConditionDeclarationExpr(Scope *S, SourceLocation StartLoc, 595 Declarator &D, 596 SourceLocation EqualLoc, 597 ExprTy *AssignExprVal) { 598 assert(AssignExprVal && "Null assignment expression"); 599 600 // C++ 6.4p2: 601 // The declarator shall not specify a function or an array. 602 // The type-specifier-seq shall not contain typedef and shall not declare a 603 // new class or enumeration. 604 605 assert(D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 606 "Parser allowed 'typedef' as storage class of condition decl."); 607 608 QualType Ty = GetTypeForDeclarator(D, S); 609 610 if (Ty->isFunctionType()) { // The declarator shall not specify a function... 611 // We exit without creating a CXXConditionDeclExpr because a FunctionDecl 612 // would be created and CXXConditionDeclExpr wants a VarDecl. 613 return Diag(StartLoc, diag::err_invalid_use_of_function_type) 614 << SourceRange(StartLoc, EqualLoc); 615 } else if (Ty->isArrayType()) { // ...or an array. 616 Diag(StartLoc, diag::err_invalid_use_of_array_type) 617 << SourceRange(StartLoc, EqualLoc); 618 } else if (const RecordType *RT = Ty->getAsRecordType()) { 619 RecordDecl *RD = RT->getDecl(); 620 // The type-specifier-seq shall not declare a new class... 621 if (RD->isDefinition() && (RD->getIdentifier() == 0 || S->isDeclScope(RD))) 622 Diag(RD->getLocation(), diag::err_type_defined_in_condition); 623 } else if (const EnumType *ET = Ty->getAsEnumType()) { 624 EnumDecl *ED = ET->getDecl(); 625 // ...or enumeration. 626 if (ED->isDefinition() && (ED->getIdentifier() == 0 || S->isDeclScope(ED))) 627 Diag(ED->getLocation(), diag::err_type_defined_in_condition); 628 } 629 630 DeclTy *Dcl = ActOnDeclarator(S, D, 0); 631 if (!Dcl) 632 return true; 633 AddInitializerToDecl(Dcl, ExprArg(*this, AssignExprVal)); 634 635 // Mark this variable as one that is declared within a conditional. 636 if (VarDecl *VD = dyn_cast<VarDecl>((Decl *)Dcl)) 637 VD->setDeclaredInCondition(true); 638 639 return new CXXConditionDeclExpr(StartLoc, EqualLoc, 640 cast<VarDecl>(static_cast<Decl *>(Dcl))); 641} 642 643/// CheckCXXBooleanCondition - Returns true if a conversion to bool is invalid. 644bool Sema::CheckCXXBooleanCondition(Expr *&CondExpr) { 645 // C++ 6.4p4: 646 // The value of a condition that is an initialized declaration in a statement 647 // other than a switch statement is the value of the declared variable 648 // implicitly converted to type bool. If that conversion is ill-formed, the 649 // program is ill-formed. 650 // The value of a condition that is an expression is the value of the 651 // expression, implicitly converted to bool. 652 // 653 QualType Ty = CondExpr->getType(); // Save the type. 654 AssignConvertType 655 ConvTy = CheckSingleAssignmentConstraints(Context.BoolTy, CondExpr); 656 if (ConvTy == Incompatible) 657 return Diag(CondExpr->getLocStart(), diag::err_typecheck_bool_condition) 658 << Ty << CondExpr->getSourceRange(); 659 return false; 660} 661 662/// Helper function to determine whether this is the (deprecated) C++ 663/// conversion from a string literal to a pointer to non-const char or 664/// non-const wchar_t (for narrow and wide string literals, 665/// respectively). 666bool 667Sema::IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType) { 668 // Look inside the implicit cast, if it exists. 669 if (ImplicitCastExpr *Cast = dyn_cast<ImplicitCastExpr>(From)) 670 From = Cast->getSubExpr(); 671 672 // A string literal (2.13.4) that is not a wide string literal can 673 // be converted to an rvalue of type "pointer to char"; a wide 674 // string literal can be converted to an rvalue of type "pointer 675 // to wchar_t" (C++ 4.2p2). 676 if (StringLiteral *StrLit = dyn_cast<StringLiteral>(From)) 677 if (const PointerType *ToPtrType = ToType->getAsPointerType()) 678 if (const BuiltinType *ToPointeeType 679 = ToPtrType->getPointeeType()->getAsBuiltinType()) { 680 // This conversion is considered only when there is an 681 // explicit appropriate pointer target type (C++ 4.2p2). 682 if (ToPtrType->getPointeeType().getCVRQualifiers() == 0 && 683 ((StrLit->isWide() && ToPointeeType->isWideCharType()) || 684 (!StrLit->isWide() && 685 (ToPointeeType->getKind() == BuiltinType::Char_U || 686 ToPointeeType->getKind() == BuiltinType::Char_S)))) 687 return true; 688 } 689 690 return false; 691} 692 693/// PerformImplicitConversion - Perform an implicit conversion of the 694/// expression From to the type ToType. Returns true if there was an 695/// error, false otherwise. The expression From is replaced with the 696/// converted expression. Flavor is the kind of conversion we're 697/// performing, used in the error message. 698bool 699Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 700 const char *Flavor) 701{ 702 ImplicitConversionSequence ICS = TryImplicitConversion(From, ToType); 703 switch (ICS.ConversionKind) { 704 case ImplicitConversionSequence::StandardConversion: 705 if (PerformImplicitConversion(From, ToType, ICS.Standard, Flavor)) 706 return true; 707 break; 708 709 case ImplicitConversionSequence::UserDefinedConversion: 710 // FIXME: This is, of course, wrong. We'll need to actually call 711 // the constructor or conversion operator, and then cope with the 712 // standard conversions. 713 ImpCastExprToType(From, ToType); 714 return false; 715 716 case ImplicitConversionSequence::EllipsisConversion: 717 assert(false && "Cannot perform an ellipsis conversion"); 718 return false; 719 720 case ImplicitConversionSequence::BadConversion: 721 return true; 722 } 723 724 // Everything went well. 725 return false; 726} 727 728/// PerformImplicitConversion - Perform an implicit conversion of the 729/// expression From to the type ToType by following the standard 730/// conversion sequence SCS. Returns true if there was an error, false 731/// otherwise. The expression From is replaced with the converted 732/// expression. Flavor is the context in which we're performing this 733/// conversion, for use in error messages. 734bool 735Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 736 const StandardConversionSequence& SCS, 737 const char *Flavor) 738{ 739 // Overall FIXME: we are recomputing too many types here and doing 740 // far too much extra work. What this means is that we need to keep 741 // track of more information that is computed when we try the 742 // implicit conversion initially, so that we don't need to recompute 743 // anything here. 744 QualType FromType = From->getType(); 745 746 if (SCS.CopyConstructor) { 747 // FIXME: Create a temporary object by calling the copy 748 // constructor. 749 ImpCastExprToType(From, ToType); 750 return false; 751 } 752 753 // Perform the first implicit conversion. 754 switch (SCS.First) { 755 case ICK_Identity: 756 case ICK_Lvalue_To_Rvalue: 757 // Nothing to do. 758 break; 759 760 case ICK_Array_To_Pointer: 761 if (FromType->isOverloadType()) { 762 FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType, true); 763 if (!Fn) 764 return true; 765 766 FixOverloadedFunctionReference(From, Fn); 767 FromType = From->getType(); 768 } else { 769 FromType = Context.getArrayDecayedType(FromType); 770 } 771 ImpCastExprToType(From, FromType); 772 break; 773 774 case ICK_Function_To_Pointer: 775 FromType = Context.getPointerType(FromType); 776 ImpCastExprToType(From, FromType); 777 break; 778 779 default: 780 assert(false && "Improper first standard conversion"); 781 break; 782 } 783 784 // Perform the second implicit conversion 785 switch (SCS.Second) { 786 case ICK_Identity: 787 // Nothing to do. 788 break; 789 790 case ICK_Integral_Promotion: 791 case ICK_Floating_Promotion: 792 case ICK_Integral_Conversion: 793 case ICK_Floating_Conversion: 794 case ICK_Floating_Integral: 795 FromType = ToType.getUnqualifiedType(); 796 ImpCastExprToType(From, FromType); 797 break; 798 799 case ICK_Pointer_Conversion: 800 if (SCS.IncompatibleObjC) { 801 // Diagnose incompatible Objective-C conversions 802 Diag(From->getSourceRange().getBegin(), 803 diag::ext_typecheck_convert_incompatible_pointer) 804 << From->getType() << ToType << Flavor 805 << From->getSourceRange(); 806 } 807 808 if (CheckPointerConversion(From, ToType)) 809 return true; 810 ImpCastExprToType(From, ToType); 811 break; 812 813 case ICK_Pointer_Member: 814 // FIXME: Implement pointer-to-member conversions. 815 assert(false && "Pointer-to-member conversions are unsupported"); 816 break; 817 818 case ICK_Boolean_Conversion: 819 FromType = Context.BoolTy; 820 ImpCastExprToType(From, FromType); 821 break; 822 823 default: 824 assert(false && "Improper second standard conversion"); 825 break; 826 } 827 828 switch (SCS.Third) { 829 case ICK_Identity: 830 // Nothing to do. 831 break; 832 833 case ICK_Qualification: 834 ImpCastExprToType(From, ToType); 835 break; 836 837 default: 838 assert(false && "Improper second standard conversion"); 839 break; 840 } 841 842 return false; 843} 844 845