1//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===// 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 type-related semantic analysis. 11// 12//===----------------------------------------------------------------------===// 13 14#include "TypeLocBuilder.h" 15#include "clang/AST/ASTConsumer.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/ASTMutationListener.h" 18#include "clang/AST/CXXInheritance.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/DeclTemplate.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/TypeLoc.h" 23#include "clang/AST/TypeLocVisitor.h" 24#include "clang/Basic/PartialDiagnostic.h" 25#include "clang/Basic/TargetInfo.h" 26#include "clang/Lex/Preprocessor.h" 27#include "clang/Sema/DeclSpec.h" 28#include "clang/Sema/DelayedDiagnostic.h" 29#include "clang/Sema/Lookup.h" 30#include "clang/Sema/ScopeInfo.h" 31#include "clang/Sema/SemaInternal.h" 32#include "clang/Sema/Template.h" 33#include "llvm/ADT/SmallPtrSet.h" 34#include "llvm/ADT/SmallString.h" 35#include "llvm/ADT/StringSwitch.h" 36#include "llvm/Support/ErrorHandling.h" 37 38using namespace clang; 39 40enum TypeDiagSelector { 41 TDS_Function, 42 TDS_Pointer, 43 TDS_ObjCObjOrBlock 44}; 45 46/// isOmittedBlockReturnType - Return true if this declarator is missing a 47/// return type because this is a omitted return type on a block literal. 48static bool isOmittedBlockReturnType(const Declarator &D) { 49 if (D.getContext() != Declarator::BlockLiteralContext || 50 D.getDeclSpec().hasTypeSpecifier()) 51 return false; 52 53 if (D.getNumTypeObjects() == 0) 54 return true; // ^{ ... } 55 56 if (D.getNumTypeObjects() == 1 && 57 D.getTypeObject(0).Kind == DeclaratorChunk::Function) 58 return true; // ^(int X, float Y) { ... } 59 60 return false; 61} 62 63/// diagnoseBadTypeAttribute - Diagnoses a type attribute which 64/// doesn't apply to the given type. 65static void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr, 66 QualType type) { 67 TypeDiagSelector WhichType; 68 bool useExpansionLoc = true; 69 switch (attr.getKind()) { 70 case AttributeList::AT_ObjCGC: WhichType = TDS_Pointer; break; 71 case AttributeList::AT_ObjCOwnership: WhichType = TDS_ObjCObjOrBlock; break; 72 default: 73 // Assume everything else was a function attribute. 74 WhichType = TDS_Function; 75 useExpansionLoc = false; 76 break; 77 } 78 79 SourceLocation loc = attr.getLoc(); 80 StringRef name = attr.getName()->getName(); 81 82 // The GC attributes are usually written with macros; special-case them. 83 IdentifierInfo *II = attr.isArgIdent(0) ? attr.getArgAsIdent(0)->Ident 84 : nullptr; 85 if (useExpansionLoc && loc.isMacroID() && II) { 86 if (II->isStr("strong")) { 87 if (S.findMacroSpelling(loc, "__strong")) name = "__strong"; 88 } else if (II->isStr("weak")) { 89 if (S.findMacroSpelling(loc, "__weak")) name = "__weak"; 90 } 91 } 92 93 S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType 94 << type; 95} 96 97// objc_gc applies to Objective-C pointers or, otherwise, to the 98// smallest available pointer type (i.e. 'void*' in 'void**'). 99#define OBJC_POINTER_TYPE_ATTRS_CASELIST \ 100 case AttributeList::AT_ObjCGC: \ 101 case AttributeList::AT_ObjCOwnership 102 103// Calling convention attributes. 104#define CALLING_CONV_ATTRS_CASELIST \ 105 case AttributeList::AT_CDecl: \ 106 case AttributeList::AT_FastCall: \ 107 case AttributeList::AT_StdCall: \ 108 case AttributeList::AT_ThisCall: \ 109 case AttributeList::AT_Pascal: \ 110 case AttributeList::AT_SwiftCall: \ 111 case AttributeList::AT_VectorCall: \ 112 case AttributeList::AT_MSABI: \ 113 case AttributeList::AT_SysVABI: \ 114 case AttributeList::AT_Pcs: \ 115 case AttributeList::AT_IntelOclBicc: \ 116 case AttributeList::AT_PreserveMost: \ 117 case AttributeList::AT_PreserveAll 118 119// Function type attributes. 120#define FUNCTION_TYPE_ATTRS_CASELIST \ 121 case AttributeList::AT_NoReturn: \ 122 case AttributeList::AT_Regparm: \ 123 CALLING_CONV_ATTRS_CASELIST 124 125// Microsoft-specific type qualifiers. 126#define MS_TYPE_ATTRS_CASELIST \ 127 case AttributeList::AT_Ptr32: \ 128 case AttributeList::AT_Ptr64: \ 129 case AttributeList::AT_SPtr: \ 130 case AttributeList::AT_UPtr 131 132// Nullability qualifiers. 133#define NULLABILITY_TYPE_ATTRS_CASELIST \ 134 case AttributeList::AT_TypeNonNull: \ 135 case AttributeList::AT_TypeNullable: \ 136 case AttributeList::AT_TypeNullUnspecified 137 138namespace { 139 /// An object which stores processing state for the entire 140 /// GetTypeForDeclarator process. 141 class TypeProcessingState { 142 Sema &sema; 143 144 /// The declarator being processed. 145 Declarator &declarator; 146 147 /// The index of the declarator chunk we're currently processing. 148 /// May be the total number of valid chunks, indicating the 149 /// DeclSpec. 150 unsigned chunkIndex; 151 152 /// Whether there are non-trivial modifications to the decl spec. 153 bool trivial; 154 155 /// Whether we saved the attributes in the decl spec. 156 bool hasSavedAttrs; 157 158 /// The original set of attributes on the DeclSpec. 159 SmallVector<AttributeList*, 2> savedAttrs; 160 161 /// A list of attributes to diagnose the uselessness of when the 162 /// processing is complete. 163 SmallVector<AttributeList*, 2> ignoredTypeAttrs; 164 165 public: 166 TypeProcessingState(Sema &sema, Declarator &declarator) 167 : sema(sema), declarator(declarator), 168 chunkIndex(declarator.getNumTypeObjects()), 169 trivial(true), hasSavedAttrs(false) {} 170 171 Sema &getSema() const { 172 return sema; 173 } 174 175 Declarator &getDeclarator() const { 176 return declarator; 177 } 178 179 bool isProcessingDeclSpec() const { 180 return chunkIndex == declarator.getNumTypeObjects(); 181 } 182 183 unsigned getCurrentChunkIndex() const { 184 return chunkIndex; 185 } 186 187 void setCurrentChunkIndex(unsigned idx) { 188 assert(idx <= declarator.getNumTypeObjects()); 189 chunkIndex = idx; 190 } 191 192 AttributeList *&getCurrentAttrListRef() const { 193 if (isProcessingDeclSpec()) 194 return getMutableDeclSpec().getAttributes().getListRef(); 195 return declarator.getTypeObject(chunkIndex).getAttrListRef(); 196 } 197 198 /// Save the current set of attributes on the DeclSpec. 199 void saveDeclSpecAttrs() { 200 // Don't try to save them multiple times. 201 if (hasSavedAttrs) return; 202 203 DeclSpec &spec = getMutableDeclSpec(); 204 for (AttributeList *attr = spec.getAttributes().getList(); attr; 205 attr = attr->getNext()) 206 savedAttrs.push_back(attr); 207 trivial &= savedAttrs.empty(); 208 hasSavedAttrs = true; 209 } 210 211 /// Record that we had nowhere to put the given type attribute. 212 /// We will diagnose such attributes later. 213 void addIgnoredTypeAttr(AttributeList &attr) { 214 ignoredTypeAttrs.push_back(&attr); 215 } 216 217 /// Diagnose all the ignored type attributes, given that the 218 /// declarator worked out to the given type. 219 void diagnoseIgnoredTypeAttrs(QualType type) const { 220 for (auto *Attr : ignoredTypeAttrs) 221 diagnoseBadTypeAttribute(getSema(), *Attr, type); 222 } 223 224 ~TypeProcessingState() { 225 if (trivial) return; 226 227 restoreDeclSpecAttrs(); 228 } 229 230 private: 231 DeclSpec &getMutableDeclSpec() const { 232 return const_cast<DeclSpec&>(declarator.getDeclSpec()); 233 } 234 235 void restoreDeclSpecAttrs() { 236 assert(hasSavedAttrs); 237 238 if (savedAttrs.empty()) { 239 getMutableDeclSpec().getAttributes().set(nullptr); 240 return; 241 } 242 243 getMutableDeclSpec().getAttributes().set(savedAttrs[0]); 244 for (unsigned i = 0, e = savedAttrs.size() - 1; i != e; ++i) 245 savedAttrs[i]->setNext(savedAttrs[i+1]); 246 savedAttrs.back()->setNext(nullptr); 247 } 248 }; 249} // end anonymous namespace 250 251static void spliceAttrIntoList(AttributeList &attr, AttributeList *&head) { 252 attr.setNext(head); 253 head = &attr; 254} 255 256static void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head) { 257 if (head == &attr) { 258 head = attr.getNext(); 259 return; 260 } 261 262 AttributeList *cur = head; 263 while (true) { 264 assert(cur && cur->getNext() && "ran out of attrs?"); 265 if (cur->getNext() == &attr) { 266 cur->setNext(attr.getNext()); 267 return; 268 } 269 cur = cur->getNext(); 270 } 271} 272 273static void moveAttrFromListToList(AttributeList &attr, 274 AttributeList *&fromList, 275 AttributeList *&toList) { 276 spliceAttrOutOfList(attr, fromList); 277 spliceAttrIntoList(attr, toList); 278} 279 280/// The location of a type attribute. 281enum TypeAttrLocation { 282 /// The attribute is in the decl-specifier-seq. 283 TAL_DeclSpec, 284 /// The attribute is part of a DeclaratorChunk. 285 TAL_DeclChunk, 286 /// The attribute is immediately after the declaration's name. 287 TAL_DeclName 288}; 289 290static void processTypeAttrs(TypeProcessingState &state, 291 QualType &type, TypeAttrLocation TAL, 292 AttributeList *attrs); 293 294static bool handleFunctionTypeAttr(TypeProcessingState &state, 295 AttributeList &attr, 296 QualType &type); 297 298static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, 299 AttributeList &attr, 300 QualType &type); 301 302static bool handleObjCGCTypeAttr(TypeProcessingState &state, 303 AttributeList &attr, QualType &type); 304 305static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, 306 AttributeList &attr, QualType &type); 307 308static bool handleObjCPointerTypeAttr(TypeProcessingState &state, 309 AttributeList &attr, QualType &type) { 310 if (attr.getKind() == AttributeList::AT_ObjCGC) 311 return handleObjCGCTypeAttr(state, attr, type); 312 assert(attr.getKind() == AttributeList::AT_ObjCOwnership); 313 return handleObjCOwnershipTypeAttr(state, attr, type); 314} 315 316/// Given the index of a declarator chunk, check whether that chunk 317/// directly specifies the return type of a function and, if so, find 318/// an appropriate place for it. 319/// 320/// \param i - a notional index which the search will start 321/// immediately inside 322/// 323/// \param onlyBlockPointers Whether we should only look into block 324/// pointer types (vs. all pointer types). 325static DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator, 326 unsigned i, 327 bool onlyBlockPointers) { 328 assert(i <= declarator.getNumTypeObjects()); 329 330 DeclaratorChunk *result = nullptr; 331 332 // First, look inwards past parens for a function declarator. 333 for (; i != 0; --i) { 334 DeclaratorChunk &fnChunk = declarator.getTypeObject(i-1); 335 switch (fnChunk.Kind) { 336 case DeclaratorChunk::Paren: 337 continue; 338 339 // If we find anything except a function, bail out. 340 case DeclaratorChunk::Pointer: 341 case DeclaratorChunk::BlockPointer: 342 case DeclaratorChunk::Array: 343 case DeclaratorChunk::Reference: 344 case DeclaratorChunk::MemberPointer: 345 case DeclaratorChunk::Pipe: 346 return result; 347 348 // If we do find a function declarator, scan inwards from that, 349 // looking for a (block-)pointer declarator. 350 case DeclaratorChunk::Function: 351 for (--i; i != 0; --i) { 352 DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1); 353 switch (ptrChunk.Kind) { 354 case DeclaratorChunk::Paren: 355 case DeclaratorChunk::Array: 356 case DeclaratorChunk::Function: 357 case DeclaratorChunk::Reference: 358 case DeclaratorChunk::Pipe: 359 continue; 360 361 case DeclaratorChunk::MemberPointer: 362 case DeclaratorChunk::Pointer: 363 if (onlyBlockPointers) 364 continue; 365 366 // fallthrough 367 368 case DeclaratorChunk::BlockPointer: 369 result = &ptrChunk; 370 goto continue_outer; 371 } 372 llvm_unreachable("bad declarator chunk kind"); 373 } 374 375 // If we run out of declarators doing that, we're done. 376 return result; 377 } 378 llvm_unreachable("bad declarator chunk kind"); 379 380 // Okay, reconsider from our new point. 381 continue_outer: ; 382 } 383 384 // Ran out of chunks, bail out. 385 return result; 386} 387 388/// Given that an objc_gc attribute was written somewhere on a 389/// declaration *other* than on the declarator itself (for which, use 390/// distributeObjCPointerTypeAttrFromDeclarator), and given that it 391/// didn't apply in whatever position it was written in, try to move 392/// it to a more appropriate position. 393static void distributeObjCPointerTypeAttr(TypeProcessingState &state, 394 AttributeList &attr, 395 QualType type) { 396 Declarator &declarator = state.getDeclarator(); 397 398 // Move it to the outermost normal or block pointer declarator. 399 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 400 DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 401 switch (chunk.Kind) { 402 case DeclaratorChunk::Pointer: 403 case DeclaratorChunk::BlockPointer: { 404 // But don't move an ARC ownership attribute to the return type 405 // of a block. 406 DeclaratorChunk *destChunk = nullptr; 407 if (state.isProcessingDeclSpec() && 408 attr.getKind() == AttributeList::AT_ObjCOwnership) 409 destChunk = maybeMovePastReturnType(declarator, i - 1, 410 /*onlyBlockPointers=*/true); 411 if (!destChunk) destChunk = &chunk; 412 413 moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 414 destChunk->getAttrListRef()); 415 return; 416 } 417 418 case DeclaratorChunk::Paren: 419 case DeclaratorChunk::Array: 420 continue; 421 422 // We may be starting at the return type of a block. 423 case DeclaratorChunk::Function: 424 if (state.isProcessingDeclSpec() && 425 attr.getKind() == AttributeList::AT_ObjCOwnership) { 426 if (DeclaratorChunk *dest = maybeMovePastReturnType( 427 declarator, i, 428 /*onlyBlockPointers=*/true)) { 429 moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 430 dest->getAttrListRef()); 431 return; 432 } 433 } 434 goto error; 435 436 // Don't walk through these. 437 case DeclaratorChunk::Reference: 438 case DeclaratorChunk::MemberPointer: 439 case DeclaratorChunk::Pipe: 440 goto error; 441 } 442 } 443 error: 444 445 diagnoseBadTypeAttribute(state.getSema(), attr, type); 446} 447 448/// Distribute an objc_gc type attribute that was written on the 449/// declarator. 450static void 451distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, 452 AttributeList &attr, 453 QualType &declSpecType) { 454 Declarator &declarator = state.getDeclarator(); 455 456 // objc_gc goes on the innermost pointer to something that's not a 457 // pointer. 458 unsigned innermost = -1U; 459 bool considerDeclSpec = true; 460 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 461 DeclaratorChunk &chunk = declarator.getTypeObject(i); 462 switch (chunk.Kind) { 463 case DeclaratorChunk::Pointer: 464 case DeclaratorChunk::BlockPointer: 465 innermost = i; 466 continue; 467 468 case DeclaratorChunk::Reference: 469 case DeclaratorChunk::MemberPointer: 470 case DeclaratorChunk::Paren: 471 case DeclaratorChunk::Array: 472 case DeclaratorChunk::Pipe: 473 continue; 474 475 case DeclaratorChunk::Function: 476 considerDeclSpec = false; 477 goto done; 478 } 479 } 480 done: 481 482 // That might actually be the decl spec if we weren't blocked by 483 // anything in the declarator. 484 if (considerDeclSpec) { 485 if (handleObjCPointerTypeAttr(state, attr, declSpecType)) { 486 // Splice the attribute into the decl spec. Prevents the 487 // attribute from being applied multiple times and gives 488 // the source-location-filler something to work with. 489 state.saveDeclSpecAttrs(); 490 moveAttrFromListToList(attr, declarator.getAttrListRef(), 491 declarator.getMutableDeclSpec().getAttributes().getListRef()); 492 return; 493 } 494 } 495 496 // Otherwise, if we found an appropriate chunk, splice the attribute 497 // into it. 498 if (innermost != -1U) { 499 moveAttrFromListToList(attr, declarator.getAttrListRef(), 500 declarator.getTypeObject(innermost).getAttrListRef()); 501 return; 502 } 503 504 // Otherwise, diagnose when we're done building the type. 505 spliceAttrOutOfList(attr, declarator.getAttrListRef()); 506 state.addIgnoredTypeAttr(attr); 507} 508 509/// A function type attribute was written somewhere in a declaration 510/// *other* than on the declarator itself or in the decl spec. Given 511/// that it didn't apply in whatever position it was written in, try 512/// to move it to a more appropriate position. 513static void distributeFunctionTypeAttr(TypeProcessingState &state, 514 AttributeList &attr, 515 QualType type) { 516 Declarator &declarator = state.getDeclarator(); 517 518 // Try to push the attribute from the return type of a function to 519 // the function itself. 520 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 521 DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 522 switch (chunk.Kind) { 523 case DeclaratorChunk::Function: 524 moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 525 chunk.getAttrListRef()); 526 return; 527 528 case DeclaratorChunk::Paren: 529 case DeclaratorChunk::Pointer: 530 case DeclaratorChunk::BlockPointer: 531 case DeclaratorChunk::Array: 532 case DeclaratorChunk::Reference: 533 case DeclaratorChunk::MemberPointer: 534 case DeclaratorChunk::Pipe: 535 continue; 536 } 537 } 538 539 diagnoseBadTypeAttribute(state.getSema(), attr, type); 540} 541 542/// Try to distribute a function type attribute to the innermost 543/// function chunk or type. Returns true if the attribute was 544/// distributed, false if no location was found. 545static bool 546distributeFunctionTypeAttrToInnermost(TypeProcessingState &state, 547 AttributeList &attr, 548 AttributeList *&attrList, 549 QualType &declSpecType) { 550 Declarator &declarator = state.getDeclarator(); 551 552 // Put it on the innermost function chunk, if there is one. 553 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 554 DeclaratorChunk &chunk = declarator.getTypeObject(i); 555 if (chunk.Kind != DeclaratorChunk::Function) continue; 556 557 moveAttrFromListToList(attr, attrList, chunk.getAttrListRef()); 558 return true; 559 } 560 561 return handleFunctionTypeAttr(state, attr, declSpecType); 562} 563 564/// A function type attribute was written in the decl spec. Try to 565/// apply it somewhere. 566static void 567distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, 568 AttributeList &attr, 569 QualType &declSpecType) { 570 state.saveDeclSpecAttrs(); 571 572 // C++11 attributes before the decl specifiers actually appertain to 573 // the declarators. Move them straight there. We don't support the 574 // 'put them wherever you like' semantics we allow for GNU attributes. 575 if (attr.isCXX11Attribute()) { 576 moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 577 state.getDeclarator().getAttrListRef()); 578 return; 579 } 580 581 // Try to distribute to the innermost. 582 if (distributeFunctionTypeAttrToInnermost(state, attr, 583 state.getCurrentAttrListRef(), 584 declSpecType)) 585 return; 586 587 // If that failed, diagnose the bad attribute when the declarator is 588 // fully built. 589 state.addIgnoredTypeAttr(attr); 590} 591 592/// A function type attribute was written on the declarator. Try to 593/// apply it somewhere. 594static void 595distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, 596 AttributeList &attr, 597 QualType &declSpecType) { 598 Declarator &declarator = state.getDeclarator(); 599 600 // Try to distribute to the innermost. 601 if (distributeFunctionTypeAttrToInnermost(state, attr, 602 declarator.getAttrListRef(), 603 declSpecType)) 604 return; 605 606 // If that failed, diagnose the bad attribute when the declarator is 607 // fully built. 608 spliceAttrOutOfList(attr, declarator.getAttrListRef()); 609 state.addIgnoredTypeAttr(attr); 610} 611 612/// \brief Given that there are attributes written on the declarator 613/// itself, try to distribute any type attributes to the appropriate 614/// declarator chunk. 615/// 616/// These are attributes like the following: 617/// int f ATTR; 618/// int (f ATTR)(); 619/// but not necessarily this: 620/// int f() ATTR; 621static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, 622 QualType &declSpecType) { 623 // Collect all the type attributes from the declarator itself. 624 assert(state.getDeclarator().getAttributes() && "declarator has no attrs!"); 625 AttributeList *attr = state.getDeclarator().getAttributes(); 626 AttributeList *next; 627 do { 628 next = attr->getNext(); 629 630 // Do not distribute C++11 attributes. They have strict rules for what 631 // they appertain to. 632 if (attr->isCXX11Attribute()) 633 continue; 634 635 switch (attr->getKind()) { 636 OBJC_POINTER_TYPE_ATTRS_CASELIST: 637 distributeObjCPointerTypeAttrFromDeclarator(state, *attr, declSpecType); 638 break; 639 640 case AttributeList::AT_NSReturnsRetained: 641 if (!state.getSema().getLangOpts().ObjCAutoRefCount) 642 break; 643 // fallthrough 644 645 FUNCTION_TYPE_ATTRS_CASELIST: 646 distributeFunctionTypeAttrFromDeclarator(state, *attr, declSpecType); 647 break; 648 649 MS_TYPE_ATTRS_CASELIST: 650 // Microsoft type attributes cannot go after the declarator-id. 651 continue; 652 653 NULLABILITY_TYPE_ATTRS_CASELIST: 654 // Nullability specifiers cannot go after the declarator-id. 655 656 // Objective-C __kindof does not get distributed. 657 case AttributeList::AT_ObjCKindOf: 658 continue; 659 660 default: 661 break; 662 } 663 } while ((attr = next)); 664} 665 666/// Add a synthetic '()' to a block-literal declarator if it is 667/// required, given the return type. 668static void maybeSynthesizeBlockSignature(TypeProcessingState &state, 669 QualType declSpecType) { 670 Declarator &declarator = state.getDeclarator(); 671 672 // First, check whether the declarator would produce a function, 673 // i.e. whether the innermost semantic chunk is a function. 674 if (declarator.isFunctionDeclarator()) { 675 // If so, make that declarator a prototyped declarator. 676 declarator.getFunctionTypeInfo().hasPrototype = true; 677 return; 678 } 679 680 // If there are any type objects, the type as written won't name a 681 // function, regardless of the decl spec type. This is because a 682 // block signature declarator is always an abstract-declarator, and 683 // abstract-declarators can't just be parentheses chunks. Therefore 684 // we need to build a function chunk unless there are no type 685 // objects and the decl spec type is a function. 686 if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType()) 687 return; 688 689 // Note that there *are* cases with invalid declarators where 690 // declarators consist solely of parentheses. In general, these 691 // occur only in failed efforts to make function declarators, so 692 // faking up the function chunk is still the right thing to do. 693 694 // Otherwise, we need to fake up a function declarator. 695 SourceLocation loc = declarator.getLocStart(); 696 697 // ...and *prepend* it to the declarator. 698 SourceLocation NoLoc; 699 declarator.AddInnermostTypeInfo(DeclaratorChunk::getFunction( 700 /*HasProto=*/true, 701 /*IsAmbiguous=*/false, 702 /*LParenLoc=*/NoLoc, 703 /*ArgInfo=*/nullptr, 704 /*NumArgs=*/0, 705 /*EllipsisLoc=*/NoLoc, 706 /*RParenLoc=*/NoLoc, 707 /*TypeQuals=*/0, 708 /*RefQualifierIsLvalueRef=*/true, 709 /*RefQualifierLoc=*/NoLoc, 710 /*ConstQualifierLoc=*/NoLoc, 711 /*VolatileQualifierLoc=*/NoLoc, 712 /*RestrictQualifierLoc=*/NoLoc, 713 /*MutableLoc=*/NoLoc, EST_None, 714 /*ESpecRange=*/SourceRange(), 715 /*Exceptions=*/nullptr, 716 /*ExceptionRanges=*/nullptr, 717 /*NumExceptions=*/0, 718 /*NoexceptExpr=*/nullptr, 719 /*ExceptionSpecTokens=*/nullptr, 720 loc, loc, declarator)); 721 722 // For consistency, make sure the state still has us as processing 723 // the decl spec. 724 assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1); 725 state.setCurrentChunkIndex(declarator.getNumTypeObjects()); 726} 727 728static void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, 729 unsigned &TypeQuals, 730 QualType TypeSoFar, 731 unsigned RemoveTQs, 732 unsigned DiagID) { 733 // If this occurs outside a template instantiation, warn the user about 734 // it; they probably didn't mean to specify a redundant qualifier. 735 typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc; 736 for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()), 737 QualLoc(DeclSpec::TQ_restrict, DS.getRestrictSpecLoc()), 738 QualLoc(DeclSpec::TQ_volatile, DS.getVolatileSpecLoc()), 739 QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) { 740 if (!(RemoveTQs & Qual.first)) 741 continue; 742 743 if (S.ActiveTemplateInstantiations.empty()) { 744 if (TypeQuals & Qual.first) 745 S.Diag(Qual.second, DiagID) 746 << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar 747 << FixItHint::CreateRemoval(Qual.second); 748 } 749 750 TypeQuals &= ~Qual.first; 751 } 752} 753 754/// Return true if this is omitted block return type. Also check type 755/// attributes and type qualifiers when returning true. 756static bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, 757 QualType Result) { 758 if (!isOmittedBlockReturnType(declarator)) 759 return false; 760 761 // Warn if we see type attributes for omitted return type on a block literal. 762 AttributeList *&attrs = 763 declarator.getMutableDeclSpec().getAttributes().getListRef(); 764 AttributeList *prev = nullptr; 765 for (AttributeList *cur = attrs; cur; cur = cur->getNext()) { 766 AttributeList &attr = *cur; 767 // Skip attributes that were marked to be invalid or non-type 768 // attributes. 769 if (attr.isInvalid() || !attr.isTypeAttr()) { 770 prev = cur; 771 continue; 772 } 773 S.Diag(attr.getLoc(), 774 diag::warn_block_literal_attributes_on_omitted_return_type) 775 << attr.getName(); 776 // Remove cur from the list. 777 if (prev) { 778 prev->setNext(cur->getNext()); 779 prev = cur; 780 } else { 781 attrs = cur->getNext(); 782 } 783 } 784 785 // Warn if we see type qualifiers for omitted return type on a block literal. 786 const DeclSpec &DS = declarator.getDeclSpec(); 787 unsigned TypeQuals = DS.getTypeQualifiers(); 788 diagnoseAndRemoveTypeQualifiers(S, DS, TypeQuals, Result, (unsigned)-1, 789 diag::warn_block_literal_qualifiers_on_omitted_return_type); 790 declarator.getMutableDeclSpec().ClearTypeQualifiers(); 791 792 return true; 793} 794 795/// Apply Objective-C type arguments to the given type. 796static QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type, 797 ArrayRef<TypeSourceInfo *> typeArgs, 798 SourceRange typeArgsRange, 799 bool failOnError = false) { 800 // We can only apply type arguments to an Objective-C class type. 801 const auto *objcObjectType = type->getAs<ObjCObjectType>(); 802 if (!objcObjectType || !objcObjectType->getInterface()) { 803 S.Diag(loc, diag::err_objc_type_args_non_class) 804 << type 805 << typeArgsRange; 806 807 if (failOnError) 808 return QualType(); 809 return type; 810 } 811 812 // The class type must be parameterized. 813 ObjCInterfaceDecl *objcClass = objcObjectType->getInterface(); 814 ObjCTypeParamList *typeParams = objcClass->getTypeParamList(); 815 if (!typeParams) { 816 S.Diag(loc, diag::err_objc_type_args_non_parameterized_class) 817 << objcClass->getDeclName() 818 << FixItHint::CreateRemoval(typeArgsRange); 819 820 if (failOnError) 821 return QualType(); 822 823 return type; 824 } 825 826 // The type must not already be specialized. 827 if (objcObjectType->isSpecialized()) { 828 S.Diag(loc, diag::err_objc_type_args_specialized_class) 829 << type 830 << FixItHint::CreateRemoval(typeArgsRange); 831 832 if (failOnError) 833 return QualType(); 834 835 return type; 836 } 837 838 // Check the type arguments. 839 SmallVector<QualType, 4> finalTypeArgs; 840 unsigned numTypeParams = typeParams->size(); 841 bool anyPackExpansions = false; 842 for (unsigned i = 0, n = typeArgs.size(); i != n; ++i) { 843 TypeSourceInfo *typeArgInfo = typeArgs[i]; 844 QualType typeArg = typeArgInfo->getType(); 845 846 // Type arguments cannot have explicit qualifiers or nullability. 847 // We ignore indirect sources of these, e.g. behind typedefs or 848 // template arguments. 849 if (TypeLoc qual = typeArgInfo->getTypeLoc().findExplicitQualifierLoc()) { 850 bool diagnosed = false; 851 SourceRange rangeToRemove; 852 if (auto attr = qual.getAs<AttributedTypeLoc>()) { 853 rangeToRemove = attr.getLocalSourceRange(); 854 if (attr.getTypePtr()->getImmediateNullability()) { 855 typeArg = attr.getTypePtr()->getModifiedType(); 856 S.Diag(attr.getLocStart(), 857 diag::err_objc_type_arg_explicit_nullability) 858 << typeArg << FixItHint::CreateRemoval(rangeToRemove); 859 diagnosed = true; 860 } 861 } 862 863 if (!diagnosed) { 864 S.Diag(qual.getLocStart(), diag::err_objc_type_arg_qualified) 865 << typeArg << typeArg.getQualifiers().getAsString() 866 << FixItHint::CreateRemoval(rangeToRemove); 867 } 868 } 869 870 // Remove qualifiers even if they're non-local. 871 typeArg = typeArg.getUnqualifiedType(); 872 873 finalTypeArgs.push_back(typeArg); 874 875 if (typeArg->getAs<PackExpansionType>()) 876 anyPackExpansions = true; 877 878 // Find the corresponding type parameter, if there is one. 879 ObjCTypeParamDecl *typeParam = nullptr; 880 if (!anyPackExpansions) { 881 if (i < numTypeParams) { 882 typeParam = typeParams->begin()[i]; 883 } else { 884 // Too many arguments. 885 S.Diag(loc, diag::err_objc_type_args_wrong_arity) 886 << false 887 << objcClass->getDeclName() 888 << (unsigned)typeArgs.size() 889 << numTypeParams; 890 S.Diag(objcClass->getLocation(), diag::note_previous_decl) 891 << objcClass; 892 893 if (failOnError) 894 return QualType(); 895 896 return type; 897 } 898 } 899 900 // Objective-C object pointer types must be substitutable for the bounds. 901 if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) { 902 // If we don't have a type parameter to match against, assume 903 // everything is fine. There was a prior pack expansion that 904 // means we won't be able to match anything. 905 if (!typeParam) { 906 assert(anyPackExpansions && "Too many arguments?"); 907 continue; 908 } 909 910 // Retrieve the bound. 911 QualType bound = typeParam->getUnderlyingType(); 912 const auto *boundObjC = bound->getAs<ObjCObjectPointerType>(); 913 914 // Determine whether the type argument is substitutable for the bound. 915 if (typeArgObjC->isObjCIdType()) { 916 // When the type argument is 'id', the only acceptable type 917 // parameter bound is 'id'. 918 if (boundObjC->isObjCIdType()) 919 continue; 920 } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) { 921 // Otherwise, we follow the assignability rules. 922 continue; 923 } 924 925 // Diagnose the mismatch. 926 S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 927 diag::err_objc_type_arg_does_not_match_bound) 928 << typeArg << bound << typeParam->getDeclName(); 929 S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here) 930 << typeParam->getDeclName(); 931 932 if (failOnError) 933 return QualType(); 934 935 return type; 936 } 937 938 // Block pointer types are permitted for unqualified 'id' bounds. 939 if (typeArg->isBlockPointerType()) { 940 // If we don't have a type parameter to match against, assume 941 // everything is fine. There was a prior pack expansion that 942 // means we won't be able to match anything. 943 if (!typeParam) { 944 assert(anyPackExpansions && "Too many arguments?"); 945 continue; 946 } 947 948 // Retrieve the bound. 949 QualType bound = typeParam->getUnderlyingType(); 950 if (bound->isBlockCompatibleObjCPointerType(S.Context)) 951 continue; 952 953 // Diagnose the mismatch. 954 S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 955 diag::err_objc_type_arg_does_not_match_bound) 956 << typeArg << bound << typeParam->getDeclName(); 957 S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here) 958 << typeParam->getDeclName(); 959 960 if (failOnError) 961 return QualType(); 962 963 return type; 964 } 965 966 // Dependent types will be checked at instantiation time. 967 if (typeArg->isDependentType()) { 968 continue; 969 } 970 971 // Diagnose non-id-compatible type arguments. 972 S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 973 diag::err_objc_type_arg_not_id_compatible) 974 << typeArg 975 << typeArgInfo->getTypeLoc().getSourceRange(); 976 977 if (failOnError) 978 return QualType(); 979 980 return type; 981 } 982 983 // Make sure we didn't have the wrong number of arguments. 984 if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) { 985 S.Diag(loc, diag::err_objc_type_args_wrong_arity) 986 << (typeArgs.size() < typeParams->size()) 987 << objcClass->getDeclName() 988 << (unsigned)finalTypeArgs.size() 989 << (unsigned)numTypeParams; 990 S.Diag(objcClass->getLocation(), diag::note_previous_decl) 991 << objcClass; 992 993 if (failOnError) 994 return QualType(); 995 996 return type; 997 } 998 999 // Success. Form the specialized type. 1000 return S.Context.getObjCObjectType(type, finalTypeArgs, { }, false); 1001} 1002 1003/// Apply Objective-C protocol qualifiers to the given type. 1004static QualType applyObjCProtocolQualifiers( 1005 Sema &S, SourceLocation loc, SourceRange range, QualType type, 1006 ArrayRef<ObjCProtocolDecl *> protocols, 1007 const SourceLocation *protocolLocs, 1008 bool failOnError = false) { 1009 ASTContext &ctx = S.Context; 1010 if (const ObjCObjectType *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){ 1011 // FIXME: Check for protocols to which the class type is already 1012 // known to conform. 1013 1014 return ctx.getObjCObjectType(objT->getBaseType(), 1015 objT->getTypeArgsAsWritten(), 1016 protocols, 1017 objT->isKindOfTypeAsWritten()); 1018 } 1019 1020 if (type->isObjCObjectType()) { 1021 // Silently overwrite any existing protocol qualifiers. 1022 // TODO: determine whether that's the right thing to do. 1023 1024 // FIXME: Check for protocols to which the class type is already 1025 // known to conform. 1026 return ctx.getObjCObjectType(type, { }, protocols, false); 1027 } 1028 1029 // id<protocol-list> 1030 if (type->isObjCIdType()) { 1031 const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>(); 1032 type = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, { }, protocols, 1033 objPtr->isKindOfType()); 1034 return ctx.getObjCObjectPointerType(type); 1035 } 1036 1037 // Class<protocol-list> 1038 if (type->isObjCClassType()) { 1039 const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>(); 1040 type = ctx.getObjCObjectType(ctx.ObjCBuiltinClassTy, { }, protocols, 1041 objPtr->isKindOfType()); 1042 return ctx.getObjCObjectPointerType(type); 1043 } 1044 1045 S.Diag(loc, diag::err_invalid_protocol_qualifiers) 1046 << range; 1047 1048 if (failOnError) 1049 return QualType(); 1050 1051 return type; 1052} 1053 1054QualType Sema::BuildObjCObjectType(QualType BaseType, 1055 SourceLocation Loc, 1056 SourceLocation TypeArgsLAngleLoc, 1057 ArrayRef<TypeSourceInfo *> TypeArgs, 1058 SourceLocation TypeArgsRAngleLoc, 1059 SourceLocation ProtocolLAngleLoc, 1060 ArrayRef<ObjCProtocolDecl *> Protocols, 1061 ArrayRef<SourceLocation> ProtocolLocs, 1062 SourceLocation ProtocolRAngleLoc, 1063 bool FailOnError) { 1064 QualType Result = BaseType; 1065 if (!TypeArgs.empty()) { 1066 Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs, 1067 SourceRange(TypeArgsLAngleLoc, 1068 TypeArgsRAngleLoc), 1069 FailOnError); 1070 if (FailOnError && Result.isNull()) 1071 return QualType(); 1072 } 1073 1074 if (!Protocols.empty()) { 1075 Result = applyObjCProtocolQualifiers(*this, Loc, 1076 SourceRange(ProtocolLAngleLoc, 1077 ProtocolRAngleLoc), 1078 Result, Protocols, 1079 ProtocolLocs.data(), 1080 FailOnError); 1081 if (FailOnError && Result.isNull()) 1082 return QualType(); 1083 } 1084 1085 return Result; 1086} 1087 1088TypeResult Sema::actOnObjCProtocolQualifierType( 1089 SourceLocation lAngleLoc, 1090 ArrayRef<Decl *> protocols, 1091 ArrayRef<SourceLocation> protocolLocs, 1092 SourceLocation rAngleLoc) { 1093 // Form id<protocol-list>. 1094 QualType Result = Context.getObjCObjectType( 1095 Context.ObjCBuiltinIdTy, { }, 1096 llvm::makeArrayRef( 1097 (ObjCProtocolDecl * const *)protocols.data(), 1098 protocols.size()), 1099 false); 1100 Result = Context.getObjCObjectPointerType(Result); 1101 1102 TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result); 1103 TypeLoc ResultTL = ResultTInfo->getTypeLoc(); 1104 1105 auto ObjCObjectPointerTL = ResultTL.castAs<ObjCObjectPointerTypeLoc>(); 1106 ObjCObjectPointerTL.setStarLoc(SourceLocation()); // implicit 1107 1108 auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc() 1109 .castAs<ObjCObjectTypeLoc>(); 1110 ObjCObjectTL.setHasBaseTypeAsWritten(false); 1111 ObjCObjectTL.getBaseLoc().initialize(Context, SourceLocation()); 1112 1113 // No type arguments. 1114 ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation()); 1115 ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation()); 1116 1117 // Fill in protocol qualifiers. 1118 ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc); 1119 ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc); 1120 for (unsigned i = 0, n = protocols.size(); i != n; ++i) 1121 ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]); 1122 1123 // We're done. Return the completed type to the parser. 1124 return CreateParsedType(Result, ResultTInfo); 1125} 1126 1127TypeResult Sema::actOnObjCTypeArgsAndProtocolQualifiers( 1128 Scope *S, 1129 SourceLocation Loc, 1130 ParsedType BaseType, 1131 SourceLocation TypeArgsLAngleLoc, 1132 ArrayRef<ParsedType> TypeArgs, 1133 SourceLocation TypeArgsRAngleLoc, 1134 SourceLocation ProtocolLAngleLoc, 1135 ArrayRef<Decl *> Protocols, 1136 ArrayRef<SourceLocation> ProtocolLocs, 1137 SourceLocation ProtocolRAngleLoc) { 1138 TypeSourceInfo *BaseTypeInfo = nullptr; 1139 QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo); 1140 if (T.isNull()) 1141 return true; 1142 1143 // Handle missing type-source info. 1144 if (!BaseTypeInfo) 1145 BaseTypeInfo = Context.getTrivialTypeSourceInfo(T, Loc); 1146 1147 // Extract type arguments. 1148 SmallVector<TypeSourceInfo *, 4> ActualTypeArgInfos; 1149 for (unsigned i = 0, n = TypeArgs.size(); i != n; ++i) { 1150 TypeSourceInfo *TypeArgInfo = nullptr; 1151 QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo); 1152 if (TypeArg.isNull()) { 1153 ActualTypeArgInfos.clear(); 1154 break; 1155 } 1156 1157 assert(TypeArgInfo && "No type source info?"); 1158 ActualTypeArgInfos.push_back(TypeArgInfo); 1159 } 1160 1161 // Build the object type. 1162 QualType Result = BuildObjCObjectType( 1163 T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(), 1164 TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc, 1165 ProtocolLAngleLoc, 1166 llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(), 1167 Protocols.size()), 1168 ProtocolLocs, ProtocolRAngleLoc, 1169 /*FailOnError=*/false); 1170 1171 if (Result == T) 1172 return BaseType; 1173 1174 // Create source information for this type. 1175 TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result); 1176 TypeLoc ResultTL = ResultTInfo->getTypeLoc(); 1177 1178 // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an 1179 // object pointer type. Fill in source information for it. 1180 if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) { 1181 // The '*' is implicit. 1182 ObjCObjectPointerTL.setStarLoc(SourceLocation()); 1183 ResultTL = ObjCObjectPointerTL.getPointeeLoc(); 1184 } 1185 1186 auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>(); 1187 1188 // Type argument information. 1189 if (ObjCObjectTL.getNumTypeArgs() > 0) { 1190 assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size()); 1191 ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc); 1192 ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc); 1193 for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i) 1194 ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]); 1195 } else { 1196 ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation()); 1197 ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation()); 1198 } 1199 1200 // Protocol qualifier information. 1201 if (ObjCObjectTL.getNumProtocols() > 0) { 1202 assert(ObjCObjectTL.getNumProtocols() == Protocols.size()); 1203 ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc); 1204 ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc); 1205 for (unsigned i = 0, n = Protocols.size(); i != n; ++i) 1206 ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]); 1207 } else { 1208 ObjCObjectTL.setProtocolLAngleLoc(SourceLocation()); 1209 ObjCObjectTL.setProtocolRAngleLoc(SourceLocation()); 1210 } 1211 1212 // Base type. 1213 ObjCObjectTL.setHasBaseTypeAsWritten(true); 1214 if (ObjCObjectTL.getType() == T) 1215 ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->getTypeLoc()); 1216 else 1217 ObjCObjectTL.getBaseLoc().initialize(Context, Loc); 1218 1219 // We're done. Return the completed type to the parser. 1220 return CreateParsedType(Result, ResultTInfo); 1221} 1222 1223static StringRef getImageAccessAttrStr(AttributeList *attrs) { 1224 if (attrs) { 1225 1226 AttributeList *Next; 1227 do { 1228 AttributeList &Attr = *attrs; 1229 Next = Attr.getNext(); 1230 if (Attr.getKind() == AttributeList::AT_OpenCLAccess) { 1231 return Attr.getName()->getName(); 1232 } 1233 } while (Next); 1234 } 1235 return ""; 1236} 1237 1238/// \brief Convert the specified declspec to the appropriate type 1239/// object. 1240/// \param state Specifies the declarator containing the declaration specifier 1241/// to be converted, along with other associated processing state. 1242/// \returns The type described by the declaration specifiers. This function 1243/// never returns null. 1244static QualType ConvertDeclSpecToType(TypeProcessingState &state) { 1245 // FIXME: Should move the logic from DeclSpec::Finish to here for validity 1246 // checking. 1247 1248 Sema &S = state.getSema(); 1249 Declarator &declarator = state.getDeclarator(); 1250 const DeclSpec &DS = declarator.getDeclSpec(); 1251 SourceLocation DeclLoc = declarator.getIdentifierLoc(); 1252 if (DeclLoc.isInvalid()) 1253 DeclLoc = DS.getLocStart(); 1254 1255 ASTContext &Context = S.Context; 1256 1257 QualType Result; 1258 switch (DS.getTypeSpecType()) { 1259 case DeclSpec::TST_void: 1260 Result = Context.VoidTy; 1261 break; 1262 case DeclSpec::TST_char: 1263 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 1264 Result = Context.CharTy; 1265 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) 1266 Result = Context.SignedCharTy; 1267 else { 1268 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 1269 "Unknown TSS value"); 1270 Result = Context.UnsignedCharTy; 1271 } 1272 break; 1273 case DeclSpec::TST_wchar: 1274 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 1275 Result = Context.WCharTy; 1276 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) { 1277 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 1278 << DS.getSpecifierName(DS.getTypeSpecType(), 1279 Context.getPrintingPolicy()); 1280 Result = Context.getSignedWCharType(); 1281 } else { 1282 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 1283 "Unknown TSS value"); 1284 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 1285 << DS.getSpecifierName(DS.getTypeSpecType(), 1286 Context.getPrintingPolicy()); 1287 Result = Context.getUnsignedWCharType(); 1288 } 1289 break; 1290 case DeclSpec::TST_char16: 1291 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 1292 "Unknown TSS value"); 1293 Result = Context.Char16Ty; 1294 break; 1295 case DeclSpec::TST_char32: 1296 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 1297 "Unknown TSS value"); 1298 Result = Context.Char32Ty; 1299 break; 1300 case DeclSpec::TST_unspecified: 1301 // If this is a missing declspec in a block literal return context, then it 1302 // is inferred from the return statements inside the block. 1303 // The declspec is always missing in a lambda expr context; it is either 1304 // specified with a trailing return type or inferred. 1305 if (S.getLangOpts().CPlusPlus14 && 1306 declarator.getContext() == Declarator::LambdaExprContext) { 1307 // In C++1y, a lambda's implicit return type is 'auto'. 1308 Result = Context.getAutoDeductType(); 1309 break; 1310 } else if (declarator.getContext() == Declarator::LambdaExprContext || 1311 checkOmittedBlockReturnType(S, declarator, 1312 Context.DependentTy)) { 1313 Result = Context.DependentTy; 1314 break; 1315 } 1316 1317 // Unspecified typespec defaults to int in C90. However, the C90 grammar 1318 // [C90 6.5] only allows a decl-spec if there was *some* type-specifier, 1319 // type-qualifier, or storage-class-specifier. If not, emit an extwarn. 1320 // Note that the one exception to this is function definitions, which are 1321 // allowed to be completely missing a declspec. This is handled in the 1322 // parser already though by it pretending to have seen an 'int' in this 1323 // case. 1324 if (S.getLangOpts().ImplicitInt) { 1325 // In C89 mode, we only warn if there is a completely missing declspec 1326 // when one is not allowed. 1327 if (DS.isEmpty()) { 1328 S.Diag(DeclLoc, diag::ext_missing_declspec) 1329 << DS.getSourceRange() 1330 << FixItHint::CreateInsertion(DS.getLocStart(), "int"); 1331 } 1332 } else if (!DS.hasTypeSpecifier()) { 1333 // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says: 1334 // "At least one type specifier shall be given in the declaration 1335 // specifiers in each declaration, and in the specifier-qualifier list in 1336 // each struct declaration and type name." 1337 if (S.getLangOpts().CPlusPlus) { 1338 S.Diag(DeclLoc, diag::err_missing_type_specifier) 1339 << DS.getSourceRange(); 1340 1341 // When this occurs in C++ code, often something is very broken with the 1342 // value being declared, poison it as invalid so we don't get chains of 1343 // errors. 1344 declarator.setInvalidType(true); 1345 } else if (S.getLangOpts().OpenCLVersion >= 200 && DS.isTypeSpecPipe()){ 1346 S.Diag(DeclLoc, diag::err_missing_actual_pipe_type) 1347 << DS.getSourceRange(); 1348 declarator.setInvalidType(true); 1349 } else { 1350 S.Diag(DeclLoc, diag::ext_missing_type_specifier) 1351 << DS.getSourceRange(); 1352 } 1353 } 1354 1355 // FALL THROUGH. 1356 case DeclSpec::TST_int: { 1357 if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) { 1358 switch (DS.getTypeSpecWidth()) { 1359 case DeclSpec::TSW_unspecified: Result = Context.IntTy; break; 1360 case DeclSpec::TSW_short: Result = Context.ShortTy; break; 1361 case DeclSpec::TSW_long: Result = Context.LongTy; break; 1362 case DeclSpec::TSW_longlong: 1363 Result = Context.LongLongTy; 1364 1365 // 'long long' is a C99 or C++11 feature. 1366 if (!S.getLangOpts().C99) { 1367 if (S.getLangOpts().CPlusPlus) 1368 S.Diag(DS.getTypeSpecWidthLoc(), 1369 S.getLangOpts().CPlusPlus11 ? 1370 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 1371 else 1372 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong); 1373 } 1374 break; 1375 } 1376 } else { 1377 switch (DS.getTypeSpecWidth()) { 1378 case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break; 1379 case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break; 1380 case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break; 1381 case DeclSpec::TSW_longlong: 1382 Result = Context.UnsignedLongLongTy; 1383 1384 // 'long long' is a C99 or C++11 feature. 1385 if (!S.getLangOpts().C99) { 1386 if (S.getLangOpts().CPlusPlus) 1387 S.Diag(DS.getTypeSpecWidthLoc(), 1388 S.getLangOpts().CPlusPlus11 ? 1389 diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 1390 else 1391 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong); 1392 } 1393 break; 1394 } 1395 } 1396 break; 1397 } 1398 case DeclSpec::TST_int128: 1399 if (!S.Context.getTargetInfo().hasInt128Type()) 1400 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported) 1401 << "__int128"; 1402 if (DS.getTypeSpecSign() == DeclSpec::TSS_unsigned) 1403 Result = Context.UnsignedInt128Ty; 1404 else 1405 Result = Context.Int128Ty; 1406 break; 1407 case DeclSpec::TST_half: Result = Context.HalfTy; break; 1408 case DeclSpec::TST_float: Result = Context.FloatTy; break; 1409 case DeclSpec::TST_double: 1410 if (DS.getTypeSpecWidth() == DeclSpec::TSW_long) 1411 Result = Context.LongDoubleTy; 1412 else 1413 Result = Context.DoubleTy; 1414 1415 if (S.getLangOpts().OpenCL && 1416 !((S.getLangOpts().OpenCLVersion >= 120) || 1417 S.getOpenCLOptions().cl_khr_fp64)) { 1418 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1419 << Result << "cl_khr_fp64"; 1420 declarator.setInvalidType(true); 1421 } 1422 break; 1423 case DeclSpec::TST_float128: 1424 if (!S.Context.getTargetInfo().hasFloat128Type()) 1425 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported) 1426 << "__float128"; 1427 Result = Context.Float128Ty; 1428 break; 1429 case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool 1430 break; 1431 case DeclSpec::TST_decimal32: // _Decimal32 1432 case DeclSpec::TST_decimal64: // _Decimal64 1433 case DeclSpec::TST_decimal128: // _Decimal128 1434 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported); 1435 Result = Context.IntTy; 1436 declarator.setInvalidType(true); 1437 break; 1438 case DeclSpec::TST_class: 1439 case DeclSpec::TST_enum: 1440 case DeclSpec::TST_union: 1441 case DeclSpec::TST_struct: 1442 case DeclSpec::TST_interface: { 1443 TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl()); 1444 if (!D) { 1445 // This can happen in C++ with ambiguous lookups. 1446 Result = Context.IntTy; 1447 declarator.setInvalidType(true); 1448 break; 1449 } 1450 1451 // If the type is deprecated or unavailable, diagnose it. 1452 S.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeNameLoc()); 1453 1454 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 1455 DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!"); 1456 1457 // TypeQuals handled by caller. 1458 Result = Context.getTypeDeclType(D); 1459 1460 // In both C and C++, make an ElaboratedType. 1461 ElaboratedTypeKeyword Keyword 1462 = ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType()); 1463 Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result); 1464 break; 1465 } 1466 case DeclSpec::TST_typename: { 1467 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 1468 DS.getTypeSpecSign() == 0 && 1469 "Can't handle qualifiers on typedef names yet!"); 1470 Result = S.GetTypeFromParser(DS.getRepAsType()); 1471 if (Result.isNull()) { 1472 declarator.setInvalidType(true); 1473 } else if (S.getLangOpts().OpenCL) { 1474 if (Result->getAs<AtomicType>()) { 1475 StringRef TypeName = Result.getBaseTypeIdentifier()->getName(); 1476 bool NoExtTypes = 1477 llvm::StringSwitch<bool>(TypeName) 1478 .Cases("atomic_int", "atomic_uint", "atomic_float", 1479 "atomic_flag", true) 1480 .Default(false); 1481 if (!S.getOpenCLOptions().cl_khr_int64_base_atomics && !NoExtTypes) { 1482 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1483 << Result << "cl_khr_int64_base_atomics"; 1484 declarator.setInvalidType(true); 1485 } 1486 if (!S.getOpenCLOptions().cl_khr_int64_extended_atomics && 1487 !NoExtTypes) { 1488 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1489 << Result << "cl_khr_int64_extended_atomics"; 1490 declarator.setInvalidType(true); 1491 } 1492 if (!S.getOpenCLOptions().cl_khr_fp64 && 1493 !TypeName.compare("atomic_double")) { 1494 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1495 << Result << "cl_khr_fp64"; 1496 declarator.setInvalidType(true); 1497 } 1498 } else if (!S.getOpenCLOptions().cl_khr_gl_msaa_sharing && 1499 (Result->isOCLImage2dArrayMSAADepthROType() || 1500 Result->isOCLImage2dArrayMSAADepthWOType() || 1501 Result->isOCLImage2dArrayMSAADepthRWType() || 1502 Result->isOCLImage2dArrayMSAAROType() || 1503 Result->isOCLImage2dArrayMSAARWType() || 1504 Result->isOCLImage2dArrayMSAAWOType() || 1505 Result->isOCLImage2dMSAADepthROType() || 1506 Result->isOCLImage2dMSAADepthRWType() || 1507 Result->isOCLImage2dMSAADepthWOType() || 1508 Result->isOCLImage2dMSAAROType() || 1509 Result->isOCLImage2dMSAARWType() || 1510 Result->isOCLImage2dMSAAWOType())) { 1511 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1512 << Result << "cl_khr_gl_msaa_sharing"; 1513 declarator.setInvalidType(true); 1514 } 1515 } 1516 1517 // TypeQuals handled by caller. 1518 break; 1519 } 1520 case DeclSpec::TST_typeofType: 1521 // FIXME: Preserve type source info. 1522 Result = S.GetTypeFromParser(DS.getRepAsType()); 1523 assert(!Result.isNull() && "Didn't get a type for typeof?"); 1524 if (!Result->isDependentType()) 1525 if (const TagType *TT = Result->getAs<TagType>()) 1526 S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc()); 1527 // TypeQuals handled by caller. 1528 Result = Context.getTypeOfType(Result); 1529 break; 1530 case DeclSpec::TST_typeofExpr: { 1531 Expr *E = DS.getRepAsExpr(); 1532 assert(E && "Didn't get an expression for typeof?"); 1533 // TypeQuals handled by caller. 1534 Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc()); 1535 if (Result.isNull()) { 1536 Result = Context.IntTy; 1537 declarator.setInvalidType(true); 1538 } 1539 break; 1540 } 1541 case DeclSpec::TST_decltype: { 1542 Expr *E = DS.getRepAsExpr(); 1543 assert(E && "Didn't get an expression for decltype?"); 1544 // TypeQuals handled by caller. 1545 Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc()); 1546 if (Result.isNull()) { 1547 Result = Context.IntTy; 1548 declarator.setInvalidType(true); 1549 } 1550 break; 1551 } 1552 case DeclSpec::TST_underlyingType: 1553 Result = S.GetTypeFromParser(DS.getRepAsType()); 1554 assert(!Result.isNull() && "Didn't get a type for __underlying_type?"); 1555 Result = S.BuildUnaryTransformType(Result, 1556 UnaryTransformType::EnumUnderlyingType, 1557 DS.getTypeSpecTypeLoc()); 1558 if (Result.isNull()) { 1559 Result = Context.IntTy; 1560 declarator.setInvalidType(true); 1561 } 1562 break; 1563 1564 case DeclSpec::TST_auto: 1565 // TypeQuals handled by caller. 1566 // If auto is mentioned in a lambda parameter context, convert it to a 1567 // template parameter type immediately, with the appropriate depth and 1568 // index, and update sema's state (LambdaScopeInfo) for the current lambda 1569 // being analyzed (which tracks the invented type template parameter). 1570 if (declarator.getContext() == Declarator::LambdaExprParameterContext) { 1571 sema::LambdaScopeInfo *LSI = S.getCurLambda(); 1572 assert(LSI && "No LambdaScopeInfo on the stack!"); 1573 const unsigned TemplateParameterDepth = LSI->AutoTemplateParameterDepth; 1574 const unsigned AutoParameterPosition = LSI->AutoTemplateParams.size(); 1575 const bool IsParameterPack = declarator.hasEllipsis(); 1576 1577 // Turns out we must create the TemplateTypeParmDecl here to 1578 // retrieve the corresponding template parameter type. 1579 TemplateTypeParmDecl *CorrespondingTemplateParam = 1580 TemplateTypeParmDecl::Create(Context, 1581 // Temporarily add to the TranslationUnit DeclContext. When the 1582 // associated TemplateParameterList is attached to a template 1583 // declaration (such as FunctionTemplateDecl), the DeclContext 1584 // for each template parameter gets updated appropriately via 1585 // a call to AdoptTemplateParameterList. 1586 Context.getTranslationUnitDecl(), 1587 /*KeyLoc*/ SourceLocation(), 1588 /*NameLoc*/ declarator.getLocStart(), 1589 TemplateParameterDepth, 1590 AutoParameterPosition, // our template param index 1591 /* Identifier*/ nullptr, false, IsParameterPack); 1592 LSI->AutoTemplateParams.push_back(CorrespondingTemplateParam); 1593 // Replace the 'auto' in the function parameter with this invented 1594 // template type parameter. 1595 Result = QualType(CorrespondingTemplateParam->getTypeForDecl(), 0); 1596 } else { 1597 Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false); 1598 } 1599 break; 1600 1601 case DeclSpec::TST_auto_type: 1602 Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false); 1603 break; 1604 1605 case DeclSpec::TST_decltype_auto: 1606 Result = Context.getAutoType(QualType(), AutoTypeKeyword::DecltypeAuto, 1607 /*IsDependent*/ false); 1608 break; 1609 1610 case DeclSpec::TST_unknown_anytype: 1611 Result = Context.UnknownAnyTy; 1612 break; 1613 1614 case DeclSpec::TST_atomic: 1615 Result = S.GetTypeFromParser(DS.getRepAsType()); 1616 assert(!Result.isNull() && "Didn't get a type for _Atomic?"); 1617 Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc()); 1618 if (Result.isNull()) { 1619 Result = Context.IntTy; 1620 declarator.setInvalidType(true); 1621 } 1622 break; 1623 1624#define GENERIC_IMAGE_TYPE(ImgType, Id) \ 1625 case DeclSpec::TST_##ImgType##_t: \ 1626 Result = llvm::StringSwitch<QualType>( \ 1627 getImageAccessAttrStr(DS.getAttributes().getList())) \ 1628 .Cases("write_only", "__write_only", Context.Id##WOTy) \ 1629 .Cases("read_write", "__read_write", Context.Id##RWTy) \ 1630 .Default(Context.Id##ROTy); \ 1631 break; 1632#include "clang/Basic/OpenCLImageTypes.def" 1633 1634 case DeclSpec::TST_error: 1635 Result = Context.IntTy; 1636 declarator.setInvalidType(true); 1637 break; 1638 } 1639 1640 // Handle complex types. 1641 if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) { 1642 if (S.getLangOpts().Freestanding) 1643 S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex); 1644 Result = Context.getComplexType(Result); 1645 } else if (DS.isTypeAltiVecVector()) { 1646 unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result)); 1647 assert(typeSize > 0 && "type size for vector must be greater than 0 bits"); 1648 VectorType::VectorKind VecKind = VectorType::AltiVecVector; 1649 if (DS.isTypeAltiVecPixel()) 1650 VecKind = VectorType::AltiVecPixel; 1651 else if (DS.isTypeAltiVecBool()) 1652 VecKind = VectorType::AltiVecBool; 1653 Result = Context.getVectorType(Result, 128/typeSize, VecKind); 1654 } 1655 1656 // FIXME: Imaginary. 1657 if (DS.getTypeSpecComplex() == DeclSpec::TSC_imaginary) 1658 S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported); 1659 1660 // Before we process any type attributes, synthesize a block literal 1661 // function declarator if necessary. 1662 if (declarator.getContext() == Declarator::BlockLiteralContext) 1663 maybeSynthesizeBlockSignature(state, Result); 1664 1665 // Apply any type attributes from the decl spec. This may cause the 1666 // list of type attributes to be temporarily saved while the type 1667 // attributes are pushed around. 1668 // pipe attributes will be handled later ( at GetFullTypeForDeclarator ) 1669 if (!DS.isTypeSpecPipe()) 1670 processTypeAttrs(state, Result, TAL_DeclSpec, DS.getAttributes().getList()); 1671 1672 // Apply const/volatile/restrict qualifiers to T. 1673 if (unsigned TypeQuals = DS.getTypeQualifiers()) { 1674 // Warn about CV qualifiers on function types. 1675 // C99 6.7.3p8: 1676 // If the specification of a function type includes any type qualifiers, 1677 // the behavior is undefined. 1678 // C++11 [dcl.fct]p7: 1679 // The effect of a cv-qualifier-seq in a function declarator is not the 1680 // same as adding cv-qualification on top of the function type. In the 1681 // latter case, the cv-qualifiers are ignored. 1682 if (TypeQuals && Result->isFunctionType()) { 1683 diagnoseAndRemoveTypeQualifiers( 1684 S, DS, TypeQuals, Result, DeclSpec::TQ_const | DeclSpec::TQ_volatile, 1685 S.getLangOpts().CPlusPlus 1686 ? diag::warn_typecheck_function_qualifiers_ignored 1687 : diag::warn_typecheck_function_qualifiers_unspecified); 1688 // No diagnostic for 'restrict' or '_Atomic' applied to a 1689 // function type; we'll diagnose those later, in BuildQualifiedType. 1690 } 1691 1692 // C++11 [dcl.ref]p1: 1693 // Cv-qualified references are ill-formed except when the 1694 // cv-qualifiers are introduced through the use of a typedef-name 1695 // or decltype-specifier, in which case the cv-qualifiers are ignored. 1696 // 1697 // There don't appear to be any other contexts in which a cv-qualified 1698 // reference type could be formed, so the 'ill-formed' clause here appears 1699 // to never happen. 1700 if (TypeQuals && Result->isReferenceType()) { 1701 diagnoseAndRemoveTypeQualifiers( 1702 S, DS, TypeQuals, Result, 1703 DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic, 1704 diag::warn_typecheck_reference_qualifiers); 1705 } 1706 1707 // C90 6.5.3 constraints: "The same type qualifier shall not appear more 1708 // than once in the same specifier-list or qualifier-list, either directly 1709 // or via one or more typedefs." 1710 if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus 1711 && TypeQuals & Result.getCVRQualifiers()) { 1712 if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) { 1713 S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec) 1714 << "const"; 1715 } 1716 1717 if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) { 1718 S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec) 1719 << "volatile"; 1720 } 1721 1722 // C90 doesn't have restrict nor _Atomic, so it doesn't force us to 1723 // produce a warning in this case. 1724 } 1725 1726 QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS); 1727 1728 // If adding qualifiers fails, just use the unqualified type. 1729 if (Qualified.isNull()) 1730 declarator.setInvalidType(true); 1731 else 1732 Result = Qualified; 1733 } 1734 1735 assert(!Result.isNull() && "This function should not return a null type"); 1736 return Result; 1737} 1738 1739static std::string getPrintableNameForEntity(DeclarationName Entity) { 1740 if (Entity) 1741 return Entity.getAsString(); 1742 1743 return "type name"; 1744} 1745 1746QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, 1747 Qualifiers Qs, const DeclSpec *DS) { 1748 if (T.isNull()) 1749 return QualType(); 1750 1751 // Enforce C99 6.7.3p2: "Types other than pointer types derived from 1752 // object or incomplete types shall not be restrict-qualified." 1753 if (Qs.hasRestrict()) { 1754 unsigned DiagID = 0; 1755 QualType ProblemTy; 1756 1757 if (T->isAnyPointerType() || T->isReferenceType() || 1758 T->isMemberPointerType()) { 1759 QualType EltTy; 1760 if (T->isObjCObjectPointerType()) 1761 EltTy = T; 1762 else if (const MemberPointerType *PTy = T->getAs<MemberPointerType>()) 1763 EltTy = PTy->getPointeeType(); 1764 else 1765 EltTy = T->getPointeeType(); 1766 1767 // If we have a pointer or reference, the pointee must have an object 1768 // incomplete type. 1769 if (!EltTy->isIncompleteOrObjectType()) { 1770 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee; 1771 ProblemTy = EltTy; 1772 } 1773 } else if (!T->isDependentType()) { 1774 DiagID = diag::err_typecheck_invalid_restrict_not_pointer; 1775 ProblemTy = T; 1776 } 1777 1778 if (DiagID) { 1779 Diag(DS ? DS->getRestrictSpecLoc() : Loc, DiagID) << ProblemTy; 1780 Qs.removeRestrict(); 1781 } 1782 } 1783 1784 return Context.getQualifiedType(T, Qs); 1785} 1786 1787QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, 1788 unsigned CVRAU, const DeclSpec *DS) { 1789 if (T.isNull()) 1790 return QualType(); 1791 1792 // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic and 1793 // TQ_unaligned; 1794 unsigned CVR = CVRAU & ~(DeclSpec::TQ_atomic | DeclSpec::TQ_unaligned); 1795 1796 // C11 6.7.3/5: 1797 // If the same qualifier appears more than once in the same 1798 // specifier-qualifier-list, either directly or via one or more typedefs, 1799 // the behavior is the same as if it appeared only once. 1800 // 1801 // It's not specified what happens when the _Atomic qualifier is applied to 1802 // a type specified with the _Atomic specifier, but we assume that this 1803 // should be treated as if the _Atomic qualifier appeared multiple times. 1804 if (CVRAU & DeclSpec::TQ_atomic && !T->isAtomicType()) { 1805 // C11 6.7.3/5: 1806 // If other qualifiers appear along with the _Atomic qualifier in a 1807 // specifier-qualifier-list, the resulting type is the so-qualified 1808 // atomic type. 1809 // 1810 // Don't need to worry about array types here, since _Atomic can't be 1811 // applied to such types. 1812 SplitQualType Split = T.getSplitUnqualifiedType(); 1813 T = BuildAtomicType(QualType(Split.Ty, 0), 1814 DS ? DS->getAtomicSpecLoc() : Loc); 1815 if (T.isNull()) 1816 return T; 1817 Split.Quals.addCVRQualifiers(CVR); 1818 return BuildQualifiedType(T, Loc, Split.Quals); 1819 } 1820 1821 Qualifiers Q = Qualifiers::fromCVRMask(CVR); 1822 Q.setUnaligned(CVRAU & DeclSpec::TQ_unaligned); 1823 return BuildQualifiedType(T, Loc, Q, DS); 1824} 1825 1826/// \brief Build a paren type including \p T. 1827QualType Sema::BuildParenType(QualType T) { 1828 return Context.getParenType(T); 1829} 1830 1831/// Given that we're building a pointer or reference to the given 1832static QualType inferARCLifetimeForPointee(Sema &S, QualType type, 1833 SourceLocation loc, 1834 bool isReference) { 1835 // Bail out if retention is unrequired or already specified. 1836 if (!type->isObjCLifetimeType() || 1837 type.getObjCLifetime() != Qualifiers::OCL_None) 1838 return type; 1839 1840 Qualifiers::ObjCLifetime implicitLifetime = Qualifiers::OCL_None; 1841 1842 // If the object type is const-qualified, we can safely use 1843 // __unsafe_unretained. This is safe (because there are no read 1844 // barriers), and it'll be safe to coerce anything but __weak* to 1845 // the resulting type. 1846 if (type.isConstQualified()) { 1847 implicitLifetime = Qualifiers::OCL_ExplicitNone; 1848 1849 // Otherwise, check whether the static type does not require 1850 // retaining. This currently only triggers for Class (possibly 1851 // protocol-qualifed, and arrays thereof). 1852 } else if (type->isObjCARCImplicitlyUnretainedType()) { 1853 implicitLifetime = Qualifiers::OCL_ExplicitNone; 1854 1855 // If we are in an unevaluated context, like sizeof, skip adding a 1856 // qualification. 1857 } else if (S.isUnevaluatedContext()) { 1858 return type; 1859 1860 // If that failed, give an error and recover using __strong. __strong 1861 // is the option most likely to prevent spurious second-order diagnostics, 1862 // like when binding a reference to a field. 1863 } else { 1864 // These types can show up in private ivars in system headers, so 1865 // we need this to not be an error in those cases. Instead we 1866 // want to delay. 1867 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) { 1868 S.DelayedDiagnostics.add( 1869 sema::DelayedDiagnostic::makeForbiddenType(loc, 1870 diag::err_arc_indirect_no_ownership, type, isReference)); 1871 } else { 1872 S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference; 1873 } 1874 implicitLifetime = Qualifiers::OCL_Strong; 1875 } 1876 assert(implicitLifetime && "didn't infer any lifetime!"); 1877 1878 Qualifiers qs; 1879 qs.addObjCLifetime(implicitLifetime); 1880 return S.Context.getQualifiedType(type, qs); 1881} 1882 1883static std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){ 1884 std::string Quals = 1885 Qualifiers::fromCVRMask(FnTy->getTypeQuals()).getAsString(); 1886 1887 switch (FnTy->getRefQualifier()) { 1888 case RQ_None: 1889 break; 1890 1891 case RQ_LValue: 1892 if (!Quals.empty()) 1893 Quals += ' '; 1894 Quals += '&'; 1895 break; 1896 1897 case RQ_RValue: 1898 if (!Quals.empty()) 1899 Quals += ' '; 1900 Quals += "&&"; 1901 break; 1902 } 1903 1904 return Quals; 1905} 1906 1907namespace { 1908/// Kinds of declarator that cannot contain a qualified function type. 1909/// 1910/// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6: 1911/// a function type with a cv-qualifier or a ref-qualifier can only appear 1912/// at the topmost level of a type. 1913/// 1914/// Parens and member pointers are permitted. We don't diagnose array and 1915/// function declarators, because they don't allow function types at all. 1916/// 1917/// The values of this enum are used in diagnostics. 1918enum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference }; 1919} // end anonymous namespace 1920 1921/// Check whether the type T is a qualified function type, and if it is, 1922/// diagnose that it cannot be contained within the given kind of declarator. 1923static bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, 1924 QualifiedFunctionKind QFK) { 1925 // Does T refer to a function type with a cv-qualifier or a ref-qualifier? 1926 const FunctionProtoType *FPT = T->getAs<FunctionProtoType>(); 1927 if (!FPT || (FPT->getTypeQuals() == 0 && FPT->getRefQualifier() == RQ_None)) 1928 return false; 1929 1930 S.Diag(Loc, diag::err_compound_qualified_function_type) 1931 << QFK << isa<FunctionType>(T.IgnoreParens()) << T 1932 << getFunctionQualifiersAsString(FPT); 1933 return true; 1934} 1935 1936/// \brief Build a pointer type. 1937/// 1938/// \param T The type to which we'll be building a pointer. 1939/// 1940/// \param Loc The location of the entity whose type involves this 1941/// pointer type or, if there is no such entity, the location of the 1942/// type that will have pointer type. 1943/// 1944/// \param Entity The name of the entity that involves the pointer 1945/// type, if known. 1946/// 1947/// \returns A suitable pointer type, if there are no 1948/// errors. Otherwise, returns a NULL type. 1949QualType Sema::BuildPointerType(QualType T, 1950 SourceLocation Loc, DeclarationName Entity) { 1951 if (T->isReferenceType()) { 1952 // C++ 8.3.2p4: There shall be no ... pointers to references ... 1953 Diag(Loc, diag::err_illegal_decl_pointer_to_reference) 1954 << getPrintableNameForEntity(Entity) << T; 1955 return QualType(); 1956 } 1957 1958 if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer)) 1959 return QualType(); 1960 1961 assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType"); 1962 1963 // In ARC, it is forbidden to build pointers to unqualified pointers. 1964 if (getLangOpts().ObjCAutoRefCount) 1965 T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false); 1966 1967 // Build the pointer type. 1968 return Context.getPointerType(T); 1969} 1970 1971/// \brief Build a reference type. 1972/// 1973/// \param T The type to which we'll be building a reference. 1974/// 1975/// \param Loc The location of the entity whose type involves this 1976/// reference type or, if there is no such entity, the location of the 1977/// type that will have reference type. 1978/// 1979/// \param Entity The name of the entity that involves the reference 1980/// type, if known. 1981/// 1982/// \returns A suitable reference type, if there are no 1983/// errors. Otherwise, returns a NULL type. 1984QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, 1985 SourceLocation Loc, 1986 DeclarationName Entity) { 1987 assert(Context.getCanonicalType(T) != Context.OverloadTy && 1988 "Unresolved overloaded function type"); 1989 1990 // C++0x [dcl.ref]p6: 1991 // If a typedef (7.1.3), a type template-parameter (14.3.1), or a 1992 // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a 1993 // type T, an attempt to create the type "lvalue reference to cv TR" creates 1994 // the type "lvalue reference to T", while an attempt to create the type 1995 // "rvalue reference to cv TR" creates the type TR. 1996 bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>(); 1997 1998 // C++ [dcl.ref]p4: There shall be no references to references. 1999 // 2000 // According to C++ DR 106, references to references are only 2001 // diagnosed when they are written directly (e.g., "int & &"), 2002 // but not when they happen via a typedef: 2003 // 2004 // typedef int& intref; 2005 // typedef intref& intref2; 2006 // 2007 // Parser::ParseDeclaratorInternal diagnoses the case where 2008 // references are written directly; here, we handle the 2009 // collapsing of references-to-references as described in C++0x. 2010 // DR 106 and 540 introduce reference-collapsing into C++98/03. 2011 2012 // C++ [dcl.ref]p1: 2013 // A declarator that specifies the type "reference to cv void" 2014 // is ill-formed. 2015 if (T->isVoidType()) { 2016 Diag(Loc, diag::err_reference_to_void); 2017 return QualType(); 2018 } 2019 2020 if (checkQualifiedFunction(*this, T, Loc, QFK_Reference)) 2021 return QualType(); 2022 2023 // In ARC, it is forbidden to build references to unqualified pointers. 2024 if (getLangOpts().ObjCAutoRefCount) 2025 T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true); 2026 2027 // Handle restrict on references. 2028 if (LValueRef) 2029 return Context.getLValueReferenceType(T, SpelledAsLValue); 2030 return Context.getRValueReferenceType(T); 2031} 2032 2033/// \brief Build a Pipe type. 2034/// 2035/// \param T The type to which we'll be building a Pipe. 2036/// 2037/// \param Loc We do not use it for now. 2038/// 2039/// \returns A suitable pipe type, if there are no errors. Otherwise, returns a 2040/// NULL type. 2041QualType Sema::BuildPipeType(QualType T, SourceLocation Loc) { 2042 assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType"); 2043 2044 // Build the pipe type. 2045 return Context.getPipeType(T); 2046} 2047 2048/// Check whether the specified array size makes the array type a VLA. If so, 2049/// return true, if not, return the size of the array in SizeVal. 2050static bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) { 2051 // If the size is an ICE, it certainly isn't a VLA. If we're in a GNU mode 2052 // (like gnu99, but not c99) accept any evaluatable value as an extension. 2053 class VLADiagnoser : public Sema::VerifyICEDiagnoser { 2054 public: 2055 VLADiagnoser() : Sema::VerifyICEDiagnoser(true) {} 2056 2057 void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 2058 } 2059 2060 void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR) override { 2061 S.Diag(Loc, diag::ext_vla_folded_to_constant) << SR; 2062 } 2063 } Diagnoser; 2064 2065 return S.VerifyIntegerConstantExpression(ArraySize, &SizeVal, Diagnoser, 2066 S.LangOpts.GNUMode || 2067 S.LangOpts.OpenCL).isInvalid(); 2068} 2069 2070/// \brief Build an array type. 2071/// 2072/// \param T The type of each element in the array. 2073/// 2074/// \param ASM C99 array size modifier (e.g., '*', 'static'). 2075/// 2076/// \param ArraySize Expression describing the size of the array. 2077/// 2078/// \param Brackets The range from the opening '[' to the closing ']'. 2079/// 2080/// \param Entity The name of the entity that involves the array 2081/// type, if known. 2082/// 2083/// \returns A suitable array type, if there are no errors. Otherwise, 2084/// returns a NULL type. 2085QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, 2086 Expr *ArraySize, unsigned Quals, 2087 SourceRange Brackets, DeclarationName Entity) { 2088 2089 SourceLocation Loc = Brackets.getBegin(); 2090 if (getLangOpts().CPlusPlus) { 2091 // C++ [dcl.array]p1: 2092 // T is called the array element type; this type shall not be a reference 2093 // type, the (possibly cv-qualified) type void, a function type or an 2094 // abstract class type. 2095 // 2096 // C++ [dcl.array]p3: 2097 // When several "array of" specifications are adjacent, [...] only the 2098 // first of the constant expressions that specify the bounds of the arrays 2099 // may be omitted. 2100 // 2101 // Note: function types are handled in the common path with C. 2102 if (T->isReferenceType()) { 2103 Diag(Loc, diag::err_illegal_decl_array_of_references) 2104 << getPrintableNameForEntity(Entity) << T; 2105 return QualType(); 2106 } 2107 2108 if (T->isVoidType() || T->isIncompleteArrayType()) { 2109 Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T; 2110 return QualType(); 2111 } 2112 2113 if (RequireNonAbstractType(Brackets.getBegin(), T, 2114 diag::err_array_of_abstract_type)) 2115 return QualType(); 2116 2117 // Mentioning a member pointer type for an array type causes us to lock in 2118 // an inheritance model, even if it's inside an unused typedef. 2119 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 2120 if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) 2121 if (!MPTy->getClass()->isDependentType()) 2122 (void)isCompleteType(Loc, T); 2123 2124 } else { 2125 // C99 6.7.5.2p1: If the element type is an incomplete or function type, 2126 // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]()) 2127 if (RequireCompleteType(Loc, T, 2128 diag::err_illegal_decl_array_incomplete_type)) 2129 return QualType(); 2130 } 2131 2132 if (T->isFunctionType()) { 2133 Diag(Loc, diag::err_illegal_decl_array_of_functions) 2134 << getPrintableNameForEntity(Entity) << T; 2135 return QualType(); 2136 } 2137 2138 if (const RecordType *EltTy = T->getAs<RecordType>()) { 2139 // If the element type is a struct or union that contains a variadic 2140 // array, accept it as a GNU extension: C99 6.7.2.1p2. 2141 if (EltTy->getDecl()->hasFlexibleArrayMember()) 2142 Diag(Loc, diag::ext_flexible_array_in_array) << T; 2143 } else if (T->isObjCObjectType()) { 2144 Diag(Loc, diag::err_objc_array_of_interfaces) << T; 2145 return QualType(); 2146 } 2147 2148 // Do placeholder conversions on the array size expression. 2149 if (ArraySize && ArraySize->hasPlaceholderType()) { 2150 ExprResult Result = CheckPlaceholderExpr(ArraySize); 2151 if (Result.isInvalid()) return QualType(); 2152 ArraySize = Result.get(); 2153 } 2154 2155 // Do lvalue-to-rvalue conversions on the array size expression. 2156 if (ArraySize && !ArraySize->isRValue()) { 2157 ExprResult Result = DefaultLvalueConversion(ArraySize); 2158 if (Result.isInvalid()) 2159 return QualType(); 2160 2161 ArraySize = Result.get(); 2162 } 2163 2164 // C99 6.7.5.2p1: The size expression shall have integer type. 2165 // C++11 allows contextual conversions to such types. 2166 if (!getLangOpts().CPlusPlus11 && 2167 ArraySize && !ArraySize->isTypeDependent() && 2168 !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) { 2169 Diag(ArraySize->getLocStart(), diag::err_array_size_non_int) 2170 << ArraySize->getType() << ArraySize->getSourceRange(); 2171 return QualType(); 2172 } 2173 2174 llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType())); 2175 if (!ArraySize) { 2176 if (ASM == ArrayType::Star) 2177 T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets); 2178 else 2179 T = Context.getIncompleteArrayType(T, ASM, Quals); 2180 } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) { 2181 T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets); 2182 } else if ((!T->isDependentType() && !T->isIncompleteType() && 2183 !T->isConstantSizeType()) || 2184 isArraySizeVLA(*this, ArraySize, ConstVal)) { 2185 // Even in C++11, don't allow contextual conversions in the array bound 2186 // of a VLA. 2187 if (getLangOpts().CPlusPlus11 && 2188 !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) { 2189 Diag(ArraySize->getLocStart(), diag::err_array_size_non_int) 2190 << ArraySize->getType() << ArraySize->getSourceRange(); 2191 return QualType(); 2192 } 2193 2194 // C99: an array with an element type that has a non-constant-size is a VLA. 2195 // C99: an array with a non-ICE size is a VLA. We accept any expression 2196 // that we can fold to a non-zero positive value as an extension. 2197 T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets); 2198 } else { 2199 // C99 6.7.5.2p1: If the expression is a constant expression, it shall 2200 // have a value greater than zero. 2201 if (ConstVal.isSigned() && ConstVal.isNegative()) { 2202 if (Entity) 2203 Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size) 2204 << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange(); 2205 else 2206 Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size) 2207 << ArraySize->getSourceRange(); 2208 return QualType(); 2209 } 2210 if (ConstVal == 0) { 2211 // GCC accepts zero sized static arrays. We allow them when 2212 // we're not in a SFINAE context. 2213 Diag(ArraySize->getLocStart(), 2214 isSFINAEContext()? diag::err_typecheck_zero_array_size 2215 : diag::ext_typecheck_zero_array_size) 2216 << ArraySize->getSourceRange(); 2217 2218 if (ASM == ArrayType::Static) { 2219 Diag(ArraySize->getLocStart(), 2220 diag::warn_typecheck_zero_static_array_size) 2221 << ArraySize->getSourceRange(); 2222 ASM = ArrayType::Normal; 2223 } 2224 } else if (!T->isDependentType() && !T->isVariablyModifiedType() && 2225 !T->isIncompleteType() && !T->isUndeducedType()) { 2226 // Is the array too large? 2227 unsigned ActiveSizeBits 2228 = ConstantArrayType::getNumAddressingBits(Context, T, ConstVal); 2229 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 2230 Diag(ArraySize->getLocStart(), diag::err_array_too_large) 2231 << ConstVal.toString(10) 2232 << ArraySize->getSourceRange(); 2233 return QualType(); 2234 } 2235 } 2236 2237 T = Context.getConstantArrayType(T, ConstVal, ASM, Quals); 2238 } 2239 2240 // OpenCL v1.2 s6.9.d: variable length arrays are not supported. 2241 if (getLangOpts().OpenCL && T->isVariableArrayType()) { 2242 Diag(Loc, diag::err_opencl_vla); 2243 return QualType(); 2244 } 2245 // If this is not C99, extwarn about VLA's and C99 array size modifiers. 2246 if (!getLangOpts().C99) { 2247 if (T->isVariableArrayType()) { 2248 // Prohibit the use of VLAs during template argument deduction. 2249 if (isSFINAEContext()) { 2250 Diag(Loc, diag::err_vla_in_sfinae); 2251 return QualType(); 2252 } 2253 // Just extwarn about VLAs. 2254 else 2255 Diag(Loc, diag::ext_vla); 2256 } else if (ASM != ArrayType::Normal || Quals != 0) 2257 Diag(Loc, 2258 getLangOpts().CPlusPlus? diag::err_c99_array_usage_cxx 2259 : diag::ext_c99_array_usage) << ASM; 2260 } 2261 2262 if (T->isVariableArrayType()) { 2263 // Warn about VLAs for -Wvla. 2264 Diag(Loc, diag::warn_vla_used); 2265 } 2266 2267 // OpenCL v2.0 s6.12.5 - Arrays of blocks are not supported. 2268 // OpenCL v2.0 s6.16.13.1 - Arrays of pipe type are not supported. 2269 // OpenCL v2.0 s6.9.b - Arrays of image/sampler type are not supported. 2270 if (getLangOpts().OpenCL) { 2271 const QualType ArrType = Context.getBaseElementType(T); 2272 if (ArrType->isBlockPointerType() || ArrType->isPipeType() || 2273 ArrType->isSamplerT() || ArrType->isImageType()) { 2274 Diag(Loc, diag::err_opencl_invalid_type_array) << ArrType; 2275 return QualType(); 2276 } 2277 } 2278 2279 return T; 2280} 2281 2282/// \brief Build an ext-vector type. 2283/// 2284/// Run the required checks for the extended vector type. 2285QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, 2286 SourceLocation AttrLoc) { 2287 // Unlike gcc's vector_size attribute, we do not allow vectors to be defined 2288 // in conjunction with complex types (pointers, arrays, functions, etc.). 2289 // 2290 // Additionally, OpenCL prohibits vectors of booleans (they're considered a 2291 // reserved data type under OpenCL v2.0 s6.1.4), we don't support selects 2292 // on bitvectors, and we have no well-defined ABI for bitvectors, so vectors 2293 // of bool aren't allowed. 2294 if ((!T->isDependentType() && !T->isIntegerType() && 2295 !T->isRealFloatingType()) || 2296 T->isBooleanType()) { 2297 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T; 2298 return QualType(); 2299 } 2300 2301 if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) { 2302 llvm::APSInt vecSize(32); 2303 if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) { 2304 Diag(AttrLoc, diag::err_attribute_argument_type) 2305 << "ext_vector_type" << AANT_ArgumentIntegerConstant 2306 << ArraySize->getSourceRange(); 2307 return QualType(); 2308 } 2309 2310 // Unlike gcc's vector_size attribute, the size is specified as the 2311 // number of elements, not the number of bytes. 2312 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue()); 2313 2314 if (vectorSize == 0) { 2315 Diag(AttrLoc, diag::err_attribute_zero_size) 2316 << ArraySize->getSourceRange(); 2317 return QualType(); 2318 } 2319 2320 if (VectorType::isVectorSizeTooLarge(vectorSize)) { 2321 Diag(AttrLoc, diag::err_attribute_size_too_large) 2322 << ArraySize->getSourceRange(); 2323 return QualType(); 2324 } 2325 2326 return Context.getExtVectorType(T, vectorSize); 2327 } 2328 2329 return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc); 2330} 2331 2332bool Sema::CheckFunctionReturnType(QualType T, SourceLocation Loc) { 2333 if (T->isArrayType() || T->isFunctionType()) { 2334 Diag(Loc, diag::err_func_returning_array_function) 2335 << T->isFunctionType() << T; 2336 return true; 2337 } 2338 2339 // Functions cannot return half FP. 2340 if (T->isHalfType() && !getLangOpts().HalfArgsAndReturns) { 2341 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 << 2342 FixItHint::CreateInsertion(Loc, "*"); 2343 return true; 2344 } 2345 2346 // Methods cannot return interface types. All ObjC objects are 2347 // passed by reference. 2348 if (T->isObjCObjectType()) { 2349 Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value) << 0 << T; 2350 return 0; 2351 } 2352 2353 return false; 2354} 2355 2356/// Check the extended parameter information. Most of the necessary 2357/// checking should occur when applying the parameter attribute; the 2358/// only other checks required are positional restrictions. 2359static void checkExtParameterInfos(Sema &S, ArrayRef<QualType> paramTypes, 2360 const FunctionProtoType::ExtProtoInfo &EPI, 2361 llvm::function_ref<SourceLocation(unsigned)> getParamLoc) { 2362 assert(EPI.ExtParameterInfos && "shouldn't get here without param infos"); 2363 2364 bool hasCheckedSwiftCall = false; 2365 auto checkForSwiftCC = [&](unsigned paramIndex) { 2366 // Only do this once. 2367 if (hasCheckedSwiftCall) return; 2368 hasCheckedSwiftCall = true; 2369 if (EPI.ExtInfo.getCC() == CC_Swift) return; 2370 S.Diag(getParamLoc(paramIndex), diag::err_swift_param_attr_not_swiftcall) 2371 << getParameterABISpelling(EPI.ExtParameterInfos[paramIndex].getABI()); 2372 }; 2373 2374 for (size_t paramIndex = 0, numParams = paramTypes.size(); 2375 paramIndex != numParams; ++paramIndex) { 2376 switch (EPI.ExtParameterInfos[paramIndex].getABI()) { 2377 // Nothing interesting to check for orindary-ABI parameters. 2378 case ParameterABI::Ordinary: 2379 continue; 2380 2381 // swift_indirect_result parameters must be a prefix of the function 2382 // arguments. 2383 case ParameterABI::SwiftIndirectResult: 2384 checkForSwiftCC(paramIndex); 2385 if (paramIndex != 0 && 2386 EPI.ExtParameterInfos[paramIndex - 1].getABI() 2387 != ParameterABI::SwiftIndirectResult) { 2388 S.Diag(getParamLoc(paramIndex), 2389 diag::err_swift_indirect_result_not_first); 2390 } 2391 continue; 2392 2393 // swift_context parameters must be the last parameter except for 2394 // a possible swift_error parameter. 2395 case ParameterABI::SwiftContext: 2396 checkForSwiftCC(paramIndex); 2397 if (!(paramIndex == numParams - 1 || 2398 (paramIndex == numParams - 2 && 2399 EPI.ExtParameterInfos[numParams - 1].getABI() 2400 == ParameterABI::SwiftErrorResult))) { 2401 S.Diag(getParamLoc(paramIndex), 2402 diag::err_swift_context_not_before_swift_error_result); 2403 } 2404 continue; 2405 2406 // swift_error parameters must be the last parameter. 2407 case ParameterABI::SwiftErrorResult: 2408 checkForSwiftCC(paramIndex); 2409 if (paramIndex != numParams - 1) { 2410 S.Diag(getParamLoc(paramIndex), 2411 diag::err_swift_error_result_not_last); 2412 } else if (paramIndex == 0 || 2413 EPI.ExtParameterInfos[paramIndex - 1].getABI() 2414 != ParameterABI::SwiftContext) { 2415 S.Diag(getParamLoc(paramIndex), 2416 diag::err_swift_error_result_not_after_swift_context); 2417 } 2418 continue; 2419 } 2420 llvm_unreachable("bad ABI kind"); 2421 } 2422} 2423 2424QualType Sema::BuildFunctionType(QualType T, 2425 MutableArrayRef<QualType> ParamTypes, 2426 SourceLocation Loc, DeclarationName Entity, 2427 const FunctionProtoType::ExtProtoInfo &EPI) { 2428 bool Invalid = false; 2429 2430 Invalid |= CheckFunctionReturnType(T, Loc); 2431 2432 for (unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) { 2433 // FIXME: Loc is too inprecise here, should use proper locations for args. 2434 QualType ParamType = Context.getAdjustedParameterType(ParamTypes[Idx]); 2435 if (ParamType->isVoidType()) { 2436 Diag(Loc, diag::err_param_with_void_type); 2437 Invalid = true; 2438 } else if (ParamType->isHalfType() && !getLangOpts().HalfArgsAndReturns) { 2439 // Disallow half FP arguments. 2440 Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 << 2441 FixItHint::CreateInsertion(Loc, "*"); 2442 Invalid = true; 2443 } 2444 2445 ParamTypes[Idx] = ParamType; 2446 } 2447 2448 if (EPI.ExtParameterInfos) { 2449 checkExtParameterInfos(*this, ParamTypes, EPI, 2450 [=](unsigned i) { return Loc; }); 2451 } 2452 2453 if (Invalid) 2454 return QualType(); 2455 2456 return Context.getFunctionType(T, ParamTypes, EPI); 2457} 2458 2459/// \brief Build a member pointer type \c T Class::*. 2460/// 2461/// \param T the type to which the member pointer refers. 2462/// \param Class the class type into which the member pointer points. 2463/// \param Loc the location where this type begins 2464/// \param Entity the name of the entity that will have this member pointer type 2465/// 2466/// \returns a member pointer type, if successful, or a NULL type if there was 2467/// an error. 2468QualType Sema::BuildMemberPointerType(QualType T, QualType Class, 2469 SourceLocation Loc, 2470 DeclarationName Entity) { 2471 // Verify that we're not building a pointer to pointer to function with 2472 // exception specification. 2473 if (CheckDistantExceptionSpec(T)) { 2474 Diag(Loc, diag::err_distant_exception_spec); 2475 return QualType(); 2476 } 2477 2478 // C++ 8.3.3p3: A pointer to member shall not point to ... a member 2479 // with reference type, or "cv void." 2480 if (T->isReferenceType()) { 2481 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference) 2482 << getPrintableNameForEntity(Entity) << T; 2483 return QualType(); 2484 } 2485 2486 if (T->isVoidType()) { 2487 Diag(Loc, diag::err_illegal_decl_mempointer_to_void) 2488 << getPrintableNameForEntity(Entity); 2489 return QualType(); 2490 } 2491 2492 if (!Class->isDependentType() && !Class->isRecordType()) { 2493 Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class; 2494 return QualType(); 2495 } 2496 2497 // Adjust the default free function calling convention to the default method 2498 // calling convention. 2499 bool IsCtorOrDtor = 2500 (Entity.getNameKind() == DeclarationName::CXXConstructorName) || 2501 (Entity.getNameKind() == DeclarationName::CXXDestructorName); 2502 if (T->isFunctionType()) 2503 adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc); 2504 2505 return Context.getMemberPointerType(T, Class.getTypePtr()); 2506} 2507 2508/// \brief Build a block pointer type. 2509/// 2510/// \param T The type to which we'll be building a block pointer. 2511/// 2512/// \param Loc The source location, used for diagnostics. 2513/// 2514/// \param Entity The name of the entity that involves the block pointer 2515/// type, if known. 2516/// 2517/// \returns A suitable block pointer type, if there are no 2518/// errors. Otherwise, returns a NULL type. 2519QualType Sema::BuildBlockPointerType(QualType T, 2520 SourceLocation Loc, 2521 DeclarationName Entity) { 2522 if (!T->isFunctionType()) { 2523 Diag(Loc, diag::err_nonfunction_block_type); 2524 return QualType(); 2525 } 2526 2527 if (checkQualifiedFunction(*this, T, Loc, QFK_BlockPointer)) 2528 return QualType(); 2529 2530 return Context.getBlockPointerType(T); 2531} 2532 2533QualType Sema::GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo) { 2534 QualType QT = Ty.get(); 2535 if (QT.isNull()) { 2536 if (TInfo) *TInfo = nullptr; 2537 return QualType(); 2538 } 2539 2540 TypeSourceInfo *DI = nullptr; 2541 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) { 2542 QT = LIT->getType(); 2543 DI = LIT->getTypeSourceInfo(); 2544 } 2545 2546 if (TInfo) *TInfo = DI; 2547 return QT; 2548} 2549 2550static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, 2551 Qualifiers::ObjCLifetime ownership, 2552 unsigned chunkIndex); 2553 2554/// Given that this is the declaration of a parameter under ARC, 2555/// attempt to infer attributes and such for pointer-to-whatever 2556/// types. 2557static void inferARCWriteback(TypeProcessingState &state, 2558 QualType &declSpecType) { 2559 Sema &S = state.getSema(); 2560 Declarator &declarator = state.getDeclarator(); 2561 2562 // TODO: should we care about decl qualifiers? 2563 2564 // Check whether the declarator has the expected form. We walk 2565 // from the inside out in order to make the block logic work. 2566 unsigned outermostPointerIndex = 0; 2567 bool isBlockPointer = false; 2568 unsigned numPointers = 0; 2569 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 2570 unsigned chunkIndex = i; 2571 DeclaratorChunk &chunk = declarator.getTypeObject(chunkIndex); 2572 switch (chunk.Kind) { 2573 case DeclaratorChunk::Paren: 2574 // Ignore parens. 2575 break; 2576 2577 case DeclaratorChunk::Reference: 2578 case DeclaratorChunk::Pointer: 2579 // Count the number of pointers. Treat references 2580 // interchangeably as pointers; if they're mis-ordered, normal 2581 // type building will discover that. 2582 outermostPointerIndex = chunkIndex; 2583 numPointers++; 2584 break; 2585 2586 case DeclaratorChunk::BlockPointer: 2587 // If we have a pointer to block pointer, that's an acceptable 2588 // indirect reference; anything else is not an application of 2589 // the rules. 2590 if (numPointers != 1) return; 2591 numPointers++; 2592 outermostPointerIndex = chunkIndex; 2593 isBlockPointer = true; 2594 2595 // We don't care about pointer structure in return values here. 2596 goto done; 2597 2598 case DeclaratorChunk::Array: // suppress if written (id[])? 2599 case DeclaratorChunk::Function: 2600 case DeclaratorChunk::MemberPointer: 2601 case DeclaratorChunk::Pipe: 2602 return; 2603 } 2604 } 2605 done: 2606 2607 // If we have *one* pointer, then we want to throw the qualifier on 2608 // the declaration-specifiers, which means that it needs to be a 2609 // retainable object type. 2610 if (numPointers == 1) { 2611 // If it's not a retainable object type, the rule doesn't apply. 2612 if (!declSpecType->isObjCRetainableType()) return; 2613 2614 // If it already has lifetime, don't do anything. 2615 if (declSpecType.getObjCLifetime()) return; 2616 2617 // Otherwise, modify the type in-place. 2618 Qualifiers qs; 2619 2620 if (declSpecType->isObjCARCImplicitlyUnretainedType()) 2621 qs.addObjCLifetime(Qualifiers::OCL_ExplicitNone); 2622 else 2623 qs.addObjCLifetime(Qualifiers::OCL_Autoreleasing); 2624 declSpecType = S.Context.getQualifiedType(declSpecType, qs); 2625 2626 // If we have *two* pointers, then we want to throw the qualifier on 2627 // the outermost pointer. 2628 } else if (numPointers == 2) { 2629 // If we don't have a block pointer, we need to check whether the 2630 // declaration-specifiers gave us something that will turn into a 2631 // retainable object pointer after we slap the first pointer on it. 2632 if (!isBlockPointer && !declSpecType->isObjCObjectType()) 2633 return; 2634 2635 // Look for an explicit lifetime attribute there. 2636 DeclaratorChunk &chunk = declarator.getTypeObject(outermostPointerIndex); 2637 if (chunk.Kind != DeclaratorChunk::Pointer && 2638 chunk.Kind != DeclaratorChunk::BlockPointer) 2639 return; 2640 for (const AttributeList *attr = chunk.getAttrs(); attr; 2641 attr = attr->getNext()) 2642 if (attr->getKind() == AttributeList::AT_ObjCOwnership) 2643 return; 2644 2645 transferARCOwnershipToDeclaratorChunk(state, Qualifiers::OCL_Autoreleasing, 2646 outermostPointerIndex); 2647 2648 // Any other number of pointers/references does not trigger the rule. 2649 } else return; 2650 2651 // TODO: mark whether we did this inference? 2652} 2653 2654void Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, 2655 SourceLocation FallbackLoc, 2656 SourceLocation ConstQualLoc, 2657 SourceLocation VolatileQualLoc, 2658 SourceLocation RestrictQualLoc, 2659 SourceLocation AtomicQualLoc, 2660 SourceLocation UnalignedQualLoc) { 2661 if (!Quals) 2662 return; 2663 2664 struct Qual { 2665 const char *Name; 2666 unsigned Mask; 2667 SourceLocation Loc; 2668 } const QualKinds[5] = { 2669 { "const", DeclSpec::TQ_const, ConstQualLoc }, 2670 { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc }, 2671 { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc }, 2672 { "__unaligned", DeclSpec::TQ_unaligned, UnalignedQualLoc }, 2673 { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc } 2674 }; 2675 2676 SmallString<32> QualStr; 2677 unsigned NumQuals = 0; 2678 SourceLocation Loc; 2679 FixItHint FixIts[5]; 2680 2681 // Build a string naming the redundant qualifiers. 2682 for (auto &E : QualKinds) { 2683 if (Quals & E.Mask) { 2684 if (!QualStr.empty()) QualStr += ' '; 2685 QualStr += E.Name; 2686 2687 // If we have a location for the qualifier, offer a fixit. 2688 SourceLocation QualLoc = E.Loc; 2689 if (QualLoc.isValid()) { 2690 FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc); 2691 if (Loc.isInvalid() || 2692 getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc)) 2693 Loc = QualLoc; 2694 } 2695 2696 ++NumQuals; 2697 } 2698 } 2699 2700 Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID) 2701 << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3]; 2702} 2703 2704// Diagnose pointless type qualifiers on the return type of a function. 2705static void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, 2706 Declarator &D, 2707 unsigned FunctionChunkIndex) { 2708 if (D.getTypeObject(FunctionChunkIndex).Fun.hasTrailingReturnType()) { 2709 // FIXME: TypeSourceInfo doesn't preserve location information for 2710 // qualifiers. 2711 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2712 RetTy.getLocalCVRQualifiers(), 2713 D.getIdentifierLoc()); 2714 return; 2715 } 2716 2717 for (unsigned OuterChunkIndex = FunctionChunkIndex + 1, 2718 End = D.getNumTypeObjects(); 2719 OuterChunkIndex != End; ++OuterChunkIndex) { 2720 DeclaratorChunk &OuterChunk = D.getTypeObject(OuterChunkIndex); 2721 switch (OuterChunk.Kind) { 2722 case DeclaratorChunk::Paren: 2723 continue; 2724 2725 case DeclaratorChunk::Pointer: { 2726 DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr; 2727 S.diagnoseIgnoredQualifiers( 2728 diag::warn_qual_return_type, 2729 PTI.TypeQuals, 2730 SourceLocation(), 2731 SourceLocation::getFromRawEncoding(PTI.ConstQualLoc), 2732 SourceLocation::getFromRawEncoding(PTI.VolatileQualLoc), 2733 SourceLocation::getFromRawEncoding(PTI.RestrictQualLoc), 2734 SourceLocation::getFromRawEncoding(PTI.AtomicQualLoc), 2735 SourceLocation::getFromRawEncoding(PTI.UnalignedQualLoc)); 2736 return; 2737 } 2738 2739 case DeclaratorChunk::Function: 2740 case DeclaratorChunk::BlockPointer: 2741 case DeclaratorChunk::Reference: 2742 case DeclaratorChunk::Array: 2743 case DeclaratorChunk::MemberPointer: 2744 case DeclaratorChunk::Pipe: 2745 // FIXME: We can't currently provide an accurate source location and a 2746 // fix-it hint for these. 2747 unsigned AtomicQual = RetTy->isAtomicType() ? DeclSpec::TQ_atomic : 0; 2748 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2749 RetTy.getCVRQualifiers() | AtomicQual, 2750 D.getIdentifierLoc()); 2751 return; 2752 } 2753 2754 llvm_unreachable("unknown declarator chunk kind"); 2755 } 2756 2757 // If the qualifiers come from a conversion function type, don't diagnose 2758 // them -- they're not necessarily redundant, since such a conversion 2759 // operator can be explicitly called as "x.operator const int()". 2760 if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) 2761 return; 2762 2763 // Just parens all the way out to the decl specifiers. Diagnose any qualifiers 2764 // which are present there. 2765 S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2766 D.getDeclSpec().getTypeQualifiers(), 2767 D.getIdentifierLoc(), 2768 D.getDeclSpec().getConstSpecLoc(), 2769 D.getDeclSpec().getVolatileSpecLoc(), 2770 D.getDeclSpec().getRestrictSpecLoc(), 2771 D.getDeclSpec().getAtomicSpecLoc(), 2772 D.getDeclSpec().getUnalignedSpecLoc()); 2773} 2774 2775static QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, 2776 TypeSourceInfo *&ReturnTypeInfo) { 2777 Sema &SemaRef = state.getSema(); 2778 Declarator &D = state.getDeclarator(); 2779 QualType T; 2780 ReturnTypeInfo = nullptr; 2781 2782 // The TagDecl owned by the DeclSpec. 2783 TagDecl *OwnedTagDecl = nullptr; 2784 2785 switch (D.getName().getKind()) { 2786 case UnqualifiedId::IK_ImplicitSelfParam: 2787 case UnqualifiedId::IK_OperatorFunctionId: 2788 case UnqualifiedId::IK_Identifier: 2789 case UnqualifiedId::IK_LiteralOperatorId: 2790 case UnqualifiedId::IK_TemplateId: 2791 T = ConvertDeclSpecToType(state); 2792 2793 if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) { 2794 OwnedTagDecl = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 2795 // Owned declaration is embedded in declarator. 2796 OwnedTagDecl->setEmbeddedInDeclarator(true); 2797 } 2798 break; 2799 2800 case UnqualifiedId::IK_ConstructorName: 2801 case UnqualifiedId::IK_ConstructorTemplateId: 2802 case UnqualifiedId::IK_DestructorName: 2803 // Constructors and destructors don't have return types. Use 2804 // "void" instead. 2805 T = SemaRef.Context.VoidTy; 2806 processTypeAttrs(state, T, TAL_DeclSpec, 2807 D.getDeclSpec().getAttributes().getList()); 2808 break; 2809 2810 case UnqualifiedId::IK_ConversionFunctionId: 2811 // The result type of a conversion function is the type that it 2812 // converts to. 2813 T = SemaRef.GetTypeFromParser(D.getName().ConversionFunctionId, 2814 &ReturnTypeInfo); 2815 break; 2816 } 2817 2818 if (D.getAttributes()) 2819 distributeTypeAttrsFromDeclarator(state, T); 2820 2821 // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context. 2822 if (D.getDeclSpec().containsPlaceholderType()) { 2823 int Error = -1; 2824 2825 switch (D.getContext()) { 2826 case Declarator::LambdaExprContext: 2827 llvm_unreachable("Can't specify a type specifier in lambda grammar"); 2828 case Declarator::ObjCParameterContext: 2829 case Declarator::ObjCResultContext: 2830 case Declarator::PrototypeContext: 2831 Error = 0; 2832 break; 2833 case Declarator::LambdaExprParameterContext: 2834 // In C++14, generic lambdas allow 'auto' in their parameters. 2835 if (!(SemaRef.getLangOpts().CPlusPlus14 2836 && D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto)) 2837 Error = 16; 2838 break; 2839 case Declarator::MemberContext: { 2840 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static || 2841 D.isFunctionDeclarator()) 2842 break; 2843 bool Cxx = SemaRef.getLangOpts().CPlusPlus; 2844 switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) { 2845 case TTK_Enum: llvm_unreachable("unhandled tag kind"); 2846 case TTK_Struct: Error = Cxx ? 1 : 2; /* Struct member */ break; 2847 case TTK_Union: Error = Cxx ? 3 : 4; /* Union member */ break; 2848 case TTK_Class: Error = 5; /* Class member */ break; 2849 case TTK_Interface: Error = 6; /* Interface member */ break; 2850 } 2851 break; 2852 } 2853 case Declarator::CXXCatchContext: 2854 case Declarator::ObjCCatchContext: 2855 Error = 7; // Exception declaration 2856 break; 2857 case Declarator::TemplateParamContext: 2858 Error = 8; // Template parameter 2859 break; 2860 case Declarator::BlockLiteralContext: 2861 Error = 9; // Block literal 2862 break; 2863 case Declarator::TemplateTypeArgContext: 2864 Error = 10; // Template type argument 2865 break; 2866 case Declarator::AliasDeclContext: 2867 case Declarator::AliasTemplateContext: 2868 Error = 12; // Type alias 2869 break; 2870 case Declarator::TrailingReturnContext: 2871 if (!SemaRef.getLangOpts().CPlusPlus14 || 2872 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2873 Error = 13; // Function return type 2874 break; 2875 case Declarator::ConversionIdContext: 2876 if (!SemaRef.getLangOpts().CPlusPlus14 || 2877 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2878 Error = 14; // conversion-type-id 2879 break; 2880 case Declarator::TypeNameContext: 2881 Error = 15; // Generic 2882 break; 2883 case Declarator::FileContext: 2884 case Declarator::BlockContext: 2885 case Declarator::ForContext: 2886 case Declarator::InitStmtContext: 2887 case Declarator::ConditionContext: 2888 break; 2889 case Declarator::CXXNewContext: 2890 if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2891 Error = 17; // 'new' type 2892 break; 2893 case Declarator::KNRTypeListContext: 2894 Error = 18; // K&R function parameter 2895 break; 2896 } 2897 2898 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 2899 Error = 11; 2900 2901 // In Objective-C it is an error to use 'auto' on a function declarator 2902 // (and everywhere for '__auto_type'). 2903 if (D.isFunctionDeclarator() && 2904 (!SemaRef.getLangOpts().CPlusPlus11 || 2905 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type)) 2906 Error = 13; 2907 2908 bool HaveTrailing = false; 2909 2910 // C++11 [dcl.spec.auto]p2: 'auto' is always fine if the declarator 2911 // contains a trailing return type. That is only legal at the outermost 2912 // level. Check all declarator chunks (outermost first) anyway, to give 2913 // better diagnostics. 2914 // We don't support '__auto_type' with trailing return types. 2915 if (SemaRef.getLangOpts().CPlusPlus11 && 2916 D.getDeclSpec().getTypeSpecType() != DeclSpec::TST_auto_type) { 2917 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 2918 unsigned chunkIndex = e - i - 1; 2919 state.setCurrentChunkIndex(chunkIndex); 2920 DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); 2921 if (DeclType.Kind == DeclaratorChunk::Function) { 2922 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 2923 if (FTI.hasTrailingReturnType()) { 2924 HaveTrailing = true; 2925 Error = -1; 2926 break; 2927 } 2928 } 2929 } 2930 } 2931 2932 SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc(); 2933 if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) 2934 AutoRange = D.getName().getSourceRange(); 2935 2936 if (Error != -1) { 2937 unsigned Keyword; 2938 switch (D.getDeclSpec().getTypeSpecType()) { 2939 case DeclSpec::TST_auto: Keyword = 0; break; 2940 case DeclSpec::TST_decltype_auto: Keyword = 1; break; 2941 case DeclSpec::TST_auto_type: Keyword = 2; break; 2942 default: llvm_unreachable("unknown auto TypeSpecType"); 2943 } 2944 SemaRef.Diag(AutoRange.getBegin(), diag::err_auto_not_allowed) 2945 << Keyword << Error << AutoRange; 2946 T = SemaRef.Context.IntTy; 2947 D.setInvalidType(true); 2948 } else if (!HaveTrailing) { 2949 // If there was a trailing return type, we already got 2950 // warn_cxx98_compat_trailing_return_type in the parser. 2951 SemaRef.Diag(AutoRange.getBegin(), 2952 diag::warn_cxx98_compat_auto_type_specifier) 2953 << AutoRange; 2954 } 2955 } 2956 2957 if (SemaRef.getLangOpts().CPlusPlus && 2958 OwnedTagDecl && OwnedTagDecl->isCompleteDefinition()) { 2959 // Check the contexts where C++ forbids the declaration of a new class 2960 // or enumeration in a type-specifier-seq. 2961 unsigned DiagID = 0; 2962 switch (D.getContext()) { 2963 case Declarator::TrailingReturnContext: 2964 // Class and enumeration definitions are syntactically not allowed in 2965 // trailing return types. 2966 llvm_unreachable("parser should not have allowed this"); 2967 break; 2968 case Declarator::FileContext: 2969 case Declarator::MemberContext: 2970 case Declarator::BlockContext: 2971 case Declarator::ForContext: 2972 case Declarator::InitStmtContext: 2973 case Declarator::BlockLiteralContext: 2974 case Declarator::LambdaExprContext: 2975 // C++11 [dcl.type]p3: 2976 // A type-specifier-seq shall not define a class or enumeration unless 2977 // it appears in the type-id of an alias-declaration (7.1.3) that is not 2978 // the declaration of a template-declaration. 2979 case Declarator::AliasDeclContext: 2980 break; 2981 case Declarator::AliasTemplateContext: 2982 DiagID = diag::err_type_defined_in_alias_template; 2983 break; 2984 case Declarator::TypeNameContext: 2985 case Declarator::ConversionIdContext: 2986 case Declarator::TemplateParamContext: 2987 case Declarator::CXXNewContext: 2988 case Declarator::CXXCatchContext: 2989 case Declarator::ObjCCatchContext: 2990 case Declarator::TemplateTypeArgContext: 2991 DiagID = diag::err_type_defined_in_type_specifier; 2992 break; 2993 case Declarator::PrototypeContext: 2994 case Declarator::LambdaExprParameterContext: 2995 case Declarator::ObjCParameterContext: 2996 case Declarator::ObjCResultContext: 2997 case Declarator::KNRTypeListContext: 2998 // C++ [dcl.fct]p6: 2999 // Types shall not be defined in return or parameter types. 3000 DiagID = diag::err_type_defined_in_param_type; 3001 break; 3002 case Declarator::ConditionContext: 3003 // C++ 6.4p2: 3004 // The type-specifier-seq shall not contain typedef and shall not declare 3005 // a new class or enumeration. 3006 DiagID = diag::err_type_defined_in_condition; 3007 break; 3008 } 3009 3010 if (DiagID != 0) { 3011 SemaRef.Diag(OwnedTagDecl->getLocation(), DiagID) 3012 << SemaRef.Context.getTypeDeclType(OwnedTagDecl); 3013 D.setInvalidType(true); 3014 } 3015 } 3016 3017 assert(!T.isNull() && "This function should not return a null type"); 3018 return T; 3019} 3020 3021/// Produce an appropriate diagnostic for an ambiguity between a function 3022/// declarator and a C++ direct-initializer. 3023static void warnAboutAmbiguousFunction(Sema &S, Declarator &D, 3024 DeclaratorChunk &DeclType, QualType RT) { 3025 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 3026 assert(FTI.isAmbiguous && "no direct-initializer / function ambiguity"); 3027 3028 // If the return type is void there is no ambiguity. 3029 if (RT->isVoidType()) 3030 return; 3031 3032 // An initializer for a non-class type can have at most one argument. 3033 if (!RT->isRecordType() && FTI.NumParams > 1) 3034 return; 3035 3036 // An initializer for a reference must have exactly one argument. 3037 if (RT->isReferenceType() && FTI.NumParams != 1) 3038 return; 3039 3040 // Only warn if this declarator is declaring a function at block scope, and 3041 // doesn't have a storage class (such as 'extern') specified. 3042 if (!D.isFunctionDeclarator() || 3043 D.getFunctionDefinitionKind() != FDK_Declaration || 3044 !S.CurContext->isFunctionOrMethod() || 3045 D.getDeclSpec().getStorageClassSpec() 3046 != DeclSpec::SCS_unspecified) 3047 return; 3048 3049 // Inside a condition, a direct initializer is not permitted. We allow one to 3050 // be parsed in order to give better diagnostics in condition parsing. 3051 if (D.getContext() == Declarator::ConditionContext) 3052 return; 3053 3054 SourceRange ParenRange(DeclType.Loc, DeclType.EndLoc); 3055 3056 S.Diag(DeclType.Loc, 3057 FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration 3058 : diag::warn_empty_parens_are_function_decl) 3059 << ParenRange; 3060 3061 // If the declaration looks like: 3062 // T var1, 3063 // f(); 3064 // and name lookup finds a function named 'f', then the ',' was 3065 // probably intended to be a ';'. 3066 if (!D.isFirstDeclarator() && D.getIdentifier()) { 3067 FullSourceLoc Comma(D.getCommaLoc(), S.SourceMgr); 3068 FullSourceLoc Name(D.getIdentifierLoc(), S.SourceMgr); 3069 if (Comma.getFileID() != Name.getFileID() || 3070 Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) { 3071 LookupResult Result(S, D.getIdentifier(), SourceLocation(), 3072 Sema::LookupOrdinaryName); 3073 if (S.LookupName(Result, S.getCurScope())) 3074 S.Diag(D.getCommaLoc(), diag::note_empty_parens_function_call) 3075 << FixItHint::CreateReplacement(D.getCommaLoc(), ";") 3076 << D.getIdentifier(); 3077 } 3078 } 3079 3080 if (FTI.NumParams > 0) { 3081 // For a declaration with parameters, eg. "T var(T());", suggest adding 3082 // parens around the first parameter to turn the declaration into a 3083 // variable declaration. 3084 SourceRange Range = FTI.Params[0].Param->getSourceRange(); 3085 SourceLocation B = Range.getBegin(); 3086 SourceLocation E = S.getLocForEndOfToken(Range.getEnd()); 3087 // FIXME: Maybe we should suggest adding braces instead of parens 3088 // in C++11 for classes that don't have an initializer_list constructor. 3089 S.Diag(B, diag::note_additional_parens_for_variable_declaration) 3090 << FixItHint::CreateInsertion(B, "(") 3091 << FixItHint::CreateInsertion(E, ")"); 3092 } else { 3093 // For a declaration without parameters, eg. "T var();", suggest replacing 3094 // the parens with an initializer to turn the declaration into a variable 3095 // declaration. 3096 const CXXRecordDecl *RD = RT->getAsCXXRecordDecl(); 3097 3098 // Empty parens mean value-initialization, and no parens mean 3099 // default initialization. These are equivalent if the default 3100 // constructor is user-provided or if zero-initialization is a 3101 // no-op. 3102 if (RD && RD->hasDefinition() && 3103 (RD->isEmpty() || RD->hasUserProvidedDefaultConstructor())) 3104 S.Diag(DeclType.Loc, diag::note_empty_parens_default_ctor) 3105 << FixItHint::CreateRemoval(ParenRange); 3106 else { 3107 std::string Init = 3108 S.getFixItZeroInitializerForType(RT, ParenRange.getBegin()); 3109 if (Init.empty() && S.LangOpts.CPlusPlus11) 3110 Init = "{}"; 3111 if (!Init.empty()) 3112 S.Diag(DeclType.Loc, diag::note_empty_parens_zero_initialize) 3113 << FixItHint::CreateReplacement(ParenRange, Init); 3114 } 3115 } 3116} 3117 3118/// Helper for figuring out the default CC for a function declarator type. If 3119/// this is the outermost chunk, then we can determine the CC from the 3120/// declarator context. If not, then this could be either a member function 3121/// type or normal function type. 3122static CallingConv 3123getCCForDeclaratorChunk(Sema &S, Declarator &D, 3124 const DeclaratorChunk::FunctionTypeInfo &FTI, 3125 unsigned ChunkIndex) { 3126 assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function); 3127 3128 // Check for an explicit CC attribute. 3129 for (auto Attr = FTI.AttrList; Attr; Attr = Attr->getNext()) { 3130 switch (Attr->getKind()) { 3131 CALLING_CONV_ATTRS_CASELIST: { 3132 // Ignore attributes that don't validate or can't apply to the 3133 // function type. We'll diagnose the failure to apply them in 3134 // handleFunctionTypeAttr. 3135 CallingConv CC; 3136 if (!S.CheckCallingConvAttr(*Attr, CC) && 3137 (!FTI.isVariadic || supportsVariadicCall(CC))) { 3138 return CC; 3139 } 3140 break; 3141 } 3142 3143 default: 3144 break; 3145 } 3146 } 3147 3148 bool IsCXXInstanceMethod = false; 3149 3150 if (S.getLangOpts().CPlusPlus) { 3151 // Look inwards through parentheses to see if this chunk will form a 3152 // member pointer type or if we're the declarator. Any type attributes 3153 // between here and there will override the CC we choose here. 3154 unsigned I = ChunkIndex; 3155 bool FoundNonParen = false; 3156 while (I && !FoundNonParen) { 3157 --I; 3158 if (D.getTypeObject(I).Kind != DeclaratorChunk::Paren) 3159 FoundNonParen = true; 3160 } 3161 3162 if (FoundNonParen) { 3163 // If we're not the declarator, we're a regular function type unless we're 3164 // in a member pointer. 3165 IsCXXInstanceMethod = 3166 D.getTypeObject(I).Kind == DeclaratorChunk::MemberPointer; 3167 } else if (D.getContext() == Declarator::LambdaExprContext) { 3168 // This can only be a call operator for a lambda, which is an instance 3169 // method. 3170 IsCXXInstanceMethod = true; 3171 } else { 3172 // We're the innermost decl chunk, so must be a function declarator. 3173 assert(D.isFunctionDeclarator()); 3174 3175 // If we're inside a record, we're declaring a method, but it could be 3176 // explicitly or implicitly static. 3177 IsCXXInstanceMethod = 3178 D.isFirstDeclarationOfMember() && 3179 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 3180 !D.isStaticMember(); 3181 } 3182 } 3183 3184 CallingConv CC = S.Context.getDefaultCallingConvention(FTI.isVariadic, 3185 IsCXXInstanceMethod); 3186 3187 // Attribute AT_OpenCLKernel affects the calling convention for SPIR 3188 // and AMDGPU targets, hence it cannot be treated as a calling 3189 // convention attribute. This is the simplest place to infer 3190 // calling convention for OpenCL kernels. 3191 if (S.getLangOpts().OpenCL) { 3192 for (const AttributeList *Attr = D.getDeclSpec().getAttributes().getList(); 3193 Attr; Attr = Attr->getNext()) { 3194 if (Attr->getKind() == AttributeList::AT_OpenCLKernel) { 3195 llvm::Triple::ArchType arch = S.Context.getTargetInfo().getTriple().getArch(); 3196 if (arch == llvm::Triple::spir || arch == llvm::Triple::spir64 || 3197 arch == llvm::Triple::amdgcn) { 3198 CC = CC_OpenCLKernel; 3199 } 3200 break; 3201 } 3202 } 3203 } 3204 3205 return CC; 3206} 3207 3208namespace { 3209 /// A simple notion of pointer kinds, which matches up with the various 3210 /// pointer declarators. 3211 enum class SimplePointerKind { 3212 Pointer, 3213 BlockPointer, 3214 MemberPointer, 3215 }; 3216} // end anonymous namespace 3217 3218IdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) { 3219 switch (nullability) { 3220 case NullabilityKind::NonNull: 3221 if (!Ident__Nonnull) 3222 Ident__Nonnull = PP.getIdentifierInfo("_Nonnull"); 3223 return Ident__Nonnull; 3224 3225 case NullabilityKind::Nullable: 3226 if (!Ident__Nullable) 3227 Ident__Nullable = PP.getIdentifierInfo("_Nullable"); 3228 return Ident__Nullable; 3229 3230 case NullabilityKind::Unspecified: 3231 if (!Ident__Null_unspecified) 3232 Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified"); 3233 return Ident__Null_unspecified; 3234 } 3235 llvm_unreachable("Unknown nullability kind."); 3236} 3237 3238/// Retrieve the identifier "NSError". 3239IdentifierInfo *Sema::getNSErrorIdent() { 3240 if (!Ident_NSError) 3241 Ident_NSError = PP.getIdentifierInfo("NSError"); 3242 3243 return Ident_NSError; 3244} 3245 3246/// Check whether there is a nullability attribute of any kind in the given 3247/// attribute list. 3248static bool hasNullabilityAttr(const AttributeList *attrs) { 3249 for (const AttributeList *attr = attrs; attr; 3250 attr = attr->getNext()) { 3251 if (attr->getKind() == AttributeList::AT_TypeNonNull || 3252 attr->getKind() == AttributeList::AT_TypeNullable || 3253 attr->getKind() == AttributeList::AT_TypeNullUnspecified) 3254 return true; 3255 } 3256 3257 return false; 3258} 3259 3260namespace { 3261 /// Describes the kind of a pointer a declarator describes. 3262 enum class PointerDeclaratorKind { 3263 // Not a pointer. 3264 NonPointer, 3265 // Single-level pointer. 3266 SingleLevelPointer, 3267 // Multi-level pointer (of any pointer kind). 3268 MultiLevelPointer, 3269 // CFFooRef* 3270 MaybePointerToCFRef, 3271 // CFErrorRef* 3272 CFErrorRefPointer, 3273 // NSError** 3274 NSErrorPointerPointer, 3275 }; 3276} // end anonymous namespace 3277 3278/// Classify the given declarator, whose type-specified is \c type, based on 3279/// what kind of pointer it refers to. 3280/// 3281/// This is used to determine the default nullability. 3282static PointerDeclaratorKind classifyPointerDeclarator(Sema &S, 3283 QualType type, 3284 Declarator &declarator) { 3285 unsigned numNormalPointers = 0; 3286 3287 // For any dependent type, we consider it a non-pointer. 3288 if (type->isDependentType()) 3289 return PointerDeclaratorKind::NonPointer; 3290 3291 // Look through the declarator chunks to identify pointers. 3292 for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) { 3293 DeclaratorChunk &chunk = declarator.getTypeObject(i); 3294 switch (chunk.Kind) { 3295 case DeclaratorChunk::Array: 3296 case DeclaratorChunk::Function: 3297 case DeclaratorChunk::Pipe: 3298 break; 3299 3300 case DeclaratorChunk::BlockPointer: 3301 case DeclaratorChunk::MemberPointer: 3302 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3303 : PointerDeclaratorKind::SingleLevelPointer; 3304 3305 case DeclaratorChunk::Paren: 3306 case DeclaratorChunk::Reference: 3307 continue; 3308 3309 case DeclaratorChunk::Pointer: 3310 ++numNormalPointers; 3311 if (numNormalPointers > 2) 3312 return PointerDeclaratorKind::MultiLevelPointer; 3313 continue; 3314 } 3315 } 3316 3317 // Then, dig into the type specifier itself. 3318 unsigned numTypeSpecifierPointers = 0; 3319 do { 3320 // Decompose normal pointers. 3321 if (auto ptrType = type->getAs<PointerType>()) { 3322 ++numNormalPointers; 3323 3324 if (numNormalPointers > 2) 3325 return PointerDeclaratorKind::MultiLevelPointer; 3326 3327 type = ptrType->getPointeeType(); 3328 ++numTypeSpecifierPointers; 3329 continue; 3330 } 3331 3332 // Decompose block pointers. 3333 if (type->getAs<BlockPointerType>()) { 3334 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3335 : PointerDeclaratorKind::SingleLevelPointer; 3336 } 3337 3338 // Decompose member pointers. 3339 if (type->getAs<MemberPointerType>()) { 3340 return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3341 : PointerDeclaratorKind::SingleLevelPointer; 3342 } 3343 3344 // Look at Objective-C object pointers. 3345 if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) { 3346 ++numNormalPointers; 3347 ++numTypeSpecifierPointers; 3348 3349 // If this is NSError**, report that. 3350 if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) { 3351 if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() && 3352 numNormalPointers == 2 && numTypeSpecifierPointers < 2) { 3353 return PointerDeclaratorKind::NSErrorPointerPointer; 3354 } 3355 } 3356 3357 break; 3358 } 3359 3360 // Look at Objective-C class types. 3361 if (auto objcClass = type->getAs<ObjCInterfaceType>()) { 3362 if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) { 3363 if (numNormalPointers == 2 && numTypeSpecifierPointers < 2) 3364 return PointerDeclaratorKind::NSErrorPointerPointer;; 3365 } 3366 3367 break; 3368 } 3369 3370 // If at this point we haven't seen a pointer, we won't see one. 3371 if (numNormalPointers == 0) 3372 return PointerDeclaratorKind::NonPointer; 3373 3374 if (auto recordType = type->getAs<RecordType>()) { 3375 RecordDecl *recordDecl = recordType->getDecl(); 3376 3377 bool isCFError = false; 3378 if (S.CFError) { 3379 // If we already know about CFError, test it directly. 3380 isCFError = (S.CFError == recordDecl); 3381 } else { 3382 // Check whether this is CFError, which we identify based on its bridge 3383 // to NSError. 3384 if (recordDecl->getTagKind() == TTK_Struct && numNormalPointers > 0) { 3385 if (auto bridgeAttr = recordDecl->getAttr<ObjCBridgeAttr>()) { 3386 if (bridgeAttr->getBridgedType() == S.getNSErrorIdent()) { 3387 S.CFError = recordDecl; 3388 isCFError = true; 3389 } 3390 } 3391 } 3392 } 3393 3394 // If this is CFErrorRef*, report it as such. 3395 if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) { 3396 return PointerDeclaratorKind::CFErrorRefPointer; 3397 } 3398 break; 3399 } 3400 3401 break; 3402 } while (true); 3403 3404 switch (numNormalPointers) { 3405 case 0: 3406 return PointerDeclaratorKind::NonPointer; 3407 3408 case 1: 3409 return PointerDeclaratorKind::SingleLevelPointer; 3410 3411 case 2: 3412 return PointerDeclaratorKind::MaybePointerToCFRef; 3413 3414 default: 3415 return PointerDeclaratorKind::MultiLevelPointer; 3416 } 3417} 3418 3419static FileID getNullabilityCompletenessCheckFileID(Sema &S, 3420 SourceLocation loc) { 3421 // If we're anywhere in a function, method, or closure context, don't perform 3422 // completeness checks. 3423 for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) { 3424 if (ctx->isFunctionOrMethod()) 3425 return FileID(); 3426 3427 if (ctx->isFileContext()) 3428 break; 3429 } 3430 3431 // We only care about the expansion location. 3432 loc = S.SourceMgr.getExpansionLoc(loc); 3433 FileID file = S.SourceMgr.getFileID(loc); 3434 if (file.isInvalid()) 3435 return FileID(); 3436 3437 // Retrieve file information. 3438 bool invalid = false; 3439 const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid); 3440 if (invalid || !sloc.isFile()) 3441 return FileID(); 3442 3443 // We don't want to perform completeness checks on the main file or in 3444 // system headers. 3445 const SrcMgr::FileInfo &fileInfo = sloc.getFile(); 3446 if (fileInfo.getIncludeLoc().isInvalid()) 3447 return FileID(); 3448 if (fileInfo.getFileCharacteristic() != SrcMgr::C_User && 3449 S.Diags.getSuppressSystemWarnings()) { 3450 return FileID(); 3451 } 3452 3453 return file; 3454} 3455 3456/// Check for consistent use of nullability. 3457static void checkNullabilityConsistency(TypeProcessingState &state, 3458 SimplePointerKind pointerKind, 3459 SourceLocation pointerLoc) { 3460 Sema &S = state.getSema(); 3461 3462 // Determine which file we're performing consistency checking for. 3463 FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc); 3464 if (file.isInvalid()) 3465 return; 3466 3467 // If we haven't seen any type nullability in this file, we won't warn now 3468 // about anything. 3469 FileNullability &fileNullability = S.NullabilityMap[file]; 3470 if (!fileNullability.SawTypeNullability) { 3471 // If this is the first pointer declarator in the file, record it. 3472 if (fileNullability.PointerLoc.isInvalid() && 3473 !S.Context.getDiagnostics().isIgnored(diag::warn_nullability_missing, 3474 pointerLoc)) { 3475 fileNullability.PointerLoc = pointerLoc; 3476 fileNullability.PointerKind = static_cast<unsigned>(pointerKind); 3477 } 3478 3479 return; 3480 } 3481 3482 // Complain about missing nullability. 3483 S.Diag(pointerLoc, diag::warn_nullability_missing) 3484 << static_cast<unsigned>(pointerKind); 3485} 3486 3487static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, 3488 QualType declSpecType, 3489 TypeSourceInfo *TInfo) { 3490 // The TypeSourceInfo that this function returns will not be a null type. 3491 // If there is an error, this function will fill in a dummy type as fallback. 3492 QualType T = declSpecType; 3493 Declarator &D = state.getDeclarator(); 3494 Sema &S = state.getSema(); 3495 ASTContext &Context = S.Context; 3496 const LangOptions &LangOpts = S.getLangOpts(); 3497 3498 // The name we're declaring, if any. 3499 DeclarationName Name; 3500 if (D.getIdentifier()) 3501 Name = D.getIdentifier(); 3502 3503 // Does this declaration declare a typedef-name? 3504 bool IsTypedefName = 3505 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef || 3506 D.getContext() == Declarator::AliasDeclContext || 3507 D.getContext() == Declarator::AliasTemplateContext; 3508 3509 // Does T refer to a function type with a cv-qualifier or a ref-qualifier? 3510 bool IsQualifiedFunction = T->isFunctionProtoType() && 3511 (T->castAs<FunctionProtoType>()->getTypeQuals() != 0 || 3512 T->castAs<FunctionProtoType>()->getRefQualifier() != RQ_None); 3513 3514 // If T is 'decltype(auto)', the only declarators we can have are parens 3515 // and at most one function declarator if this is a function declaration. 3516 if (const AutoType *AT = T->getAs<AutoType>()) { 3517 if (AT->isDecltypeAuto()) { 3518 for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 3519 unsigned Index = E - I - 1; 3520 DeclaratorChunk &DeclChunk = D.getTypeObject(Index); 3521 unsigned DiagId = diag::err_decltype_auto_compound_type; 3522 unsigned DiagKind = 0; 3523 switch (DeclChunk.Kind) { 3524 case DeclaratorChunk::Paren: 3525 continue; 3526 case DeclaratorChunk::Function: { 3527 unsigned FnIndex; 3528 if (D.isFunctionDeclarationContext() && 3529 D.isFunctionDeclarator(FnIndex) && FnIndex == Index) 3530 continue; 3531 DiagId = diag::err_decltype_auto_function_declarator_not_declaration; 3532 break; 3533 } 3534 case DeclaratorChunk::Pointer: 3535 case DeclaratorChunk::BlockPointer: 3536 case DeclaratorChunk::MemberPointer: 3537 DiagKind = 0; 3538 break; 3539 case DeclaratorChunk::Reference: 3540 DiagKind = 1; 3541 break; 3542 case DeclaratorChunk::Array: 3543 DiagKind = 2; 3544 break; 3545 case DeclaratorChunk::Pipe: 3546 break; 3547 } 3548 3549 S.Diag(DeclChunk.Loc, DiagId) << DiagKind; 3550 D.setInvalidType(true); 3551 break; 3552 } 3553 } 3554 } 3555 3556 // Determine whether we should infer _Nonnull on pointer types. 3557 Optional<NullabilityKind> inferNullability; 3558 bool inferNullabilityCS = false; 3559 bool inferNullabilityInnerOnly = false; 3560 bool inferNullabilityInnerOnlyComplete = false; 3561 3562 // Are we in an assume-nonnull region? 3563 bool inAssumeNonNullRegion = false; 3564 if (S.PP.getPragmaAssumeNonNullLoc().isValid()) { 3565 inAssumeNonNullRegion = true; 3566 // Determine which file we saw the assume-nonnull region in. 3567 FileID file = getNullabilityCompletenessCheckFileID( 3568 S, S.PP.getPragmaAssumeNonNullLoc()); 3569 if (file.isValid()) { 3570 FileNullability &fileNullability = S.NullabilityMap[file]; 3571 3572 // If we haven't seen any type nullability before, now we have. 3573 if (!fileNullability.SawTypeNullability) { 3574 if (fileNullability.PointerLoc.isValid()) { 3575 S.Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) 3576 << static_cast<unsigned>(fileNullability.PointerKind); 3577 } 3578 3579 fileNullability.SawTypeNullability = true; 3580 } 3581 } 3582 } 3583 3584 // Whether to complain about missing nullability specifiers or not. 3585 enum { 3586 /// Never complain. 3587 CAMN_No, 3588 /// Complain on the inner pointers (but not the outermost 3589 /// pointer). 3590 CAMN_InnerPointers, 3591 /// Complain about any pointers that don't have nullability 3592 /// specified or inferred. 3593 CAMN_Yes 3594 } complainAboutMissingNullability = CAMN_No; 3595 unsigned NumPointersRemaining = 0; 3596 3597 if (IsTypedefName) { 3598 // For typedefs, we do not infer any nullability (the default), 3599 // and we only complain about missing nullability specifiers on 3600 // inner pointers. 3601 complainAboutMissingNullability = CAMN_InnerPointers; 3602 3603 if (T->canHaveNullability() && !T->getNullability(S.Context)) { 3604 ++NumPointersRemaining; 3605 } 3606 3607 for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) { 3608 DeclaratorChunk &chunk = D.getTypeObject(i); 3609 switch (chunk.Kind) { 3610 case DeclaratorChunk::Array: 3611 case DeclaratorChunk::Function: 3612 case DeclaratorChunk::Pipe: 3613 break; 3614 3615 case DeclaratorChunk::BlockPointer: 3616 case DeclaratorChunk::MemberPointer: 3617 ++NumPointersRemaining; 3618 break; 3619 3620 case DeclaratorChunk::Paren: 3621 case DeclaratorChunk::Reference: 3622 continue; 3623 3624 case DeclaratorChunk::Pointer: 3625 ++NumPointersRemaining; 3626 continue; 3627 } 3628 } 3629 } else { 3630 bool isFunctionOrMethod = false; 3631 switch (auto context = state.getDeclarator().getContext()) { 3632 case Declarator::ObjCParameterContext: 3633 case Declarator::ObjCResultContext: 3634 case Declarator::PrototypeContext: 3635 case Declarator::TrailingReturnContext: 3636 isFunctionOrMethod = true; 3637 // fallthrough 3638 3639 case Declarator::MemberContext: 3640 if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) { 3641 complainAboutMissingNullability = CAMN_No; 3642 break; 3643 } 3644 3645 // Weak properties are inferred to be nullable. 3646 if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) { 3647 inferNullability = NullabilityKind::Nullable; 3648 break; 3649 } 3650 3651 // fallthrough 3652 3653 case Declarator::FileContext: 3654 case Declarator::KNRTypeListContext: 3655 complainAboutMissingNullability = CAMN_Yes; 3656 3657 // Nullability inference depends on the type and declarator. 3658 switch (classifyPointerDeclarator(S, T, D)) { 3659 case PointerDeclaratorKind::NonPointer: 3660 case PointerDeclaratorKind::MultiLevelPointer: 3661 // Cannot infer nullability. 3662 break; 3663 3664 case PointerDeclaratorKind::SingleLevelPointer: 3665 // Infer _Nonnull if we are in an assumes-nonnull region. 3666 if (inAssumeNonNullRegion) { 3667 inferNullability = NullabilityKind::NonNull; 3668 inferNullabilityCS = (context == Declarator::ObjCParameterContext || 3669 context == Declarator::ObjCResultContext); 3670 } 3671 break; 3672 3673 case PointerDeclaratorKind::CFErrorRefPointer: 3674 case PointerDeclaratorKind::NSErrorPointerPointer: 3675 // Within a function or method signature, infer _Nullable at both 3676 // levels. 3677 if (isFunctionOrMethod && inAssumeNonNullRegion) 3678 inferNullability = NullabilityKind::Nullable; 3679 break; 3680 3681 case PointerDeclaratorKind::MaybePointerToCFRef: 3682 if (isFunctionOrMethod) { 3683 // On pointer-to-pointer parameters marked cf_returns_retained or 3684 // cf_returns_not_retained, if the outer pointer is explicit then 3685 // infer the inner pointer as _Nullable. 3686 auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool { 3687 while (NextAttr) { 3688 if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained || 3689 NextAttr->getKind() == AttributeList::AT_CFReturnsNotRetained) 3690 return true; 3691 NextAttr = NextAttr->getNext(); 3692 } 3693 return false; 3694 }; 3695 if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) { 3696 if (hasCFReturnsAttr(D.getAttributes()) || 3697 hasCFReturnsAttr(InnermostChunk->getAttrs()) || 3698 hasCFReturnsAttr(D.getDeclSpec().getAttributes().getList())) { 3699 inferNullability = NullabilityKind::Nullable; 3700 inferNullabilityInnerOnly = true; 3701 } 3702 } 3703 } 3704 break; 3705 } 3706 break; 3707 3708 case Declarator::ConversionIdContext: 3709 complainAboutMissingNullability = CAMN_Yes; 3710 break; 3711 3712 case Declarator::AliasDeclContext: 3713 case Declarator::AliasTemplateContext: 3714 case Declarator::BlockContext: 3715 case Declarator::BlockLiteralContext: 3716 case Declarator::ConditionContext: 3717 case Declarator::CXXCatchContext: 3718 case Declarator::CXXNewContext: 3719 case Declarator::ForContext: 3720 case Declarator::InitStmtContext: 3721 case Declarator::LambdaExprContext: 3722 case Declarator::LambdaExprParameterContext: 3723 case Declarator::ObjCCatchContext: 3724 case Declarator::TemplateParamContext: 3725 case Declarator::TemplateTypeArgContext: 3726 case Declarator::TypeNameContext: 3727 // Don't infer in these contexts. 3728 break; 3729 } 3730 } 3731 3732 // Local function that checks the nullability for a given pointer declarator. 3733 // Returns true if _Nonnull was inferred. 3734 auto inferPointerNullability = [&](SimplePointerKind pointerKind, 3735 SourceLocation pointerLoc, 3736 AttributeList *&attrs) -> AttributeList * { 3737 // We've seen a pointer. 3738 if (NumPointersRemaining > 0) 3739 --NumPointersRemaining; 3740 3741 // If a nullability attribute is present, there's nothing to do. 3742 if (hasNullabilityAttr(attrs)) 3743 return nullptr; 3744 3745 // If we're supposed to infer nullability, do so now. 3746 if (inferNullability && !inferNullabilityInnerOnlyComplete) { 3747 AttributeList::Syntax syntax 3748 = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword 3749 : AttributeList::AS_Keyword; 3750 AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool() 3751 .create( 3752 S.getNullabilityKeyword( 3753 *inferNullability), 3754 SourceRange(pointerLoc), 3755 nullptr, SourceLocation(), 3756 nullptr, 0, syntax); 3757 3758 spliceAttrIntoList(*nullabilityAttr, attrs); 3759 3760 if (inferNullabilityCS) { 3761 state.getDeclarator().getMutableDeclSpec().getObjCQualifiers() 3762 ->setObjCDeclQualifier(ObjCDeclSpec::DQ_CSNullability); 3763 } 3764 3765 if (inferNullabilityInnerOnly) 3766 inferNullabilityInnerOnlyComplete = true; 3767 return nullabilityAttr; 3768 } 3769 3770 // If we're supposed to complain about missing nullability, do so 3771 // now if it's truly missing. 3772 switch (complainAboutMissingNullability) { 3773 case CAMN_No: 3774 break; 3775 3776 case CAMN_InnerPointers: 3777 if (NumPointersRemaining == 0) 3778 break; 3779 // Fallthrough. 3780 3781 case CAMN_Yes: 3782 checkNullabilityConsistency(state, pointerKind, pointerLoc); 3783 } 3784 return nullptr; 3785 }; 3786 3787 // If the type itself could have nullability but does not, infer pointer 3788 // nullability and perform consistency checking. 3789 if (T->canHaveNullability() && S.ActiveTemplateInstantiations.empty() && 3790 !T->getNullability(S.Context)) { 3791 SimplePointerKind pointerKind = SimplePointerKind::Pointer; 3792 if (T->isBlockPointerType()) 3793 pointerKind = SimplePointerKind::BlockPointer; 3794 else if (T->isMemberPointerType()) 3795 pointerKind = SimplePointerKind::MemberPointer; 3796 3797 if (auto *attr = inferPointerNullability( 3798 pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(), 3799 D.getMutableDeclSpec().getAttributes().getListRef())) { 3800 T = Context.getAttributedType( 3801 AttributedType::getNullabilityAttrKind(*inferNullability), T, T); 3802 attr->setUsedAsTypeAttr(); 3803 } 3804 } 3805 3806 // Walk the DeclTypeInfo, building the recursive type as we go. 3807 // DeclTypeInfos are ordered from the identifier out, which is 3808 // opposite of what we want :). 3809 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 3810 unsigned chunkIndex = e - i - 1; 3811 state.setCurrentChunkIndex(chunkIndex); 3812 DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); 3813 IsQualifiedFunction &= DeclType.Kind == DeclaratorChunk::Paren; 3814 switch (DeclType.Kind) { 3815 case DeclaratorChunk::Paren: 3816 T = S.BuildParenType(T); 3817 break; 3818 case DeclaratorChunk::BlockPointer: 3819 // If blocks are disabled, emit an error. 3820 if (!LangOpts.Blocks) 3821 S.Diag(DeclType.Loc, diag::err_blocks_disable) << LangOpts.OpenCL; 3822 3823 // Handle pointer nullability. 3824 inferPointerNullability(SimplePointerKind::BlockPointer, 3825 DeclType.Loc, DeclType.getAttrListRef()); 3826 3827 T = S.BuildBlockPointerType(T, D.getIdentifierLoc(), Name); 3828 if (DeclType.Cls.TypeQuals || LangOpts.OpenCL) { 3829 // OpenCL v2.0, s6.12.5 - Block variable declarations are implicitly 3830 // qualified with const. 3831 if (LangOpts.OpenCL) 3832 DeclType.Cls.TypeQuals |= DeclSpec::TQ_const; 3833 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals); 3834 } 3835 break; 3836 case DeclaratorChunk::Pointer: 3837 // Verify that we're not building a pointer to pointer to function with 3838 // exception specification. 3839 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3840 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3841 D.setInvalidType(true); 3842 // Build the type anyway. 3843 } 3844 3845 // Handle pointer nullability 3846 inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc, 3847 DeclType.getAttrListRef()); 3848 3849 if (LangOpts.ObjC1 && T->getAs<ObjCObjectType>()) { 3850 T = Context.getObjCObjectPointerType(T); 3851 if (DeclType.Ptr.TypeQuals) 3852 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals); 3853 break; 3854 } 3855 3856 // OpenCL v2.0 s6.9b - Pointer to image/sampler cannot be used. 3857 // OpenCL v2.0 s6.13.16.1 - Pointer to pipe cannot be used. 3858 // OpenCL v2.0 s6.12.5 - Pointers to Blocks are not allowed. 3859 if (LangOpts.OpenCL) { 3860 if (T->isImageType() || T->isSamplerT() || T->isPipeType() || 3861 T->isBlockPointerType()) { 3862 S.Diag(D.getIdentifierLoc(), diag::err_opencl_pointer_to_type) << T; 3863 D.setInvalidType(true); 3864 } 3865 } 3866 3867 T = S.BuildPointerType(T, DeclType.Loc, Name); 3868 if (DeclType.Ptr.TypeQuals) 3869 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals); 3870 break; 3871 case DeclaratorChunk::Reference: { 3872 // Verify that we're not building a reference to pointer to function with 3873 // exception specification. 3874 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3875 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3876 D.setInvalidType(true); 3877 // Build the type anyway. 3878 } 3879 T = S.BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name); 3880 3881 if (DeclType.Ref.HasRestrict) 3882 T = S.BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict); 3883 break; 3884 } 3885 case DeclaratorChunk::Array: { 3886 // Verify that we're not building an array of pointers to function with 3887 // exception specification. 3888 if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3889 S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3890 D.setInvalidType(true); 3891 // Build the type anyway. 3892 } 3893 DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr; 3894 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts); 3895 ArrayType::ArraySizeModifier ASM; 3896 if (ATI.isStar) 3897 ASM = ArrayType::Star; 3898 else if (ATI.hasStatic) 3899 ASM = ArrayType::Static; 3900 else 3901 ASM = ArrayType::Normal; 3902 if (ASM == ArrayType::Star && !D.isPrototypeContext()) { 3903 // FIXME: This check isn't quite right: it allows star in prototypes 3904 // for function definitions, and disallows some edge cases detailed 3905 // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html 3906 S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype); 3907 ASM = ArrayType::Normal; 3908 D.setInvalidType(true); 3909 } 3910 3911 // C99 6.7.5.2p1: The optional type qualifiers and the keyword static 3912 // shall appear only in a declaration of a function parameter with an 3913 // array type, ... 3914 if (ASM == ArrayType::Static || ATI.TypeQuals) { 3915 if (!(D.isPrototypeContext() || 3916 D.getContext() == Declarator::KNRTypeListContext)) { 3917 S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) << 3918 (ASM == ArrayType::Static ? "'static'" : "type qualifier"); 3919 // Remove the 'static' and the type qualifiers. 3920 if (ASM == ArrayType::Static) 3921 ASM = ArrayType::Normal; 3922 ATI.TypeQuals = 0; 3923 D.setInvalidType(true); 3924 } 3925 3926 // C99 6.7.5.2p1: ... and then only in the outermost array type 3927 // derivation. 3928 unsigned x = chunkIndex; 3929 while (x != 0) { 3930 // Walk outwards along the declarator chunks. 3931 x--; 3932 const DeclaratorChunk &DC = D.getTypeObject(x); 3933 switch (DC.Kind) { 3934 case DeclaratorChunk::Paren: 3935 continue; 3936 case DeclaratorChunk::Array: 3937 case DeclaratorChunk::Pointer: 3938 case DeclaratorChunk::Reference: 3939 case DeclaratorChunk::MemberPointer: 3940 S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) << 3941 (ASM == ArrayType::Static ? "'static'" : "type qualifier"); 3942 if (ASM == ArrayType::Static) 3943 ASM = ArrayType::Normal; 3944 ATI.TypeQuals = 0; 3945 D.setInvalidType(true); 3946 break; 3947 case DeclaratorChunk::Function: 3948 case DeclaratorChunk::BlockPointer: 3949 case DeclaratorChunk::Pipe: 3950 // These are invalid anyway, so just ignore. 3951 break; 3952 } 3953 } 3954 } 3955 const AutoType *AT = T->getContainedAutoType(); 3956 // Allow arrays of auto if we are a generic lambda parameter. 3957 // i.e. [](auto (&array)[5]) { return array[0]; }; OK 3958 if (AT && D.getContext() != Declarator::LambdaExprParameterContext) { 3959 // We've already diagnosed this for decltype(auto). 3960 if (!AT->isDecltypeAuto()) 3961 S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto) 3962 << getPrintableNameForEntity(Name) << T; 3963 T = QualType(); 3964 break; 3965 } 3966 3967 T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals, 3968 SourceRange(DeclType.Loc, DeclType.EndLoc), Name); 3969 break; 3970 } 3971 case DeclaratorChunk::Function: { 3972 // If the function declarator has a prototype (i.e. it is not () and 3973 // does not have a K&R-style identifier list), then the arguments are part 3974 // of the type, otherwise the argument list is (). 3975 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 3976 IsQualifiedFunction = FTI.TypeQuals || FTI.hasRefQualifier(); 3977 3978 // Check for auto functions and trailing return type and adjust the 3979 // return type accordingly. 3980 if (!D.isInvalidType()) { 3981 // trailing-return-type is only required if we're declaring a function, 3982 // and not, for instance, a pointer to a function. 3983 if (D.getDeclSpec().containsPlaceholderType() && 3984 !FTI.hasTrailingReturnType() && chunkIndex == 0 && 3985 !S.getLangOpts().CPlusPlus14) { 3986 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 3987 D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto 3988 ? diag::err_auto_missing_trailing_return 3989 : diag::err_deduced_return_type); 3990 T = Context.IntTy; 3991 D.setInvalidType(true); 3992 } else if (FTI.hasTrailingReturnType()) { 3993 // T must be exactly 'auto' at this point. See CWG issue 681. 3994 if (isa<ParenType>(T)) { 3995 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 3996 diag::err_trailing_return_in_parens) 3997 << T << D.getDeclSpec().getSourceRange(); 3998 D.setInvalidType(true); 3999 } else if (D.getContext() != Declarator::LambdaExprContext && 4000 (T.hasQualifiers() || !isa<AutoType>(T) || 4001 cast<AutoType>(T)->getKeyword() != AutoTypeKeyword::Auto)) { 4002 S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 4003 diag::err_trailing_return_without_auto) 4004 << T << D.getDeclSpec().getSourceRange(); 4005 D.setInvalidType(true); 4006 } 4007 T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo); 4008 if (T.isNull()) { 4009 // An error occurred parsing the trailing return type. 4010 T = Context.IntTy; 4011 D.setInvalidType(true); 4012 } 4013 } 4014 } 4015 4016 // C99 6.7.5.3p1: The return type may not be a function or array type. 4017 // For conversion functions, we'll diagnose this particular error later. 4018 if ((T->isArrayType() || T->isFunctionType()) && 4019 (D.getName().getKind() != UnqualifiedId::IK_ConversionFunctionId)) { 4020 unsigned diagID = diag::err_func_returning_array_function; 4021 // Last processing chunk in block context means this function chunk 4022 // represents the block. 4023 if (chunkIndex == 0 && 4024 D.getContext() == Declarator::BlockLiteralContext) 4025 diagID = diag::err_block_returning_array_function; 4026 S.Diag(DeclType.Loc, diagID) << T->isFunctionType() << T; 4027 T = Context.IntTy; 4028 D.setInvalidType(true); 4029 } 4030 4031 // Do not allow returning half FP value. 4032 // FIXME: This really should be in BuildFunctionType. 4033 if (T->isHalfType()) { 4034 if (S.getLangOpts().OpenCL) { 4035 if (!S.getOpenCLOptions().cl_khr_fp16) { 4036 S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return) 4037 << T << 0 /*pointer hint*/; 4038 D.setInvalidType(true); 4039 } 4040 } else if (!S.getLangOpts().HalfArgsAndReturns) { 4041 S.Diag(D.getIdentifierLoc(), 4042 diag::err_parameters_retval_cannot_have_fp16_type) << 1; 4043 D.setInvalidType(true); 4044 } 4045 } 4046 4047 // OpenCL v2.0 s6.12.5 - A block cannot be the return value of a 4048 // function. 4049 if (LangOpts.OpenCL && (T->isBlockPointerType() || T->isImageType() || 4050 T->isSamplerT() || T->isPipeType())) { 4051 S.Diag(D.getIdentifierLoc(), diag::err_opencl_invalid_return) 4052 << T << 1 /*hint off*/; 4053 D.setInvalidType(true); 4054 } 4055 4056 // Methods cannot return interface types. All ObjC objects are 4057 // passed by reference. 4058 if (T->isObjCObjectType()) { 4059 SourceLocation DiagLoc, FixitLoc; 4060 if (TInfo) { 4061 DiagLoc = TInfo->getTypeLoc().getLocStart(); 4062 FixitLoc = S.getLocForEndOfToken(TInfo->getTypeLoc().getLocEnd()); 4063 } else { 4064 DiagLoc = D.getDeclSpec().getTypeSpecTypeLoc(); 4065 FixitLoc = S.getLocForEndOfToken(D.getDeclSpec().getLocEnd()); 4066 } 4067 S.Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value) 4068 << 0 << T 4069 << FixItHint::CreateInsertion(FixitLoc, "*"); 4070 4071 T = Context.getObjCObjectPointerType(T); 4072 if (TInfo) { 4073 TypeLocBuilder TLB; 4074 TLB.pushFullCopy(TInfo->getTypeLoc()); 4075 ObjCObjectPointerTypeLoc TLoc = TLB.push<ObjCObjectPointerTypeLoc>(T); 4076 TLoc.setStarLoc(FixitLoc); 4077 TInfo = TLB.getTypeSourceInfo(Context, T); 4078 } 4079 4080 D.setInvalidType(true); 4081 } 4082 4083 // cv-qualifiers on return types are pointless except when the type is a 4084 // class type in C++. 4085 if ((T.getCVRQualifiers() || T->isAtomicType()) && 4086 !(S.getLangOpts().CPlusPlus && 4087 (T->isDependentType() || T->isRecordType()))) { 4088 if (T->isVoidType() && !S.getLangOpts().CPlusPlus && 4089 D.getFunctionDefinitionKind() == FDK_Definition) { 4090 // [6.9.1/3] qualified void return is invalid on a C 4091 // function definition. Apparently ok on declarations and 4092 // in C++ though (!) 4093 S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T; 4094 } else 4095 diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex); 4096 } 4097 4098 // Objective-C ARC ownership qualifiers are ignored on the function 4099 // return type (by type canonicalization). Complain if this attribute 4100 // was written here. 4101 if (T.getQualifiers().hasObjCLifetime()) { 4102 SourceLocation AttrLoc; 4103 if (chunkIndex + 1 < D.getNumTypeObjects()) { 4104 DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1); 4105 for (const AttributeList *Attr = ReturnTypeChunk.getAttrs(); 4106 Attr; Attr = Attr->getNext()) { 4107 if (Attr->getKind() == AttributeList::AT_ObjCOwnership) { 4108 AttrLoc = Attr->getLoc(); 4109 break; 4110 } 4111 } 4112 } 4113 if (AttrLoc.isInvalid()) { 4114 for (const AttributeList *Attr 4115 = D.getDeclSpec().getAttributes().getList(); 4116 Attr; Attr = Attr->getNext()) { 4117 if (Attr->getKind() == AttributeList::AT_ObjCOwnership) { 4118 AttrLoc = Attr->getLoc(); 4119 break; 4120 } 4121 } 4122 } 4123 4124 if (AttrLoc.isValid()) { 4125 // The ownership attributes are almost always written via 4126 // the predefined 4127 // __strong/__weak/__autoreleasing/__unsafe_unretained. 4128 if (AttrLoc.isMacroID()) 4129 AttrLoc = S.SourceMgr.getImmediateExpansionRange(AttrLoc).first; 4130 4131 S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type) 4132 << T.getQualifiers().getObjCLifetime(); 4133 } 4134 } 4135 4136 if (LangOpts.CPlusPlus && D.getDeclSpec().hasTagDefinition()) { 4137 // C++ [dcl.fct]p6: 4138 // Types shall not be defined in return or parameter types. 4139 TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 4140 S.Diag(Tag->getLocation(), diag::err_type_defined_in_result_type) 4141 << Context.getTypeDeclType(Tag); 4142 } 4143 4144 // Exception specs are not allowed in typedefs. Complain, but add it 4145 // anyway. 4146 if (IsTypedefName && FTI.getExceptionSpecType()) 4147 S.Diag(FTI.getExceptionSpecLocBeg(), 4148 diag::err_exception_spec_in_typedef) 4149 << (D.getContext() == Declarator::AliasDeclContext || 4150 D.getContext() == Declarator::AliasTemplateContext); 4151 4152 // If we see "T var();" or "T var(T());" at block scope, it is probably 4153 // an attempt to initialize a variable, not a function declaration. 4154 if (FTI.isAmbiguous) 4155 warnAboutAmbiguousFunction(S, D, DeclType, T); 4156 4157 FunctionType::ExtInfo EI(getCCForDeclaratorChunk(S, D, FTI, chunkIndex)); 4158 4159 if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.CPlusPlus) { 4160 // Simple void foo(), where the incoming T is the result type. 4161 T = Context.getFunctionNoProtoType(T, EI); 4162 } else { 4163 // We allow a zero-parameter variadic function in C if the 4164 // function is marked with the "overloadable" attribute. Scan 4165 // for this attribute now. 4166 if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus) { 4167 bool Overloadable = false; 4168 for (const AttributeList *Attrs = D.getAttributes(); 4169 Attrs; Attrs = Attrs->getNext()) { 4170 if (Attrs->getKind() == AttributeList::AT_Overloadable) { 4171 Overloadable = true; 4172 break; 4173 } 4174 } 4175 4176 if (!Overloadable) 4177 S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param); 4178 } 4179 4180 if (FTI.NumParams && FTI.Params[0].Param == nullptr) { 4181 // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function 4182 // definition. 4183 S.Diag(FTI.Params[0].IdentLoc, 4184 diag::err_ident_list_in_fn_declaration); 4185 D.setInvalidType(true); 4186 // Recover by creating a K&R-style function type. 4187 T = Context.getFunctionNoProtoType(T, EI); 4188 break; 4189 } 4190 4191 FunctionProtoType::ExtProtoInfo EPI; 4192 EPI.ExtInfo = EI; 4193 EPI.Variadic = FTI.isVariadic; 4194 EPI.HasTrailingReturn = FTI.hasTrailingReturnType(); 4195 EPI.TypeQuals = FTI.TypeQuals; 4196 EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None 4197 : FTI.RefQualifierIsLValueRef? RQ_LValue 4198 : RQ_RValue; 4199 4200 // Otherwise, we have a function with a parameter list that is 4201 // potentially variadic. 4202 SmallVector<QualType, 16> ParamTys; 4203 ParamTys.reserve(FTI.NumParams); 4204 4205 SmallVector<FunctionProtoType::ExtParameterInfo, 16> 4206 ExtParameterInfos(FTI.NumParams); 4207 bool HasAnyInterestingExtParameterInfos = false; 4208 4209 for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) { 4210 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 4211 QualType ParamTy = Param->getType(); 4212 assert(!ParamTy.isNull() && "Couldn't parse type?"); 4213 4214 // Look for 'void'. void is allowed only as a single parameter to a 4215 // function with no other parameters (C99 6.7.5.3p10). We record 4216 // int(void) as a FunctionProtoType with an empty parameter list. 4217 if (ParamTy->isVoidType()) { 4218 // If this is something like 'float(int, void)', reject it. 'void' 4219 // is an incomplete type (C99 6.2.5p19) and function decls cannot 4220 // have parameters of incomplete type. 4221 if (FTI.NumParams != 1 || FTI.isVariadic) { 4222 S.Diag(DeclType.Loc, diag::err_void_only_param); 4223 ParamTy = Context.IntTy; 4224 Param->setType(ParamTy); 4225 } else if (FTI.Params[i].Ident) { 4226 // Reject, but continue to parse 'int(void abc)'. 4227 S.Diag(FTI.Params[i].IdentLoc, diag::err_param_with_void_type); 4228 ParamTy = Context.IntTy; 4229 Param->setType(ParamTy); 4230 } else { 4231 // Reject, but continue to parse 'float(const void)'. 4232 if (ParamTy.hasQualifiers()) 4233 S.Diag(DeclType.Loc, diag::err_void_param_qualified); 4234 4235 // Do not add 'void' to the list. 4236 break; 4237 } 4238 } else if (ParamTy->isHalfType()) { 4239 // Disallow half FP parameters. 4240 // FIXME: This really should be in BuildFunctionType. 4241 if (S.getLangOpts().OpenCL) { 4242 if (!S.getOpenCLOptions().cl_khr_fp16) { 4243 S.Diag(Param->getLocation(), 4244 diag::err_opencl_half_param) << ParamTy; 4245 D.setInvalidType(); 4246 Param->setInvalidDecl(); 4247 } 4248 } else if (!S.getLangOpts().HalfArgsAndReturns) { 4249 S.Diag(Param->getLocation(), 4250 diag::err_parameters_retval_cannot_have_fp16_type) << 0; 4251 D.setInvalidType(); 4252 } 4253 } else if (!FTI.hasPrototype) { 4254 if (ParamTy->isPromotableIntegerType()) { 4255 ParamTy = Context.getPromotedIntegerType(ParamTy); 4256 Param->setKNRPromoted(true); 4257 } else if (const BuiltinType* BTy = ParamTy->getAs<BuiltinType>()) { 4258 if (BTy->getKind() == BuiltinType::Float) { 4259 ParamTy = Context.DoubleTy; 4260 Param->setKNRPromoted(true); 4261 } 4262 } 4263 } 4264 4265 if (LangOpts.ObjCAutoRefCount && Param->hasAttr<NSConsumedAttr>()) { 4266 ExtParameterInfos[i] = ExtParameterInfos[i].withIsConsumed(true); 4267 HasAnyInterestingExtParameterInfos = true; 4268 } 4269 4270 if (auto attr = Param->getAttr<ParameterABIAttr>()) { 4271 ExtParameterInfos[i] = 4272 ExtParameterInfos[i].withABI(attr->getABI()); 4273 HasAnyInterestingExtParameterInfos = true; 4274 } 4275 4276 ParamTys.push_back(ParamTy); 4277 } 4278 4279 if (HasAnyInterestingExtParameterInfos) { 4280 EPI.ExtParameterInfos = ExtParameterInfos.data(); 4281 checkExtParameterInfos(S, ParamTys, EPI, 4282 [&](unsigned i) { return FTI.Params[i].Param->getLocation(); }); 4283 } 4284 4285 SmallVector<QualType, 4> Exceptions; 4286 SmallVector<ParsedType, 2> DynamicExceptions; 4287 SmallVector<SourceRange, 2> DynamicExceptionRanges; 4288 Expr *NoexceptExpr = nullptr; 4289 4290 if (FTI.getExceptionSpecType() == EST_Dynamic) { 4291 // FIXME: It's rather inefficient to have to split into two vectors 4292 // here. 4293 unsigned N = FTI.NumExceptions; 4294 DynamicExceptions.reserve(N); 4295 DynamicExceptionRanges.reserve(N); 4296 for (unsigned I = 0; I != N; ++I) { 4297 DynamicExceptions.push_back(FTI.Exceptions[I].Ty); 4298 DynamicExceptionRanges.push_back(FTI.Exceptions[I].Range); 4299 } 4300 } else if (FTI.getExceptionSpecType() == EST_ComputedNoexcept) { 4301 NoexceptExpr = FTI.NoexceptExpr; 4302 } 4303 4304 S.checkExceptionSpecification(D.isFunctionDeclarationContext(), 4305 FTI.getExceptionSpecType(), 4306 DynamicExceptions, 4307 DynamicExceptionRanges, 4308 NoexceptExpr, 4309 Exceptions, 4310 EPI.ExceptionSpec); 4311 4312 T = Context.getFunctionType(T, ParamTys, EPI); 4313 } 4314 break; 4315 } 4316 case DeclaratorChunk::MemberPointer: { 4317 // The scope spec must refer to a class, or be dependent. 4318 CXXScopeSpec &SS = DeclType.Mem.Scope(); 4319 QualType ClsType; 4320 4321 // Handle pointer nullability. 4322 inferPointerNullability(SimplePointerKind::MemberPointer, 4323 DeclType.Loc, DeclType.getAttrListRef()); 4324 4325 if (SS.isInvalid()) { 4326 // Avoid emitting extra errors if we already errored on the scope. 4327 D.setInvalidType(true); 4328 } else if (S.isDependentScopeSpecifier(SS) || 4329 dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS))) { 4330 NestedNameSpecifier *NNS = SS.getScopeRep(); 4331 NestedNameSpecifier *NNSPrefix = NNS->getPrefix(); 4332 switch (NNS->getKind()) { 4333 case NestedNameSpecifier::Identifier: 4334 ClsType = Context.getDependentNameType(ETK_None, NNSPrefix, 4335 NNS->getAsIdentifier()); 4336 break; 4337 4338 case NestedNameSpecifier::Namespace: 4339 case NestedNameSpecifier::NamespaceAlias: 4340 case NestedNameSpecifier::Global: 4341 case NestedNameSpecifier::Super: 4342 llvm_unreachable("Nested-name-specifier must name a type"); 4343 4344 case NestedNameSpecifier::TypeSpec: 4345 case NestedNameSpecifier::TypeSpecWithTemplate: 4346 ClsType = QualType(NNS->getAsType(), 0); 4347 // Note: if the NNS has a prefix and ClsType is a nondependent 4348 // TemplateSpecializationType, then the NNS prefix is NOT included 4349 // in ClsType; hence we wrap ClsType into an ElaboratedType. 4350 // NOTE: in particular, no wrap occurs if ClsType already is an 4351 // Elaborated, DependentName, or DependentTemplateSpecialization. 4352 if (NNSPrefix && isa<TemplateSpecializationType>(NNS->getAsType())) 4353 ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType); 4354 break; 4355 } 4356 } else { 4357 S.Diag(DeclType.Mem.Scope().getBeginLoc(), 4358 diag::err_illegal_decl_mempointer_in_nonclass) 4359 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name") 4360 << DeclType.Mem.Scope().getRange(); 4361 D.setInvalidType(true); 4362 } 4363 4364 if (!ClsType.isNull()) 4365 T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc, 4366 D.getIdentifier()); 4367 if (T.isNull()) { 4368 T = Context.IntTy; 4369 D.setInvalidType(true); 4370 } else if (DeclType.Mem.TypeQuals) { 4371 T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals); 4372 } 4373 break; 4374 } 4375 4376 case DeclaratorChunk::Pipe: { 4377 T = S.BuildPipeType(T, DeclType.Loc ); 4378 break; 4379 } 4380 } 4381 4382 if (T.isNull()) { 4383 D.setInvalidType(true); 4384 T = Context.IntTy; 4385 } 4386 4387 // See if there are any attributes on this declarator chunk. 4388 processTypeAttrs(state, T, TAL_DeclChunk, 4389 const_cast<AttributeList *>(DeclType.getAttrs())); 4390 } 4391 4392 assert(!T.isNull() && "T must not be null after this point"); 4393 4394 if (LangOpts.CPlusPlus && T->isFunctionType()) { 4395 const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>(); 4396 assert(FnTy && "Why oh why is there not a FunctionProtoType here?"); 4397 4398 // C++ 8.3.5p4: 4399 // A cv-qualifier-seq shall only be part of the function type 4400 // for a nonstatic member function, the function type to which a pointer 4401 // to member refers, or the top-level function type of a function typedef 4402 // declaration. 4403 // 4404 // Core issue 547 also allows cv-qualifiers on function types that are 4405 // top-level template type arguments. 4406 bool FreeFunction; 4407 if (!D.getCXXScopeSpec().isSet()) { 4408 FreeFunction = ((D.getContext() != Declarator::MemberContext && 4409 D.getContext() != Declarator::LambdaExprContext) || 4410 D.getDeclSpec().isFriendSpecified()); 4411 } else { 4412 DeclContext *DC = S.computeDeclContext(D.getCXXScopeSpec()); 4413 FreeFunction = (DC && !DC->isRecord()); 4414 } 4415 4416 // C++11 [dcl.fct]p6 (w/DR1417): 4417 // An attempt to specify a function type with a cv-qualifier-seq or a 4418 // ref-qualifier (including by typedef-name) is ill-formed unless it is: 4419 // - the function type for a non-static member function, 4420 // - the function type to which a pointer to member refers, 4421 // - the top-level function type of a function typedef declaration or 4422 // alias-declaration, 4423 // - the type-id in the default argument of a type-parameter, or 4424 // - the type-id of a template-argument for a type-parameter 4425 // 4426 // FIXME: Checking this here is insufficient. We accept-invalid on: 4427 // 4428 // template<typename T> struct S { void f(T); }; 4429 // S<int() const> s; 4430 // 4431 // ... for instance. 4432 if (IsQualifiedFunction && 4433 !(!FreeFunction && 4434 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) && 4435 !IsTypedefName && 4436 D.getContext() != Declarator::TemplateTypeArgContext) { 4437 SourceLocation Loc = D.getLocStart(); 4438 SourceRange RemovalRange; 4439 unsigned I; 4440 if (D.isFunctionDeclarator(I)) { 4441 SmallVector<SourceLocation, 4> RemovalLocs; 4442 const DeclaratorChunk &Chunk = D.getTypeObject(I); 4443 assert(Chunk.Kind == DeclaratorChunk::Function); 4444 if (Chunk.Fun.hasRefQualifier()) 4445 RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc()); 4446 if (Chunk.Fun.TypeQuals & Qualifiers::Const) 4447 RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc()); 4448 if (Chunk.Fun.TypeQuals & Qualifiers::Volatile) 4449 RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc()); 4450 if (Chunk.Fun.TypeQuals & Qualifiers::Restrict) 4451 RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc()); 4452 if (!RemovalLocs.empty()) { 4453 std::sort(RemovalLocs.begin(), RemovalLocs.end(), 4454 BeforeThanCompare<SourceLocation>(S.getSourceManager())); 4455 RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back()); 4456 Loc = RemovalLocs.front(); 4457 } 4458 } 4459 4460 S.Diag(Loc, diag::err_invalid_qualified_function_type) 4461 << FreeFunction << D.isFunctionDeclarator() << T 4462 << getFunctionQualifiersAsString(FnTy) 4463 << FixItHint::CreateRemoval(RemovalRange); 4464 4465 // Strip the cv-qualifiers and ref-qualifiers from the type. 4466 FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo(); 4467 EPI.TypeQuals = 0; 4468 EPI.RefQualifier = RQ_None; 4469 4470 T = Context.getFunctionType(FnTy->getReturnType(), FnTy->getParamTypes(), 4471 EPI); 4472 // Rebuild any parens around the identifier in the function type. 4473 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 4474 if (D.getTypeObject(i).Kind != DeclaratorChunk::Paren) 4475 break; 4476 T = S.BuildParenType(T); 4477 } 4478 } 4479 } 4480 4481 // Apply any undistributed attributes from the declarator. 4482 processTypeAttrs(state, T, TAL_DeclName, D.getAttributes()); 4483 4484 // Diagnose any ignored type attributes. 4485 state.diagnoseIgnoredTypeAttrs(T); 4486 4487 // C++0x [dcl.constexpr]p9: 4488 // A constexpr specifier used in an object declaration declares the object 4489 // as const. 4490 if (D.getDeclSpec().isConstexprSpecified() && T->isObjectType()) { 4491 T.addConst(); 4492 } 4493 4494 // If there was an ellipsis in the declarator, the declaration declares a 4495 // parameter pack whose type may be a pack expansion type. 4496 if (D.hasEllipsis()) { 4497 // C++0x [dcl.fct]p13: 4498 // A declarator-id or abstract-declarator containing an ellipsis shall 4499 // only be used in a parameter-declaration. Such a parameter-declaration 4500 // is a parameter pack (14.5.3). [...] 4501 switch (D.getContext()) { 4502 case Declarator::PrototypeContext: 4503 case Declarator::LambdaExprParameterContext: 4504 // C++0x [dcl.fct]p13: 4505 // [...] When it is part of a parameter-declaration-clause, the 4506 // parameter pack is a function parameter pack (14.5.3). The type T 4507 // of the declarator-id of the function parameter pack shall contain 4508 // a template parameter pack; each template parameter pack in T is 4509 // expanded by the function parameter pack. 4510 // 4511 // We represent function parameter packs as function parameters whose 4512 // type is a pack expansion. 4513 if (!T->containsUnexpandedParameterPack()) { 4514 S.Diag(D.getEllipsisLoc(), 4515 diag::err_function_parameter_pack_without_parameter_packs) 4516 << T << D.getSourceRange(); 4517 D.setEllipsisLoc(SourceLocation()); 4518 } else { 4519 T = Context.getPackExpansionType(T, None); 4520 } 4521 break; 4522 case Declarator::TemplateParamContext: 4523 // C++0x [temp.param]p15: 4524 // If a template-parameter is a [...] is a parameter-declaration that 4525 // declares a parameter pack (8.3.5), then the template-parameter is a 4526 // template parameter pack (14.5.3). 4527 // 4528 // Note: core issue 778 clarifies that, if there are any unexpanded 4529 // parameter packs in the type of the non-type template parameter, then 4530 // it expands those parameter packs. 4531 if (T->containsUnexpandedParameterPack()) 4532 T = Context.getPackExpansionType(T, None); 4533 else 4534 S.Diag(D.getEllipsisLoc(), 4535 LangOpts.CPlusPlus11 4536 ? diag::warn_cxx98_compat_variadic_templates 4537 : diag::ext_variadic_templates); 4538 break; 4539 4540 case Declarator::FileContext: 4541 case Declarator::KNRTypeListContext: 4542 case Declarator::ObjCParameterContext: // FIXME: special diagnostic here? 4543 case Declarator::ObjCResultContext: // FIXME: special diagnostic here? 4544 case Declarator::TypeNameContext: 4545 case Declarator::CXXNewContext: 4546 case Declarator::AliasDeclContext: 4547 case Declarator::AliasTemplateContext: 4548 case Declarator::MemberContext: 4549 case Declarator::BlockContext: 4550 case Declarator::ForContext: 4551 case Declarator::InitStmtContext: 4552 case Declarator::ConditionContext: 4553 case Declarator::CXXCatchContext: 4554 case Declarator::ObjCCatchContext: 4555 case Declarator::BlockLiteralContext: 4556 case Declarator::LambdaExprContext: 4557 case Declarator::ConversionIdContext: 4558 case Declarator::TrailingReturnContext: 4559 case Declarator::TemplateTypeArgContext: 4560 // FIXME: We may want to allow parameter packs in block-literal contexts 4561 // in the future. 4562 S.Diag(D.getEllipsisLoc(), 4563 diag::err_ellipsis_in_declarator_not_parameter); 4564 D.setEllipsisLoc(SourceLocation()); 4565 break; 4566 } 4567 } 4568 4569 assert(!T.isNull() && "T must not be null at the end of this function"); 4570 if (D.isInvalidType()) 4571 return Context.getTrivialTypeSourceInfo(T); 4572 4573 return S.GetTypeSourceInfoForDeclarator(D, T, TInfo); 4574} 4575 4576/// GetTypeForDeclarator - Convert the type for the specified 4577/// declarator to Type instances. 4578/// 4579/// The result of this call will never be null, but the associated 4580/// type may be a null type if there's an unrecoverable error. 4581TypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D, Scope *S) { 4582 // Determine the type of the declarator. Not all forms of declarator 4583 // have a type. 4584 4585 TypeProcessingState state(*this, D); 4586 4587 TypeSourceInfo *ReturnTypeInfo = nullptr; 4588 QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo); 4589 4590 if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount) 4591 inferARCWriteback(state, T); 4592 4593 return GetFullTypeForDeclarator(state, T, ReturnTypeInfo); 4594} 4595 4596static void transferARCOwnershipToDeclSpec(Sema &S, 4597 QualType &declSpecTy, 4598 Qualifiers::ObjCLifetime ownership) { 4599 if (declSpecTy->isObjCRetainableType() && 4600 declSpecTy.getObjCLifetime() == Qualifiers::OCL_None) { 4601 Qualifiers qs; 4602 qs.addObjCLifetime(ownership); 4603 declSpecTy = S.Context.getQualifiedType(declSpecTy, qs); 4604 } 4605} 4606 4607static void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, 4608 Qualifiers::ObjCLifetime ownership, 4609 unsigned chunkIndex) { 4610 Sema &S = state.getSema(); 4611 Declarator &D = state.getDeclarator(); 4612 4613 // Look for an explicit lifetime attribute. 4614 DeclaratorChunk &chunk = D.getTypeObject(chunkIndex); 4615 for (const AttributeList *attr = chunk.getAttrs(); attr; 4616 attr = attr->getNext()) 4617 if (attr->getKind() == AttributeList::AT_ObjCOwnership) 4618 return; 4619 4620 const char *attrStr = nullptr; 4621 switch (ownership) { 4622 case Qualifiers::OCL_None: llvm_unreachable("no ownership!"); 4623 case Qualifiers::OCL_ExplicitNone: attrStr = "none"; break; 4624 case Qualifiers::OCL_Strong: attrStr = "strong"; break; 4625 case Qualifiers::OCL_Weak: attrStr = "weak"; break; 4626 case Qualifiers::OCL_Autoreleasing: attrStr = "autoreleasing"; break; 4627 } 4628 4629 IdentifierLoc *Arg = new (S.Context) IdentifierLoc; 4630 Arg->Ident = &S.Context.Idents.get(attrStr); 4631 Arg->Loc = SourceLocation(); 4632 4633 ArgsUnion Args(Arg); 4634 4635 // If there wasn't one, add one (with an invalid source location 4636 // so that we don't make an AttributedType for it). 4637 AttributeList *attr = D.getAttributePool() 4638 .create(&S.Context.Idents.get("objc_ownership"), SourceLocation(), 4639 /*scope*/ nullptr, SourceLocation(), 4640 /*args*/ &Args, 1, AttributeList::AS_GNU); 4641 spliceAttrIntoList(*attr, chunk.getAttrListRef()); 4642 4643 // TODO: mark whether we did this inference? 4644} 4645 4646/// \brief Used for transferring ownership in casts resulting in l-values. 4647static void transferARCOwnership(TypeProcessingState &state, 4648 QualType &declSpecTy, 4649 Qualifiers::ObjCLifetime ownership) { 4650 Sema &S = state.getSema(); 4651 Declarator &D = state.getDeclarator(); 4652 4653 int inner = -1; 4654 bool hasIndirection = false; 4655 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 4656 DeclaratorChunk &chunk = D.getTypeObject(i); 4657 switch (chunk.Kind) { 4658 case DeclaratorChunk::Paren: 4659 // Ignore parens. 4660 break; 4661 4662 case DeclaratorChunk::Array: 4663 case DeclaratorChunk::Reference: 4664 case DeclaratorChunk::Pointer: 4665 if (inner != -1) 4666 hasIndirection = true; 4667 inner = i; 4668 break; 4669 4670 case DeclaratorChunk::BlockPointer: 4671 if (inner != -1) 4672 transferARCOwnershipToDeclaratorChunk(state, ownership, i); 4673 return; 4674 4675 case DeclaratorChunk::Function: 4676 case DeclaratorChunk::MemberPointer: 4677 case DeclaratorChunk::Pipe: 4678 return; 4679 } 4680 } 4681 4682 if (inner == -1) 4683 return; 4684 4685 DeclaratorChunk &chunk = D.getTypeObject(inner); 4686 if (chunk.Kind == DeclaratorChunk::Pointer) { 4687 if (declSpecTy->isObjCRetainableType()) 4688 return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership); 4689 if (declSpecTy->isObjCObjectType() && hasIndirection) 4690 return transferARCOwnershipToDeclaratorChunk(state, ownership, inner); 4691 } else { 4692 assert(chunk.Kind == DeclaratorChunk::Array || 4693 chunk.Kind == DeclaratorChunk::Reference); 4694 return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership); 4695 } 4696} 4697 4698TypeSourceInfo *Sema::GetTypeForDeclaratorCast(Declarator &D, QualType FromTy) { 4699 TypeProcessingState state(*this, D); 4700 4701 TypeSourceInfo *ReturnTypeInfo = nullptr; 4702 QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo); 4703 4704 if (getLangOpts().ObjC1) { 4705 Qualifiers::ObjCLifetime ownership = Context.getInnerObjCOwnership(FromTy); 4706 if (ownership != Qualifiers::OCL_None) 4707 transferARCOwnership(state, declSpecTy, ownership); 4708 } 4709 4710 return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo); 4711} 4712 4713/// Map an AttributedType::Kind to an AttributeList::Kind. 4714static AttributeList::Kind getAttrListKind(AttributedType::Kind kind) { 4715 switch (kind) { 4716 case AttributedType::attr_address_space: 4717 return AttributeList::AT_AddressSpace; 4718 case AttributedType::attr_regparm: 4719 return AttributeList::AT_Regparm; 4720 case AttributedType::attr_vector_size: 4721 return AttributeList::AT_VectorSize; 4722 case AttributedType::attr_neon_vector_type: 4723 return AttributeList::AT_NeonVectorType; 4724 case AttributedType::attr_neon_polyvector_type: 4725 return AttributeList::AT_NeonPolyVectorType; 4726 case AttributedType::attr_objc_gc: 4727 return AttributeList::AT_ObjCGC; 4728 case AttributedType::attr_objc_ownership: 4729 case AttributedType::attr_objc_inert_unsafe_unretained: 4730 return AttributeList::AT_ObjCOwnership; 4731 case AttributedType::attr_noreturn: 4732 return AttributeList::AT_NoReturn; 4733 case AttributedType::attr_cdecl: 4734 return AttributeList::AT_CDecl; 4735 case AttributedType::attr_fastcall: 4736 return AttributeList::AT_FastCall; 4737 case AttributedType::attr_stdcall: 4738 return AttributeList::AT_StdCall; 4739 case AttributedType::attr_thiscall: 4740 return AttributeList::AT_ThisCall; 4741 case AttributedType::attr_pascal: 4742 return AttributeList::AT_Pascal; 4743 case AttributedType::attr_swiftcall: 4744 return AttributeList::AT_SwiftCall; 4745 case AttributedType::attr_vectorcall: 4746 return AttributeList::AT_VectorCall; 4747 case AttributedType::attr_pcs: 4748 case AttributedType::attr_pcs_vfp: 4749 return AttributeList::AT_Pcs; 4750 case AttributedType::attr_inteloclbicc: 4751 return AttributeList::AT_IntelOclBicc; 4752 case AttributedType::attr_ms_abi: 4753 return AttributeList::AT_MSABI; 4754 case AttributedType::attr_sysv_abi: 4755 return AttributeList::AT_SysVABI; 4756 case AttributedType::attr_preserve_most: 4757 return AttributeList::AT_PreserveMost; 4758 case AttributedType::attr_preserve_all: 4759 return AttributeList::AT_PreserveAll; 4760 case AttributedType::attr_ptr32: 4761 return AttributeList::AT_Ptr32; 4762 case AttributedType::attr_ptr64: 4763 return AttributeList::AT_Ptr64; 4764 case AttributedType::attr_sptr: 4765 return AttributeList::AT_SPtr; 4766 case AttributedType::attr_uptr: 4767 return AttributeList::AT_UPtr; 4768 case AttributedType::attr_nonnull: 4769 return AttributeList::AT_TypeNonNull; 4770 case AttributedType::attr_nullable: 4771 return AttributeList::AT_TypeNullable; 4772 case AttributedType::attr_null_unspecified: 4773 return AttributeList::AT_TypeNullUnspecified; 4774 case AttributedType::attr_objc_kindof: 4775 return AttributeList::AT_ObjCKindOf; 4776 } 4777 llvm_unreachable("unexpected attribute kind!"); 4778} 4779 4780static void fillAttributedTypeLoc(AttributedTypeLoc TL, 4781 const AttributeList *attrs, 4782 const AttributeList *DeclAttrs = nullptr) { 4783 // DeclAttrs and attrs cannot be both empty. 4784 assert((attrs || DeclAttrs) && 4785 "no type attributes in the expected location!"); 4786 4787 AttributeList::Kind parsedKind = getAttrListKind(TL.getAttrKind()); 4788 // Try to search for an attribute of matching kind in attrs list. 4789 while (attrs && attrs->getKind() != parsedKind) 4790 attrs = attrs->getNext(); 4791 if (!attrs) { 4792 // No matching type attribute in attrs list found. 4793 // Try searching through C++11 attributes in the declarator attribute list. 4794 while (DeclAttrs && (!DeclAttrs->isCXX11Attribute() || 4795 DeclAttrs->getKind() != parsedKind)) 4796 DeclAttrs = DeclAttrs->getNext(); 4797 attrs = DeclAttrs; 4798 } 4799 4800 assert(attrs && "no matching type attribute in expected location!"); 4801 4802 TL.setAttrNameLoc(attrs->getLoc()); 4803 if (TL.hasAttrExprOperand()) { 4804 assert(attrs->isArgExpr(0) && "mismatched attribute operand kind"); 4805 TL.setAttrExprOperand(attrs->getArgAsExpr(0)); 4806 } else if (TL.hasAttrEnumOperand()) { 4807 assert((attrs->isArgIdent(0) || attrs->isArgExpr(0)) && 4808 "unexpected attribute operand kind"); 4809 if (attrs->isArgIdent(0)) 4810 TL.setAttrEnumOperandLoc(attrs->getArgAsIdent(0)->Loc); 4811 else 4812 TL.setAttrEnumOperandLoc(attrs->getArgAsExpr(0)->getExprLoc()); 4813 } 4814 4815 // FIXME: preserve this information to here. 4816 if (TL.hasAttrOperand()) 4817 TL.setAttrOperandParensRange(SourceRange()); 4818} 4819 4820namespace { 4821 class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> { 4822 ASTContext &Context; 4823 const DeclSpec &DS; 4824 4825 public: 4826 TypeSpecLocFiller(ASTContext &Context, const DeclSpec &DS) 4827 : Context(Context), DS(DS) {} 4828 4829 void VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4830 fillAttributedTypeLoc(TL, DS.getAttributes().getList()); 4831 Visit(TL.getModifiedLoc()); 4832 } 4833 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4834 Visit(TL.getUnqualifiedLoc()); 4835 } 4836 void VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4837 TL.setNameLoc(DS.getTypeSpecTypeLoc()); 4838 } 4839 void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4840 TL.setNameLoc(DS.getTypeSpecTypeLoc()); 4841 // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires 4842 // addition field. What we have is good enough for dispay of location 4843 // of 'fixit' on interface name. 4844 TL.setNameEndLoc(DS.getLocEnd()); 4845 } 4846 void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4847 TypeSourceInfo *RepTInfo = nullptr; 4848 Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo); 4849 TL.copy(RepTInfo->getTypeLoc()); 4850 } 4851 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4852 TypeSourceInfo *RepTInfo = nullptr; 4853 Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo); 4854 TL.copy(RepTInfo->getTypeLoc()); 4855 } 4856 void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { 4857 TypeSourceInfo *TInfo = nullptr; 4858 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4859 4860 // If we got no declarator info from previous Sema routines, 4861 // just fill with the typespec loc. 4862 if (!TInfo) { 4863 TL.initialize(Context, DS.getTypeSpecTypeNameLoc()); 4864 return; 4865 } 4866 4867 TypeLoc OldTL = TInfo->getTypeLoc(); 4868 if (TInfo->getType()->getAs<ElaboratedType>()) { 4869 ElaboratedTypeLoc ElabTL = OldTL.castAs<ElaboratedTypeLoc>(); 4870 TemplateSpecializationTypeLoc NamedTL = ElabTL.getNamedTypeLoc() 4871 .castAs<TemplateSpecializationTypeLoc>(); 4872 TL.copy(NamedTL); 4873 } else { 4874 TL.copy(OldTL.castAs<TemplateSpecializationTypeLoc>()); 4875 assert(TL.getRAngleLoc() == OldTL.castAs<TemplateSpecializationTypeLoc>().getRAngleLoc()); 4876 } 4877 4878 } 4879 void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4880 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr); 4881 TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 4882 TL.setParensRange(DS.getTypeofParensRange()); 4883 } 4884 void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4885 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType); 4886 TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 4887 TL.setParensRange(DS.getTypeofParensRange()); 4888 assert(DS.getRepAsType()); 4889 TypeSourceInfo *TInfo = nullptr; 4890 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4891 TL.setUnderlyingTInfo(TInfo); 4892 } 4893 void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4894 // FIXME: This holds only because we only have one unary transform. 4895 assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType); 4896 TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4897 TL.setParensRange(DS.getTypeofParensRange()); 4898 assert(DS.getRepAsType()); 4899 TypeSourceInfo *TInfo = nullptr; 4900 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4901 TL.setUnderlyingTInfo(TInfo); 4902 } 4903 void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4904 // By default, use the source location of the type specifier. 4905 TL.setBuiltinLoc(DS.getTypeSpecTypeLoc()); 4906 if (TL.needsExtraLocalData()) { 4907 // Set info for the written builtin specifiers. 4908 TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs(); 4909 // Try to have a meaningful source location. 4910 if (TL.getWrittenSignSpec() != TSS_unspecified) 4911 // Sign spec loc overrides the others (e.g., 'unsigned long'). 4912 TL.setBuiltinLoc(DS.getTypeSpecSignLoc()); 4913 else if (TL.getWrittenWidthSpec() != TSW_unspecified) 4914 // Width spec loc overrides type spec loc (e.g., 'short int'). 4915 TL.setBuiltinLoc(DS.getTypeSpecWidthLoc()); 4916 } 4917 } 4918 void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4919 ElaboratedTypeKeyword Keyword 4920 = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType()); 4921 if (DS.getTypeSpecType() == TST_typename) { 4922 TypeSourceInfo *TInfo = nullptr; 4923 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4924 if (TInfo) { 4925 TL.copy(TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>()); 4926 return; 4927 } 4928 } 4929 TL.setElaboratedKeywordLoc(Keyword != ETK_None 4930 ? DS.getTypeSpecTypeLoc() 4931 : SourceLocation()); 4932 const CXXScopeSpec& SS = DS.getTypeSpecScope(); 4933 TL.setQualifierLoc(SS.getWithLocInContext(Context)); 4934 Visit(TL.getNextTypeLoc().getUnqualifiedLoc()); 4935 } 4936 void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4937 assert(DS.getTypeSpecType() == TST_typename); 4938 TypeSourceInfo *TInfo = nullptr; 4939 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4940 assert(TInfo); 4941 TL.copy(TInfo->getTypeLoc().castAs<DependentNameTypeLoc>()); 4942 } 4943 void VisitDependentTemplateSpecializationTypeLoc( 4944 DependentTemplateSpecializationTypeLoc TL) { 4945 assert(DS.getTypeSpecType() == TST_typename); 4946 TypeSourceInfo *TInfo = nullptr; 4947 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4948 assert(TInfo); 4949 TL.copy( 4950 TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>()); 4951 } 4952 void VisitTagTypeLoc(TagTypeLoc TL) { 4953 TL.setNameLoc(DS.getTypeSpecTypeNameLoc()); 4954 } 4955 void VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4956 // An AtomicTypeLoc can come from either an _Atomic(...) type specifier 4957 // or an _Atomic qualifier. 4958 if (DS.getTypeSpecType() == DeclSpec::TST_atomic) { 4959 TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4960 TL.setParensRange(DS.getTypeofParensRange()); 4961 4962 TypeSourceInfo *TInfo = nullptr; 4963 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4964 assert(TInfo); 4965 TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc()); 4966 } else { 4967 TL.setKWLoc(DS.getAtomicSpecLoc()); 4968 // No parens, to indicate this was spelled as an _Atomic qualifier. 4969 TL.setParensRange(SourceRange()); 4970 Visit(TL.getValueLoc()); 4971 } 4972 } 4973 4974 void VisitPipeTypeLoc(PipeTypeLoc TL) { 4975 TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4976 4977 TypeSourceInfo *TInfo = nullptr; 4978 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4979 TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc()); 4980 } 4981 4982 void VisitTypeLoc(TypeLoc TL) { 4983 // FIXME: add other typespec types and change this to an assert. 4984 TL.initialize(Context, DS.getTypeSpecTypeLoc()); 4985 } 4986 }; 4987 4988 class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> { 4989 ASTContext &Context; 4990 const DeclaratorChunk &Chunk; 4991 4992 public: 4993 DeclaratorLocFiller(ASTContext &Context, const DeclaratorChunk &Chunk) 4994 : Context(Context), Chunk(Chunk) {} 4995 4996 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4997 llvm_unreachable("qualified type locs not expected here!"); 4998 } 4999 void VisitDecayedTypeLoc(DecayedTypeLoc TL) { 5000 llvm_unreachable("decayed type locs not expected here!"); 5001 } 5002 5003 void VisitAttributedTypeLoc(AttributedTypeLoc TL) { 5004 fillAttributedTypeLoc(TL, Chunk.getAttrs()); 5005 } 5006 void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 5007 // nothing 5008 } 5009 void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 5010 assert(Chunk.Kind == DeclaratorChunk::BlockPointer); 5011 TL.setCaretLoc(Chunk.Loc); 5012 } 5013 void VisitPointerTypeLoc(PointerTypeLoc TL) { 5014 assert(Chunk.Kind == DeclaratorChunk::Pointer); 5015 TL.setStarLoc(Chunk.Loc); 5016 } 5017 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 5018 assert(Chunk.Kind == DeclaratorChunk::Pointer); 5019 TL.setStarLoc(Chunk.Loc); 5020 } 5021 void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 5022 assert(Chunk.Kind == DeclaratorChunk::MemberPointer); 5023 const CXXScopeSpec& SS = Chunk.Mem.Scope(); 5024 NestedNameSpecifierLoc NNSLoc = SS.getWithLocInContext(Context); 5025 5026 const Type* ClsTy = TL.getClass(); 5027 QualType ClsQT = QualType(ClsTy, 0); 5028 TypeSourceInfo *ClsTInfo = Context.CreateTypeSourceInfo(ClsQT, 0); 5029 // Now copy source location info into the type loc component. 5030 TypeLoc ClsTL = ClsTInfo->getTypeLoc(); 5031 switch (NNSLoc.getNestedNameSpecifier()->getKind()) { 5032 case NestedNameSpecifier::Identifier: 5033 assert(isa<DependentNameType>(ClsTy) && "Unexpected TypeLoc"); 5034 { 5035 DependentNameTypeLoc DNTLoc = ClsTL.castAs<DependentNameTypeLoc>(); 5036 DNTLoc.setElaboratedKeywordLoc(SourceLocation()); 5037 DNTLoc.setQualifierLoc(NNSLoc.getPrefix()); 5038 DNTLoc.setNameLoc(NNSLoc.getLocalBeginLoc()); 5039 } 5040 break; 5041 5042 case NestedNameSpecifier::TypeSpec: 5043 case NestedNameSpecifier::TypeSpecWithTemplate: 5044 if (isa<ElaboratedType>(ClsTy)) { 5045 ElaboratedTypeLoc ETLoc = ClsTL.castAs<ElaboratedTypeLoc>(); 5046 ETLoc.setElaboratedKeywordLoc(SourceLocation()); 5047 ETLoc.setQualifierLoc(NNSLoc.getPrefix()); 5048 TypeLoc NamedTL = ETLoc.getNamedTypeLoc(); 5049 NamedTL.initializeFullCopy(NNSLoc.getTypeLoc()); 5050 } else { 5051 ClsTL.initializeFullCopy(NNSLoc.getTypeLoc()); 5052 } 5053 break; 5054 5055 case NestedNameSpecifier::Namespace: 5056 case NestedNameSpecifier::NamespaceAlias: 5057 case NestedNameSpecifier::Global: 5058 case NestedNameSpecifier::Super: 5059 llvm_unreachable("Nested-name-specifier must name a type"); 5060 } 5061 5062 // Finally fill in MemberPointerLocInfo fields. 5063 TL.setStarLoc(Chunk.Loc); 5064 TL.setClassTInfo(ClsTInfo); 5065 } 5066 void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 5067 assert(Chunk.Kind == DeclaratorChunk::Reference); 5068 // 'Amp' is misleading: this might have been originally 5069 /// spelled with AmpAmp. 5070 TL.setAmpLoc(Chunk.Loc); 5071 } 5072 void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 5073 assert(Chunk.Kind == DeclaratorChunk::Reference); 5074 assert(!Chunk.Ref.LValueRef); 5075 TL.setAmpAmpLoc(Chunk.Loc); 5076 } 5077 void VisitArrayTypeLoc(ArrayTypeLoc TL) { 5078 assert(Chunk.Kind == DeclaratorChunk::Array); 5079 TL.setLBracketLoc(Chunk.Loc); 5080 TL.setRBracketLoc(Chunk.EndLoc); 5081 TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts)); 5082 } 5083 void VisitFunctionTypeLoc(FunctionTypeLoc TL) { 5084 assert(Chunk.Kind == DeclaratorChunk::Function); 5085 TL.setLocalRangeBegin(Chunk.Loc); 5086 TL.setLocalRangeEnd(Chunk.EndLoc); 5087 5088 const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun; 5089 TL.setLParenLoc(FTI.getLParenLoc()); 5090 TL.setRParenLoc(FTI.getRParenLoc()); 5091 for (unsigned i = 0, e = TL.getNumParams(), tpi = 0; i != e; ++i) { 5092 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 5093 TL.setParam(tpi++, Param); 5094 } 5095 // FIXME: exception specs 5096 } 5097 void VisitParenTypeLoc(ParenTypeLoc TL) { 5098 assert(Chunk.Kind == DeclaratorChunk::Paren); 5099 TL.setLParenLoc(Chunk.Loc); 5100 TL.setRParenLoc(Chunk.EndLoc); 5101 } 5102 void VisitPipeTypeLoc(PipeTypeLoc TL) { 5103 assert(Chunk.Kind == DeclaratorChunk::Pipe); 5104 TL.setKWLoc(Chunk.Loc); 5105 } 5106 5107 void VisitTypeLoc(TypeLoc TL) { 5108 llvm_unreachable("unsupported TypeLoc kind in declarator!"); 5109 } 5110 }; 5111} // end anonymous namespace 5112 5113static void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) { 5114 SourceLocation Loc; 5115 switch (Chunk.Kind) { 5116 case DeclaratorChunk::Function: 5117 case DeclaratorChunk::Array: 5118 case DeclaratorChunk::Paren: 5119 case DeclaratorChunk::Pipe: 5120 llvm_unreachable("cannot be _Atomic qualified"); 5121 5122 case DeclaratorChunk::Pointer: 5123 Loc = SourceLocation::getFromRawEncoding(Chunk.Ptr.AtomicQualLoc); 5124 break; 5125 5126 case DeclaratorChunk::BlockPointer: 5127 case DeclaratorChunk::Reference: 5128 case DeclaratorChunk::MemberPointer: 5129 // FIXME: Provide a source location for the _Atomic keyword. 5130 break; 5131 } 5132 5133 ATL.setKWLoc(Loc); 5134 ATL.setParensRange(SourceRange()); 5135} 5136 5137/// \brief Create and instantiate a TypeSourceInfo with type source information. 5138/// 5139/// \param T QualType referring to the type as written in source code. 5140/// 5141/// \param ReturnTypeInfo For declarators whose return type does not show 5142/// up in the normal place in the declaration specifiers (such as a C++ 5143/// conversion function), this pointer will refer to a type source information 5144/// for that return type. 5145TypeSourceInfo * 5146Sema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, 5147 TypeSourceInfo *ReturnTypeInfo) { 5148 TypeSourceInfo *TInfo = Context.CreateTypeSourceInfo(T); 5149 UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc(); 5150 const AttributeList *DeclAttrs = D.getAttributes(); 5151 5152 // Handle parameter packs whose type is a pack expansion. 5153 if (isa<PackExpansionType>(T)) { 5154 CurrTL.castAs<PackExpansionTypeLoc>().setEllipsisLoc(D.getEllipsisLoc()); 5155 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc(); 5156 } 5157 5158 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 5159 // An AtomicTypeLoc might be produced by an atomic qualifier in this 5160 // declarator chunk. 5161 if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) { 5162 fillAtomicQualLoc(ATL, D.getTypeObject(i)); 5163 CurrTL = ATL.getValueLoc().getUnqualifiedLoc(); 5164 } 5165 5166 while (AttributedTypeLoc TL = CurrTL.getAs<AttributedTypeLoc>()) { 5167 fillAttributedTypeLoc(TL, D.getTypeObject(i).getAttrs(), DeclAttrs); 5168 CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc(); 5169 } 5170 5171 // FIXME: Ordering here? 5172 while (AdjustedTypeLoc TL = CurrTL.getAs<AdjustedTypeLoc>()) 5173 CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc(); 5174 5175 DeclaratorLocFiller(Context, D.getTypeObject(i)).Visit(CurrTL); 5176 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc(); 5177 } 5178 5179 // If we have different source information for the return type, use 5180 // that. This really only applies to C++ conversion functions. 5181 if (ReturnTypeInfo) { 5182 TypeLoc TL = ReturnTypeInfo->getTypeLoc(); 5183 assert(TL.getFullDataSize() == CurrTL.getFullDataSize()); 5184 memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize()); 5185 } else { 5186 TypeSpecLocFiller(Context, D.getDeclSpec()).Visit(CurrTL); 5187 } 5188 5189 return TInfo; 5190} 5191 5192/// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo. 5193ParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) { 5194 // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser 5195 // and Sema during declaration parsing. Try deallocating/caching them when 5196 // it's appropriate, instead of allocating them and keeping them around. 5197 LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType), 5198 TypeAlignment); 5199 new (LocT) LocInfoType(T, TInfo); 5200 assert(LocT->getTypeClass() != T->getTypeClass() && 5201 "LocInfoType's TypeClass conflicts with an existing Type class"); 5202 return ParsedType::make(QualType(LocT, 0)); 5203} 5204 5205void LocInfoType::getAsStringInternal(std::string &Str, 5206 const PrintingPolicy &Policy) const { 5207 llvm_unreachable("LocInfoType leaked into the type system; an opaque TypeTy*" 5208 " was used directly instead of getting the QualType through" 5209 " GetTypeFromParser"); 5210} 5211 5212TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) { 5213 // C99 6.7.6: Type names have no identifier. This is already validated by 5214 // the parser. 5215 assert(D.getIdentifier() == nullptr && 5216 "Type name should have no identifier!"); 5217 5218 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 5219 QualType T = TInfo->getType(); 5220 if (D.isInvalidType()) 5221 return true; 5222 5223 // Make sure there are no unused decl attributes on the declarator. 5224 // We don't want to do this for ObjC parameters because we're going 5225 // to apply them to the actual parameter declaration. 5226 // Likewise, we don't want to do this for alias declarations, because 5227 // we are actually going to build a declaration from this eventually. 5228 if (D.getContext() != Declarator::ObjCParameterContext && 5229 D.getContext() != Declarator::AliasDeclContext && 5230 D.getContext() != Declarator::AliasTemplateContext) 5231 checkUnusedDeclAttributes(D); 5232 5233 if (getLangOpts().CPlusPlus) { 5234 // Check that there are no default arguments (C++ only). 5235 CheckExtraCXXDefaultArguments(D); 5236 } 5237 5238 return CreateParsedType(T, TInfo); 5239} 5240 5241ParsedType Sema::ActOnObjCInstanceType(SourceLocation Loc) { 5242 QualType T = Context.getObjCInstanceType(); 5243 TypeSourceInfo *TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 5244 return CreateParsedType(T, TInfo); 5245} 5246 5247//===----------------------------------------------------------------------===// 5248// Type Attribute Processing 5249//===----------------------------------------------------------------------===// 5250 5251/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the 5252/// specified type. The attribute contains 1 argument, the id of the address 5253/// space for the type. 5254static void HandleAddressSpaceTypeAttribute(QualType &Type, 5255 const AttributeList &Attr, Sema &S){ 5256 5257 // If this type is already address space qualified, reject it. 5258 // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified by 5259 // qualifiers for two or more different address spaces." 5260 if (Type.getAddressSpace()) { 5261 S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers); 5262 Attr.setInvalid(); 5263 return; 5264 } 5265 5266 // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "A function type shall not be 5267 // qualified by an address-space qualifier." 5268 if (Type->isFunctionType()) { 5269 S.Diag(Attr.getLoc(), diag::err_attribute_address_function_type); 5270 Attr.setInvalid(); 5271 return; 5272 } 5273 5274 unsigned ASIdx; 5275 if (Attr.getKind() == AttributeList::AT_AddressSpace) { 5276 // Check the attribute arguments. 5277 if (Attr.getNumArgs() != 1) { 5278 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 5279 << Attr.getName() << 1; 5280 Attr.setInvalid(); 5281 return; 5282 } 5283 Expr *ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 5284 llvm::APSInt addrSpace(32); 5285 if (ASArgExpr->isTypeDependent() || ASArgExpr->isValueDependent() || 5286 !ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) { 5287 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 5288 << Attr.getName() << AANT_ArgumentIntegerConstant 5289 << ASArgExpr->getSourceRange(); 5290 Attr.setInvalid(); 5291 return; 5292 } 5293 5294 // Bounds checking. 5295 if (addrSpace.isSigned()) { 5296 if (addrSpace.isNegative()) { 5297 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative) 5298 << ASArgExpr->getSourceRange(); 5299 Attr.setInvalid(); 5300 return; 5301 } 5302 addrSpace.setIsSigned(false); 5303 } 5304 llvm::APSInt max(addrSpace.getBitWidth()); 5305 max = Qualifiers::MaxAddressSpace; 5306 if (addrSpace > max) { 5307 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high) 5308 << int(Qualifiers::MaxAddressSpace) << ASArgExpr->getSourceRange(); 5309 Attr.setInvalid(); 5310 return; 5311 } 5312 ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()); 5313 } else { 5314 // The keyword-based type attributes imply which address space to use. 5315 switch (Attr.getKind()) { 5316 case AttributeList::AT_OpenCLGlobalAddressSpace: 5317 ASIdx = LangAS::opencl_global; break; 5318 case AttributeList::AT_OpenCLLocalAddressSpace: 5319 ASIdx = LangAS::opencl_local; break; 5320 case AttributeList::AT_OpenCLConstantAddressSpace: 5321 ASIdx = LangAS::opencl_constant; break; 5322 case AttributeList::AT_OpenCLGenericAddressSpace: 5323 ASIdx = LangAS::opencl_generic; break; 5324 default: 5325 assert(Attr.getKind() == AttributeList::AT_OpenCLPrivateAddressSpace); 5326 ASIdx = 0; break; 5327 } 5328 } 5329 5330 Type = S.Context.getAddrSpaceQualType(Type, ASIdx); 5331} 5332 5333/// Does this type have a "direct" ownership qualifier? That is, 5334/// is it written like "__strong id", as opposed to something like 5335/// "typeof(foo)", where that happens to be strong? 5336static bool hasDirectOwnershipQualifier(QualType type) { 5337 // Fast path: no qualifier at all. 5338 assert(type.getQualifiers().hasObjCLifetime()); 5339 5340 while (true) { 5341 // __strong id 5342 if (const AttributedType *attr = dyn_cast<AttributedType>(type)) { 5343 if (attr->getAttrKind() == AttributedType::attr_objc_ownership) 5344 return true; 5345 5346 type = attr->getModifiedType(); 5347 5348 // X *__strong (...) 5349 } else if (const ParenType *paren = dyn_cast<ParenType>(type)) { 5350 type = paren->getInnerType(); 5351 5352 // That's it for things we want to complain about. In particular, 5353 // we do not want to look through typedefs, typeof(expr), 5354 // typeof(type), or any other way that the type is somehow 5355 // abstracted. 5356 } else { 5357 5358 return false; 5359 } 5360 } 5361} 5362 5363/// handleObjCOwnershipTypeAttr - Process an objc_ownership 5364/// attribute on the specified type. 5365/// 5366/// Returns 'true' if the attribute was handled. 5367static bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, 5368 AttributeList &attr, 5369 QualType &type) { 5370 bool NonObjCPointer = false; 5371 5372 if (!type->isDependentType() && !type->isUndeducedType()) { 5373 if (const PointerType *ptr = type->getAs<PointerType>()) { 5374 QualType pointee = ptr->getPointeeType(); 5375 if (pointee->isObjCRetainableType() || pointee->isPointerType()) 5376 return false; 5377 // It is important not to lose the source info that there was an attribute 5378 // applied to non-objc pointer. We will create an attributed type but 5379 // its type will be the same as the original type. 5380 NonObjCPointer = true; 5381 } else if (!type->isObjCRetainableType()) { 5382 return false; 5383 } 5384 5385 // Don't accept an ownership attribute in the declspec if it would 5386 // just be the return type of a block pointer. 5387 if (state.isProcessingDeclSpec()) { 5388 Declarator &D = state.getDeclarator(); 5389 if (maybeMovePastReturnType(D, D.getNumTypeObjects(), 5390 /*onlyBlockPointers=*/true)) 5391 return false; 5392 } 5393 } 5394 5395 Sema &S = state.getSema(); 5396 SourceLocation AttrLoc = attr.getLoc(); 5397 if (AttrLoc.isMacroID()) 5398 AttrLoc = S.getSourceManager().getImmediateExpansionRange(AttrLoc).first; 5399 5400 if (!attr.isArgIdent(0)) { 5401 S.Diag(AttrLoc, diag::err_attribute_argument_type) 5402 << attr.getName() << AANT_ArgumentString; 5403 attr.setInvalid(); 5404 return true; 5405 } 5406 5407 IdentifierInfo *II = attr.getArgAsIdent(0)->Ident; 5408 Qualifiers::ObjCLifetime lifetime; 5409 if (II->isStr("none")) 5410 lifetime = Qualifiers::OCL_ExplicitNone; 5411 else if (II->isStr("strong")) 5412 lifetime = Qualifiers::OCL_Strong; 5413 else if (II->isStr("weak")) 5414 lifetime = Qualifiers::OCL_Weak; 5415 else if (II->isStr("autoreleasing")) 5416 lifetime = Qualifiers::OCL_Autoreleasing; 5417 else { 5418 S.Diag(AttrLoc, diag::warn_attribute_type_not_supported) 5419 << attr.getName() << II; 5420 attr.setInvalid(); 5421 return true; 5422 } 5423 5424 // Just ignore lifetime attributes other than __weak and __unsafe_unretained 5425 // outside of ARC mode. 5426 if (!S.getLangOpts().ObjCAutoRefCount && 5427 lifetime != Qualifiers::OCL_Weak && 5428 lifetime != Qualifiers::OCL_ExplicitNone) { 5429 return true; 5430 } 5431 5432 SplitQualType underlyingType = type.split(); 5433 5434 // Check for redundant/conflicting ownership qualifiers. 5435 if (Qualifiers::ObjCLifetime previousLifetime 5436 = type.getQualifiers().getObjCLifetime()) { 5437 // If it's written directly, that's an error. 5438 if (hasDirectOwnershipQualifier(type)) { 5439 S.Diag(AttrLoc, diag::err_attr_objc_ownership_redundant) 5440 << type; 5441 return true; 5442 } 5443 5444 // Otherwise, if the qualifiers actually conflict, pull sugar off 5445 // and remove the ObjCLifetime qualifiers. 5446 if (previousLifetime != lifetime) { 5447 // It's possible to have multiple local ObjCLifetime qualifiers. We 5448 // can't stop after we reach a type that is directly qualified. 5449 const Type *prevTy = nullptr; 5450 while (!prevTy || prevTy != underlyingType.Ty) { 5451 prevTy = underlyingType.Ty; 5452 underlyingType = underlyingType.getSingleStepDesugaredType(); 5453 } 5454 underlyingType.Quals.removeObjCLifetime(); 5455 } 5456 } 5457 5458 underlyingType.Quals.addObjCLifetime(lifetime); 5459 5460 if (NonObjCPointer) { 5461 StringRef name = attr.getName()->getName(); 5462 switch (lifetime) { 5463 case Qualifiers::OCL_None: 5464 case Qualifiers::OCL_ExplicitNone: 5465 break; 5466 case Qualifiers::OCL_Strong: name = "__strong"; break; 5467 case Qualifiers::OCL_Weak: name = "__weak"; break; 5468 case Qualifiers::OCL_Autoreleasing: name = "__autoreleasing"; break; 5469 } 5470 S.Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name 5471 << TDS_ObjCObjOrBlock << type; 5472 } 5473 5474 // Don't actually add the __unsafe_unretained qualifier in non-ARC files, 5475 // because having both 'T' and '__unsafe_unretained T' exist in the type 5476 // system causes unfortunate widespread consistency problems. (For example, 5477 // they're not considered compatible types, and we mangle them identicially 5478 // as template arguments.) These problems are all individually fixable, 5479 // but it's easier to just not add the qualifier and instead sniff it out 5480 // in specific places using isObjCInertUnsafeUnretainedType(). 5481 // 5482 // Doing this does means we miss some trivial consistency checks that 5483 // would've triggered in ARC, but that's better than trying to solve all 5484 // the coexistence problems with __unsafe_unretained. 5485 if (!S.getLangOpts().ObjCAutoRefCount && 5486 lifetime == Qualifiers::OCL_ExplicitNone) { 5487 type = S.Context.getAttributedType( 5488 AttributedType::attr_objc_inert_unsafe_unretained, 5489 type, type); 5490 return true; 5491 } 5492 5493 QualType origType = type; 5494 if (!NonObjCPointer) 5495 type = S.Context.getQualifiedType(underlyingType); 5496 5497 // If we have a valid source location for the attribute, use an 5498 // AttributedType instead. 5499 if (AttrLoc.isValid()) 5500 type = S.Context.getAttributedType(AttributedType::attr_objc_ownership, 5501 origType, type); 5502 5503 auto diagnoseOrDelay = [](Sema &S, SourceLocation loc, 5504 unsigned diagnostic, QualType type) { 5505 if (S.DelayedDiagnostics.shouldDelayDiagnostics()) { 5506 S.DelayedDiagnostics.add( 5507 sema::DelayedDiagnostic::makeForbiddenType( 5508 S.getSourceManager().getExpansionLoc(loc), 5509 diagnostic, type, /*ignored*/ 0)); 5510 } else { 5511 S.Diag(loc, diagnostic); 5512 } 5513 }; 5514 5515 // Sometimes, __weak isn't allowed. 5516 if (lifetime == Qualifiers::OCL_Weak && 5517 !S.getLangOpts().ObjCWeak && !NonObjCPointer) { 5518 5519 // Use a specialized diagnostic if the runtime just doesn't support them. 5520 unsigned diagnostic = 5521 (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled 5522 : diag::err_arc_weak_no_runtime); 5523 5524 // In any case, delay the diagnostic until we know what we're parsing. 5525 diagnoseOrDelay(S, AttrLoc, diagnostic, type); 5526 5527 attr.setInvalid(); 5528 return true; 5529 } 5530 5531 // Forbid __weak for class objects marked as 5532 // objc_arc_weak_reference_unavailable 5533 if (lifetime == Qualifiers::OCL_Weak) { 5534 if (const ObjCObjectPointerType *ObjT = 5535 type->getAs<ObjCObjectPointerType>()) { 5536 if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) { 5537 if (Class->isArcWeakrefUnavailable()) { 5538 S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class); 5539 S.Diag(ObjT->getInterfaceDecl()->getLocation(), 5540 diag::note_class_declared); 5541 } 5542 } 5543 } 5544 } 5545 5546 return true; 5547} 5548 5549/// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type 5550/// attribute on the specified type. Returns true to indicate that 5551/// the attribute was handled, false to indicate that the type does 5552/// not permit the attribute. 5553static bool handleObjCGCTypeAttr(TypeProcessingState &state, 5554 AttributeList &attr, 5555 QualType &type) { 5556 Sema &S = state.getSema(); 5557 5558 // Delay if this isn't some kind of pointer. 5559 if (!type->isPointerType() && 5560 !type->isObjCObjectPointerType() && 5561 !type->isBlockPointerType()) 5562 return false; 5563 5564 if (type.getObjCGCAttr() != Qualifiers::GCNone) { 5565 S.Diag(attr.getLoc(), diag::err_attribute_multiple_objc_gc); 5566 attr.setInvalid(); 5567 return true; 5568 } 5569 5570 // Check the attribute arguments. 5571 if (!attr.isArgIdent(0)) { 5572 S.Diag(attr.getLoc(), diag::err_attribute_argument_type) 5573 << attr.getName() << AANT_ArgumentString; 5574 attr.setInvalid(); 5575 return true; 5576 } 5577 Qualifiers::GC GCAttr; 5578 if (attr.getNumArgs() > 1) { 5579 S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) 5580 << attr.getName() << 1; 5581 attr.setInvalid(); 5582 return true; 5583 } 5584 5585 IdentifierInfo *II = attr.getArgAsIdent(0)->Ident; 5586 if (II->isStr("weak")) 5587 GCAttr = Qualifiers::Weak; 5588 else if (II->isStr("strong")) 5589 GCAttr = Qualifiers::Strong; 5590 else { 5591 S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported) 5592 << attr.getName() << II; 5593 attr.setInvalid(); 5594 return true; 5595 } 5596 5597 QualType origType = type; 5598 type = S.Context.getObjCGCQualType(origType, GCAttr); 5599 5600 // Make an attributed type to preserve the source information. 5601 if (attr.getLoc().isValid()) 5602 type = S.Context.getAttributedType(AttributedType::attr_objc_gc, 5603 origType, type); 5604 5605 return true; 5606} 5607 5608namespace { 5609 /// A helper class to unwrap a type down to a function for the 5610 /// purposes of applying attributes there. 5611 /// 5612 /// Use: 5613 /// FunctionTypeUnwrapper unwrapped(SemaRef, T); 5614 /// if (unwrapped.isFunctionType()) { 5615 /// const FunctionType *fn = unwrapped.get(); 5616 /// // change fn somehow 5617 /// T = unwrapped.wrap(fn); 5618 /// } 5619 struct FunctionTypeUnwrapper { 5620 enum WrapKind { 5621 Desugar, 5622 Attributed, 5623 Parens, 5624 Pointer, 5625 BlockPointer, 5626 Reference, 5627 MemberPointer 5628 }; 5629 5630 QualType Original; 5631 const FunctionType *Fn; 5632 SmallVector<unsigned char /*WrapKind*/, 8> Stack; 5633 5634 FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) { 5635 while (true) { 5636 const Type *Ty = T.getTypePtr(); 5637 if (isa<FunctionType>(Ty)) { 5638 Fn = cast<FunctionType>(Ty); 5639 return; 5640 } else if (isa<ParenType>(Ty)) { 5641 T = cast<ParenType>(Ty)->getInnerType(); 5642 Stack.push_back(Parens); 5643 } else if (isa<PointerType>(Ty)) { 5644 T = cast<PointerType>(Ty)->getPointeeType(); 5645 Stack.push_back(Pointer); 5646 } else if (isa<BlockPointerType>(Ty)) { 5647 T = cast<BlockPointerType>(Ty)->getPointeeType(); 5648 Stack.push_back(BlockPointer); 5649 } else if (isa<MemberPointerType>(Ty)) { 5650 T = cast<MemberPointerType>(Ty)->getPointeeType(); 5651 Stack.push_back(MemberPointer); 5652 } else if (isa<ReferenceType>(Ty)) { 5653 T = cast<ReferenceType>(Ty)->getPointeeType(); 5654 Stack.push_back(Reference); 5655 } else if (isa<AttributedType>(Ty)) { 5656 T = cast<AttributedType>(Ty)->getEquivalentType(); 5657 Stack.push_back(Attributed); 5658 } else { 5659 const Type *DTy = Ty->getUnqualifiedDesugaredType(); 5660 if (Ty == DTy) { 5661 Fn = nullptr; 5662 return; 5663 } 5664 5665 T = QualType(DTy, 0); 5666 Stack.push_back(Desugar); 5667 } 5668 } 5669 } 5670 5671 bool isFunctionType() const { return (Fn != nullptr); } 5672 const FunctionType *get() const { return Fn; } 5673 5674 QualType wrap(Sema &S, const FunctionType *New) { 5675 // If T wasn't modified from the unwrapped type, do nothing. 5676 if (New == get()) return Original; 5677 5678 Fn = New; 5679 return wrap(S.Context, Original, 0); 5680 } 5681 5682 private: 5683 QualType wrap(ASTContext &C, QualType Old, unsigned I) { 5684 if (I == Stack.size()) 5685 return C.getQualifiedType(Fn, Old.getQualifiers()); 5686 5687 // Build up the inner type, applying the qualifiers from the old 5688 // type to the new type. 5689 SplitQualType SplitOld = Old.split(); 5690 5691 // As a special case, tail-recurse if there are no qualifiers. 5692 if (SplitOld.Quals.empty()) 5693 return wrap(C, SplitOld.Ty, I); 5694 return C.getQualifiedType(wrap(C, SplitOld.Ty, I), SplitOld.Quals); 5695 } 5696 5697 QualType wrap(ASTContext &C, const Type *Old, unsigned I) { 5698 if (I == Stack.size()) return QualType(Fn, 0); 5699 5700 switch (static_cast<WrapKind>(Stack[I++])) { 5701 case Desugar: 5702 // This is the point at which we potentially lose source 5703 // information. 5704 return wrap(C, Old->getUnqualifiedDesugaredType(), I); 5705 5706 case Attributed: 5707 return wrap(C, cast<AttributedType>(Old)->getEquivalentType(), I); 5708 5709 case Parens: { 5710 QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I); 5711 return C.getParenType(New); 5712 } 5713 5714 case Pointer: { 5715 QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I); 5716 return C.getPointerType(New); 5717 } 5718 5719 case BlockPointer: { 5720 QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I); 5721 return C.getBlockPointerType(New); 5722 } 5723 5724 case MemberPointer: { 5725 const MemberPointerType *OldMPT = cast<MemberPointerType>(Old); 5726 QualType New = wrap(C, OldMPT->getPointeeType(), I); 5727 return C.getMemberPointerType(New, OldMPT->getClass()); 5728 } 5729 5730 case Reference: { 5731 const ReferenceType *OldRef = cast<ReferenceType>(Old); 5732 QualType New = wrap(C, OldRef->getPointeeType(), I); 5733 if (isa<LValueReferenceType>(OldRef)) 5734 return C.getLValueReferenceType(New, OldRef->isSpelledAsLValue()); 5735 else 5736 return C.getRValueReferenceType(New); 5737 } 5738 } 5739 5740 llvm_unreachable("unknown wrapping kind"); 5741 } 5742 }; 5743} // end anonymous namespace 5744 5745static bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State, 5746 AttributeList &Attr, 5747 QualType &Type) { 5748 Sema &S = State.getSema(); 5749 5750 AttributeList::Kind Kind = Attr.getKind(); 5751 QualType Desugared = Type; 5752 const AttributedType *AT = dyn_cast<AttributedType>(Type); 5753 while (AT) { 5754 AttributedType::Kind CurAttrKind = AT->getAttrKind(); 5755 5756 // You cannot specify duplicate type attributes, so if the attribute has 5757 // already been applied, flag it. 5758 if (getAttrListKind(CurAttrKind) == Kind) { 5759 S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute_exact) 5760 << Attr.getName(); 5761 return true; 5762 } 5763 5764 // You cannot have both __sptr and __uptr on the same type, nor can you 5765 // have __ptr32 and __ptr64. 5766 if ((CurAttrKind == AttributedType::attr_ptr32 && 5767 Kind == AttributeList::AT_Ptr64) || 5768 (CurAttrKind == AttributedType::attr_ptr64 && 5769 Kind == AttributeList::AT_Ptr32)) { 5770 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 5771 << "'__ptr32'" << "'__ptr64'"; 5772 return true; 5773 } else if ((CurAttrKind == AttributedType::attr_sptr && 5774 Kind == AttributeList::AT_UPtr) || 5775 (CurAttrKind == AttributedType::attr_uptr && 5776 Kind == AttributeList::AT_SPtr)) { 5777 S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 5778 << "'__sptr'" << "'__uptr'"; 5779 return true; 5780 } 5781 5782 Desugared = AT->getEquivalentType(); 5783 AT = dyn_cast<AttributedType>(Desugared); 5784 } 5785 5786 // Pointer type qualifiers can only operate on pointer types, but not 5787 // pointer-to-member types. 5788 if (!isa<PointerType>(Desugared)) { 5789 if (Type->isMemberPointerType()) 5790 S.Diag(Attr.getLoc(), diag::err_attribute_no_member_pointers) 5791 << Attr.getName(); 5792 else 5793 S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only) 5794 << Attr.getName() << 0; 5795 return true; 5796 } 5797 5798 AttributedType::Kind TAK; 5799 switch (Kind) { 5800 default: llvm_unreachable("Unknown attribute kind"); 5801 case AttributeList::AT_Ptr32: TAK = AttributedType::attr_ptr32; break; 5802 case AttributeList::AT_Ptr64: TAK = AttributedType::attr_ptr64; break; 5803 case AttributeList::AT_SPtr: TAK = AttributedType::attr_sptr; break; 5804 case AttributeList::AT_UPtr: TAK = AttributedType::attr_uptr; break; 5805 } 5806 5807 Type = S.Context.getAttributedType(TAK, Type, Type); 5808 return false; 5809} 5810 5811bool Sema::checkNullabilityTypeSpecifier(QualType &type, 5812 NullabilityKind nullability, 5813 SourceLocation nullabilityLoc, 5814 bool isContextSensitive) { 5815 // We saw a nullability type specifier. If this is the first one for 5816 // this file, note that. 5817 FileID file = getNullabilityCompletenessCheckFileID(*this, nullabilityLoc); 5818 if (!file.isInvalid()) { 5819 FileNullability &fileNullability = NullabilityMap[file]; 5820 if (!fileNullability.SawTypeNullability) { 5821 // If we have already seen a pointer declarator without a nullability 5822 // annotation, complain about it. 5823 if (fileNullability.PointerLoc.isValid()) { 5824 Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) 5825 << static_cast<unsigned>(fileNullability.PointerKind); 5826 } 5827 5828 fileNullability.SawTypeNullability = true; 5829 } 5830 } 5831 5832 // Check for existing nullability attributes on the type. 5833 QualType desugared = type; 5834 while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) { 5835 // Check whether there is already a null 5836 if (auto existingNullability = attributed->getImmediateNullability()) { 5837 // Duplicated nullability. 5838 if (nullability == *existingNullability) { 5839 Diag(nullabilityLoc, diag::warn_nullability_duplicate) 5840 << DiagNullabilityKind(nullability, isContextSensitive) 5841 << FixItHint::CreateRemoval(nullabilityLoc); 5842 5843 break; 5844 } 5845 5846 // Conflicting nullability. 5847 Diag(nullabilityLoc, diag::err_nullability_conflicting) 5848 << DiagNullabilityKind(nullability, isContextSensitive) 5849 << DiagNullabilityKind(*existingNullability, false); 5850 return true; 5851 } 5852 5853 desugared = attributed->getModifiedType(); 5854 } 5855 5856 // If there is already a different nullability specifier, complain. 5857 // This (unlike the code above) looks through typedefs that might 5858 // have nullability specifiers on them, which means we cannot 5859 // provide a useful Fix-It. 5860 if (auto existingNullability = desugared->getNullability(Context)) { 5861 if (nullability != *existingNullability) { 5862 Diag(nullabilityLoc, diag::err_nullability_conflicting) 5863 << DiagNullabilityKind(nullability, isContextSensitive) 5864 << DiagNullabilityKind(*existingNullability, false); 5865 5866 // Try to find the typedef with the existing nullability specifier. 5867 if (auto typedefType = desugared->getAs<TypedefType>()) { 5868 TypedefNameDecl *typedefDecl = typedefType->getDecl(); 5869 QualType underlyingType = typedefDecl->getUnderlyingType(); 5870 if (auto typedefNullability 5871 = AttributedType::stripOuterNullability(underlyingType)) { 5872 if (*typedefNullability == *existingNullability) { 5873 Diag(typedefDecl->getLocation(), diag::note_nullability_here) 5874 << DiagNullabilityKind(*existingNullability, false); 5875 } 5876 } 5877 } 5878 5879 return true; 5880 } 5881 } 5882 5883 // If this definitely isn't a pointer type, reject the specifier. 5884 if (!desugared->canHaveNullability()) { 5885 Diag(nullabilityLoc, diag::err_nullability_nonpointer) 5886 << DiagNullabilityKind(nullability, isContextSensitive) << type; 5887 return true; 5888 } 5889 5890 // For the context-sensitive keywords/Objective-C property 5891 // attributes, require that the type be a single-level pointer. 5892 if (isContextSensitive) { 5893 // Make sure that the pointee isn't itself a pointer type. 5894 QualType pointeeType = desugared->getPointeeType(); 5895 if (pointeeType->isAnyPointerType() || 5896 pointeeType->isObjCObjectPointerType() || 5897 pointeeType->isMemberPointerType()) { 5898 Diag(nullabilityLoc, diag::err_nullability_cs_multilevel) 5899 << DiagNullabilityKind(nullability, true) 5900 << type; 5901 Diag(nullabilityLoc, diag::note_nullability_type_specifier) 5902 << DiagNullabilityKind(nullability, false) 5903 << type 5904 << FixItHint::CreateReplacement(nullabilityLoc, 5905 getNullabilitySpelling(nullability)); 5906 return true; 5907 } 5908 } 5909 5910 // Form the attributed type. 5911 type = Context.getAttributedType( 5912 AttributedType::getNullabilityAttrKind(nullability), type, type); 5913 return false; 5914} 5915 5916bool Sema::checkObjCKindOfType(QualType &type, SourceLocation loc) { 5917 // Find out if it's an Objective-C object or object pointer type; 5918 const ObjCObjectPointerType *ptrType = type->getAs<ObjCObjectPointerType>(); 5919 const ObjCObjectType *objType = ptrType ? ptrType->getObjectType() 5920 : type->getAs<ObjCObjectType>(); 5921 5922 // If not, we can't apply __kindof. 5923 if (!objType) { 5924 // FIXME: Handle dependent types that aren't yet object types. 5925 Diag(loc, diag::err_objc_kindof_nonobject) 5926 << type; 5927 return true; 5928 } 5929 5930 // Rebuild the "equivalent" type, which pushes __kindof down into 5931 // the object type. 5932 // There is no need to apply kindof on an unqualified id type. 5933 QualType equivType = Context.getObjCObjectType( 5934 objType->getBaseType(), objType->getTypeArgsAsWritten(), 5935 objType->getProtocols(), 5936 /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true); 5937 5938 // If we started with an object pointer type, rebuild it. 5939 if (ptrType) { 5940 equivType = Context.getObjCObjectPointerType(equivType); 5941 if (auto nullability = type->getNullability(Context)) { 5942 auto attrKind = AttributedType::getNullabilityAttrKind(*nullability); 5943 equivType = Context.getAttributedType(attrKind, equivType, equivType); 5944 } 5945 } 5946 5947 // Build the attributed type to record where __kindof occurred. 5948 type = Context.getAttributedType(AttributedType::attr_objc_kindof, 5949 type, 5950 equivType); 5951 5952 return false; 5953} 5954 5955/// Map a nullability attribute kind to a nullability kind. 5956static NullabilityKind mapNullabilityAttrKind(AttributeList::Kind kind) { 5957 switch (kind) { 5958 case AttributeList::AT_TypeNonNull: 5959 return NullabilityKind::NonNull; 5960 5961 case AttributeList::AT_TypeNullable: 5962 return NullabilityKind::Nullable; 5963 5964 case AttributeList::AT_TypeNullUnspecified: 5965 return NullabilityKind::Unspecified; 5966 5967 default: 5968 llvm_unreachable("not a nullability attribute kind"); 5969 } 5970} 5971 5972/// Distribute a nullability type attribute that cannot be applied to 5973/// the type specifier to a pointer, block pointer, or member pointer 5974/// declarator, complaining if necessary. 5975/// 5976/// \returns true if the nullability annotation was distributed, false 5977/// otherwise. 5978static bool distributeNullabilityTypeAttr(TypeProcessingState &state, 5979 QualType type, 5980 AttributeList &attr) { 5981 Declarator &declarator = state.getDeclarator(); 5982 5983 /// Attempt to move the attribute to the specified chunk. 5984 auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool { 5985 // If there is already a nullability attribute there, don't add 5986 // one. 5987 if (hasNullabilityAttr(chunk.getAttrListRef())) 5988 return false; 5989 5990 // Complain about the nullability qualifier being in the wrong 5991 // place. 5992 enum { 5993 PK_Pointer, 5994 PK_BlockPointer, 5995 PK_MemberPointer, 5996 PK_FunctionPointer, 5997 PK_MemberFunctionPointer, 5998 } pointerKind 5999 = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? PK_FunctionPointer 6000 : PK_Pointer) 6001 : chunk.Kind == DeclaratorChunk::BlockPointer ? PK_BlockPointer 6002 : inFunction? PK_MemberFunctionPointer : PK_MemberPointer; 6003 6004 auto diag = state.getSema().Diag(attr.getLoc(), 6005 diag::warn_nullability_declspec) 6006 << DiagNullabilityKind(mapNullabilityAttrKind(attr.getKind()), 6007 attr.isContextSensitiveKeywordAttribute()) 6008 << type 6009 << static_cast<unsigned>(pointerKind); 6010 6011 // FIXME: MemberPointer chunks don't carry the location of the *. 6012 if (chunk.Kind != DeclaratorChunk::MemberPointer) { 6013 diag << FixItHint::CreateRemoval(attr.getLoc()) 6014 << FixItHint::CreateInsertion( 6015 state.getSema().getPreprocessor() 6016 .getLocForEndOfToken(chunk.Loc), 6017 " " + attr.getName()->getName().str() + " "); 6018 } 6019 6020 moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 6021 chunk.getAttrListRef()); 6022 return true; 6023 }; 6024 6025 // Move it to the outermost pointer, member pointer, or block 6026 // pointer declarator. 6027 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 6028 DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 6029 switch (chunk.Kind) { 6030 case DeclaratorChunk::Pointer: 6031 case DeclaratorChunk::BlockPointer: 6032 case DeclaratorChunk::MemberPointer: 6033 return moveToChunk(chunk, false); 6034 6035 case DeclaratorChunk::Paren: 6036 case DeclaratorChunk::Array: 6037 continue; 6038 6039 case DeclaratorChunk::Function: 6040 // Try to move past the return type to a function/block/member 6041 // function pointer. 6042 if (DeclaratorChunk *dest = maybeMovePastReturnType( 6043 declarator, i, 6044 /*onlyBlockPointers=*/false)) { 6045 return moveToChunk(*dest, true); 6046 } 6047 6048 return false; 6049 6050 // Don't walk through these. 6051 case DeclaratorChunk::Reference: 6052 case DeclaratorChunk::Pipe: 6053 return false; 6054 } 6055 } 6056 6057 return false; 6058} 6059 6060static AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr) { 6061 assert(!Attr.isInvalid()); 6062 switch (Attr.getKind()) { 6063 default: 6064 llvm_unreachable("not a calling convention attribute"); 6065 case AttributeList::AT_CDecl: 6066 return AttributedType::attr_cdecl; 6067 case AttributeList::AT_FastCall: 6068 return AttributedType::attr_fastcall; 6069 case AttributeList::AT_StdCall: 6070 return AttributedType::attr_stdcall; 6071 case AttributeList::AT_ThisCall: 6072 return AttributedType::attr_thiscall; 6073 case AttributeList::AT_Pascal: 6074 return AttributedType::attr_pascal; 6075 case AttributeList::AT_SwiftCall: 6076 return AttributedType::attr_swiftcall; 6077 case AttributeList::AT_VectorCall: 6078 return AttributedType::attr_vectorcall; 6079 case AttributeList::AT_Pcs: { 6080 // The attribute may have had a fixit applied where we treated an 6081 // identifier as a string literal. The contents of the string are valid, 6082 // but the form may not be. 6083 StringRef Str; 6084 if (Attr.isArgExpr(0)) 6085 Str = cast<StringLiteral>(Attr.getArgAsExpr(0))->getString(); 6086 else 6087 Str = Attr.getArgAsIdent(0)->Ident->getName(); 6088 return llvm::StringSwitch<AttributedType::Kind>(Str) 6089 .Case("aapcs", AttributedType::attr_pcs) 6090 .Case("aapcs-vfp", AttributedType::attr_pcs_vfp); 6091 } 6092 case AttributeList::AT_IntelOclBicc: 6093 return AttributedType::attr_inteloclbicc; 6094 case AttributeList::AT_MSABI: 6095 return AttributedType::attr_ms_abi; 6096 case AttributeList::AT_SysVABI: 6097 return AttributedType::attr_sysv_abi; 6098 case AttributeList::AT_PreserveMost: 6099 return AttributedType::attr_preserve_most; 6100 case AttributeList::AT_PreserveAll: 6101 return AttributedType::attr_preserve_all; 6102 } 6103 llvm_unreachable("unexpected attribute kind!"); 6104} 6105 6106/// Process an individual function attribute. Returns true to 6107/// indicate that the attribute was handled, false if it wasn't. 6108static bool handleFunctionTypeAttr(TypeProcessingState &state, 6109 AttributeList &attr, 6110 QualType &type) { 6111 Sema &S = state.getSema(); 6112 6113 FunctionTypeUnwrapper unwrapped(S, type); 6114 6115 if (attr.getKind() == AttributeList::AT_NoReturn) { 6116 if (S.CheckNoReturnAttr(attr)) 6117 return true; 6118 6119 // Delay if this is not a function type. 6120 if (!unwrapped.isFunctionType()) 6121 return false; 6122 6123 // Otherwise we can process right away. 6124 FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withNoReturn(true); 6125 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 6126 return true; 6127 } 6128 6129 // ns_returns_retained is not always a type attribute, but if we got 6130 // here, we're treating it as one right now. 6131 if (attr.getKind() == AttributeList::AT_NSReturnsRetained) { 6132 assert(S.getLangOpts().ObjCAutoRefCount && 6133 "ns_returns_retained treated as type attribute in non-ARC"); 6134 if (attr.getNumArgs()) return true; 6135 6136 // Delay if this is not a function type. 6137 if (!unwrapped.isFunctionType()) 6138 return false; 6139 6140 FunctionType::ExtInfo EI 6141 = unwrapped.get()->getExtInfo().withProducesResult(true); 6142 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 6143 return true; 6144 } 6145 6146 if (attr.getKind() == AttributeList::AT_Regparm) { 6147 unsigned value; 6148 if (S.CheckRegparmAttr(attr, value)) 6149 return true; 6150 6151 // Delay if this is not a function type. 6152 if (!unwrapped.isFunctionType()) 6153 return false; 6154 6155 // Diagnose regparm with fastcall. 6156 const FunctionType *fn = unwrapped.get(); 6157 CallingConv CC = fn->getCallConv(); 6158 if (CC == CC_X86FastCall) { 6159 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 6160 << FunctionType::getNameForCallConv(CC) 6161 << "regparm"; 6162 attr.setInvalid(); 6163 return true; 6164 } 6165 6166 FunctionType::ExtInfo EI = 6167 unwrapped.get()->getExtInfo().withRegParm(value); 6168 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 6169 return true; 6170 } 6171 6172 // Delay if the type didn't work out to a function. 6173 if (!unwrapped.isFunctionType()) return false; 6174 6175 // Otherwise, a calling convention. 6176 CallingConv CC; 6177 if (S.CheckCallingConvAttr(attr, CC)) 6178 return true; 6179 6180 const FunctionType *fn = unwrapped.get(); 6181 CallingConv CCOld = fn->getCallConv(); 6182 AttributedType::Kind CCAttrKind = getCCTypeAttrKind(attr); 6183 6184 if (CCOld != CC) { 6185 // Error out on when there's already an attribute on the type 6186 // and the CCs don't match. 6187 const AttributedType *AT = S.getCallingConvAttributedType(type); 6188 if (AT && AT->getAttrKind() != CCAttrKind) { 6189 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 6190 << FunctionType::getNameForCallConv(CC) 6191 << FunctionType::getNameForCallConv(CCOld); 6192 attr.setInvalid(); 6193 return true; 6194 } 6195 } 6196 6197 // Diagnose use of variadic functions with calling conventions that 6198 // don't support them (e.g. because they're callee-cleanup). 6199 // We delay warning about this on unprototyped function declarations 6200 // until after redeclaration checking, just in case we pick up a 6201 // prototype that way. And apparently we also "delay" warning about 6202 // unprototyped function types in general, despite not necessarily having 6203 // much ability to diagnose it later. 6204 if (!supportsVariadicCall(CC)) { 6205 const FunctionProtoType *FnP = dyn_cast<FunctionProtoType>(fn); 6206 if (FnP && FnP->isVariadic()) { 6207 unsigned DiagID = diag::err_cconv_varargs; 6208 6209 // stdcall and fastcall are ignored with a warning for GCC and MS 6210 // compatibility. 6211 bool IsInvalid = true; 6212 if (CC == CC_X86StdCall || CC == CC_X86FastCall) { 6213 DiagID = diag::warn_cconv_varargs; 6214 IsInvalid = false; 6215 } 6216 6217 S.Diag(attr.getLoc(), DiagID) << FunctionType::getNameForCallConv(CC); 6218 if (IsInvalid) attr.setInvalid(); 6219 return true; 6220 } 6221 } 6222 6223 // Also diagnose fastcall with regparm. 6224 if (CC == CC_X86FastCall && fn->getHasRegParm()) { 6225 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 6226 << "regparm" << FunctionType::getNameForCallConv(CC_X86FastCall); 6227 attr.setInvalid(); 6228 return true; 6229 } 6230 6231 // Modify the CC from the wrapped function type, wrap it all back, and then 6232 // wrap the whole thing in an AttributedType as written. The modified type 6233 // might have a different CC if we ignored the attribute. 6234 QualType Equivalent; 6235 if (CCOld == CC) { 6236 Equivalent = type; 6237 } else { 6238 auto EI = unwrapped.get()->getExtInfo().withCallingConv(CC); 6239 Equivalent = 6240 unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 6241 } 6242 type = S.Context.getAttributedType(CCAttrKind, type, Equivalent); 6243 return true; 6244} 6245 6246bool Sema::hasExplicitCallingConv(QualType &T) { 6247 QualType R = T.IgnoreParens(); 6248 while (const AttributedType *AT = dyn_cast<AttributedType>(R)) { 6249 if (AT->isCallingConv()) 6250 return true; 6251 R = AT->getModifiedType().IgnoreParens(); 6252 } 6253 return false; 6254} 6255 6256void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, 6257 SourceLocation Loc) { 6258 FunctionTypeUnwrapper Unwrapped(*this, T); 6259 const FunctionType *FT = Unwrapped.get(); 6260 bool IsVariadic = (isa<FunctionProtoType>(FT) && 6261 cast<FunctionProtoType>(FT)->isVariadic()); 6262 CallingConv CurCC = FT->getCallConv(); 6263 CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic); 6264 6265 if (CurCC == ToCC) 6266 return; 6267 6268 // MS compiler ignores explicit calling convention attributes on structors. We 6269 // should do the same. 6270 if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) { 6271 // Issue a warning on ignored calling convention -- except of __stdcall. 6272 // Again, this is what MS compiler does. 6273 if (CurCC != CC_X86StdCall) 6274 Diag(Loc, diag::warn_cconv_structors) 6275 << FunctionType::getNameForCallConv(CurCC); 6276 // Default adjustment. 6277 } else { 6278 // Only adjust types with the default convention. For example, on Windows 6279 // we should adjust a __cdecl type to __thiscall for instance methods, and a 6280 // __thiscall type to __cdecl for static methods. 6281 CallingConv DefaultCC = 6282 Context.getDefaultCallingConvention(IsVariadic, IsStatic); 6283 6284 if (CurCC != DefaultCC || DefaultCC == ToCC) 6285 return; 6286 6287 if (hasExplicitCallingConv(T)) 6288 return; 6289 } 6290 6291 FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC)); 6292 QualType Wrapped = Unwrapped.wrap(*this, FT); 6293 T = Context.getAdjustedType(T, Wrapped); 6294} 6295 6296/// HandleVectorSizeAttribute - this attribute is only applicable to integral 6297/// and float scalars, although arrays, pointers, and function return values are 6298/// allowed in conjunction with this construct. Aggregates with this attribute 6299/// are invalid, even if they are of the same size as a corresponding scalar. 6300/// The raw attribute should contain precisely 1 argument, the vector size for 6301/// the variable, measured in bytes. If curType and rawAttr are well formed, 6302/// this routine will return a new vector type. 6303static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr, 6304 Sema &S) { 6305 // Check the attribute arguments. 6306 if (Attr.getNumArgs() != 1) { 6307 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6308 << Attr.getName() << 1; 6309 Attr.setInvalid(); 6310 return; 6311 } 6312 Expr *sizeExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 6313 llvm::APSInt vecSize(32); 6314 if (sizeExpr->isTypeDependent() || sizeExpr->isValueDependent() || 6315 !sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) { 6316 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 6317 << Attr.getName() << AANT_ArgumentIntegerConstant 6318 << sizeExpr->getSourceRange(); 6319 Attr.setInvalid(); 6320 return; 6321 } 6322 // The base type must be integer (not Boolean or enumeration) or float, and 6323 // can't already be a vector. 6324 if (!CurType->isBuiltinType() || CurType->isBooleanType() || 6325 (!CurType->isIntegerType() && !CurType->isRealFloatingType())) { 6326 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType; 6327 Attr.setInvalid(); 6328 return; 6329 } 6330 unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType)); 6331 // vecSize is specified in bytes - convert to bits. 6332 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8); 6333 6334 // the vector size needs to be an integral multiple of the type size. 6335 if (vectorSize % typeSize) { 6336 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size) 6337 << sizeExpr->getSourceRange(); 6338 Attr.setInvalid(); 6339 return; 6340 } 6341 if (VectorType::isVectorSizeTooLarge(vectorSize / typeSize)) { 6342 S.Diag(Attr.getLoc(), diag::err_attribute_size_too_large) 6343 << sizeExpr->getSourceRange(); 6344 Attr.setInvalid(); 6345 return; 6346 } 6347 if (vectorSize == 0) { 6348 S.Diag(Attr.getLoc(), diag::err_attribute_zero_size) 6349 << sizeExpr->getSourceRange(); 6350 Attr.setInvalid(); 6351 return; 6352 } 6353 6354 // Success! Instantiate the vector type, the number of elements is > 0, and 6355 // not required to be a power of 2, unlike GCC. 6356 CurType = S.Context.getVectorType(CurType, vectorSize/typeSize, 6357 VectorType::GenericVector); 6358} 6359 6360/// \brief Process the OpenCL-like ext_vector_type attribute when it occurs on 6361/// a type. 6362static void HandleExtVectorTypeAttr(QualType &CurType, 6363 const AttributeList &Attr, 6364 Sema &S) { 6365 // check the attribute arguments. 6366 if (Attr.getNumArgs() != 1) { 6367 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6368 << Attr.getName() << 1; 6369 return; 6370 } 6371 6372 Expr *sizeExpr; 6373 6374 // Special case where the argument is a template id. 6375 if (Attr.isArgIdent(0)) { 6376 CXXScopeSpec SS; 6377 SourceLocation TemplateKWLoc; 6378 UnqualifiedId id; 6379 id.setIdentifier(Attr.getArgAsIdent(0)->Ident, Attr.getLoc()); 6380 6381 ExprResult Size = S.ActOnIdExpression(S.getCurScope(), SS, TemplateKWLoc, 6382 id, false, false); 6383 if (Size.isInvalid()) 6384 return; 6385 6386 sizeExpr = Size.get(); 6387 } else { 6388 sizeExpr = Attr.getArgAsExpr(0); 6389 } 6390 6391 // Create the vector type. 6392 QualType T = S.BuildExtVectorType(CurType, sizeExpr, Attr.getLoc()); 6393 if (!T.isNull()) 6394 CurType = T; 6395} 6396 6397static bool isPermittedNeonBaseType(QualType &Ty, 6398 VectorType::VectorKind VecKind, Sema &S) { 6399 const BuiltinType *BTy = Ty->getAs<BuiltinType>(); 6400 if (!BTy) 6401 return false; 6402 6403 llvm::Triple Triple = S.Context.getTargetInfo().getTriple(); 6404 6405 // Signed poly is mathematically wrong, but has been baked into some ABIs by 6406 // now. 6407 bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 || 6408 Triple.getArch() == llvm::Triple::aarch64_be; 6409 if (VecKind == VectorType::NeonPolyVector) { 6410 if (IsPolyUnsigned) { 6411 // AArch64 polynomial vectors are unsigned and support poly64. 6412 return BTy->getKind() == BuiltinType::UChar || 6413 BTy->getKind() == BuiltinType::UShort || 6414 BTy->getKind() == BuiltinType::ULong || 6415 BTy->getKind() == BuiltinType::ULongLong; 6416 } else { 6417 // AArch32 polynomial vector are signed. 6418 return BTy->getKind() == BuiltinType::SChar || 6419 BTy->getKind() == BuiltinType::Short; 6420 } 6421 } 6422 6423 // Non-polynomial vector types: the usual suspects are allowed, as well as 6424 // float64_t on AArch64. 6425 bool Is64Bit = Triple.getArch() == llvm::Triple::aarch64 || 6426 Triple.getArch() == llvm::Triple::aarch64_be; 6427 6428 if (Is64Bit && BTy->getKind() == BuiltinType::Double) 6429 return true; 6430 6431 return BTy->getKind() == BuiltinType::SChar || 6432 BTy->getKind() == BuiltinType::UChar || 6433 BTy->getKind() == BuiltinType::Short || 6434 BTy->getKind() == BuiltinType::UShort || 6435 BTy->getKind() == BuiltinType::Int || 6436 BTy->getKind() == BuiltinType::UInt || 6437 BTy->getKind() == BuiltinType::Long || 6438 BTy->getKind() == BuiltinType::ULong || 6439 BTy->getKind() == BuiltinType::LongLong || 6440 BTy->getKind() == BuiltinType::ULongLong || 6441 BTy->getKind() == BuiltinType::Float || 6442 BTy->getKind() == BuiltinType::Half; 6443} 6444 6445/// HandleNeonVectorTypeAttr - The "neon_vector_type" and 6446/// "neon_polyvector_type" attributes are used to create vector types that 6447/// are mangled according to ARM's ABI. Otherwise, these types are identical 6448/// to those created with the "vector_size" attribute. Unlike "vector_size" 6449/// the argument to these Neon attributes is the number of vector elements, 6450/// not the vector size in bytes. The vector width and element type must 6451/// match one of the standard Neon vector types. 6452static void HandleNeonVectorTypeAttr(QualType& CurType, 6453 const AttributeList &Attr, Sema &S, 6454 VectorType::VectorKind VecKind) { 6455 // Target must have NEON 6456 if (!S.Context.getTargetInfo().hasFeature("neon")) { 6457 S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr.getName(); 6458 Attr.setInvalid(); 6459 return; 6460 } 6461 // Check the attribute arguments. 6462 if (Attr.getNumArgs() != 1) { 6463 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6464 << Attr.getName() << 1; 6465 Attr.setInvalid(); 6466 return; 6467 } 6468 // The number of elements must be an ICE. 6469 Expr *numEltsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 6470 llvm::APSInt numEltsInt(32); 6471 if (numEltsExpr->isTypeDependent() || numEltsExpr->isValueDependent() || 6472 !numEltsExpr->isIntegerConstantExpr(numEltsInt, S.Context)) { 6473 S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 6474 << Attr.getName() << AANT_ArgumentIntegerConstant 6475 << numEltsExpr->getSourceRange(); 6476 Attr.setInvalid(); 6477 return; 6478 } 6479 // Only certain element types are supported for Neon vectors. 6480 if (!isPermittedNeonBaseType(CurType, VecKind, S)) { 6481 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType; 6482 Attr.setInvalid(); 6483 return; 6484 } 6485 6486 // The total size of the vector must be 64 or 128 bits. 6487 unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType)); 6488 unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue()); 6489 unsigned vecSize = typeSize * numElts; 6490 if (vecSize != 64 && vecSize != 128) { 6491 S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType; 6492 Attr.setInvalid(); 6493 return; 6494 } 6495 6496 CurType = S.Context.getVectorType(CurType, numElts, VecKind); 6497} 6498 6499/// Handle OpenCL Access Qualifier Attribute. 6500static void HandleOpenCLAccessAttr(QualType &CurType, const AttributeList &Attr, 6501 Sema &S) { 6502 // OpenCL v2.0 s6.6 - Access qualifier can be used only for image and pipe type. 6503 if (!(CurType->isImageType() || CurType->isPipeType())) { 6504 S.Diag(Attr.getLoc(), diag::err_opencl_invalid_access_qualifier); 6505 Attr.setInvalid(); 6506 return; 6507 } 6508 6509 if (const TypedefType* TypedefTy = CurType->getAs<TypedefType>()) { 6510 QualType PointeeTy = TypedefTy->desugar(); 6511 S.Diag(Attr.getLoc(), diag::err_opencl_multiple_access_qualifiers); 6512 6513 std::string PrevAccessQual; 6514 switch (cast<BuiltinType>(PointeeTy.getTypePtr())->getKind()) { 6515 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \ 6516 case BuiltinType::Id: \ 6517 PrevAccessQual = #Access; \ 6518 break; 6519 #include "clang/Basic/OpenCLImageTypes.def" 6520 default: 6521 assert(0 && "Unable to find corresponding image type."); 6522 } 6523 6524 S.Diag(TypedefTy->getDecl()->getLocStart(), 6525 diag::note_opencl_typedef_access_qualifier) << PrevAccessQual; 6526 } 6527} 6528 6529static void processTypeAttrs(TypeProcessingState &state, QualType &type, 6530 TypeAttrLocation TAL, AttributeList *attrs) { 6531 // Scan through and apply attributes to this type where it makes sense. Some 6532 // attributes (such as __address_space__, __vector_size__, etc) apply to the 6533 // type, but others can be present in the type specifiers even though they 6534 // apply to the decl. Here we apply type attributes and ignore the rest. 6535 6536 bool hasOpenCLAddressSpace = false; 6537 while (attrs) { 6538 AttributeList &attr = *attrs; 6539 attrs = attr.getNext(); // reset to the next here due to early loop continue 6540 // stmts 6541 6542 // Skip attributes that were marked to be invalid. 6543 if (attr.isInvalid()) 6544 continue; 6545 6546 if (attr.isCXX11Attribute()) { 6547 // [[gnu::...]] attributes are treated as declaration attributes, so may 6548 // not appertain to a DeclaratorChunk, even if we handle them as type 6549 // attributes. 6550 if (attr.getScopeName() && attr.getScopeName()->isStr("gnu")) { 6551 if (TAL == TAL_DeclChunk) { 6552 state.getSema().Diag(attr.getLoc(), 6553 diag::warn_cxx11_gnu_attribute_on_type) 6554 << attr.getName(); 6555 continue; 6556 } 6557 } else if (TAL != TAL_DeclChunk) { 6558 // Otherwise, only consider type processing for a C++11 attribute if 6559 // it's actually been applied to a type. 6560 continue; 6561 } 6562 } 6563 6564 // If this is an attribute we can handle, do so now, 6565 // otherwise, add it to the FnAttrs list for rechaining. 6566 switch (attr.getKind()) { 6567 default: 6568 // A C++11 attribute on a declarator chunk must appertain to a type. 6569 if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk) { 6570 state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr) 6571 << attr.getName(); 6572 attr.setUsedAsTypeAttr(); 6573 } 6574 break; 6575 6576 case AttributeList::UnknownAttribute: 6577 if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk) 6578 state.getSema().Diag(attr.getLoc(), 6579 diag::warn_unknown_attribute_ignored) 6580 << attr.getName(); 6581 break; 6582 6583 case AttributeList::IgnoredAttribute: 6584 break; 6585 6586 case AttributeList::AT_MayAlias: 6587 // FIXME: This attribute needs to actually be handled, but if we ignore 6588 // it it breaks large amounts of Linux software. 6589 attr.setUsedAsTypeAttr(); 6590 break; 6591 case AttributeList::AT_OpenCLPrivateAddressSpace: 6592 case AttributeList::AT_OpenCLGlobalAddressSpace: 6593 case AttributeList::AT_OpenCLLocalAddressSpace: 6594 case AttributeList::AT_OpenCLConstantAddressSpace: 6595 case AttributeList::AT_OpenCLGenericAddressSpace: 6596 case AttributeList::AT_AddressSpace: 6597 HandleAddressSpaceTypeAttribute(type, attr, state.getSema()); 6598 attr.setUsedAsTypeAttr(); 6599 hasOpenCLAddressSpace = true; 6600 break; 6601 OBJC_POINTER_TYPE_ATTRS_CASELIST: 6602 if (!handleObjCPointerTypeAttr(state, attr, type)) 6603 distributeObjCPointerTypeAttr(state, attr, type); 6604 attr.setUsedAsTypeAttr(); 6605 break; 6606 case AttributeList::AT_VectorSize: 6607 HandleVectorSizeAttr(type, attr, state.getSema()); 6608 attr.setUsedAsTypeAttr(); 6609 break; 6610 case AttributeList::AT_ExtVectorType: 6611 HandleExtVectorTypeAttr(type, attr, state.getSema()); 6612 attr.setUsedAsTypeAttr(); 6613 break; 6614 case AttributeList::AT_NeonVectorType: 6615 HandleNeonVectorTypeAttr(type, attr, state.getSema(), 6616 VectorType::NeonVector); 6617 attr.setUsedAsTypeAttr(); 6618 break; 6619 case AttributeList::AT_NeonPolyVectorType: 6620 HandleNeonVectorTypeAttr(type, attr, state.getSema(), 6621 VectorType::NeonPolyVector); 6622 attr.setUsedAsTypeAttr(); 6623 break; 6624 case AttributeList::AT_OpenCLAccess: 6625 HandleOpenCLAccessAttr(type, attr, state.getSema()); 6626 attr.setUsedAsTypeAttr(); 6627 break; 6628 6629 MS_TYPE_ATTRS_CASELIST: 6630 if (!handleMSPointerTypeQualifierAttr(state, attr, type)) 6631 attr.setUsedAsTypeAttr(); 6632 break; 6633 6634 6635 NULLABILITY_TYPE_ATTRS_CASELIST: 6636 // Either add nullability here or try to distribute it. We 6637 // don't want to distribute the nullability specifier past any 6638 // dependent type, because that complicates the user model. 6639 if (type->canHaveNullability() || type->isDependentType() || 6640 !distributeNullabilityTypeAttr(state, type, attr)) { 6641 if (state.getSema().checkNullabilityTypeSpecifier( 6642 type, 6643 mapNullabilityAttrKind(attr.getKind()), 6644 attr.getLoc(), 6645 attr.isContextSensitiveKeywordAttribute())) { 6646 attr.setInvalid(); 6647 } 6648 6649 attr.setUsedAsTypeAttr(); 6650 } 6651 break; 6652 6653 case AttributeList::AT_ObjCKindOf: 6654 // '__kindof' must be part of the decl-specifiers. 6655 switch (TAL) { 6656 case TAL_DeclSpec: 6657 break; 6658 6659 case TAL_DeclChunk: 6660 case TAL_DeclName: 6661 state.getSema().Diag(attr.getLoc(), 6662 diag::err_objc_kindof_wrong_position) 6663 << FixItHint::CreateRemoval(attr.getLoc()) 6664 << FixItHint::CreateInsertion( 6665 state.getDeclarator().getDeclSpec().getLocStart(), "__kindof "); 6666 break; 6667 } 6668 6669 // Apply it regardless. 6670 if (state.getSema().checkObjCKindOfType(type, attr.getLoc())) 6671 attr.setInvalid(); 6672 attr.setUsedAsTypeAttr(); 6673 break; 6674 6675 case AttributeList::AT_NSReturnsRetained: 6676 if (!state.getSema().getLangOpts().ObjCAutoRefCount) 6677 break; 6678 // fallthrough into the function attrs 6679 6680 FUNCTION_TYPE_ATTRS_CASELIST: 6681 attr.setUsedAsTypeAttr(); 6682 6683 // Never process function type attributes as part of the 6684 // declaration-specifiers. 6685 if (TAL == TAL_DeclSpec) 6686 distributeFunctionTypeAttrFromDeclSpec(state, attr, type); 6687 6688 // Otherwise, handle the possible delays. 6689 else if (!handleFunctionTypeAttr(state, attr, type)) 6690 distributeFunctionTypeAttr(state, attr, type); 6691 break; 6692 } 6693 } 6694 6695 // If address space is not set, OpenCL 2.0 defines non private default 6696 // address spaces for some cases: 6697 // OpenCL 2.0, section 6.5: 6698 // The address space for a variable at program scope or a static variable 6699 // inside a function can either be __global or __constant, but defaults to 6700 // __global if not specified. 6701 // (...) 6702 // Pointers that are declared without pointing to a named address space point 6703 // to the generic address space. 6704 if (state.getSema().getLangOpts().OpenCLVersion >= 200 && 6705 !hasOpenCLAddressSpace && type.getAddressSpace() == 0 && 6706 (TAL == TAL_DeclSpec || TAL == TAL_DeclChunk)) { 6707 Declarator &D = state.getDeclarator(); 6708 if (state.getCurrentChunkIndex() > 0 && 6709 D.getTypeObject(state.getCurrentChunkIndex() - 1).Kind == 6710 DeclaratorChunk::Pointer) { 6711 type = state.getSema().Context.getAddrSpaceQualType( 6712 type, LangAS::opencl_generic); 6713 } else if (state.getCurrentChunkIndex() == 0 && 6714 D.getContext() == Declarator::FileContext && 6715 !D.isFunctionDeclarator() && !D.isFunctionDefinition() && 6716 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 6717 !type->isSamplerT()) 6718 type = state.getSema().Context.getAddrSpaceQualType( 6719 type, LangAS::opencl_global); 6720 else if (state.getCurrentChunkIndex() == 0 && 6721 D.getContext() == Declarator::BlockContext && 6722 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static) 6723 type = state.getSema().Context.getAddrSpaceQualType( 6724 type, LangAS::opencl_global); 6725 } 6726} 6727 6728void Sema::completeExprArrayBound(Expr *E) { 6729 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 6730 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 6731 if (isTemplateInstantiation(Var->getTemplateSpecializationKind())) { 6732 SourceLocation PointOfInstantiation = E->getExprLoc(); 6733 6734 if (MemberSpecializationInfo *MSInfo = 6735 Var->getMemberSpecializationInfo()) { 6736 // If we don't already have a point of instantiation, this is it. 6737 if (MSInfo->getPointOfInstantiation().isInvalid()) { 6738 MSInfo->setPointOfInstantiation(PointOfInstantiation); 6739 6740 // This is a modification of an existing AST node. Notify 6741 // listeners. 6742 if (ASTMutationListener *L = getASTMutationListener()) 6743 L->StaticDataMemberInstantiated(Var); 6744 } 6745 } else { 6746 VarTemplateSpecializationDecl *VarSpec = 6747 cast<VarTemplateSpecializationDecl>(Var); 6748 if (VarSpec->getPointOfInstantiation().isInvalid()) 6749 VarSpec->setPointOfInstantiation(PointOfInstantiation); 6750 } 6751 6752 InstantiateVariableDefinition(PointOfInstantiation, Var); 6753 6754 // Update the type to the newly instantiated definition's type both 6755 // here and within the expression. 6756 if (VarDecl *Def = Var->getDefinition()) { 6757 DRE->setDecl(Def); 6758 QualType T = Def->getType(); 6759 DRE->setType(T); 6760 // FIXME: Update the type on all intervening expressions. 6761 E->setType(T); 6762 } 6763 6764 // We still go on to try to complete the type independently, as it 6765 // may also require instantiations or diagnostics if it remains 6766 // incomplete. 6767 } 6768 } 6769 } 6770} 6771 6772/// \brief Ensure that the type of the given expression is complete. 6773/// 6774/// This routine checks whether the expression \p E has a complete type. If the 6775/// expression refers to an instantiable construct, that instantiation is 6776/// performed as needed to complete its type. Furthermore 6777/// Sema::RequireCompleteType is called for the expression's type (or in the 6778/// case of a reference type, the referred-to type). 6779/// 6780/// \param E The expression whose type is required to be complete. 6781/// \param Diagnoser The object that will emit a diagnostic if the type is 6782/// incomplete. 6783/// 6784/// \returns \c true if the type of \p E is incomplete and diagnosed, \c false 6785/// otherwise. 6786bool Sema::RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser) { 6787 QualType T = E->getType(); 6788 6789 // Incomplete array types may be completed by the initializer attached to 6790 // their definitions. For static data members of class templates and for 6791 // variable templates, we need to instantiate the definition to get this 6792 // initializer and complete the type. 6793 if (T->isIncompleteArrayType()) { 6794 completeExprArrayBound(E); 6795 T = E->getType(); 6796 } 6797 6798 // FIXME: Are there other cases which require instantiating something other 6799 // than the type to complete the type of an expression? 6800 6801 return RequireCompleteType(E->getExprLoc(), T, Diagnoser); 6802} 6803 6804bool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) { 6805 BoundTypeDiagnoser<> Diagnoser(DiagID); 6806 return RequireCompleteExprType(E, Diagnoser); 6807} 6808 6809/// @brief Ensure that the type T is a complete type. 6810/// 6811/// This routine checks whether the type @p T is complete in any 6812/// context where a complete type is required. If @p T is a complete 6813/// type, returns false. If @p T is a class template specialization, 6814/// this routine then attempts to perform class template 6815/// instantiation. If instantiation fails, or if @p T is incomplete 6816/// and cannot be completed, issues the diagnostic @p diag (giving it 6817/// the type @p T) and returns true. 6818/// 6819/// @param Loc The location in the source that the incomplete type 6820/// diagnostic should refer to. 6821/// 6822/// @param T The type that this routine is examining for completeness. 6823/// 6824/// @returns @c true if @p T is incomplete and a diagnostic was emitted, 6825/// @c false otherwise. 6826bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 6827 TypeDiagnoser &Diagnoser) { 6828 if (RequireCompleteTypeImpl(Loc, T, &Diagnoser)) 6829 return true; 6830 if (const TagType *Tag = T->getAs<TagType>()) { 6831 if (!Tag->getDecl()->isCompleteDefinitionRequired()) { 6832 Tag->getDecl()->setCompleteDefinitionRequired(); 6833 Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl()); 6834 } 6835 } 6836 return false; 6837} 6838 6839/// \brief Determine whether there is any declaration of \p D that was ever a 6840/// definition (perhaps before module merging) and is currently visible. 6841/// \param D The definition of the entity. 6842/// \param Suggested Filled in with the declaration that should be made visible 6843/// in order to provide a definition of this entity. 6844/// \param OnlyNeedComplete If \c true, we only need the type to be complete, 6845/// not defined. This only matters for enums with a fixed underlying 6846/// type, since in all other cases, a type is complete if and only if it 6847/// is defined. 6848bool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, 6849 bool OnlyNeedComplete) { 6850 // Easy case: if we don't have modules, all declarations are visible. 6851 if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility) 6852 return true; 6853 6854 // If this definition was instantiated from a template, map back to the 6855 // pattern from which it was instantiated. 6856 if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) { 6857 // We're in the middle of defining it; this definition should be treated 6858 // as visible. 6859 return true; 6860 } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) { 6861 if (auto *Pattern = RD->getTemplateInstantiationPattern()) 6862 RD = Pattern; 6863 D = RD->getDefinition(); 6864 } else if (auto *ED = dyn_cast<EnumDecl>(D)) { 6865 if (auto *Pattern = ED->getTemplateInstantiationPattern()) 6866 ED = Pattern; 6867 if (OnlyNeedComplete && ED->isFixed()) { 6868 // If the enum has a fixed underlying type, and we're only looking for a 6869 // complete type (not a definition), any visible declaration of it will 6870 // do. 6871 *Suggested = nullptr; 6872 for (auto *Redecl : ED->redecls()) { 6873 if (isVisible(Redecl)) 6874 return true; 6875 if (Redecl->isThisDeclarationADefinition() || 6876 (Redecl->isCanonicalDecl() && !*Suggested)) 6877 *Suggested = Redecl; 6878 } 6879 return false; 6880 } 6881 D = ED->getDefinition(); 6882 } 6883 assert(D && "missing definition for pattern of instantiated definition"); 6884 6885 *Suggested = D; 6886 if (isVisible(D)) 6887 return true; 6888 6889 // The external source may have additional definitions of this type that are 6890 // visible, so complete the redeclaration chain now and ask again. 6891 if (auto *Source = Context.getExternalSource()) { 6892 Source->CompleteRedeclChain(D); 6893 return isVisible(D); 6894 } 6895 6896 return false; 6897} 6898 6899/// Locks in the inheritance model for the given class and all of its bases. 6900static void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) { 6901 RD = RD->getMostRecentDecl(); 6902 if (!RD->hasAttr<MSInheritanceAttr>()) { 6903 MSInheritanceAttr::Spelling IM; 6904 6905 switch (S.MSPointerToMemberRepresentationMethod) { 6906 case LangOptions::PPTMK_BestCase: 6907 IM = RD->calculateInheritanceModel(); 6908 break; 6909 case LangOptions::PPTMK_FullGeneralitySingleInheritance: 6910 IM = MSInheritanceAttr::Keyword_single_inheritance; 6911 break; 6912 case LangOptions::PPTMK_FullGeneralityMultipleInheritance: 6913 IM = MSInheritanceAttr::Keyword_multiple_inheritance; 6914 break; 6915 case LangOptions::PPTMK_FullGeneralityVirtualInheritance: 6916 IM = MSInheritanceAttr::Keyword_unspecified_inheritance; 6917 break; 6918 } 6919 6920 RD->addAttr(MSInheritanceAttr::CreateImplicit( 6921 S.getASTContext(), IM, 6922 /*BestCase=*/S.MSPointerToMemberRepresentationMethod == 6923 LangOptions::PPTMK_BestCase, 6924 S.ImplicitMSInheritanceAttrLoc.isValid() 6925 ? S.ImplicitMSInheritanceAttrLoc 6926 : RD->getSourceRange())); 6927 S.Consumer.AssignInheritanceModel(RD); 6928 } 6929} 6930 6931/// \brief The implementation of RequireCompleteType 6932bool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, 6933 TypeDiagnoser *Diagnoser) { 6934 // FIXME: Add this assertion to make sure we always get instantiation points. 6935 // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType"); 6936 // FIXME: Add this assertion to help us flush out problems with 6937 // checking for dependent types and type-dependent expressions. 6938 // 6939 // assert(!T->isDependentType() && 6940 // "Can't ask whether a dependent type is complete"); 6941 6942 // We lock in the inheritance model once somebody has asked us to ensure 6943 // that a pointer-to-member type is complete. 6944 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { 6945 if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) { 6946 if (!MPTy->getClass()->isDependentType()) { 6947 (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0)); 6948 assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl()); 6949 } 6950 } 6951 } 6952 6953 NamedDecl *Def = nullptr; 6954 bool Incomplete = T->isIncompleteType(&Def); 6955 6956 // Check that any necessary explicit specializations are visible. For an 6957 // enum, we just need the declaration, so don't check this. 6958 if (Def && !isa<EnumDecl>(Def)) 6959 checkSpecializationVisibility(Loc, Def); 6960 6961 // If we have a complete type, we're done. 6962 if (!Incomplete) { 6963 // If we know about the definition but it is not visible, complain. 6964 NamedDecl *SuggestedDef = nullptr; 6965 if (Def && 6966 !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) { 6967 // If the user is going to see an error here, recover by making the 6968 // definition visible. 6969 bool TreatAsComplete = Diagnoser && !isSFINAEContext(); 6970 if (Diagnoser) 6971 diagnoseMissingImport(Loc, SuggestedDef, MissingImportKind::Definition, 6972 /*Recover*/TreatAsComplete); 6973 return !TreatAsComplete; 6974 } 6975 6976 return false; 6977 } 6978 6979 const TagType *Tag = T->getAs<TagType>(); 6980 const ObjCInterfaceType *IFace = T->getAs<ObjCInterfaceType>(); 6981 6982 // If there's an unimported definition of this type in a module (for 6983 // instance, because we forward declared it, then imported the definition), 6984 // import that definition now. 6985 // 6986 // FIXME: What about other cases where an import extends a redeclaration 6987 // chain for a declaration that can be accessed through a mechanism other 6988 // than name lookup (eg, referenced in a template, or a variable whose type 6989 // could be completed by the module)? 6990 // 6991 // FIXME: Should we map through to the base array element type before 6992 // checking for a tag type? 6993 if (Tag || IFace) { 6994 NamedDecl *D = 6995 Tag ? static_cast<NamedDecl *>(Tag->getDecl()) : IFace->getDecl(); 6996 6997 // Avoid diagnosing invalid decls as incomplete. 6998 if (D->isInvalidDecl()) 6999 return true; 7000 7001 // Give the external AST source a chance to complete the type. 7002 if (auto *Source = Context.getExternalSource()) { 7003 if (Tag) 7004 Source->CompleteType(Tag->getDecl()); 7005 else 7006 Source->CompleteType(IFace->getDecl()); 7007 7008 // If the external source completed the type, go through the motions 7009 // again to ensure we're allowed to use the completed type. 7010 if (!T->isIncompleteType()) 7011 return RequireCompleteTypeImpl(Loc, T, Diagnoser); 7012 } 7013 } 7014 7015 // If we have a class template specialization or a class member of a 7016 // class template specialization, or an array with known size of such, 7017 // try to instantiate it. 7018 QualType MaybeTemplate = T; 7019 while (const ConstantArrayType *Array 7020 = Context.getAsConstantArrayType(MaybeTemplate)) 7021 MaybeTemplate = Array->getElementType(); 7022 if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) { 7023 bool Instantiated = false; 7024 bool Diagnosed = false; 7025 if (ClassTemplateSpecializationDecl *ClassTemplateSpec 7026 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) { 7027 if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) { 7028 Diagnosed = InstantiateClassTemplateSpecialization( 7029 Loc, ClassTemplateSpec, TSK_ImplicitInstantiation, 7030 /*Complain=*/Diagnoser); 7031 Instantiated = true; 7032 } 7033 } else if (CXXRecordDecl *Rec 7034 = dyn_cast<CXXRecordDecl>(Record->getDecl())) { 7035 CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass(); 7036 if (!Rec->isBeingDefined() && Pattern) { 7037 MemberSpecializationInfo *MSI = Rec->getMemberSpecializationInfo(); 7038 assert(MSI && "Missing member specialization information?"); 7039 // This record was instantiated from a class within a template. 7040 if (MSI->getTemplateSpecializationKind() != 7041 TSK_ExplicitSpecialization) { 7042 Diagnosed = InstantiateClass(Loc, Rec, Pattern, 7043 getTemplateInstantiationArgs(Rec), 7044 TSK_ImplicitInstantiation, 7045 /*Complain=*/Diagnoser); 7046 Instantiated = true; 7047 } 7048 } 7049 } 7050 7051 if (Instantiated) { 7052 // Instantiate* might have already complained that the template is not 7053 // defined, if we asked it to. 7054 if (Diagnoser && Diagnosed) 7055 return true; 7056 // If we instantiated a definition, check that it's usable, even if 7057 // instantiation produced an error, so that repeated calls to this 7058 // function give consistent answers. 7059 if (!T->isIncompleteType()) 7060 return RequireCompleteTypeImpl(Loc, T, Diagnoser); 7061 } 7062 } 7063 7064 // FIXME: If we didn't instantiate a definition because of an explicit 7065 // specialization declaration, check that it's visible. 7066 7067 if (!Diagnoser) 7068 return true; 7069 7070 Diagnoser->diagnose(*this, Loc, T); 7071 7072 // If the type was a forward declaration of a class/struct/union 7073 // type, produce a note. 7074 if (Tag && !Tag->getDecl()->isInvalidDecl()) 7075 Diag(Tag->getDecl()->getLocation(), 7076 Tag->isBeingDefined() ? diag::note_type_being_defined 7077 : diag::note_forward_declaration) 7078 << QualType(Tag, 0); 7079 7080 // If the Objective-C class was a forward declaration, produce a note. 7081 if (IFace && !IFace->getDecl()->isInvalidDecl()) 7082 Diag(IFace->getDecl()->getLocation(), diag::note_forward_class); 7083 7084 // If we have external information that we can use to suggest a fix, 7085 // produce a note. 7086 if (ExternalSource) 7087 ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T); 7088 7089 return true; 7090} 7091 7092bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 7093 unsigned DiagID) { 7094 BoundTypeDiagnoser<> Diagnoser(DiagID); 7095 return RequireCompleteType(Loc, T, Diagnoser); 7096} 7097 7098/// \brief Get diagnostic %select index for tag kind for 7099/// literal type diagnostic message. 7100/// WARNING: Indexes apply to particular diagnostics only! 7101/// 7102/// \returns diagnostic %select index. 7103static unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) { 7104 switch (Tag) { 7105 case TTK_Struct: return 0; 7106 case TTK_Interface: return 1; 7107 case TTK_Class: return 2; 7108 default: llvm_unreachable("Invalid tag kind for literal type diagnostic!"); 7109 } 7110} 7111 7112/// @brief Ensure that the type T is a literal type. 7113/// 7114/// This routine checks whether the type @p T is a literal type. If @p T is an 7115/// incomplete type, an attempt is made to complete it. If @p T is a literal 7116/// type, or @p AllowIncompleteType is true and @p T is an incomplete type, 7117/// returns false. Otherwise, this routine issues the diagnostic @p PD (giving 7118/// it the type @p T), along with notes explaining why the type is not a 7119/// literal type, and returns true. 7120/// 7121/// @param Loc The location in the source that the non-literal type 7122/// diagnostic should refer to. 7123/// 7124/// @param T The type that this routine is examining for literalness. 7125/// 7126/// @param Diagnoser Emits a diagnostic if T is not a literal type. 7127/// 7128/// @returns @c true if @p T is not a literal type and a diagnostic was emitted, 7129/// @c false otherwise. 7130bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, 7131 TypeDiagnoser &Diagnoser) { 7132 assert(!T->isDependentType() && "type should not be dependent"); 7133 7134 QualType ElemType = Context.getBaseElementType(T); 7135 if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) && 7136 T->isLiteralType(Context)) 7137 return false; 7138 7139 Diagnoser.diagnose(*this, Loc, T); 7140 7141 if (T->isVariableArrayType()) 7142 return true; 7143 7144 const RecordType *RT = ElemType->getAs<RecordType>(); 7145 if (!RT) 7146 return true; 7147 7148 const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 7149 7150 // A partially-defined class type can't be a literal type, because a literal 7151 // class type must have a trivial destructor (which can't be checked until 7152 // the class definition is complete). 7153 if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T)) 7154 return true; 7155 7156 // If the class has virtual base classes, then it's not an aggregate, and 7157 // cannot have any constexpr constructors or a trivial default constructor, 7158 // so is non-literal. This is better to diagnose than the resulting absence 7159 // of constexpr constructors. 7160 if (RD->getNumVBases()) { 7161 Diag(RD->getLocation(), diag::note_non_literal_virtual_base) 7162 << getLiteralDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases(); 7163 for (const auto &I : RD->vbases()) 7164 Diag(I.getLocStart(), diag::note_constexpr_virtual_base_here) 7165 << I.getSourceRange(); 7166 } else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() && 7167 !RD->hasTrivialDefaultConstructor()) { 7168 Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD; 7169 } else if (RD->hasNonLiteralTypeFieldsOrBases()) { 7170 for (const auto &I : RD->bases()) { 7171 if (!I.getType()->isLiteralType(Context)) { 7172 Diag(I.getLocStart(), 7173 diag::note_non_literal_base_class) 7174 << RD << I.getType() << I.getSourceRange(); 7175 return true; 7176 } 7177 } 7178 for (const auto *I : RD->fields()) { 7179 if (!I->getType()->isLiteralType(Context) || 7180 I->getType().isVolatileQualified()) { 7181 Diag(I->getLocation(), diag::note_non_literal_field) 7182 << RD << I << I->getType() 7183 << I->getType().isVolatileQualified(); 7184 return true; 7185 } 7186 } 7187 } else if (!RD->hasTrivialDestructor()) { 7188 // All fields and bases are of literal types, so have trivial destructors. 7189 // If this class's destructor is non-trivial it must be user-declared. 7190 CXXDestructorDecl *Dtor = RD->getDestructor(); 7191 assert(Dtor && "class has literal fields and bases but no dtor?"); 7192 if (!Dtor) 7193 return true; 7194 7195 Diag(Dtor->getLocation(), Dtor->isUserProvided() ? 7196 diag::note_non_literal_user_provided_dtor : 7197 diag::note_non_literal_nontrivial_dtor) << RD; 7198 if (!Dtor->isUserProvided()) 7199 SpecialMemberIsTrivial(Dtor, CXXDestructor, /*Diagnose*/true); 7200 } 7201 7202 return true; 7203} 7204 7205bool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) { 7206 BoundTypeDiagnoser<> Diagnoser(DiagID); 7207 return RequireLiteralType(Loc, T, Diagnoser); 7208} 7209 7210/// \brief Retrieve a version of the type 'T' that is elaborated by Keyword 7211/// and qualified by the nested-name-specifier contained in SS. 7212QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword, 7213 const CXXScopeSpec &SS, QualType T) { 7214 if (T.isNull()) 7215 return T; 7216 NestedNameSpecifier *NNS; 7217 if (SS.isValid()) 7218 NNS = SS.getScopeRep(); 7219 else { 7220 if (Keyword == ETK_None) 7221 return T; 7222 NNS = nullptr; 7223 } 7224 return Context.getElaboratedType(Keyword, NNS, T); 7225} 7226 7227QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) { 7228 ExprResult ER = CheckPlaceholderExpr(E); 7229 if (ER.isInvalid()) return QualType(); 7230 E = ER.get(); 7231 7232 if (!getLangOpts().CPlusPlus && E->refersToBitField()) 7233 Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2; 7234 7235 if (!E->isTypeDependent()) { 7236 QualType T = E->getType(); 7237 if (const TagType *TT = T->getAs<TagType>()) 7238 DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc()); 7239 } 7240 return Context.getTypeOfExprType(E); 7241} 7242 7243/// getDecltypeForExpr - Given an expr, will return the decltype for 7244/// that expression, according to the rules in C++11 7245/// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18. 7246static QualType getDecltypeForExpr(Sema &S, Expr *E) { 7247 if (E->isTypeDependent()) 7248 return S.Context.DependentTy; 7249 7250 // C++11 [dcl.type.simple]p4: 7251 // The type denoted by decltype(e) is defined as follows: 7252 // 7253 // - if e is an unparenthesized id-expression or an unparenthesized class 7254 // member access (5.2.5), decltype(e) is the type of the entity named 7255 // by e. If there is no such entity, or if e names a set of overloaded 7256 // functions, the program is ill-formed; 7257 // 7258 // We apply the same rules for Objective-C ivar and property references. 7259 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 7260 if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) 7261 return VD->getType(); 7262 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 7263 if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 7264 return FD->getType(); 7265 } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) { 7266 return IR->getDecl()->getType(); 7267 } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) { 7268 if (PR->isExplicitProperty()) 7269 return PR->getExplicitProperty()->getType(); 7270 } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) { 7271 return PE->getType(); 7272 } 7273 7274 // C++11 [expr.lambda.prim]p18: 7275 // Every occurrence of decltype((x)) where x is a possibly 7276 // parenthesized id-expression that names an entity of automatic 7277 // storage duration is treated as if x were transformed into an 7278 // access to a corresponding data member of the closure type that 7279 // would have been declared if x were an odr-use of the denoted 7280 // entity. 7281 using namespace sema; 7282 if (S.getCurLambda()) { 7283 if (isa<ParenExpr>(E)) { 7284 if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 7285 if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 7286 QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation()); 7287 if (!T.isNull()) 7288 return S.Context.getLValueReferenceType(T); 7289 } 7290 } 7291 } 7292 } 7293 7294 7295 // C++11 [dcl.type.simple]p4: 7296 // [...] 7297 QualType T = E->getType(); 7298 switch (E->getValueKind()) { 7299 // - otherwise, if e is an xvalue, decltype(e) is T&&, where T is the 7300 // type of e; 7301 case VK_XValue: T = S.Context.getRValueReferenceType(T); break; 7302 // - otherwise, if e is an lvalue, decltype(e) is T&, where T is the 7303 // type of e; 7304 case VK_LValue: T = S.Context.getLValueReferenceType(T); break; 7305 // - otherwise, decltype(e) is the type of e. 7306 case VK_RValue: break; 7307 } 7308 7309 return T; 7310} 7311 7312QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc, 7313 bool AsUnevaluated) { 7314 ExprResult ER = CheckPlaceholderExpr(E); 7315 if (ER.isInvalid()) return QualType(); 7316 E = ER.get(); 7317 7318 if (AsUnevaluated && ActiveTemplateInstantiations.empty() && 7319 E->HasSideEffects(Context, false)) { 7320 // The expression operand for decltype is in an unevaluated expression 7321 // context, so side effects could result in unintended consequences. 7322 Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context); 7323 } 7324 7325 return Context.getDecltypeType(E, getDecltypeForExpr(*this, E)); 7326} 7327 7328QualType Sema::BuildUnaryTransformType(QualType BaseType, 7329 UnaryTransformType::UTTKind UKind, 7330 SourceLocation Loc) { 7331 switch (UKind) { 7332 case UnaryTransformType::EnumUnderlyingType: 7333 if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) { 7334 Diag(Loc, diag::err_only_enums_have_underlying_types); 7335 return QualType(); 7336 } else { 7337 QualType Underlying = BaseType; 7338 if (!BaseType->isDependentType()) { 7339 // The enum could be incomplete if we're parsing its definition or 7340 // recovering from an error. 7341 NamedDecl *FwdDecl = nullptr; 7342 if (BaseType->isIncompleteType(&FwdDecl)) { 7343 Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType; 7344 Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl; 7345 return QualType(); 7346 } 7347 7348 EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl(); 7349 assert(ED && "EnumType has no EnumDecl"); 7350 7351 DiagnoseUseOfDecl(ED, Loc); 7352 7353 Underlying = ED->getIntegerType(); 7354 assert(!Underlying.isNull()); 7355 } 7356 return Context.getUnaryTransformType(BaseType, Underlying, 7357 UnaryTransformType::EnumUnderlyingType); 7358 } 7359 } 7360 llvm_unreachable("unknown unary transform type"); 7361} 7362 7363QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) { 7364 if (!T->isDependentType()) { 7365 // FIXME: It isn't entirely clear whether incomplete atomic types 7366 // are allowed or not; for simplicity, ban them for the moment. 7367 if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0)) 7368 return QualType(); 7369 7370 int DisallowedKind = -1; 7371 if (T->isArrayType()) 7372 DisallowedKind = 1; 7373 else if (T->isFunctionType()) 7374 DisallowedKind = 2; 7375 else if (T->isReferenceType()) 7376 DisallowedKind = 3; 7377 else if (T->isAtomicType()) 7378 DisallowedKind = 4; 7379 else if (T.hasQualifiers()) 7380 DisallowedKind = 5; 7381 else if (!T.isTriviallyCopyableType(Context)) 7382 // Some other non-trivially-copyable type (probably a C++ class) 7383 DisallowedKind = 6; 7384 7385 if (DisallowedKind != -1) { 7386 Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T; 7387 return QualType(); 7388 } 7389 7390 // FIXME: Do we need any handling for ARC here? 7391 } 7392 7393 // Build the pointer type. 7394 return Context.getAtomicType(T); 7395} 7396