1193326Sed//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This file implements type-related semantic analysis. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14212904Sdim#include "clang/Sema/SemaInternal.h" 15276479Sdim#include "TypeLocBuilder.h" 16261991Sdim#include "clang/AST/ASTConsumer.h" 17193326Sed#include "clang/AST/ASTContext.h" 18223017Sdim#include "clang/AST/ASTMutationListener.h" 19198092Srdivacky#include "clang/AST/CXXInheritance.h" 20193326Sed#include "clang/AST/DeclObjC.h" 21193326Sed#include "clang/AST/DeclTemplate.h" 22249423Sdim#include "clang/AST/Expr.h" 23198092Srdivacky#include "clang/AST/TypeLoc.h" 24198398Srdivacky#include "clang/AST/TypeLocVisitor.h" 25288943Sdim#include "clang/Lex/Preprocessor.h" 26198092Srdivacky#include "clang/Basic/PartialDiagnostic.h" 27212904Sdim#include "clang/Basic/TargetInfo.h" 28288943Sdim#include "clang/Lex/Preprocessor.h" 29212904Sdim#include "clang/Sema/DeclSpec.h" 30224145Sdim#include "clang/Sema/DelayedDiagnostic.h" 31234353Sdim#include "clang/Sema/Lookup.h" 32249423Sdim#include "clang/Sema/ScopeInfo.h" 33249423Sdim#include "clang/Sema/Template.h" 34195341Sed#include "llvm/ADT/SmallPtrSet.h" 35249423Sdim#include "llvm/ADT/SmallString.h" 36198954Srdivacky#include "llvm/Support/ErrorHandling.h" 37261991Sdim 38193326Sedusing namespace clang; 39193326Sed 40261991Sdimenum TypeDiagSelector { 41261991Sdim TDS_Function, 42261991Sdim TDS_Pointer, 43261991Sdim TDS_ObjCObjOrBlock 44261991Sdim}; 45261991Sdim 46198893Srdivacky/// isOmittedBlockReturnType - Return true if this declarator is missing a 47239462Sdim/// return type because this is a omitted return type on a block literal. 48198893Srdivackystatic bool isOmittedBlockReturnType(const Declarator &D) { 49198893Srdivacky if (D.getContext() != Declarator::BlockLiteralContext || 50198893Srdivacky D.getDeclSpec().hasTypeSpecifier()) 51198893Srdivacky return false; 52239462Sdim 53198893Srdivacky if (D.getNumTypeObjects() == 0) 54198893Srdivacky return true; // ^{ ... } 55239462Sdim 56198893Srdivacky if (D.getNumTypeObjects() == 1 && 57198893Srdivacky D.getTypeObject(0).Kind == DeclaratorChunk::Function) 58198893Srdivacky return true; // ^(int X, float Y) { ... } 59239462Sdim 60198893Srdivacky return false; 61198893Srdivacky} 62198893Srdivacky 63221345Sdim/// diagnoseBadTypeAttribute - Diagnoses a type attribute which 64221345Sdim/// doesn't apply to the given type. 65221345Sdimstatic void diagnoseBadTypeAttribute(Sema &S, const AttributeList &attr, 66221345Sdim QualType type) { 67261991Sdim TypeDiagSelector WhichType; 68261991Sdim bool useExpansionLoc = true; 69221345Sdim switch (attr.getKind()) { 70261991Sdim case AttributeList::AT_ObjCGC: WhichType = TDS_Pointer; break; 71261991Sdim case AttributeList::AT_ObjCOwnership: WhichType = TDS_ObjCObjOrBlock; break; 72221345Sdim default: 73221345Sdim // Assume everything else was a function attribute. 74261991Sdim WhichType = TDS_Function; 75261991Sdim useExpansionLoc = false; 76221345Sdim break; 77221345Sdim } 78221345Sdim 79221345Sdim SourceLocation loc = attr.getLoc(); 80226633Sdim StringRef name = attr.getName()->getName(); 81221345Sdim 82221345Sdim // The GC attributes are usually written with macros; special-case them. 83276479Sdim IdentifierInfo *II = attr.isArgIdent(0) ? attr.getArgAsIdent(0)->Ident 84276479Sdim : nullptr; 85261991Sdim if (useExpansionLoc && loc.isMacroID() && II) { 86261991Sdim if (II->isStr("strong")) { 87221345Sdim if (S.findMacroSpelling(loc, "__strong")) name = "__strong"; 88261991Sdim } else if (II->isStr("weak")) { 89221345Sdim if (S.findMacroSpelling(loc, "__weak")) name = "__weak"; 90221345Sdim } 91221345Sdim } 92221345Sdim 93261991Sdim S.Diag(loc, diag::warn_type_attribute_wrong_type) << name << WhichType 94261991Sdim << type; 95221345Sdim} 96221345Sdim 97218893Sdim// objc_gc applies to Objective-C pointers or, otherwise, to the 98218893Sdim// smallest available pointer type (i.e. 'void*' in 'void**'). 99218893Sdim#define OBJC_POINTER_TYPE_ATTRS_CASELIST \ 100239462Sdim case AttributeList::AT_ObjCGC: \ 101239462Sdim case AttributeList::AT_ObjCOwnership 102203955Srdivacky 103218893Sdim// Function type attributes. 104218893Sdim#define FUNCTION_TYPE_ATTRS_CASELIST \ 105239462Sdim case AttributeList::AT_NoReturn: \ 106239462Sdim case AttributeList::AT_CDecl: \ 107239462Sdim case AttributeList::AT_FastCall: \ 108239462Sdim case AttributeList::AT_StdCall: \ 109239462Sdim case AttributeList::AT_ThisCall: \ 110239462Sdim case AttributeList::AT_Pascal: \ 111280031Sdim case AttributeList::AT_VectorCall: \ 112256030Sdim case AttributeList::AT_MSABI: \ 113256030Sdim case AttributeList::AT_SysVABI: \ 114239462Sdim case AttributeList::AT_Regparm: \ 115243830Sdim case AttributeList::AT_Pcs: \ 116261991Sdim case AttributeList::AT_IntelOclBicc 117203955Srdivacky 118261991Sdim// Microsoft-specific type qualifiers. 119261991Sdim#define MS_TYPE_ATTRS_CASELIST \ 120261991Sdim case AttributeList::AT_Ptr32: \ 121261991Sdim case AttributeList::AT_Ptr64: \ 122261991Sdim case AttributeList::AT_SPtr: \ 123261991Sdim case AttributeList::AT_UPtr 124261991Sdim 125288943Sdim// Nullability qualifiers. 126288943Sdim#define NULLABILITY_TYPE_ATTRS_CASELIST \ 127288943Sdim case AttributeList::AT_TypeNonNull: \ 128288943Sdim case AttributeList::AT_TypeNullable: \ 129288943Sdim case AttributeList::AT_TypeNullUnspecified 130288943Sdim 131218893Sdimnamespace { 132218893Sdim /// An object which stores processing state for the entire 133218893Sdim /// GetTypeForDeclarator process. 134218893Sdim class TypeProcessingState { 135218893Sdim Sema &sema; 136218893Sdim 137218893Sdim /// The declarator being processed. 138218893Sdim Declarator &declarator; 139218893Sdim 140218893Sdim /// The index of the declarator chunk we're currently processing. 141218893Sdim /// May be the total number of valid chunks, indicating the 142218893Sdim /// DeclSpec. 143218893Sdim unsigned chunkIndex; 144218893Sdim 145218893Sdim /// Whether there are non-trivial modifications to the decl spec. 146218893Sdim bool trivial; 147218893Sdim 148221345Sdim /// Whether we saved the attributes in the decl spec. 149221345Sdim bool hasSavedAttrs; 150221345Sdim 151218893Sdim /// The original set of attributes on the DeclSpec. 152226633Sdim SmallVector<AttributeList*, 2> savedAttrs; 153218893Sdim 154218893Sdim /// A list of attributes to diagnose the uselessness of when the 155218893Sdim /// processing is complete. 156226633Sdim SmallVector<AttributeList*, 2> ignoredTypeAttrs; 157218893Sdim 158218893Sdim public: 159218893Sdim TypeProcessingState(Sema &sema, Declarator &declarator) 160218893Sdim : sema(sema), declarator(declarator), 161218893Sdim chunkIndex(declarator.getNumTypeObjects()), 162221345Sdim trivial(true), hasSavedAttrs(false) {} 163218893Sdim 164218893Sdim Sema &getSema() const { 165218893Sdim return sema; 166207619Srdivacky } 167218893Sdim 168218893Sdim Declarator &getDeclarator() const { 169218893Sdim return declarator; 170218893Sdim } 171218893Sdim 172249423Sdim bool isProcessingDeclSpec() const { 173249423Sdim return chunkIndex == declarator.getNumTypeObjects(); 174249423Sdim } 175249423Sdim 176218893Sdim unsigned getCurrentChunkIndex() const { 177218893Sdim return chunkIndex; 178218893Sdim } 179218893Sdim 180218893Sdim void setCurrentChunkIndex(unsigned idx) { 181218893Sdim assert(idx <= declarator.getNumTypeObjects()); 182218893Sdim chunkIndex = idx; 183218893Sdim } 184218893Sdim 185218893Sdim AttributeList *&getCurrentAttrListRef() const { 186249423Sdim if (isProcessingDeclSpec()) 187218893Sdim return getMutableDeclSpec().getAttributes().getListRef(); 188218893Sdim return declarator.getTypeObject(chunkIndex).getAttrListRef(); 189218893Sdim } 190218893Sdim 191218893Sdim /// Save the current set of attributes on the DeclSpec. 192218893Sdim void saveDeclSpecAttrs() { 193218893Sdim // Don't try to save them multiple times. 194221345Sdim if (hasSavedAttrs) return; 195218893Sdim 196218893Sdim DeclSpec &spec = getMutableDeclSpec(); 197218893Sdim for (AttributeList *attr = spec.getAttributes().getList(); attr; 198218893Sdim attr = attr->getNext()) 199218893Sdim savedAttrs.push_back(attr); 200218893Sdim trivial &= savedAttrs.empty(); 201221345Sdim hasSavedAttrs = true; 202218893Sdim } 203218893Sdim 204218893Sdim /// Record that we had nowhere to put the given type attribute. 205218893Sdim /// We will diagnose such attributes later. 206218893Sdim void addIgnoredTypeAttr(AttributeList &attr) { 207218893Sdim ignoredTypeAttrs.push_back(&attr); 208218893Sdim } 209218893Sdim 210218893Sdim /// Diagnose all the ignored type attributes, given that the 211218893Sdim /// declarator worked out to the given type. 212218893Sdim void diagnoseIgnoredTypeAttrs(QualType type) const { 213296417Sdim for (auto *Attr : ignoredTypeAttrs) 214296417Sdim diagnoseBadTypeAttribute(getSema(), *Attr, type); 215218893Sdim } 216218893Sdim 217218893Sdim ~TypeProcessingState() { 218218893Sdim if (trivial) return; 219218893Sdim 220218893Sdim restoreDeclSpecAttrs(); 221218893Sdim } 222218893Sdim 223218893Sdim private: 224218893Sdim DeclSpec &getMutableDeclSpec() const { 225218893Sdim return const_cast<DeclSpec&>(declarator.getDeclSpec()); 226218893Sdim } 227218893Sdim 228218893Sdim void restoreDeclSpecAttrs() { 229221345Sdim assert(hasSavedAttrs); 230221345Sdim 231221345Sdim if (savedAttrs.empty()) { 232276479Sdim getMutableDeclSpec().getAttributes().set(nullptr); 233221345Sdim return; 234221345Sdim } 235221345Sdim 236218893Sdim getMutableDeclSpec().getAttributes().set(savedAttrs[0]); 237218893Sdim for (unsigned i = 0, e = savedAttrs.size() - 1; i != e; ++i) 238218893Sdim savedAttrs[i]->setNext(savedAttrs[i+1]); 239276479Sdim savedAttrs.back()->setNext(nullptr); 240218893Sdim } 241218893Sdim }; 242203955Srdivacky} 243203955Srdivacky 244218893Sdimstatic void spliceAttrIntoList(AttributeList &attr, AttributeList *&head) { 245218893Sdim attr.setNext(head); 246218893Sdim head = &attr; 247218893Sdim} 248218893Sdim 249218893Sdimstatic void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head) { 250218893Sdim if (head == &attr) { 251218893Sdim head = attr.getNext(); 252218893Sdim return; 253203955Srdivacky } 254218893Sdim 255218893Sdim AttributeList *cur = head; 256218893Sdim while (true) { 257218893Sdim assert(cur && cur->getNext() && "ran out of attrs?"); 258218893Sdim if (cur->getNext() == &attr) { 259218893Sdim cur->setNext(attr.getNext()); 260218893Sdim return; 261218893Sdim } 262218893Sdim cur = cur->getNext(); 263218893Sdim } 264203955Srdivacky} 265203955Srdivacky 266218893Sdimstatic void moveAttrFromListToList(AttributeList &attr, 267218893Sdim AttributeList *&fromList, 268218893Sdim AttributeList *&toList) { 269218893Sdim spliceAttrOutOfList(attr, fromList); 270218893Sdim spliceAttrIntoList(attr, toList); 271218893Sdim} 272218893Sdim 273249423Sdim/// The location of a type attribute. 274249423Sdimenum TypeAttrLocation { 275249423Sdim /// The attribute is in the decl-specifier-seq. 276249423Sdim TAL_DeclSpec, 277249423Sdim /// The attribute is part of a DeclaratorChunk. 278249423Sdim TAL_DeclChunk, 279249423Sdim /// The attribute is immediately after the declaration's name. 280249423Sdim TAL_DeclName 281249423Sdim}; 282249423Sdim 283218893Sdimstatic void processTypeAttrs(TypeProcessingState &state, 284249423Sdim QualType &type, TypeAttrLocation TAL, 285218893Sdim AttributeList *attrs); 286218893Sdim 287218893Sdimstatic bool handleFunctionTypeAttr(TypeProcessingState &state, 288218893Sdim AttributeList &attr, 289218893Sdim QualType &type); 290218893Sdim 291261991Sdimstatic bool handleMSPointerTypeQualifierAttr(TypeProcessingState &state, 292261991Sdim AttributeList &attr, 293261991Sdim QualType &type); 294261991Sdim 295218893Sdimstatic bool handleObjCGCTypeAttr(TypeProcessingState &state, 296218893Sdim AttributeList &attr, QualType &type); 297218893Sdim 298224145Sdimstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, 299224145Sdim AttributeList &attr, QualType &type); 300224145Sdim 301218893Sdimstatic bool handleObjCPointerTypeAttr(TypeProcessingState &state, 302218893Sdim AttributeList &attr, QualType &type) { 303239462Sdim if (attr.getKind() == AttributeList::AT_ObjCGC) 304224145Sdim return handleObjCGCTypeAttr(state, attr, type); 305239462Sdim assert(attr.getKind() == AttributeList::AT_ObjCOwnership); 306224145Sdim return handleObjCOwnershipTypeAttr(state, attr, type); 307218893Sdim} 308218893Sdim 309249423Sdim/// Given the index of a declarator chunk, check whether that chunk 310249423Sdim/// directly specifies the return type of a function and, if so, find 311249423Sdim/// an appropriate place for it. 312249423Sdim/// 313249423Sdim/// \param i - a notional index which the search will start 314249423Sdim/// immediately inside 315288943Sdim/// 316288943Sdim/// \param onlyBlockPointers Whether we should only look into block 317288943Sdim/// pointer types (vs. all pointer types). 318249423Sdimstatic DeclaratorChunk *maybeMovePastReturnType(Declarator &declarator, 319288943Sdim unsigned i, 320288943Sdim bool onlyBlockPointers) { 321249423Sdim assert(i <= declarator.getNumTypeObjects()); 322249423Sdim 323276479Sdim DeclaratorChunk *result = nullptr; 324249423Sdim 325249423Sdim // First, look inwards past parens for a function declarator. 326249423Sdim for (; i != 0; --i) { 327249423Sdim DeclaratorChunk &fnChunk = declarator.getTypeObject(i-1); 328249423Sdim switch (fnChunk.Kind) { 329249423Sdim case DeclaratorChunk::Paren: 330249423Sdim continue; 331249423Sdim 332249423Sdim // If we find anything except a function, bail out. 333249423Sdim case DeclaratorChunk::Pointer: 334249423Sdim case DeclaratorChunk::BlockPointer: 335249423Sdim case DeclaratorChunk::Array: 336249423Sdim case DeclaratorChunk::Reference: 337249423Sdim case DeclaratorChunk::MemberPointer: 338296417Sdim case DeclaratorChunk::Pipe: 339249423Sdim return result; 340249423Sdim 341249423Sdim // If we do find a function declarator, scan inwards from that, 342288943Sdim // looking for a (block-)pointer declarator. 343249423Sdim case DeclaratorChunk::Function: 344249423Sdim for (--i; i != 0; --i) { 345288943Sdim DeclaratorChunk &ptrChunk = declarator.getTypeObject(i-1); 346288943Sdim switch (ptrChunk.Kind) { 347249423Sdim case DeclaratorChunk::Paren: 348249423Sdim case DeclaratorChunk::Array: 349249423Sdim case DeclaratorChunk::Function: 350249423Sdim case DeclaratorChunk::Reference: 351296417Sdim case DeclaratorChunk::Pipe: 352288943Sdim continue; 353288943Sdim 354249423Sdim case DeclaratorChunk::MemberPointer: 355288943Sdim case DeclaratorChunk::Pointer: 356288943Sdim if (onlyBlockPointers) 357288943Sdim continue; 358288943Sdim 359288943Sdim // fallthrough 360288943Sdim 361249423Sdim case DeclaratorChunk::BlockPointer: 362288943Sdim result = &ptrChunk; 363249423Sdim goto continue_outer; 364249423Sdim } 365249423Sdim llvm_unreachable("bad declarator chunk kind"); 366249423Sdim } 367249423Sdim 368249423Sdim // If we run out of declarators doing that, we're done. 369249423Sdim return result; 370249423Sdim } 371249423Sdim llvm_unreachable("bad declarator chunk kind"); 372249423Sdim 373249423Sdim // Okay, reconsider from our new point. 374249423Sdim continue_outer: ; 375249423Sdim } 376249423Sdim 377249423Sdim // Ran out of chunks, bail out. 378249423Sdim return result; 379249423Sdim} 380249423Sdim 381218893Sdim/// Given that an objc_gc attribute was written somewhere on a 382218893Sdim/// declaration *other* than on the declarator itself (for which, use 383218893Sdim/// distributeObjCPointerTypeAttrFromDeclarator), and given that it 384218893Sdim/// didn't apply in whatever position it was written in, try to move 385218893Sdim/// it to a more appropriate position. 386218893Sdimstatic void distributeObjCPointerTypeAttr(TypeProcessingState &state, 387218893Sdim AttributeList &attr, 388218893Sdim QualType type) { 389218893Sdim Declarator &declarator = state.getDeclarator(); 390249423Sdim 391249423Sdim // Move it to the outermost normal or block pointer declarator. 392218893Sdim for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 393218893Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 394218893Sdim switch (chunk.Kind) { 395218893Sdim case DeclaratorChunk::Pointer: 396249423Sdim case DeclaratorChunk::BlockPointer: { 397249423Sdim // But don't move an ARC ownership attribute to the return type 398249423Sdim // of a block. 399276479Sdim DeclaratorChunk *destChunk = nullptr; 400249423Sdim if (state.isProcessingDeclSpec() && 401249423Sdim attr.getKind() == AttributeList::AT_ObjCOwnership) 402288943Sdim destChunk = maybeMovePastReturnType(declarator, i - 1, 403288943Sdim /*onlyBlockPointers=*/true); 404249423Sdim if (!destChunk) destChunk = &chunk; 405249423Sdim 406218893Sdim moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 407249423Sdim destChunk->getAttrListRef()); 408218893Sdim return; 409249423Sdim } 410218893Sdim 411218893Sdim case DeclaratorChunk::Paren: 412218893Sdim case DeclaratorChunk::Array: 413218893Sdim continue; 414218893Sdim 415249423Sdim // We may be starting at the return type of a block. 416249423Sdim case DeclaratorChunk::Function: 417249423Sdim if (state.isProcessingDeclSpec() && 418249423Sdim attr.getKind() == AttributeList::AT_ObjCOwnership) { 419288943Sdim if (DeclaratorChunk *dest = maybeMovePastReturnType( 420288943Sdim declarator, i, 421288943Sdim /*onlyBlockPointers=*/true)) { 422249423Sdim moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 423249423Sdim dest->getAttrListRef()); 424249423Sdim return; 425249423Sdim } 426249423Sdim } 427249423Sdim goto error; 428249423Sdim 429218893Sdim // Don't walk through these. 430218893Sdim case DeclaratorChunk::Reference: 431218893Sdim case DeclaratorChunk::MemberPointer: 432296417Sdim case DeclaratorChunk::Pipe: 433218893Sdim goto error; 434218893Sdim } 435218893Sdim } 436218893Sdim error: 437221345Sdim 438221345Sdim diagnoseBadTypeAttribute(state.getSema(), attr, type); 439218893Sdim} 440218893Sdim 441218893Sdim/// Distribute an objc_gc type attribute that was written on the 442218893Sdim/// declarator. 443218893Sdimstatic void 444218893SdimdistributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state, 445218893Sdim AttributeList &attr, 446218893Sdim QualType &declSpecType) { 447218893Sdim Declarator &declarator = state.getDeclarator(); 448218893Sdim 449218893Sdim // objc_gc goes on the innermost pointer to something that's not a 450218893Sdim // pointer. 451218893Sdim unsigned innermost = -1U; 452218893Sdim bool considerDeclSpec = true; 453218893Sdim for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 454218893Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i); 455218893Sdim switch (chunk.Kind) { 456218893Sdim case DeclaratorChunk::Pointer: 457218893Sdim case DeclaratorChunk::BlockPointer: 458218893Sdim innermost = i; 459218893Sdim continue; 460218893Sdim 461218893Sdim case DeclaratorChunk::Reference: 462218893Sdim case DeclaratorChunk::MemberPointer: 463218893Sdim case DeclaratorChunk::Paren: 464218893Sdim case DeclaratorChunk::Array: 465296417Sdim case DeclaratorChunk::Pipe: 466218893Sdim continue; 467218893Sdim 468218893Sdim case DeclaratorChunk::Function: 469218893Sdim considerDeclSpec = false; 470218893Sdim goto done; 471218893Sdim } 472218893Sdim } 473218893Sdim done: 474218893Sdim 475218893Sdim // That might actually be the decl spec if we weren't blocked by 476218893Sdim // anything in the declarator. 477218893Sdim if (considerDeclSpec) { 478221345Sdim if (handleObjCPointerTypeAttr(state, attr, declSpecType)) { 479221345Sdim // Splice the attribute into the decl spec. Prevents the 480221345Sdim // attribute from being applied multiple times and gives 481221345Sdim // the source-location-filler something to work with. 482221345Sdim state.saveDeclSpecAttrs(); 483221345Sdim moveAttrFromListToList(attr, declarator.getAttrListRef(), 484221345Sdim declarator.getMutableDeclSpec().getAttributes().getListRef()); 485218893Sdim return; 486221345Sdim } 487218893Sdim } 488218893Sdim 489218893Sdim // Otherwise, if we found an appropriate chunk, splice the attribute 490218893Sdim // into it. 491218893Sdim if (innermost != -1U) { 492218893Sdim moveAttrFromListToList(attr, declarator.getAttrListRef(), 493218893Sdim declarator.getTypeObject(innermost).getAttrListRef()); 494218893Sdim return; 495218893Sdim } 496218893Sdim 497218893Sdim // Otherwise, diagnose when we're done building the type. 498218893Sdim spliceAttrOutOfList(attr, declarator.getAttrListRef()); 499218893Sdim state.addIgnoredTypeAttr(attr); 500218893Sdim} 501218893Sdim 502218893Sdim/// A function type attribute was written somewhere in a declaration 503218893Sdim/// *other* than on the declarator itself or in the decl spec. Given 504218893Sdim/// that it didn't apply in whatever position it was written in, try 505218893Sdim/// to move it to a more appropriate position. 506218893Sdimstatic void distributeFunctionTypeAttr(TypeProcessingState &state, 507218893Sdim AttributeList &attr, 508218893Sdim QualType type) { 509218893Sdim Declarator &declarator = state.getDeclarator(); 510218893Sdim 511218893Sdim // Try to push the attribute from the return type of a function to 512218893Sdim // the function itself. 513218893Sdim for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 514218893Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 515218893Sdim switch (chunk.Kind) { 516218893Sdim case DeclaratorChunk::Function: 517218893Sdim moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 518218893Sdim chunk.getAttrListRef()); 519218893Sdim return; 520218893Sdim 521218893Sdim case DeclaratorChunk::Paren: 522218893Sdim case DeclaratorChunk::Pointer: 523218893Sdim case DeclaratorChunk::BlockPointer: 524218893Sdim case DeclaratorChunk::Array: 525218893Sdim case DeclaratorChunk::Reference: 526218893Sdim case DeclaratorChunk::MemberPointer: 527296417Sdim case DeclaratorChunk::Pipe: 528218893Sdim continue; 529218893Sdim } 530218893Sdim } 531239462Sdim 532221345Sdim diagnoseBadTypeAttribute(state.getSema(), attr, type); 533218893Sdim} 534218893Sdim 535218893Sdim/// Try to distribute a function type attribute to the innermost 536218893Sdim/// function chunk or type. Returns true if the attribute was 537218893Sdim/// distributed, false if no location was found. 538218893Sdimstatic bool 539218893SdimdistributeFunctionTypeAttrToInnermost(TypeProcessingState &state, 540218893Sdim AttributeList &attr, 541218893Sdim AttributeList *&attrList, 542218893Sdim QualType &declSpecType) { 543218893Sdim Declarator &declarator = state.getDeclarator(); 544218893Sdim 545218893Sdim // Put it on the innermost function chunk, if there is one. 546218893Sdim for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 547218893Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i); 548218893Sdim if (chunk.Kind != DeclaratorChunk::Function) continue; 549218893Sdim 550218893Sdim moveAttrFromListToList(attr, attrList, chunk.getAttrListRef()); 551218893Sdim return true; 552218893Sdim } 553218893Sdim 554261991Sdim return handleFunctionTypeAttr(state, attr, declSpecType); 555218893Sdim} 556218893Sdim 557218893Sdim/// A function type attribute was written in the decl spec. Try to 558218893Sdim/// apply it somewhere. 559218893Sdimstatic void 560218893SdimdistributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state, 561218893Sdim AttributeList &attr, 562218893Sdim QualType &declSpecType) { 563218893Sdim state.saveDeclSpecAttrs(); 564218893Sdim 565249423Sdim // C++11 attributes before the decl specifiers actually appertain to 566249423Sdim // the declarators. Move them straight there. We don't support the 567249423Sdim // 'put them wherever you like' semantics we allow for GNU attributes. 568249423Sdim if (attr.isCXX11Attribute()) { 569249423Sdim moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 570249423Sdim state.getDeclarator().getAttrListRef()); 571249423Sdim return; 572249423Sdim } 573249423Sdim 574218893Sdim // Try to distribute to the innermost. 575218893Sdim if (distributeFunctionTypeAttrToInnermost(state, attr, 576218893Sdim state.getCurrentAttrListRef(), 577218893Sdim declSpecType)) 578218893Sdim return; 579218893Sdim 580218893Sdim // If that failed, diagnose the bad attribute when the declarator is 581218893Sdim // fully built. 582218893Sdim state.addIgnoredTypeAttr(attr); 583218893Sdim} 584218893Sdim 585218893Sdim/// A function type attribute was written on the declarator. Try to 586218893Sdim/// apply it somewhere. 587218893Sdimstatic void 588218893SdimdistributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state, 589218893Sdim AttributeList &attr, 590218893Sdim QualType &declSpecType) { 591218893Sdim Declarator &declarator = state.getDeclarator(); 592218893Sdim 593218893Sdim // Try to distribute to the innermost. 594218893Sdim if (distributeFunctionTypeAttrToInnermost(state, attr, 595218893Sdim declarator.getAttrListRef(), 596218893Sdim declSpecType)) 597218893Sdim return; 598218893Sdim 599218893Sdim // If that failed, diagnose the bad attribute when the declarator is 600218893Sdim // fully built. 601218893Sdim spliceAttrOutOfList(attr, declarator.getAttrListRef()); 602218893Sdim state.addIgnoredTypeAttr(attr); 603218893Sdim} 604218893Sdim 605218893Sdim/// \brief Given that there are attributes written on the declarator 606218893Sdim/// itself, try to distribute any type attributes to the appropriate 607218893Sdim/// declarator chunk. 608218893Sdim/// 609218893Sdim/// These are attributes like the following: 610218893Sdim/// int f ATTR; 611218893Sdim/// int (f ATTR)(); 612218893Sdim/// but not necessarily this: 613218893Sdim/// int f() ATTR; 614218893Sdimstatic void distributeTypeAttrsFromDeclarator(TypeProcessingState &state, 615218893Sdim QualType &declSpecType) { 616218893Sdim // Collect all the type attributes from the declarator itself. 617218893Sdim assert(state.getDeclarator().getAttributes() && "declarator has no attrs!"); 618218893Sdim AttributeList *attr = state.getDeclarator().getAttributes(); 619218893Sdim AttributeList *next; 620218893Sdim do { 621218893Sdim next = attr->getNext(); 622218893Sdim 623249423Sdim // Do not distribute C++11 attributes. They have strict rules for what 624249423Sdim // they appertain to. 625249423Sdim if (attr->isCXX11Attribute()) 626249423Sdim continue; 627249423Sdim 628218893Sdim switch (attr->getKind()) { 629218893Sdim OBJC_POINTER_TYPE_ATTRS_CASELIST: 630218893Sdim distributeObjCPointerTypeAttrFromDeclarator(state, *attr, declSpecType); 631218893Sdim break; 632218893Sdim 633239462Sdim case AttributeList::AT_NSReturnsRetained: 634234353Sdim if (!state.getSema().getLangOpts().ObjCAutoRefCount) 635224145Sdim break; 636224145Sdim // fallthrough 637224145Sdim 638218893Sdim FUNCTION_TYPE_ATTRS_CASELIST: 639218893Sdim distributeFunctionTypeAttrFromDeclarator(state, *attr, declSpecType); 640218893Sdim break; 641218893Sdim 642261991Sdim MS_TYPE_ATTRS_CASELIST: 643261991Sdim // Microsoft type attributes cannot go after the declarator-id. 644261991Sdim continue; 645261991Sdim 646288943Sdim NULLABILITY_TYPE_ATTRS_CASELIST: 647288943Sdim // Nullability specifiers cannot go after the declarator-id. 648288943Sdim 649288943Sdim // Objective-C __kindof does not get distributed. 650288943Sdim case AttributeList::AT_ObjCKindOf: 651288943Sdim continue; 652288943Sdim 653218893Sdim default: 654218893Sdim break; 655218893Sdim } 656218893Sdim } while ((attr = next)); 657218893Sdim} 658218893Sdim 659218893Sdim/// Add a synthetic '()' to a block-literal declarator if it is 660218893Sdim/// required, given the return type. 661218893Sdimstatic void maybeSynthesizeBlockSignature(TypeProcessingState &state, 662218893Sdim QualType declSpecType) { 663218893Sdim Declarator &declarator = state.getDeclarator(); 664218893Sdim 665218893Sdim // First, check whether the declarator would produce a function, 666218893Sdim // i.e. whether the innermost semantic chunk is a function. 667218893Sdim if (declarator.isFunctionDeclarator()) { 668218893Sdim // If so, make that declarator a prototyped declarator. 669218893Sdim declarator.getFunctionTypeInfo().hasPrototype = true; 670218893Sdim return; 671218893Sdim } 672218893Sdim 673218893Sdim // If there are any type objects, the type as written won't name a 674218893Sdim // function, regardless of the decl spec type. This is because a 675218893Sdim // block signature declarator is always an abstract-declarator, and 676218893Sdim // abstract-declarators can't just be parentheses chunks. Therefore 677218893Sdim // we need to build a function chunk unless there are no type 678218893Sdim // objects and the decl spec type is a function. 679218893Sdim if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType()) 680218893Sdim return; 681218893Sdim 682218893Sdim // Note that there *are* cases with invalid declarators where 683218893Sdim // declarators consist solely of parentheses. In general, these 684218893Sdim // occur only in failed efforts to make function declarators, so 685218893Sdim // faking up the function chunk is still the right thing to do. 686218893Sdim 687218893Sdim // Otherwise, we need to fake up a function declarator. 688234353Sdim SourceLocation loc = declarator.getLocStart(); 689218893Sdim 690218893Sdim // ...and *prepend* it to the declarator. 691243830Sdim SourceLocation NoLoc; 692218893Sdim declarator.AddInnermostTypeInfo(DeclaratorChunk::getFunction( 693280031Sdim /*HasProto=*/true, 694280031Sdim /*IsAmbiguous=*/false, 695280031Sdim /*LParenLoc=*/NoLoc, 696280031Sdim /*ArgInfo=*/nullptr, 697280031Sdim /*NumArgs=*/0, 698280031Sdim /*EllipsisLoc=*/NoLoc, 699280031Sdim /*RParenLoc=*/NoLoc, 700280031Sdim /*TypeQuals=*/0, 701280031Sdim /*RefQualifierIsLvalueRef=*/true, 702280031Sdim /*RefQualifierLoc=*/NoLoc, 703280031Sdim /*ConstQualifierLoc=*/NoLoc, 704280031Sdim /*VolatileQualifierLoc=*/NoLoc, 705280031Sdim /*RestrictQualifierLoc=*/NoLoc, 706280031Sdim /*MutableLoc=*/NoLoc, EST_None, 707296417Sdim /*ESpecRange=*/SourceRange(), 708280031Sdim /*Exceptions=*/nullptr, 709280031Sdim /*ExceptionRanges=*/nullptr, 710280031Sdim /*NumExceptions=*/0, 711280031Sdim /*NoexceptExpr=*/nullptr, 712280031Sdim /*ExceptionSpecTokens=*/nullptr, 713280031Sdim loc, loc, declarator)); 714218893Sdim 715218893Sdim // For consistency, make sure the state still has us as processing 716218893Sdim // the decl spec. 717218893Sdim assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1); 718218893Sdim state.setCurrentChunkIndex(declarator.getNumTypeObjects()); 719218893Sdim} 720218893Sdim 721288943Sdimstatic void diagnoseAndRemoveTypeQualifiers(Sema &S, const DeclSpec &DS, 722288943Sdim unsigned &TypeQuals, 723288943Sdim QualType TypeSoFar, 724288943Sdim unsigned RemoveTQs, 725288943Sdim unsigned DiagID) { 726288943Sdim // If this occurs outside a template instantiation, warn the user about 727288943Sdim // it; they probably didn't mean to specify a redundant qualifier. 728288943Sdim typedef std::pair<DeclSpec::TQ, SourceLocation> QualLoc; 729288943Sdim for (QualLoc Qual : {QualLoc(DeclSpec::TQ_const, DS.getConstSpecLoc()), 730288943Sdim QualLoc(DeclSpec::TQ_volatile, DS.getVolatileSpecLoc()), 731288943Sdim QualLoc(DeclSpec::TQ_atomic, DS.getAtomicSpecLoc())}) { 732288943Sdim if (!(RemoveTQs & Qual.first)) 733288943Sdim continue; 734288943Sdim 735288943Sdim if (S.ActiveTemplateInstantiations.empty()) { 736288943Sdim if (TypeQuals & Qual.first) 737288943Sdim S.Diag(Qual.second, DiagID) 738288943Sdim << DeclSpec::getSpecifierName(Qual.first) << TypeSoFar 739288943Sdim << FixItHint::CreateRemoval(Qual.second); 740288943Sdim } 741288943Sdim 742288943Sdim TypeQuals &= ~Qual.first; 743288943Sdim } 744288943Sdim} 745288943Sdim 746288943Sdim/// Apply Objective-C type arguments to the given type. 747288943Sdimstatic QualType applyObjCTypeArgs(Sema &S, SourceLocation loc, QualType type, 748288943Sdim ArrayRef<TypeSourceInfo *> typeArgs, 749288943Sdim SourceRange typeArgsRange, 750288943Sdim bool failOnError = false) { 751288943Sdim // We can only apply type arguments to an Objective-C class type. 752288943Sdim const auto *objcObjectType = type->getAs<ObjCObjectType>(); 753288943Sdim if (!objcObjectType || !objcObjectType->getInterface()) { 754288943Sdim S.Diag(loc, diag::err_objc_type_args_non_class) 755288943Sdim << type 756288943Sdim << typeArgsRange; 757288943Sdim 758288943Sdim if (failOnError) 759288943Sdim return QualType(); 760288943Sdim return type; 761288943Sdim } 762288943Sdim 763288943Sdim // The class type must be parameterized. 764288943Sdim ObjCInterfaceDecl *objcClass = objcObjectType->getInterface(); 765288943Sdim ObjCTypeParamList *typeParams = objcClass->getTypeParamList(); 766288943Sdim if (!typeParams) { 767288943Sdim S.Diag(loc, diag::err_objc_type_args_non_parameterized_class) 768288943Sdim << objcClass->getDeclName() 769288943Sdim << FixItHint::CreateRemoval(typeArgsRange); 770288943Sdim 771288943Sdim if (failOnError) 772288943Sdim return QualType(); 773288943Sdim 774288943Sdim return type; 775288943Sdim } 776288943Sdim 777288943Sdim // The type must not already be specialized. 778288943Sdim if (objcObjectType->isSpecialized()) { 779288943Sdim S.Diag(loc, diag::err_objc_type_args_specialized_class) 780288943Sdim << type 781288943Sdim << FixItHint::CreateRemoval(typeArgsRange); 782288943Sdim 783288943Sdim if (failOnError) 784288943Sdim return QualType(); 785288943Sdim 786288943Sdim return type; 787288943Sdim } 788288943Sdim 789288943Sdim // Check the type arguments. 790288943Sdim SmallVector<QualType, 4> finalTypeArgs; 791288943Sdim unsigned numTypeParams = typeParams->size(); 792288943Sdim bool anyPackExpansions = false; 793288943Sdim for (unsigned i = 0, n = typeArgs.size(); i != n; ++i) { 794288943Sdim TypeSourceInfo *typeArgInfo = typeArgs[i]; 795288943Sdim QualType typeArg = typeArgInfo->getType(); 796288943Sdim 797296417Sdim // Type arguments cannot have explicit qualifiers or nullability. 798296417Sdim // We ignore indirect sources of these, e.g. behind typedefs or 799296417Sdim // template arguments. 800296417Sdim if (TypeLoc qual = typeArgInfo->getTypeLoc().findExplicitQualifierLoc()) { 801296417Sdim bool diagnosed = false; 802296417Sdim SourceRange rangeToRemove; 803296417Sdim if (auto attr = qual.getAs<AttributedTypeLoc>()) { 804296417Sdim rangeToRemove = attr.getLocalSourceRange(); 805296417Sdim if (attr.getTypePtr()->getImmediateNullability()) { 806296417Sdim typeArg = attr.getTypePtr()->getModifiedType(); 807296417Sdim S.Diag(attr.getLocStart(), 808296417Sdim diag::err_objc_type_arg_explicit_nullability) 809296417Sdim << typeArg << FixItHint::CreateRemoval(rangeToRemove); 810296417Sdim diagnosed = true; 811296417Sdim } 812296417Sdim } 813296417Sdim 814296417Sdim if (!diagnosed) { 815296417Sdim S.Diag(qual.getLocStart(), diag::err_objc_type_arg_qualified) 816296417Sdim << typeArg << typeArg.getQualifiers().getAsString() 817296417Sdim << FixItHint::CreateRemoval(rangeToRemove); 818296417Sdim } 819288943Sdim } 820288943Sdim 821296417Sdim // Remove qualifiers even if they're non-local. 822296417Sdim typeArg = typeArg.getUnqualifiedType(); 823296417Sdim 824288943Sdim finalTypeArgs.push_back(typeArg); 825288943Sdim 826288943Sdim if (typeArg->getAs<PackExpansionType>()) 827288943Sdim anyPackExpansions = true; 828288943Sdim 829288943Sdim // Find the corresponding type parameter, if there is one. 830288943Sdim ObjCTypeParamDecl *typeParam = nullptr; 831288943Sdim if (!anyPackExpansions) { 832288943Sdim if (i < numTypeParams) { 833288943Sdim typeParam = typeParams->begin()[i]; 834288943Sdim } else { 835288943Sdim // Too many arguments. 836288943Sdim S.Diag(loc, diag::err_objc_type_args_wrong_arity) 837288943Sdim << false 838288943Sdim << objcClass->getDeclName() 839288943Sdim << (unsigned)typeArgs.size() 840288943Sdim << numTypeParams; 841288943Sdim S.Diag(objcClass->getLocation(), diag::note_previous_decl) 842288943Sdim << objcClass; 843288943Sdim 844288943Sdim if (failOnError) 845288943Sdim return QualType(); 846288943Sdim 847288943Sdim return type; 848288943Sdim } 849288943Sdim } 850288943Sdim 851288943Sdim // Objective-C object pointer types must be substitutable for the bounds. 852288943Sdim if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) { 853288943Sdim // If we don't have a type parameter to match against, assume 854288943Sdim // everything is fine. There was a prior pack expansion that 855288943Sdim // means we won't be able to match anything. 856288943Sdim if (!typeParam) { 857288943Sdim assert(anyPackExpansions && "Too many arguments?"); 858288943Sdim continue; 859288943Sdim } 860288943Sdim 861288943Sdim // Retrieve the bound. 862288943Sdim QualType bound = typeParam->getUnderlyingType(); 863288943Sdim const auto *boundObjC = bound->getAs<ObjCObjectPointerType>(); 864288943Sdim 865288943Sdim // Determine whether the type argument is substitutable for the bound. 866288943Sdim if (typeArgObjC->isObjCIdType()) { 867288943Sdim // When the type argument is 'id', the only acceptable type 868288943Sdim // parameter bound is 'id'. 869288943Sdim if (boundObjC->isObjCIdType()) 870288943Sdim continue; 871288943Sdim } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) { 872288943Sdim // Otherwise, we follow the assignability rules. 873288943Sdim continue; 874288943Sdim } 875288943Sdim 876288943Sdim // Diagnose the mismatch. 877288943Sdim S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 878288943Sdim diag::err_objc_type_arg_does_not_match_bound) 879288943Sdim << typeArg << bound << typeParam->getDeclName(); 880288943Sdim S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here) 881288943Sdim << typeParam->getDeclName(); 882288943Sdim 883288943Sdim if (failOnError) 884288943Sdim return QualType(); 885288943Sdim 886288943Sdim return type; 887288943Sdim } 888288943Sdim 889288943Sdim // Block pointer types are permitted for unqualified 'id' bounds. 890288943Sdim if (typeArg->isBlockPointerType()) { 891288943Sdim // If we don't have a type parameter to match against, assume 892288943Sdim // everything is fine. There was a prior pack expansion that 893288943Sdim // means we won't be able to match anything. 894288943Sdim if (!typeParam) { 895288943Sdim assert(anyPackExpansions && "Too many arguments?"); 896288943Sdim continue; 897288943Sdim } 898288943Sdim 899288943Sdim // Retrieve the bound. 900288943Sdim QualType bound = typeParam->getUnderlyingType(); 901288943Sdim if (bound->isBlockCompatibleObjCPointerType(S.Context)) 902288943Sdim continue; 903288943Sdim 904288943Sdim // Diagnose the mismatch. 905288943Sdim S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 906288943Sdim diag::err_objc_type_arg_does_not_match_bound) 907288943Sdim << typeArg << bound << typeParam->getDeclName(); 908288943Sdim S.Diag(typeParam->getLocation(), diag::note_objc_type_param_here) 909288943Sdim << typeParam->getDeclName(); 910288943Sdim 911288943Sdim if (failOnError) 912288943Sdim return QualType(); 913288943Sdim 914288943Sdim return type; 915288943Sdim } 916288943Sdim 917288943Sdim // Dependent types will be checked at instantiation time. 918288943Sdim if (typeArg->isDependentType()) { 919288943Sdim continue; 920288943Sdim } 921288943Sdim 922288943Sdim // Diagnose non-id-compatible type arguments. 923288943Sdim S.Diag(typeArgInfo->getTypeLoc().getLocStart(), 924288943Sdim diag::err_objc_type_arg_not_id_compatible) 925288943Sdim << typeArg 926288943Sdim << typeArgInfo->getTypeLoc().getSourceRange(); 927288943Sdim 928288943Sdim if (failOnError) 929288943Sdim return QualType(); 930288943Sdim 931288943Sdim return type; 932288943Sdim } 933288943Sdim 934288943Sdim // Make sure we didn't have the wrong number of arguments. 935288943Sdim if (!anyPackExpansions && finalTypeArgs.size() != numTypeParams) { 936288943Sdim S.Diag(loc, diag::err_objc_type_args_wrong_arity) 937288943Sdim << (typeArgs.size() < typeParams->size()) 938288943Sdim << objcClass->getDeclName() 939288943Sdim << (unsigned)finalTypeArgs.size() 940288943Sdim << (unsigned)numTypeParams; 941288943Sdim S.Diag(objcClass->getLocation(), diag::note_previous_decl) 942288943Sdim << objcClass; 943288943Sdim 944288943Sdim if (failOnError) 945288943Sdim return QualType(); 946288943Sdim 947288943Sdim return type; 948288943Sdim } 949288943Sdim 950288943Sdim // Success. Form the specialized type. 951288943Sdim return S.Context.getObjCObjectType(type, finalTypeArgs, { }, false); 952288943Sdim} 953288943Sdim 954288943Sdim/// Apply Objective-C protocol qualifiers to the given type. 955288943Sdimstatic QualType applyObjCProtocolQualifiers( 956288943Sdim Sema &S, SourceLocation loc, SourceRange range, QualType type, 957288943Sdim ArrayRef<ObjCProtocolDecl *> protocols, 958288943Sdim const SourceLocation *protocolLocs, 959288943Sdim bool failOnError = false) { 960288943Sdim ASTContext &ctx = S.Context; 961288943Sdim if (const ObjCObjectType *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){ 962288943Sdim // FIXME: Check for protocols to which the class type is already 963288943Sdim // known to conform. 964288943Sdim 965288943Sdim return ctx.getObjCObjectType(objT->getBaseType(), 966288943Sdim objT->getTypeArgsAsWritten(), 967288943Sdim protocols, 968288943Sdim objT->isKindOfTypeAsWritten()); 969288943Sdim } 970288943Sdim 971288943Sdim if (type->isObjCObjectType()) { 972288943Sdim // Silently overwrite any existing protocol qualifiers. 973288943Sdim // TODO: determine whether that's the right thing to do. 974288943Sdim 975288943Sdim // FIXME: Check for protocols to which the class type is already 976288943Sdim // known to conform. 977288943Sdim return ctx.getObjCObjectType(type, { }, protocols, false); 978288943Sdim } 979288943Sdim 980288943Sdim // id<protocol-list> 981288943Sdim if (type->isObjCIdType()) { 982288943Sdim const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>(); 983288943Sdim type = ctx.getObjCObjectType(ctx.ObjCBuiltinIdTy, { }, protocols, 984288943Sdim objPtr->isKindOfType()); 985288943Sdim return ctx.getObjCObjectPointerType(type); 986288943Sdim } 987288943Sdim 988288943Sdim // Class<protocol-list> 989288943Sdim if (type->isObjCClassType()) { 990288943Sdim const ObjCObjectPointerType *objPtr = type->castAs<ObjCObjectPointerType>(); 991288943Sdim type = ctx.getObjCObjectType(ctx.ObjCBuiltinClassTy, { }, protocols, 992288943Sdim objPtr->isKindOfType()); 993288943Sdim return ctx.getObjCObjectPointerType(type); 994288943Sdim } 995288943Sdim 996288943Sdim S.Diag(loc, diag::err_invalid_protocol_qualifiers) 997288943Sdim << range; 998288943Sdim 999288943Sdim if (failOnError) 1000288943Sdim return QualType(); 1001288943Sdim 1002288943Sdim return type; 1003288943Sdim} 1004288943Sdim 1005288943SdimQualType Sema::BuildObjCObjectType(QualType BaseType, 1006288943Sdim SourceLocation Loc, 1007288943Sdim SourceLocation TypeArgsLAngleLoc, 1008288943Sdim ArrayRef<TypeSourceInfo *> TypeArgs, 1009288943Sdim SourceLocation TypeArgsRAngleLoc, 1010288943Sdim SourceLocation ProtocolLAngleLoc, 1011288943Sdim ArrayRef<ObjCProtocolDecl *> Protocols, 1012288943Sdim ArrayRef<SourceLocation> ProtocolLocs, 1013288943Sdim SourceLocation ProtocolRAngleLoc, 1014288943Sdim bool FailOnError) { 1015288943Sdim QualType Result = BaseType; 1016288943Sdim if (!TypeArgs.empty()) { 1017288943Sdim Result = applyObjCTypeArgs(*this, Loc, Result, TypeArgs, 1018288943Sdim SourceRange(TypeArgsLAngleLoc, 1019288943Sdim TypeArgsRAngleLoc), 1020288943Sdim FailOnError); 1021288943Sdim if (FailOnError && Result.isNull()) 1022288943Sdim return QualType(); 1023288943Sdim } 1024288943Sdim 1025288943Sdim if (!Protocols.empty()) { 1026288943Sdim Result = applyObjCProtocolQualifiers(*this, Loc, 1027288943Sdim SourceRange(ProtocolLAngleLoc, 1028288943Sdim ProtocolRAngleLoc), 1029288943Sdim Result, Protocols, 1030288943Sdim ProtocolLocs.data(), 1031288943Sdim FailOnError); 1032288943Sdim if (FailOnError && Result.isNull()) 1033288943Sdim return QualType(); 1034288943Sdim } 1035288943Sdim 1036288943Sdim return Result; 1037288943Sdim} 1038288943Sdim 1039288943SdimTypeResult Sema::actOnObjCProtocolQualifierType( 1040288943Sdim SourceLocation lAngleLoc, 1041288943Sdim ArrayRef<Decl *> protocols, 1042288943Sdim ArrayRef<SourceLocation> protocolLocs, 1043288943Sdim SourceLocation rAngleLoc) { 1044288943Sdim // Form id<protocol-list>. 1045288943Sdim QualType Result = Context.getObjCObjectType( 1046288943Sdim Context.ObjCBuiltinIdTy, { }, 1047288943Sdim llvm::makeArrayRef( 1048288943Sdim (ObjCProtocolDecl * const *)protocols.data(), 1049288943Sdim protocols.size()), 1050288943Sdim false); 1051288943Sdim Result = Context.getObjCObjectPointerType(Result); 1052288943Sdim 1053288943Sdim TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result); 1054288943Sdim TypeLoc ResultTL = ResultTInfo->getTypeLoc(); 1055288943Sdim 1056288943Sdim auto ObjCObjectPointerTL = ResultTL.castAs<ObjCObjectPointerTypeLoc>(); 1057288943Sdim ObjCObjectPointerTL.setStarLoc(SourceLocation()); // implicit 1058288943Sdim 1059288943Sdim auto ObjCObjectTL = ObjCObjectPointerTL.getPointeeLoc() 1060288943Sdim .castAs<ObjCObjectTypeLoc>(); 1061288943Sdim ObjCObjectTL.setHasBaseTypeAsWritten(false); 1062288943Sdim ObjCObjectTL.getBaseLoc().initialize(Context, SourceLocation()); 1063288943Sdim 1064288943Sdim // No type arguments. 1065288943Sdim ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation()); 1066288943Sdim ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation()); 1067288943Sdim 1068288943Sdim // Fill in protocol qualifiers. 1069288943Sdim ObjCObjectTL.setProtocolLAngleLoc(lAngleLoc); 1070288943Sdim ObjCObjectTL.setProtocolRAngleLoc(rAngleLoc); 1071288943Sdim for (unsigned i = 0, n = protocols.size(); i != n; ++i) 1072288943Sdim ObjCObjectTL.setProtocolLoc(i, protocolLocs[i]); 1073288943Sdim 1074288943Sdim // We're done. Return the completed type to the parser. 1075288943Sdim return CreateParsedType(Result, ResultTInfo); 1076288943Sdim} 1077288943Sdim 1078288943SdimTypeResult Sema::actOnObjCTypeArgsAndProtocolQualifiers( 1079288943Sdim Scope *S, 1080288943Sdim SourceLocation Loc, 1081288943Sdim ParsedType BaseType, 1082288943Sdim SourceLocation TypeArgsLAngleLoc, 1083288943Sdim ArrayRef<ParsedType> TypeArgs, 1084288943Sdim SourceLocation TypeArgsRAngleLoc, 1085288943Sdim SourceLocation ProtocolLAngleLoc, 1086288943Sdim ArrayRef<Decl *> Protocols, 1087288943Sdim ArrayRef<SourceLocation> ProtocolLocs, 1088288943Sdim SourceLocation ProtocolRAngleLoc) { 1089288943Sdim TypeSourceInfo *BaseTypeInfo = nullptr; 1090288943Sdim QualType T = GetTypeFromParser(BaseType, &BaseTypeInfo); 1091288943Sdim if (T.isNull()) 1092288943Sdim return true; 1093288943Sdim 1094288943Sdim // Handle missing type-source info. 1095288943Sdim if (!BaseTypeInfo) 1096288943Sdim BaseTypeInfo = Context.getTrivialTypeSourceInfo(T, Loc); 1097288943Sdim 1098288943Sdim // Extract type arguments. 1099288943Sdim SmallVector<TypeSourceInfo *, 4> ActualTypeArgInfos; 1100288943Sdim for (unsigned i = 0, n = TypeArgs.size(); i != n; ++i) { 1101288943Sdim TypeSourceInfo *TypeArgInfo = nullptr; 1102288943Sdim QualType TypeArg = GetTypeFromParser(TypeArgs[i], &TypeArgInfo); 1103288943Sdim if (TypeArg.isNull()) { 1104288943Sdim ActualTypeArgInfos.clear(); 1105288943Sdim break; 1106288943Sdim } 1107288943Sdim 1108288943Sdim assert(TypeArgInfo && "No type source info?"); 1109288943Sdim ActualTypeArgInfos.push_back(TypeArgInfo); 1110288943Sdim } 1111288943Sdim 1112288943Sdim // Build the object type. 1113288943Sdim QualType Result = BuildObjCObjectType( 1114288943Sdim T, BaseTypeInfo->getTypeLoc().getSourceRange().getBegin(), 1115288943Sdim TypeArgsLAngleLoc, ActualTypeArgInfos, TypeArgsRAngleLoc, 1116288943Sdim ProtocolLAngleLoc, 1117288943Sdim llvm::makeArrayRef((ObjCProtocolDecl * const *)Protocols.data(), 1118288943Sdim Protocols.size()), 1119288943Sdim ProtocolLocs, ProtocolRAngleLoc, 1120288943Sdim /*FailOnError=*/false); 1121288943Sdim 1122288943Sdim if (Result == T) 1123288943Sdim return BaseType; 1124288943Sdim 1125288943Sdim // Create source information for this type. 1126288943Sdim TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result); 1127288943Sdim TypeLoc ResultTL = ResultTInfo->getTypeLoc(); 1128288943Sdim 1129288943Sdim // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an 1130288943Sdim // object pointer type. Fill in source information for it. 1131288943Sdim if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) { 1132288943Sdim // The '*' is implicit. 1133288943Sdim ObjCObjectPointerTL.setStarLoc(SourceLocation()); 1134288943Sdim ResultTL = ObjCObjectPointerTL.getPointeeLoc(); 1135288943Sdim } 1136288943Sdim 1137288943Sdim auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>(); 1138288943Sdim 1139288943Sdim // Type argument information. 1140288943Sdim if (ObjCObjectTL.getNumTypeArgs() > 0) { 1141288943Sdim assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size()); 1142288943Sdim ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc); 1143288943Sdim ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc); 1144288943Sdim for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i) 1145288943Sdim ObjCObjectTL.setTypeArgTInfo(i, ActualTypeArgInfos[i]); 1146288943Sdim } else { 1147288943Sdim ObjCObjectTL.setTypeArgsLAngleLoc(SourceLocation()); 1148288943Sdim ObjCObjectTL.setTypeArgsRAngleLoc(SourceLocation()); 1149288943Sdim } 1150288943Sdim 1151288943Sdim // Protocol qualifier information. 1152288943Sdim if (ObjCObjectTL.getNumProtocols() > 0) { 1153288943Sdim assert(ObjCObjectTL.getNumProtocols() == Protocols.size()); 1154288943Sdim ObjCObjectTL.setProtocolLAngleLoc(ProtocolLAngleLoc); 1155288943Sdim ObjCObjectTL.setProtocolRAngleLoc(ProtocolRAngleLoc); 1156288943Sdim for (unsigned i = 0, n = Protocols.size(); i != n; ++i) 1157288943Sdim ObjCObjectTL.setProtocolLoc(i, ProtocolLocs[i]); 1158288943Sdim } else { 1159288943Sdim ObjCObjectTL.setProtocolLAngleLoc(SourceLocation()); 1160288943Sdim ObjCObjectTL.setProtocolRAngleLoc(SourceLocation()); 1161288943Sdim } 1162288943Sdim 1163288943Sdim // Base type. 1164288943Sdim ObjCObjectTL.setHasBaseTypeAsWritten(true); 1165288943Sdim if (ObjCObjectTL.getType() == T) 1166288943Sdim ObjCObjectTL.getBaseLoc().initializeFullCopy(BaseTypeInfo->getTypeLoc()); 1167288943Sdim else 1168288943Sdim ObjCObjectTL.getBaseLoc().initialize(Context, Loc); 1169288943Sdim 1170288943Sdim // We're done. Return the completed type to the parser. 1171288943Sdim return CreateParsedType(Result, ResultTInfo); 1172288943Sdim} 1173288943Sdim 1174193326Sed/// \brief Convert the specified declspec to the appropriate type 1175193326Sed/// object. 1176239462Sdim/// \param state Specifies the declarator containing the declaration specifier 1177239462Sdim/// to be converted, along with other associated processing state. 1178193326Sed/// \returns The type described by the declaration specifiers. This function 1179193326Sed/// never returns null. 1180224145Sdimstatic QualType ConvertDeclSpecToType(TypeProcessingState &state) { 1181193326Sed // FIXME: Should move the logic from DeclSpec::Finish to here for validity 1182193326Sed // checking. 1183218893Sdim 1184224145Sdim Sema &S = state.getSema(); 1185218893Sdim Declarator &declarator = state.getDeclarator(); 1186218893Sdim const DeclSpec &DS = declarator.getDeclSpec(); 1187218893Sdim SourceLocation DeclLoc = declarator.getIdentifierLoc(); 1188198893Srdivacky if (DeclLoc.isInvalid()) 1189234353Sdim DeclLoc = DS.getLocStart(); 1190239462Sdim 1191218893Sdim ASTContext &Context = S.Context; 1192198893Srdivacky 1193193326Sed QualType Result; 1194193326Sed switch (DS.getTypeSpecType()) { 1195193326Sed case DeclSpec::TST_void: 1196193326Sed Result = Context.VoidTy; 1197193326Sed break; 1198193326Sed case DeclSpec::TST_char: 1199193326Sed if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 1200193326Sed Result = Context.CharTy; 1201193326Sed else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) 1202193326Sed Result = Context.SignedCharTy; 1203193326Sed else { 1204193326Sed assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 1205193326Sed "Unknown TSS value"); 1206193326Sed Result = Context.UnsignedCharTy; 1207193326Sed } 1208193326Sed break; 1209193326Sed case DeclSpec::TST_wchar: 1210193326Sed if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 1211193326Sed Result = Context.WCharTy; 1212193326Sed else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) { 1213218893Sdim S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 1214276479Sdim << DS.getSpecifierName(DS.getTypeSpecType(), 1215276479Sdim Context.getPrintingPolicy()); 1216193326Sed Result = Context.getSignedWCharType(); 1217193326Sed } else { 1218193326Sed assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 1219193326Sed "Unknown TSS value"); 1220218893Sdim S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 1221276479Sdim << DS.getSpecifierName(DS.getTypeSpecType(), 1222276479Sdim Context.getPrintingPolicy()); 1223193326Sed Result = Context.getUnsignedWCharType(); 1224193326Sed } 1225193326Sed break; 1226198092Srdivacky case DeclSpec::TST_char16: 1227198092Srdivacky assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 1228198092Srdivacky "Unknown TSS value"); 1229198092Srdivacky Result = Context.Char16Ty; 1230198092Srdivacky break; 1231198092Srdivacky case DeclSpec::TST_char32: 1232198092Srdivacky assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 1233198092Srdivacky "Unknown TSS value"); 1234198092Srdivacky Result = Context.Char32Ty; 1235198092Srdivacky break; 1236193326Sed case DeclSpec::TST_unspecified: 1237198893Srdivacky // If this is a missing declspec in a block literal return context, then it 1238198893Srdivacky // is inferred from the return statements inside the block. 1239234353Sdim // The declspec is always missing in a lambda expr context; it is either 1240234353Sdim // specified with a trailing return type or inferred. 1241280031Sdim if (S.getLangOpts().CPlusPlus14 && 1242261991Sdim declarator.getContext() == Declarator::LambdaExprContext) { 1243261991Sdim // In C++1y, a lambda's implicit return type is 'auto'. 1244261991Sdim Result = Context.getAutoDeductType(); 1245261991Sdim break; 1246261991Sdim } else if (declarator.getContext() == Declarator::LambdaExprContext || 1247261991Sdim isOmittedBlockReturnType(declarator)) { 1248198893Srdivacky Result = Context.DependentTy; 1249198893Srdivacky break; 1250198893Srdivacky } 1251198092Srdivacky 1252193326Sed // Unspecified typespec defaults to int in C90. However, the C90 grammar 1253193326Sed // [C90 6.5] only allows a decl-spec if there was *some* type-specifier, 1254193326Sed // type-qualifier, or storage-class-specifier. If not, emit an extwarn. 1255193326Sed // Note that the one exception to this is function definitions, which are 1256193326Sed // allowed to be completely missing a declspec. This is handled in the 1257193326Sed // parser already though by it pretending to have seen an 'int' in this 1258193326Sed // case. 1259234353Sdim if (S.getLangOpts().ImplicitInt) { 1260193326Sed // In C89 mode, we only warn if there is a completely missing declspec 1261193326Sed // when one is not allowed. 1262193326Sed if (DS.isEmpty()) { 1263218893Sdim S.Diag(DeclLoc, diag::ext_missing_declspec) 1264193326Sed << DS.getSourceRange() 1265234353Sdim << FixItHint::CreateInsertion(DS.getLocStart(), "int"); 1266193326Sed } 1267193326Sed } else if (!DS.hasTypeSpecifier()) { 1268193326Sed // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says: 1269193326Sed // "At least one type specifier shall be given in the declaration 1270193326Sed // specifiers in each declaration, and in the specifier-qualifier list in 1271193326Sed // each struct declaration and type name." 1272251662Sdim if (S.getLangOpts().CPlusPlus) { 1273218893Sdim S.Diag(DeclLoc, diag::err_missing_type_specifier) 1274193326Sed << DS.getSourceRange(); 1275198092Srdivacky 1276195099Sed // When this occurs in C++ code, often something is very broken with the 1277195099Sed // value being declared, poison it as invalid so we don't get chains of 1278195099Sed // errors. 1279218893Sdim declarator.setInvalidType(true); 1280296417Sdim } else if (S.getLangOpts().OpenCLVersion >= 200 && DS.isTypeSpecPipe()){ 1281296417Sdim S.Diag(DeclLoc, diag::err_missing_actual_pipe_type) 1282296417Sdim << DS.getSourceRange(); 1283296417Sdim declarator.setInvalidType(true); 1284195099Sed } else { 1285218893Sdim S.Diag(DeclLoc, diag::ext_missing_type_specifier) 1286193326Sed << DS.getSourceRange(); 1287195099Sed } 1288193326Sed } 1289198092Srdivacky 1290198092Srdivacky // FALL THROUGH. 1291193326Sed case DeclSpec::TST_int: { 1292193326Sed if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) { 1293193326Sed switch (DS.getTypeSpecWidth()) { 1294193326Sed case DeclSpec::TSW_unspecified: Result = Context.IntTy; break; 1295193326Sed case DeclSpec::TSW_short: Result = Context.ShortTy; break; 1296193326Sed case DeclSpec::TSW_long: Result = Context.LongTy; break; 1297198893Srdivacky case DeclSpec::TSW_longlong: 1298198893Srdivacky Result = Context.LongLongTy; 1299239462Sdim 1300243830Sdim // 'long long' is a C99 or C++11 feature. 1301243830Sdim if (!S.getLangOpts().C99) { 1302243830Sdim if (S.getLangOpts().CPlusPlus) 1303243830Sdim S.Diag(DS.getTypeSpecWidthLoc(), 1304249423Sdim S.getLangOpts().CPlusPlus11 ? 1305243830Sdim diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 1306243830Sdim else 1307243830Sdim S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong); 1308243830Sdim } 1309198893Srdivacky break; 1310193326Sed } 1311193326Sed } else { 1312193326Sed switch (DS.getTypeSpecWidth()) { 1313193326Sed case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break; 1314193326Sed case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break; 1315193326Sed case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break; 1316198893Srdivacky case DeclSpec::TSW_longlong: 1317198893Srdivacky Result = Context.UnsignedLongLongTy; 1318239462Sdim 1319243830Sdim // 'long long' is a C99 or C++11 feature. 1320243830Sdim if (!S.getLangOpts().C99) { 1321243830Sdim if (S.getLangOpts().CPlusPlus) 1322243830Sdim S.Diag(DS.getTypeSpecWidthLoc(), 1323249423Sdim S.getLangOpts().CPlusPlus11 ? 1324243830Sdim diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); 1325243830Sdim else 1326243830Sdim S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_c99_longlong); 1327243830Sdim } 1328198893Srdivacky break; 1329193326Sed } 1330193326Sed } 1331193326Sed break; 1332193326Sed } 1333234353Sdim case DeclSpec::TST_int128: 1334276479Sdim if (!S.Context.getTargetInfo().hasInt128Type()) 1335249423Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_int128_unsupported); 1336234353Sdim if (DS.getTypeSpecSign() == DeclSpec::TSS_unsigned) 1337234353Sdim Result = Context.UnsignedInt128Ty; 1338234353Sdim else 1339234353Sdim Result = Context.Int128Ty; 1340234353Sdim break; 1341226633Sdim case DeclSpec::TST_half: Result = Context.HalfTy; break; 1342193326Sed case DeclSpec::TST_float: Result = Context.FloatTy; break; 1343193326Sed case DeclSpec::TST_double: 1344193326Sed if (DS.getTypeSpecWidth() == DeclSpec::TSW_long) 1345193326Sed Result = Context.LongDoubleTy; 1346193326Sed else 1347193326Sed Result = Context.DoubleTy; 1348218893Sdim 1349288943Sdim if (S.getLangOpts().OpenCL && 1350288943Sdim !((S.getLangOpts().OpenCLVersion >= 120) || 1351288943Sdim S.getOpenCLOptions().cl_khr_fp64)) { 1352288943Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1353288943Sdim << Result << "cl_khr_fp64"; 1354218893Sdim declarator.setInvalidType(true); 1355218893Sdim } 1356193326Sed break; 1357193326Sed case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool 1358193326Sed case DeclSpec::TST_decimal32: // _Decimal32 1359193326Sed case DeclSpec::TST_decimal64: // _Decimal64 1360193326Sed case DeclSpec::TST_decimal128: // _Decimal128 1361218893Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported); 1362193326Sed Result = Context.IntTy; 1363218893Sdim declarator.setInvalidType(true); 1364193326Sed break; 1365193326Sed case DeclSpec::TST_class: 1366193326Sed case DeclSpec::TST_enum: 1367193326Sed case DeclSpec::TST_union: 1368243830Sdim case DeclSpec::TST_struct: 1369243830Sdim case DeclSpec::TST_interface: { 1370212904Sdim TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl()); 1371198092Srdivacky if (!D) { 1372198092Srdivacky // This can happen in C++ with ambiguous lookups. 1373198092Srdivacky Result = Context.IntTy; 1374218893Sdim declarator.setInvalidType(true); 1375198092Srdivacky break; 1376198092Srdivacky } 1377198092Srdivacky 1378198893Srdivacky // If the type is deprecated or unavailable, diagnose it. 1379221345Sdim S.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeNameLoc()); 1380239462Sdim 1381193326Sed assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 1382198893Srdivacky DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!"); 1383239462Sdim 1384193326Sed // TypeQuals handled by caller. 1385198893Srdivacky Result = Context.getTypeDeclType(D); 1386198092Srdivacky 1387221345Sdim // In both C and C++, make an ElaboratedType. 1388221345Sdim ElaboratedTypeKeyword Keyword 1389221345Sdim = ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType()); 1390221345Sdim Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result); 1391193326Sed break; 1392198092Srdivacky } 1393193326Sed case DeclSpec::TST_typename: { 1394193326Sed assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 1395193326Sed DS.getTypeSpecSign() == 0 && 1396193326Sed "Can't handle qualifiers on typedef names yet!"); 1397218893Sdim Result = S.GetTypeFromParser(DS.getRepAsType()); 1398288943Sdim if (Result.isNull()) { 1399218893Sdim declarator.setInvalidType(true); 1400288943Sdim } else if (S.getLangOpts().OpenCL) { 1401296417Sdim if (Result->getAs<AtomicType>()) { 1402296417Sdim StringRef TypeName = Result.getBaseTypeIdentifier()->getName(); 1403296417Sdim bool NoExtTypes = 1404296417Sdim llvm::StringSwitch<bool>(TypeName) 1405296417Sdim .Cases("atomic_int", "atomic_uint", "atomic_float", 1406296417Sdim "atomic_flag", true) 1407296417Sdim .Default(false); 1408288943Sdim if (!S.getOpenCLOptions().cl_khr_int64_base_atomics && !NoExtTypes) { 1409288943Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1410288943Sdim << Result << "cl_khr_int64_base_atomics"; 1411288943Sdim declarator.setInvalidType(true); 1412288943Sdim } 1413288943Sdim if (!S.getOpenCLOptions().cl_khr_int64_extended_atomics && 1414288943Sdim !NoExtTypes) { 1415288943Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1416288943Sdim << Result << "cl_khr_int64_extended_atomics"; 1417288943Sdim declarator.setInvalidType(true); 1418288943Sdim } 1419296417Sdim if (!S.getOpenCLOptions().cl_khr_fp64 && 1420296417Sdim !TypeName.compare("atomic_double")) { 1421288943Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1422288943Sdim << Result << "cl_khr_fp64"; 1423288943Sdim declarator.setInvalidType(true); 1424288943Sdim } 1425296417Sdim } else if (!S.getOpenCLOptions().cl_khr_gl_msaa_sharing && 1426296417Sdim (Result->isImage2dMSAAT() || Result->isImage2dArrayMSAAT() || 1427296417Sdim Result->isImage2dArrayMSAATDepth() || 1428296417Sdim Result->isImage2dMSAATDepth())) { 1429296417Sdim S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension) 1430296417Sdim << Result << "cl_khr_gl_msaa_sharing"; 1431296417Sdim declarator.setInvalidType(true); 1432193326Sed } 1433193326Sed } 1434198092Srdivacky 1435193326Sed // TypeQuals handled by caller. 1436193326Sed break; 1437193326Sed } 1438193326Sed case DeclSpec::TST_typeofType: 1439198092Srdivacky // FIXME: Preserve type source info. 1440218893Sdim Result = S.GetTypeFromParser(DS.getRepAsType()); 1441193326Sed assert(!Result.isNull() && "Didn't get a type for typeof?"); 1442218893Sdim if (!Result->isDependentType()) 1443218893Sdim if (const TagType *TT = Result->getAs<TagType>()) 1444218893Sdim S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc()); 1445193326Sed // TypeQuals handled by caller. 1446193326Sed Result = Context.getTypeOfType(Result); 1447193326Sed break; 1448193326Sed case DeclSpec::TST_typeofExpr: { 1449212904Sdim Expr *E = DS.getRepAsExpr(); 1450193326Sed assert(E && "Didn't get an expression for typeof?"); 1451193326Sed // TypeQuals handled by caller. 1452218893Sdim Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc()); 1453201361Srdivacky if (Result.isNull()) { 1454201361Srdivacky Result = Context.IntTy; 1455218893Sdim declarator.setInvalidType(true); 1456201361Srdivacky } 1457193326Sed break; 1458193326Sed } 1459195099Sed case DeclSpec::TST_decltype: { 1460212904Sdim Expr *E = DS.getRepAsExpr(); 1461195099Sed assert(E && "Didn't get an expression for decltype?"); 1462195099Sed // TypeQuals handled by caller. 1463218893Sdim Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc()); 1464195341Sed if (Result.isNull()) { 1465195341Sed Result = Context.IntTy; 1466218893Sdim declarator.setInvalidType(true); 1467195341Sed } 1468195099Sed break; 1469195099Sed } 1470223017Sdim case DeclSpec::TST_underlyingType: 1471223017Sdim Result = S.GetTypeFromParser(DS.getRepAsType()); 1472223017Sdim assert(!Result.isNull() && "Didn't get a type for __underlying_type?"); 1473223017Sdim Result = S.BuildUnaryTransformType(Result, 1474223017Sdim UnaryTransformType::EnumUnderlyingType, 1475223017Sdim DS.getTypeSpecTypeLoc()); 1476223017Sdim if (Result.isNull()) { 1477223017Sdim Result = Context.IntTy; 1478223017Sdim declarator.setInvalidType(true); 1479223017Sdim } 1480239462Sdim break; 1481223017Sdim 1482251662Sdim case DeclSpec::TST_auto: 1483195099Sed // TypeQuals handled by caller. 1484261991Sdim // If auto is mentioned in a lambda parameter context, convert it to a 1485261991Sdim // template parameter type immediately, with the appropriate depth and 1486261991Sdim // index, and update sema's state (LambdaScopeInfo) for the current lambda 1487261991Sdim // being analyzed (which tracks the invented type template parameter). 1488261991Sdim if (declarator.getContext() == Declarator::LambdaExprParameterContext) { 1489261991Sdim sema::LambdaScopeInfo *LSI = S.getCurLambda(); 1490261991Sdim assert(LSI && "No LambdaScopeInfo on the stack!"); 1491261991Sdim const unsigned TemplateParameterDepth = LSI->AutoTemplateParameterDepth; 1492261991Sdim const unsigned AutoParameterPosition = LSI->AutoTemplateParams.size(); 1493261991Sdim const bool IsParameterPack = declarator.hasEllipsis(); 1494261991Sdim 1495261991Sdim // Turns out we must create the TemplateTypeParmDecl here to 1496261991Sdim // retrieve the corresponding template parameter type. 1497261991Sdim TemplateTypeParmDecl *CorrespondingTemplateParam = 1498261991Sdim TemplateTypeParmDecl::Create(Context, 1499261991Sdim // Temporarily add to the TranslationUnit DeclContext. When the 1500261991Sdim // associated TemplateParameterList is attached to a template 1501261991Sdim // declaration (such as FunctionTemplateDecl), the DeclContext 1502261991Sdim // for each template parameter gets updated appropriately via 1503261991Sdim // a call to AdoptTemplateParameterList. 1504261991Sdim Context.getTranslationUnitDecl(), 1505261991Sdim /*KeyLoc*/ SourceLocation(), 1506261991Sdim /*NameLoc*/ declarator.getLocStart(), 1507261991Sdim TemplateParameterDepth, 1508261991Sdim AutoParameterPosition, // our template param index 1509280031Sdim /* Identifier*/ nullptr, false, IsParameterPack); 1510261991Sdim LSI->AutoTemplateParams.push_back(CorrespondingTemplateParam); 1511261991Sdim // Replace the 'auto' in the function parameter with this invented 1512261991Sdim // template type parameter. 1513280031Sdim Result = QualType(CorrespondingTemplateParam->getTypeForDecl(), 0); 1514261991Sdim } else { 1515296417Sdim Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false); 1516261991Sdim } 1517195099Sed break; 1518198092Srdivacky 1519296417Sdim case DeclSpec::TST_auto_type: 1520296417Sdim Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false); 1521296417Sdim break; 1522296417Sdim 1523251662Sdim case DeclSpec::TST_decltype_auto: 1524296417Sdim Result = Context.getAutoType(QualType(), AutoTypeKeyword::DecltypeAuto, 1525296417Sdim /*IsDependent*/ false); 1526251662Sdim break; 1527251662Sdim 1528221345Sdim case DeclSpec::TST_unknown_anytype: 1529221345Sdim Result = Context.UnknownAnyTy; 1530221345Sdim break; 1531221345Sdim 1532226633Sdim case DeclSpec::TST_atomic: 1533226633Sdim Result = S.GetTypeFromParser(DS.getRepAsType()); 1534226633Sdim assert(!Result.isNull() && "Didn't get a type for _Atomic?"); 1535226633Sdim Result = S.BuildAtomicType(Result, DS.getTypeSpecTypeLoc()); 1536226633Sdim if (Result.isNull()) { 1537226633Sdim Result = Context.IntTy; 1538226633Sdim declarator.setInvalidType(true); 1539226633Sdim } 1540239462Sdim break; 1541226633Sdim 1542193326Sed case DeclSpec::TST_error: 1543193326Sed Result = Context.IntTy; 1544218893Sdim declarator.setInvalidType(true); 1545193326Sed break; 1546193326Sed } 1547198092Srdivacky 1548193326Sed // Handle complex types. 1549193326Sed if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) { 1550234353Sdim if (S.getLangOpts().Freestanding) 1551218893Sdim S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex); 1552193326Sed Result = Context.getComplexType(Result); 1553203955Srdivacky } else if (DS.isTypeAltiVecVector()) { 1554203955Srdivacky unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result)); 1555203955Srdivacky assert(typeSize > 0 && "type size for vector must be greater than 0 bits"); 1556218893Sdim VectorType::VectorKind VecKind = VectorType::AltiVecVector; 1557210299Sed if (DS.isTypeAltiVecPixel()) 1558218893Sdim VecKind = VectorType::AltiVecPixel; 1559210299Sed else if (DS.isTypeAltiVecBool()) 1560218893Sdim VecKind = VectorType::AltiVecBool; 1561218893Sdim Result = Context.getVectorType(Result, 128/typeSize, VecKind); 1562193326Sed } 1563198092Srdivacky 1564218893Sdim // FIXME: Imaginary. 1565218893Sdim if (DS.getTypeSpecComplex() == DeclSpec::TSC_imaginary) 1566218893Sdim S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported); 1567198092Srdivacky 1568218893Sdim // Before we process any type attributes, synthesize a block literal 1569218893Sdim // function declarator if necessary. 1570218893Sdim if (declarator.getContext() == Declarator::BlockLiteralContext) 1571218893Sdim maybeSynthesizeBlockSignature(state, Result); 1572198092Srdivacky 1573218893Sdim // Apply any type attributes from the decl spec. This may cause the 1574218893Sdim // list of type attributes to be temporarily saved while the type 1575218893Sdim // attributes are pushed around. 1576296417Sdim // pipe attributes will be handled later ( at GetFullTypeForDeclarator ) 1577296417Sdim if (!DS.isTypeSpecPipe()) 1578296417Sdim processTypeAttrs(state, Result, TAL_DeclSpec, DS.getAttributes().getList()); 1579218893Sdim 1580193326Sed // Apply const/volatile/restrict qualifiers to T. 1581193326Sed if (unsigned TypeQuals = DS.getTypeQualifiers()) { 1582288943Sdim // Warn about CV qualifiers on function types. 1583288943Sdim // C99 6.7.3p8: 1584288943Sdim // If the specification of a function type includes any type qualifiers, 1585288943Sdim // the behavior is undefined. 1586288943Sdim // C++11 [dcl.fct]p7: 1587288943Sdim // The effect of a cv-qualifier-seq in a function declarator is not the 1588288943Sdim // same as adding cv-qualification on top of the function type. In the 1589288943Sdim // latter case, the cv-qualifiers are ignored. 1590288943Sdim if (TypeQuals && Result->isFunctionType()) { 1591288943Sdim diagnoseAndRemoveTypeQualifiers( 1592288943Sdim S, DS, TypeQuals, Result, DeclSpec::TQ_const | DeclSpec::TQ_volatile, 1593288943Sdim S.getLangOpts().CPlusPlus 1594288943Sdim ? diag::warn_typecheck_function_qualifiers_ignored 1595288943Sdim : diag::warn_typecheck_function_qualifiers_unspecified); 1596288943Sdim // No diagnostic for 'restrict' or '_Atomic' applied to a 1597288943Sdim // function type; we'll diagnose those later, in BuildQualifiedType. 1598193326Sed } 1599198092Srdivacky 1600276479Sdim // C++11 [dcl.ref]p1: 1601193326Sed // Cv-qualified references are ill-formed except when the 1602276479Sdim // cv-qualifiers are introduced through the use of a typedef-name 1603276479Sdim // or decltype-specifier, in which case the cv-qualifiers are ignored. 1604276479Sdim // 1605276479Sdim // There don't appear to be any other contexts in which a cv-qualified 1606276479Sdim // reference type could be formed, so the 'ill-formed' clause here appears 1607276479Sdim // to never happen. 1608288943Sdim if (TypeQuals && Result->isReferenceType()) { 1609288943Sdim diagnoseAndRemoveTypeQualifiers( 1610288943Sdim S, DS, TypeQuals, Result, 1611288943Sdim DeclSpec::TQ_const | DeclSpec::TQ_volatile | DeclSpec::TQ_atomic, 1612288943Sdim diag::warn_typecheck_reference_qualifiers); 1613198092Srdivacky } 1614198092Srdivacky 1615234353Sdim // C90 6.5.3 constraints: "The same type qualifier shall not appear more 1616234353Sdim // than once in the same specifier-list or qualifier-list, either directly 1617234353Sdim // or via one or more typedefs." 1618239462Sdim if (!S.getLangOpts().C99 && !S.getLangOpts().CPlusPlus 1619234353Sdim && TypeQuals & Result.getCVRQualifiers()) { 1620234353Sdim if (TypeQuals & DeclSpec::TQ_const && Result.isConstQualified()) { 1621239462Sdim S.Diag(DS.getConstSpecLoc(), diag::ext_duplicate_declspec) 1622234353Sdim << "const"; 1623234353Sdim } 1624234353Sdim 1625234353Sdim if (TypeQuals & DeclSpec::TQ_volatile && Result.isVolatileQualified()) { 1626239462Sdim S.Diag(DS.getVolatileSpecLoc(), diag::ext_duplicate_declspec) 1627234353Sdim << "volatile"; 1628234353Sdim } 1629234353Sdim 1630249423Sdim // C90 doesn't have restrict nor _Atomic, so it doesn't force us to 1631249423Sdim // produce a warning in this case. 1632234353Sdim } 1633234353Sdim 1634249423Sdim QualType Qualified = S.BuildQualifiedType(Result, DeclLoc, TypeQuals, &DS); 1635249423Sdim 1636249423Sdim // If adding qualifiers fails, just use the unqualified type. 1637249423Sdim if (Qualified.isNull()) 1638249423Sdim declarator.setInvalidType(true); 1639249423Sdim else 1640249423Sdim Result = Qualified; 1641193326Sed } 1642198092Srdivacky 1643280031Sdim assert(!Result.isNull() && "This function should not return a null type"); 1644193326Sed return Result; 1645193326Sed} 1646193326Sed 1647193326Sedstatic std::string getPrintableNameForEntity(DeclarationName Entity) { 1648193326Sed if (Entity) 1649193326Sed return Entity.getAsString(); 1650198092Srdivacky 1651193326Sed return "type name"; 1652193326Sed} 1653193326Sed 1654210299SedQualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, 1655249423Sdim Qualifiers Qs, const DeclSpec *DS) { 1656280031Sdim if (T.isNull()) 1657280031Sdim return QualType(); 1658280031Sdim 1659210299Sed // Enforce C99 6.7.3p2: "Types other than pointer types derived from 1660210299Sed // object or incomplete types shall not be restrict-qualified." 1661210299Sed if (Qs.hasRestrict()) { 1662210299Sed unsigned DiagID = 0; 1663210299Sed QualType ProblemTy; 1664210299Sed 1665249423Sdim if (T->isAnyPointerType() || T->isReferenceType() || 1666249423Sdim T->isMemberPointerType()) { 1667249423Sdim QualType EltTy; 1668249423Sdim if (T->isObjCObjectPointerType()) 1669249423Sdim EltTy = T; 1670249423Sdim else if (const MemberPointerType *PTy = T->getAs<MemberPointerType>()) 1671249423Sdim EltTy = PTy->getPointeeType(); 1672249423Sdim else 1673249423Sdim EltTy = T->getPointeeType(); 1674249423Sdim 1675249423Sdim // If we have a pointer or reference, the pointee must have an object 1676249423Sdim // incomplete type. 1677249423Sdim if (!EltTy->isIncompleteOrObjectType()) { 1678210299Sed DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee; 1679249423Sdim ProblemTy = EltTy; 1680210299Sed } 1681249423Sdim } else if (!T->isDependentType()) { 1682249423Sdim DiagID = diag::err_typecheck_invalid_restrict_not_pointer; 1683210299Sed ProblemTy = T; 1684210299Sed } 1685210299Sed 1686210299Sed if (DiagID) { 1687249423Sdim Diag(DS ? DS->getRestrictSpecLoc() : Loc, DiagID) << ProblemTy; 1688210299Sed Qs.removeRestrict(); 1689210299Sed } 1690210299Sed } 1691210299Sed 1692210299Sed return Context.getQualifiedType(T, Qs); 1693210299Sed} 1694210299Sed 1695249423SdimQualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc, 1696249423Sdim unsigned CVRA, const DeclSpec *DS) { 1697280031Sdim if (T.isNull()) 1698280031Sdim return QualType(); 1699280031Sdim 1700249423Sdim // Convert from DeclSpec::TQ to Qualifiers::TQ by just dropping TQ_atomic. 1701249423Sdim unsigned CVR = CVRA & ~DeclSpec::TQ_atomic; 1702249423Sdim 1703249423Sdim // C11 6.7.3/5: 1704249423Sdim // If the same qualifier appears more than once in the same 1705249423Sdim // specifier-qualifier-list, either directly or via one or more typedefs, 1706249423Sdim // the behavior is the same as if it appeared only once. 1707249423Sdim // 1708249423Sdim // It's not specified what happens when the _Atomic qualifier is applied to 1709249423Sdim // a type specified with the _Atomic specifier, but we assume that this 1710249423Sdim // should be treated as if the _Atomic qualifier appeared multiple times. 1711249423Sdim if (CVRA & DeclSpec::TQ_atomic && !T->isAtomicType()) { 1712249423Sdim // C11 6.7.3/5: 1713249423Sdim // If other qualifiers appear along with the _Atomic qualifier in a 1714249423Sdim // specifier-qualifier-list, the resulting type is the so-qualified 1715249423Sdim // atomic type. 1716249423Sdim // 1717249423Sdim // Don't need to worry about array types here, since _Atomic can't be 1718249423Sdim // applied to such types. 1719249423Sdim SplitQualType Split = T.getSplitUnqualifiedType(); 1720249423Sdim T = BuildAtomicType(QualType(Split.Ty, 0), 1721249423Sdim DS ? DS->getAtomicSpecLoc() : Loc); 1722249423Sdim if (T.isNull()) 1723249423Sdim return T; 1724249423Sdim Split.Quals.addCVRQualifiers(CVR); 1725249423Sdim return BuildQualifiedType(T, Loc, Split.Quals); 1726249423Sdim } 1727249423Sdim 1728249423Sdim return BuildQualifiedType(T, Loc, Qualifiers::fromCVRMask(CVR), DS); 1729249423Sdim} 1730249423Sdim 1731218893Sdim/// \brief Build a paren type including \p T. 1732218893SdimQualType Sema::BuildParenType(QualType T) { 1733218893Sdim return Context.getParenType(T); 1734218893Sdim} 1735218893Sdim 1736224145Sdim/// Given that we're building a pointer or reference to the given 1737224145Sdimstatic QualType inferARCLifetimeForPointee(Sema &S, QualType type, 1738224145Sdim SourceLocation loc, 1739224145Sdim bool isReference) { 1740224145Sdim // Bail out if retention is unrequired or already specified. 1741224145Sdim if (!type->isObjCLifetimeType() || 1742224145Sdim type.getObjCLifetime() != Qualifiers::OCL_None) 1743224145Sdim return type; 1744224145Sdim 1745224145Sdim Qualifiers::ObjCLifetime implicitLifetime = Qualifiers::OCL_None; 1746224145Sdim 1747224145Sdim // If the object type is const-qualified, we can safely use 1748224145Sdim // __unsafe_unretained. This is safe (because there are no read 1749224145Sdim // barriers), and it'll be safe to coerce anything but __weak* to 1750224145Sdim // the resulting type. 1751224145Sdim if (type.isConstQualified()) { 1752224145Sdim implicitLifetime = Qualifiers::OCL_ExplicitNone; 1753224145Sdim 1754224145Sdim // Otherwise, check whether the static type does not require 1755224145Sdim // retaining. This currently only triggers for Class (possibly 1756224145Sdim // protocol-qualifed, and arrays thereof). 1757224145Sdim } else if (type->isObjCARCImplicitlyUnretainedType()) { 1758224145Sdim implicitLifetime = Qualifiers::OCL_ExplicitNone; 1759224145Sdim 1760234353Sdim // If we are in an unevaluated context, like sizeof, skip adding a 1761234353Sdim // qualification. 1762239462Sdim } else if (S.isUnevaluatedContext()) { 1763234353Sdim return type; 1764226633Sdim 1765234353Sdim // If that failed, give an error and recover using __strong. __strong 1766234353Sdim // is the option most likely to prevent spurious second-order diagnostics, 1767234353Sdim // like when binding a reference to a field. 1768224145Sdim } else { 1769224145Sdim // These types can show up in private ivars in system headers, so 1770224145Sdim // we need this to not be an error in those cases. Instead we 1771224145Sdim // want to delay. 1772224145Sdim if (S.DelayedDiagnostics.shouldDelayDiagnostics()) { 1773224145Sdim S.DelayedDiagnostics.add( 1774224145Sdim sema::DelayedDiagnostic::makeForbiddenType(loc, 1775224145Sdim diag::err_arc_indirect_no_ownership, type, isReference)); 1776224145Sdim } else { 1777224145Sdim S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference; 1778224145Sdim } 1779234353Sdim implicitLifetime = Qualifiers::OCL_Strong; 1780224145Sdim } 1781224145Sdim assert(implicitLifetime && "didn't infer any lifetime!"); 1782224145Sdim 1783224145Sdim Qualifiers qs; 1784224145Sdim qs.addObjCLifetime(implicitLifetime); 1785224145Sdim return S.Context.getQualifiedType(type, qs); 1786224145Sdim} 1787224145Sdim 1788276479Sdimstatic std::string getFunctionQualifiersAsString(const FunctionProtoType *FnTy){ 1789276479Sdim std::string Quals = 1790276479Sdim Qualifiers::fromCVRMask(FnTy->getTypeQuals()).getAsString(); 1791276479Sdim 1792276479Sdim switch (FnTy->getRefQualifier()) { 1793276479Sdim case RQ_None: 1794276479Sdim break; 1795276479Sdim 1796276479Sdim case RQ_LValue: 1797276479Sdim if (!Quals.empty()) 1798276479Sdim Quals += ' '; 1799276479Sdim Quals += '&'; 1800276479Sdim break; 1801276479Sdim 1802276479Sdim case RQ_RValue: 1803276479Sdim if (!Quals.empty()) 1804276479Sdim Quals += ' '; 1805276479Sdim Quals += "&&"; 1806276479Sdim break; 1807276479Sdim } 1808276479Sdim 1809276479Sdim return Quals; 1810276479Sdim} 1811276479Sdim 1812276479Sdimnamespace { 1813276479Sdim/// Kinds of declarator that cannot contain a qualified function type. 1814276479Sdim/// 1815276479Sdim/// C++98 [dcl.fct]p4 / C++11 [dcl.fct]p6: 1816276479Sdim/// a function type with a cv-qualifier or a ref-qualifier can only appear 1817276479Sdim/// at the topmost level of a type. 1818276479Sdim/// 1819276479Sdim/// Parens and member pointers are permitted. We don't diagnose array and 1820276479Sdim/// function declarators, because they don't allow function types at all. 1821276479Sdim/// 1822276479Sdim/// The values of this enum are used in diagnostics. 1823276479Sdimenum QualifiedFunctionKind { QFK_BlockPointer, QFK_Pointer, QFK_Reference }; 1824276479Sdim} 1825276479Sdim 1826276479Sdim/// Check whether the type T is a qualified function type, and if it is, 1827276479Sdim/// diagnose that it cannot be contained within the given kind of declarator. 1828276479Sdimstatic bool checkQualifiedFunction(Sema &S, QualType T, SourceLocation Loc, 1829276479Sdim QualifiedFunctionKind QFK) { 1830276479Sdim // Does T refer to a function type with a cv-qualifier or a ref-qualifier? 1831276479Sdim const FunctionProtoType *FPT = T->getAs<FunctionProtoType>(); 1832276479Sdim if (!FPT || (FPT->getTypeQuals() == 0 && FPT->getRefQualifier() == RQ_None)) 1833276479Sdim return false; 1834276479Sdim 1835276479Sdim S.Diag(Loc, diag::err_compound_qualified_function_type) 1836276479Sdim << QFK << isa<FunctionType>(T.IgnoreParens()) << T 1837276479Sdim << getFunctionQualifiersAsString(FPT); 1838276479Sdim return true; 1839276479Sdim} 1840276479Sdim 1841193326Sed/// \brief Build a pointer type. 1842193326Sed/// 1843193326Sed/// \param T The type to which we'll be building a pointer. 1844193326Sed/// 1845193326Sed/// \param Loc The location of the entity whose type involves this 1846193326Sed/// pointer type or, if there is no such entity, the location of the 1847193326Sed/// type that will have pointer type. 1848193326Sed/// 1849193326Sed/// \param Entity The name of the entity that involves the pointer 1850193326Sed/// type, if known. 1851193326Sed/// 1852193326Sed/// \returns A suitable pointer type, if there are no 1853193326Sed/// errors. Otherwise, returns a NULL type. 1854210299SedQualType Sema::BuildPointerType(QualType T, 1855193326Sed SourceLocation Loc, DeclarationName Entity) { 1856193326Sed if (T->isReferenceType()) { 1857193326Sed // C++ 8.3.2p4: There shall be no ... pointers to references ... 1858193326Sed Diag(Loc, diag::err_illegal_decl_pointer_to_reference) 1859198893Srdivacky << getPrintableNameForEntity(Entity) << T; 1860193326Sed return QualType(); 1861193326Sed } 1862193326Sed 1863276479Sdim if (checkQualifiedFunction(*this, T, Loc, QFK_Pointer)) 1864276479Sdim return QualType(); 1865276479Sdim 1866208600Srdivacky assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType"); 1867207619Srdivacky 1868224145Sdim // In ARC, it is forbidden to build pointers to unqualified pointers. 1869234353Sdim if (getLangOpts().ObjCAutoRefCount) 1870224145Sdim T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ false); 1871224145Sdim 1872193326Sed // Build the pointer type. 1873210299Sed return Context.getPointerType(T); 1874193326Sed} 1875193326Sed 1876193326Sed/// \brief Build a reference type. 1877193326Sed/// 1878193326Sed/// \param T The type to which we'll be building a reference. 1879193326Sed/// 1880193326Sed/// \param Loc The location of the entity whose type involves this 1881193326Sed/// reference type or, if there is no such entity, the location of the 1882193326Sed/// type that will have reference type. 1883193326Sed/// 1884193326Sed/// \param Entity The name of the entity that involves the reference 1885193326Sed/// type, if known. 1886193326Sed/// 1887193326Sed/// \returns A suitable reference type, if there are no 1888193326Sed/// errors. Otherwise, returns a NULL type. 1889198398SrdivackyQualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, 1890210299Sed SourceLocation Loc, 1891198398Srdivacky DeclarationName Entity) { 1892239462Sdim assert(Context.getCanonicalType(T) != Context.OverloadTy && 1893223017Sdim "Unresolved overloaded function type"); 1894239462Sdim 1895218893Sdim // C++0x [dcl.ref]p6: 1896239462Sdim // If a typedef (7.1.3), a type template-parameter (14.3.1), or a 1897239462Sdim // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a 1898239462Sdim // type T, an attempt to create the type "lvalue reference to cv TR" creates 1899239462Sdim // the type "lvalue reference to T", while an attempt to create the type 1900218893Sdim // "rvalue reference to cv TR" creates the type TR. 1901198398Srdivacky bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>(); 1902198398Srdivacky 1903198398Srdivacky // C++ [dcl.ref]p4: There shall be no references to references. 1904198398Srdivacky // 1905198398Srdivacky // According to C++ DR 106, references to references are only 1906198398Srdivacky // diagnosed when they are written directly (e.g., "int & &"), 1907198398Srdivacky // but not when they happen via a typedef: 1908198398Srdivacky // 1909198398Srdivacky // typedef int& intref; 1910198398Srdivacky // typedef intref& intref2; 1911198398Srdivacky // 1912198398Srdivacky // Parser::ParseDeclaratorInternal diagnoses the case where 1913198398Srdivacky // references are written directly; here, we handle the 1914218893Sdim // collapsing of references-to-references as described in C++0x. 1915218893Sdim // DR 106 and 540 introduce reference-collapsing into C++98/03. 1916198398Srdivacky 1917193326Sed // C++ [dcl.ref]p1: 1918198092Srdivacky // A declarator that specifies the type "reference to cv void" 1919193326Sed // is ill-formed. 1920193326Sed if (T->isVoidType()) { 1921193326Sed Diag(Loc, diag::err_reference_to_void); 1922193326Sed return QualType(); 1923193326Sed } 1924193326Sed 1925276479Sdim if (checkQualifiedFunction(*this, T, Loc, QFK_Reference)) 1926276479Sdim return QualType(); 1927276479Sdim 1928224145Sdim // In ARC, it is forbidden to build references to unqualified pointers. 1929234353Sdim if (getLangOpts().ObjCAutoRefCount) 1930224145Sdim T = inferARCLifetimeForPointee(*this, T, Loc, /*reference*/ true); 1931224145Sdim 1932193326Sed // Handle restrict on references. 1933193326Sed if (LValueRef) 1934210299Sed return Context.getLValueReferenceType(T, SpelledAsLValue); 1935210299Sed return Context.getRValueReferenceType(T); 1936193326Sed} 1937193326Sed 1938296417Sdim/// \brief Build a Pipe type. 1939296417Sdim/// 1940296417Sdim/// \param T The type to which we'll be building a Pipe. 1941296417Sdim/// 1942296417Sdim/// \param Loc We do not use it for now. 1943296417Sdim/// 1944296417Sdim/// \returns A suitable pipe type, if there are no errors. Otherwise, returns a 1945296417Sdim/// NULL type. 1946296417SdimQualType Sema::BuildPipeType(QualType T, SourceLocation Loc) { 1947296417Sdim assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType"); 1948296417Sdim 1949296417Sdim // Build the pipe type. 1950296417Sdim return Context.getPipeType(T); 1951296417Sdim} 1952296417Sdim 1953224145Sdim/// Check whether the specified array size makes the array type a VLA. If so, 1954224145Sdim/// return true, if not, return the size of the array in SizeVal. 1955234353Sdimstatic bool isArraySizeVLA(Sema &S, Expr *ArraySize, llvm::APSInt &SizeVal) { 1956234353Sdim // If the size is an ICE, it certainly isn't a VLA. If we're in a GNU mode 1957234353Sdim // (like gnu99, but not c99) accept any evaluatable value as an extension. 1958239462Sdim class VLADiagnoser : public Sema::VerifyICEDiagnoser { 1959239462Sdim public: 1960239462Sdim VLADiagnoser() : Sema::VerifyICEDiagnoser(true) {} 1961239462Sdim 1962276479Sdim void diagnoseNotICE(Sema &S, SourceLocation Loc, SourceRange SR) override { 1963239462Sdim } 1964239462Sdim 1965276479Sdim void diagnoseFold(Sema &S, SourceLocation Loc, SourceRange SR) override { 1966239462Sdim S.Diag(Loc, diag::ext_vla_folded_to_constant) << SR; 1967239462Sdim } 1968239462Sdim } Diagnoser; 1969239462Sdim 1970239462Sdim return S.VerifyIntegerConstantExpression(ArraySize, &SizeVal, Diagnoser, 1971239462Sdim S.LangOpts.GNUMode).isInvalid(); 1972224145Sdim} 1973224145Sdim 1974224145Sdim 1975193326Sed/// \brief Build an array type. 1976193326Sed/// 1977193326Sed/// \param T The type of each element in the array. 1978193326Sed/// 1979193326Sed/// \param ASM C99 array size modifier (e.g., '*', 'static'). 1980193326Sed/// 1981198092Srdivacky/// \param ArraySize Expression describing the size of the array. 1982198092Srdivacky/// 1983239462Sdim/// \param Brackets The range from the opening '[' to the closing ']'. 1984193326Sed/// 1985193326Sed/// \param Entity The name of the entity that involves the array 1986193326Sed/// type, if known. 1987193326Sed/// 1988193326Sed/// \returns A suitable array type, if there are no errors. Otherwise, 1989193326Sed/// returns a NULL type. 1990193326SedQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, 1991193326Sed Expr *ArraySize, unsigned Quals, 1992198092Srdivacky SourceRange Brackets, DeclarationName Entity) { 1993198092Srdivacky 1994198092Srdivacky SourceLocation Loc = Brackets.getBegin(); 1995234353Sdim if (getLangOpts().CPlusPlus) { 1996207619Srdivacky // C++ [dcl.array]p1: 1997207619Srdivacky // T is called the array element type; this type shall not be a reference 1998239462Sdim // type, the (possibly cv-qualified) type void, a function type or an 1999207619Srdivacky // abstract class type. 2000207619Srdivacky // 2001239462Sdim // C++ [dcl.array]p3: 2002239462Sdim // When several "array of" specifications are adjacent, [...] only the 2003239462Sdim // first of the constant expressions that specify the bounds of the arrays 2004239462Sdim // may be omitted. 2005239462Sdim // 2006207619Srdivacky // Note: function types are handled in the common path with C. 2007207619Srdivacky if (T->isReferenceType()) { 2008207619Srdivacky Diag(Loc, diag::err_illegal_decl_array_of_references) 2009207619Srdivacky << getPrintableNameForEntity(Entity) << T; 2010207619Srdivacky return QualType(); 2011207619Srdivacky } 2012239462Sdim 2013239462Sdim if (T->isVoidType() || T->isIncompleteArrayType()) { 2014198954Srdivacky Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T; 2015198954Srdivacky return QualType(); 2016198954Srdivacky } 2017239462Sdim 2018239462Sdim if (RequireNonAbstractType(Brackets.getBegin(), T, 2019207619Srdivacky diag::err_array_of_abstract_type)) 2020207619Srdivacky return QualType(); 2021239462Sdim 2022276479Sdim // Mentioning a member pointer type for an array type causes us to lock in 2023276479Sdim // an inheritance model, even if it's inside an unused typedef. 2024276479Sdim if (Context.getTargetInfo().getCXXABI().isMicrosoft()) 2025276479Sdim if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) 2026276479Sdim if (!MPTy->getClass()->isDependentType()) 2027296417Sdim (void)isCompleteType(Loc, T); 2028276479Sdim 2029198954Srdivacky } else { 2030207619Srdivacky // C99 6.7.5.2p1: If the element type is an incomplete or function type, 2031207619Srdivacky // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]()) 2032198954Srdivacky if (RequireCompleteType(Loc, T, 2033198954Srdivacky diag::err_illegal_decl_array_incomplete_type)) 2034198954Srdivacky return QualType(); 2035198954Srdivacky } 2036193326Sed 2037193326Sed if (T->isFunctionType()) { 2038193326Sed Diag(Loc, diag::err_illegal_decl_array_of_functions) 2039198893Srdivacky << getPrintableNameForEntity(Entity) << T; 2040193326Sed return QualType(); 2041193326Sed } 2042198092Srdivacky 2043198092Srdivacky if (const RecordType *EltTy = T->getAs<RecordType>()) { 2044193326Sed // If the element type is a struct or union that contains a variadic 2045193326Sed // array, accept it as a GNU extension: C99 6.7.2.1p2. 2046193326Sed if (EltTy->getDecl()->hasFlexibleArrayMember()) 2047193326Sed Diag(Loc, diag::ext_flexible_array_in_array) << T; 2048208600Srdivacky } else if (T->isObjCObjectType()) { 2049193326Sed Diag(Loc, diag::err_objc_array_of_interfaces) << T; 2050193326Sed return QualType(); 2051193326Sed } 2052198092Srdivacky 2053234353Sdim // Do placeholder conversions on the array size expression. 2054234353Sdim if (ArraySize && ArraySize->hasPlaceholderType()) { 2055234353Sdim ExprResult Result = CheckPlaceholderExpr(ArraySize); 2056234353Sdim if (Result.isInvalid()) return QualType(); 2057276479Sdim ArraySize = Result.get(); 2058234353Sdim } 2059234353Sdim 2060218893Sdim // Do lvalue-to-rvalue conversions on the array size expression. 2061221345Sdim if (ArraySize && !ArraySize->isRValue()) { 2062221345Sdim ExprResult Result = DefaultLvalueConversion(ArraySize); 2063221345Sdim if (Result.isInvalid()) 2064221345Sdim return QualType(); 2065218893Sdim 2066276479Sdim ArraySize = Result.get(); 2067221345Sdim } 2068221345Sdim 2069193326Sed // C99 6.7.5.2p1: The size expression shall have integer type. 2070234353Sdim // C++11 allows contextual conversions to such types. 2071249423Sdim if (!getLangOpts().CPlusPlus11 && 2072234353Sdim ArraySize && !ArraySize->isTypeDependent() && 2073218893Sdim !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) { 2074193326Sed Diag(ArraySize->getLocStart(), diag::err_array_size_non_int) 2075193326Sed << ArraySize->getType() << ArraySize->getSourceRange(); 2076193326Sed return QualType(); 2077193326Sed } 2078234353Sdim 2079212904Sdim llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType())); 2080193326Sed if (!ArraySize) { 2081193326Sed if (ASM == ArrayType::Star) 2082276479Sdim T = Context.getVariableArrayType(T, nullptr, ASM, Quals, Brackets); 2083193326Sed else 2084193326Sed T = Context.getIncompleteArrayType(T, ASM, Quals); 2085208600Srdivacky } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) { 2086198092Srdivacky T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets); 2087234353Sdim } else if ((!T->isDependentType() && !T->isIncompleteType() && 2088234353Sdim !T->isConstantSizeType()) || 2089234353Sdim isArraySizeVLA(*this, ArraySize, ConstVal)) { 2090234353Sdim // Even in C++11, don't allow contextual conversions in the array bound 2091234353Sdim // of a VLA. 2092249423Sdim if (getLangOpts().CPlusPlus11 && 2093234353Sdim !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) { 2094234353Sdim Diag(ArraySize->getLocStart(), diag::err_array_size_non_int) 2095234353Sdim << ArraySize->getType() << ArraySize->getSourceRange(); 2096234353Sdim return QualType(); 2097234353Sdim } 2098234353Sdim 2099224145Sdim // C99: an array with an element type that has a non-constant-size is a VLA. 2100224145Sdim // C99: an array with a non-ICE size is a VLA. We accept any expression 2101224145Sdim // that we can fold to a non-zero positive value as an extension. 2102224145Sdim T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets); 2103193326Sed } else { 2104193326Sed // C99 6.7.5.2p1: If the expression is a constant expression, it shall 2105193326Sed // have a value greater than zero. 2106198954Srdivacky if (ConstVal.isSigned() && ConstVal.isNegative()) { 2107218893Sdim if (Entity) 2108218893Sdim Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size) 2109218893Sdim << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange(); 2110218893Sdim else 2111218893Sdim Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size) 2112218893Sdim << ArraySize->getSourceRange(); 2113198954Srdivacky return QualType(); 2114198092Srdivacky } 2115198954Srdivacky if (ConstVal == 0) { 2116206084Srdivacky // GCC accepts zero sized static arrays. We allow them when 2117206084Srdivacky // we're not in a SFINAE context. 2118239462Sdim Diag(ArraySize->getLocStart(), 2119206084Srdivacky isSFINAEContext()? diag::err_typecheck_zero_array_size 2120206084Srdivacky : diag::ext_typecheck_zero_array_size) 2121198954Srdivacky << ArraySize->getSourceRange(); 2122234353Sdim 2123234353Sdim if (ASM == ArrayType::Static) { 2124234353Sdim Diag(ArraySize->getLocStart(), 2125234353Sdim diag::warn_typecheck_zero_static_array_size) 2126234353Sdim << ArraySize->getSourceRange(); 2127234353Sdim ASM = ArrayType::Normal; 2128234353Sdim } 2129239462Sdim } else if (!T->isDependentType() && !T->isVariablyModifiedType() && 2130261991Sdim !T->isIncompleteType() && !T->isUndeducedType()) { 2131239462Sdim // Is the array too large? 2132212904Sdim unsigned ActiveSizeBits 2133212904Sdim = ConstantArrayType::getNumAddressingBits(Context, T, ConstVal); 2134261991Sdim if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) { 2135212904Sdim Diag(ArraySize->getLocStart(), diag::err_array_too_large) 2136212904Sdim << ConstVal.toString(10) 2137212904Sdim << ArraySize->getSourceRange(); 2138261991Sdim return QualType(); 2139261991Sdim } 2140198954Srdivacky } 2141239462Sdim 2142198398Srdivacky T = Context.getConstantArrayType(T, ConstVal, ASM, Quals); 2143193326Sed } 2144249423Sdim 2145249423Sdim // OpenCL v1.2 s6.9.d: variable length arrays are not supported. 2146249423Sdim if (getLangOpts().OpenCL && T->isVariableArrayType()) { 2147249423Sdim Diag(Loc, diag::err_opencl_vla); 2148249423Sdim return QualType(); 2149249423Sdim } 2150193326Sed // If this is not C99, extwarn about VLA's and C99 array size modifiers. 2151234353Sdim if (!getLangOpts().C99) { 2152208600Srdivacky if (T->isVariableArrayType()) { 2153208600Srdivacky // Prohibit the use of non-POD types in VLAs. 2154224145Sdim QualType BaseT = Context.getBaseElementType(T); 2155296417Sdim if (!T->isDependentType() && isCompleteType(Loc, BaseT) && 2156296417Sdim !BaseT.isPODType(Context) && !BaseT->isObjCLifetimeType()) { 2157296417Sdim Diag(Loc, diag::err_vla_non_pod) << BaseT; 2158208600Srdivacky return QualType(); 2159239462Sdim } 2160208600Srdivacky // Prohibit the use of VLAs during template argument deduction. 2161208600Srdivacky else if (isSFINAEContext()) { 2162208600Srdivacky Diag(Loc, diag::err_vla_in_sfinae); 2163208600Srdivacky return QualType(); 2164208600Srdivacky } 2165208600Srdivacky // Just extwarn about VLAs. 2166208600Srdivacky else 2167261991Sdim Diag(Loc, diag::ext_vla); 2168208600Srdivacky } else if (ASM != ArrayType::Normal || Quals != 0) 2169234353Sdim Diag(Loc, 2170234353Sdim getLangOpts().CPlusPlus? diag::err_c99_array_usage_cxx 2171296417Sdim : diag::ext_c99_array_usage) << ASM; 2172193326Sed } 2173193326Sed 2174249423Sdim if (T->isVariableArrayType()) { 2175249423Sdim // Warn about VLAs for -Wvla. 2176249423Sdim Diag(Loc, diag::warn_vla_used); 2177249423Sdim } 2178249423Sdim 2179193326Sed return T; 2180193326Sed} 2181194613Sed 2182194613Sed/// \brief Build an ext-vector type. 2183194613Sed/// 2184194613Sed/// Run the required checks for the extended vector type. 2185212904SdimQualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, 2186194613Sed SourceLocation AttrLoc) { 2187194613Sed // unlike gcc's vector_size attribute, we do not allow vectors to be defined 2188194613Sed // in conjunction with complex types (pointers, arrays, functions, etc.). 2189198092Srdivacky if (!T->isDependentType() && 2190194613Sed !T->isIntegerType() && !T->isRealFloatingType()) { 2191194613Sed Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T; 2192194613Sed return QualType(); 2193194613Sed } 2194194613Sed 2195212904Sdim if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) { 2196194613Sed llvm::APSInt vecSize(32); 2197212904Sdim if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) { 2198261991Sdim Diag(AttrLoc, diag::err_attribute_argument_type) 2199261991Sdim << "ext_vector_type" << AANT_ArgumentIntegerConstant 2200261991Sdim << ArraySize->getSourceRange(); 2201194613Sed return QualType(); 2202194613Sed } 2203198092Srdivacky 2204198092Srdivacky // unlike gcc's vector_size attribute, the size is specified as the 2205194613Sed // number of elements, not the number of bytes. 2206198092Srdivacky unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue()); 2207198092Srdivacky 2208194613Sed if (vectorSize == 0) { 2209194613Sed Diag(AttrLoc, diag::err_attribute_zero_size) 2210212904Sdim << ArraySize->getSourceRange(); 2211194613Sed return QualType(); 2212194613Sed } 2213198092Srdivacky 2214261991Sdim if (VectorType::isVectorSizeTooLarge(vectorSize)) { 2215261991Sdim Diag(AttrLoc, diag::err_attribute_size_too_large) 2216261991Sdim << ArraySize->getSourceRange(); 2217261991Sdim return QualType(); 2218261991Sdim } 2219261991Sdim 2220224145Sdim return Context.getExtVectorType(T, vectorSize); 2221198092Srdivacky } 2222198092Srdivacky 2223212904Sdim return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc); 2224194613Sed} 2225198092Srdivacky 2226261991Sdimbool Sema::CheckFunctionReturnType(QualType T, SourceLocation Loc) { 2227193326Sed if (T->isArrayType() || T->isFunctionType()) { 2228239462Sdim Diag(Loc, diag::err_func_returning_array_function) 2229202379Srdivacky << T->isFunctionType() << T; 2230261991Sdim return true; 2231193326Sed } 2232226633Sdim 2233226633Sdim // Functions cannot return half FP. 2234280031Sdim if (T->isHalfType() && !getLangOpts().HalfArgsAndReturns) { 2235226633Sdim Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 1 << 2236226633Sdim FixItHint::CreateInsertion(Loc, "*"); 2237261991Sdim return true; 2238226633Sdim } 2239226633Sdim 2240261991Sdim // Methods cannot return interface types. All ObjC objects are 2241261991Sdim // passed by reference. 2242261991Sdim if (T->isObjCObjectType()) { 2243261991Sdim Diag(Loc, diag::err_object_cannot_be_passed_returned_by_value) << 0 << T; 2244261991Sdim return 0; 2245261991Sdim } 2246261991Sdim 2247261991Sdim return false; 2248261991Sdim} 2249261991Sdim 2250261991SdimQualType Sema::BuildFunctionType(QualType T, 2251276479Sdim MutableArrayRef<QualType> ParamTypes, 2252261991Sdim SourceLocation Loc, DeclarationName Entity, 2253261991Sdim const FunctionProtoType::ExtProtoInfo &EPI) { 2254193326Sed bool Invalid = false; 2255261991Sdim 2256261991Sdim Invalid |= CheckFunctionReturnType(T, Loc); 2257261991Sdim 2258249423Sdim for (unsigned Idx = 0, Cnt = ParamTypes.size(); Idx < Cnt; ++Idx) { 2259226633Sdim // FIXME: Loc is too inprecise here, should use proper locations for args. 2260224145Sdim QualType ParamType = Context.getAdjustedParameterType(ParamTypes[Idx]); 2261193326Sed if (ParamType->isVoidType()) { 2262193326Sed Diag(Loc, diag::err_param_with_void_type); 2263193326Sed Invalid = true; 2264280031Sdim } else if (ParamType->isHalfType() && !getLangOpts().HalfArgsAndReturns) { 2265226633Sdim // Disallow half FP arguments. 2266226633Sdim Diag(Loc, diag::err_parameters_retval_cannot_have_fp16_type) << 0 << 2267226633Sdim FixItHint::CreateInsertion(Loc, "*"); 2268226633Sdim Invalid = true; 2269193326Sed } 2270193326Sed 2271198398Srdivacky ParamTypes[Idx] = ParamType; 2272193326Sed } 2273193326Sed 2274193326Sed if (Invalid) 2275193326Sed return QualType(); 2276193326Sed 2277249423Sdim return Context.getFunctionType(T, ParamTypes, EPI); 2278193326Sed} 2279198092Srdivacky 2280194179Sed/// \brief Build a member pointer type \c T Class::*. 2281194179Sed/// 2282194179Sed/// \param T the type to which the member pointer refers. 2283194179Sed/// \param Class the class type into which the member pointer points. 2284194179Sed/// \param Loc the location where this type begins 2285194179Sed/// \param Entity the name of the entity that will have this member pointer type 2286194179Sed/// 2287194179Sed/// \returns a member pointer type, if successful, or a NULL type if there was 2288194179Sed/// an error. 2289198092SrdivackyQualType Sema::BuildMemberPointerType(QualType T, QualType Class, 2290210299Sed SourceLocation Loc, 2291194179Sed DeclarationName Entity) { 2292194179Sed // Verify that we're not building a pointer to pointer to function with 2293194179Sed // exception specification. 2294194179Sed if (CheckDistantExceptionSpec(T)) { 2295194179Sed Diag(Loc, diag::err_distant_exception_spec); 2296288943Sdim return QualType(); 2297194179Sed } 2298194179Sed 2299210299Sed // C++ 8.3.3p3: A pointer to member shall not point to ... a member 2300194179Sed // with reference type, or "cv void." 2301194179Sed if (T->isReferenceType()) { 2302195341Sed Diag(Loc, diag::err_illegal_decl_mempointer_to_reference) 2303276479Sdim << getPrintableNameForEntity(Entity) << T; 2304194179Sed return QualType(); 2305194179Sed } 2306194179Sed 2307194179Sed if (T->isVoidType()) { 2308194179Sed Diag(Loc, diag::err_illegal_decl_mempointer_to_void) 2309276479Sdim << getPrintableNameForEntity(Entity); 2310194179Sed return QualType(); 2311194179Sed } 2312194179Sed 2313194179Sed if (!Class->isDependentType() && !Class->isRecordType()) { 2314194179Sed Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class; 2315194179Sed return QualType(); 2316194179Sed } 2317194179Sed 2318276479Sdim // Adjust the default free function calling convention to the default method 2319276479Sdim // calling convention. 2320296417Sdim bool IsCtorOrDtor = 2321296417Sdim (Entity.getNameKind() == DeclarationName::CXXConstructorName) || 2322296417Sdim (Entity.getNameKind() == DeclarationName::CXXDestructorName); 2323276479Sdim if (T->isFunctionType()) 2324296417Sdim adjustMemberFunctionCC(T, /*IsStatic=*/false, IsCtorOrDtor, Loc); 2325212904Sdim 2326210299Sed return Context.getMemberPointerType(T, Class.getTypePtr()); 2327194179Sed} 2328198092Srdivacky 2329194179Sed/// \brief Build a block pointer type. 2330194179Sed/// 2331194179Sed/// \param T The type to which we'll be building a block pointer. 2332194179Sed/// 2333239462Sdim/// \param Loc The source location, used for diagnostics. 2334194179Sed/// 2335194179Sed/// \param Entity The name of the entity that involves the block pointer 2336194179Sed/// type, if known. 2337194179Sed/// 2338194179Sed/// \returns A suitable block pointer type, if there are no 2339194179Sed/// errors. Otherwise, returns a NULL type. 2340239462SdimQualType Sema::BuildBlockPointerType(QualType T, 2341198092Srdivacky SourceLocation Loc, 2342194179Sed DeclarationName Entity) { 2343198092Srdivacky if (!T->isFunctionType()) { 2344194179Sed Diag(Loc, diag::err_nonfunction_block_type); 2345194179Sed return QualType(); 2346194179Sed } 2347198092Srdivacky 2348276479Sdim if (checkQualifiedFunction(*this, T, Loc, QFK_BlockPointer)) 2349276479Sdim return QualType(); 2350276479Sdim 2351210299Sed return Context.getBlockPointerType(T); 2352194179Sed} 2353194179Sed 2354212904SdimQualType Sema::GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo) { 2355212904Sdim QualType QT = Ty.get(); 2356198893Srdivacky if (QT.isNull()) { 2357276479Sdim if (TInfo) *TInfo = nullptr; 2358198893Srdivacky return QualType(); 2359198893Srdivacky } 2360198893Srdivacky 2361276479Sdim TypeSourceInfo *DI = nullptr; 2362218893Sdim if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) { 2363198092Srdivacky QT = LIT->getType(); 2364200583Srdivacky DI = LIT->getTypeSourceInfo(); 2365198092Srdivacky } 2366198092Srdivacky 2367200583Srdivacky if (TInfo) *TInfo = DI; 2368198092Srdivacky return QT; 2369198092Srdivacky} 2370198092Srdivacky 2371224145Sdimstatic void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, 2372224145Sdim Qualifiers::ObjCLifetime ownership, 2373224145Sdim unsigned chunkIndex); 2374224145Sdim 2375224145Sdim/// Given that this is the declaration of a parameter under ARC, 2376224145Sdim/// attempt to infer attributes and such for pointer-to-whatever 2377224145Sdim/// types. 2378224145Sdimstatic void inferARCWriteback(TypeProcessingState &state, 2379224145Sdim QualType &declSpecType) { 2380224145Sdim Sema &S = state.getSema(); 2381224145Sdim Declarator &declarator = state.getDeclarator(); 2382224145Sdim 2383224145Sdim // TODO: should we care about decl qualifiers? 2384224145Sdim 2385224145Sdim // Check whether the declarator has the expected form. We walk 2386224145Sdim // from the inside out in order to make the block logic work. 2387224145Sdim unsigned outermostPointerIndex = 0; 2388224145Sdim bool isBlockPointer = false; 2389224145Sdim unsigned numPointers = 0; 2390224145Sdim for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) { 2391224145Sdim unsigned chunkIndex = i; 2392224145Sdim DeclaratorChunk &chunk = declarator.getTypeObject(chunkIndex); 2393224145Sdim switch (chunk.Kind) { 2394224145Sdim case DeclaratorChunk::Paren: 2395224145Sdim // Ignore parens. 2396224145Sdim break; 2397224145Sdim 2398224145Sdim case DeclaratorChunk::Reference: 2399224145Sdim case DeclaratorChunk::Pointer: 2400224145Sdim // Count the number of pointers. Treat references 2401224145Sdim // interchangeably as pointers; if they're mis-ordered, normal 2402224145Sdim // type building will discover that. 2403224145Sdim outermostPointerIndex = chunkIndex; 2404224145Sdim numPointers++; 2405224145Sdim break; 2406224145Sdim 2407224145Sdim case DeclaratorChunk::BlockPointer: 2408224145Sdim // If we have a pointer to block pointer, that's an acceptable 2409224145Sdim // indirect reference; anything else is not an application of 2410224145Sdim // the rules. 2411224145Sdim if (numPointers != 1) return; 2412224145Sdim numPointers++; 2413224145Sdim outermostPointerIndex = chunkIndex; 2414224145Sdim isBlockPointer = true; 2415224145Sdim 2416224145Sdim // We don't care about pointer structure in return values here. 2417224145Sdim goto done; 2418224145Sdim 2419224145Sdim case DeclaratorChunk::Array: // suppress if written (id[])? 2420224145Sdim case DeclaratorChunk::Function: 2421224145Sdim case DeclaratorChunk::MemberPointer: 2422296417Sdim case DeclaratorChunk::Pipe: 2423224145Sdim return; 2424224145Sdim } 2425224145Sdim } 2426224145Sdim done: 2427224145Sdim 2428224145Sdim // If we have *one* pointer, then we want to throw the qualifier on 2429224145Sdim // the declaration-specifiers, which means that it needs to be a 2430224145Sdim // retainable object type. 2431224145Sdim if (numPointers == 1) { 2432224145Sdim // If it's not a retainable object type, the rule doesn't apply. 2433224145Sdim if (!declSpecType->isObjCRetainableType()) return; 2434224145Sdim 2435224145Sdim // If it already has lifetime, don't do anything. 2436224145Sdim if (declSpecType.getObjCLifetime()) return; 2437224145Sdim 2438224145Sdim // Otherwise, modify the type in-place. 2439224145Sdim Qualifiers qs; 2440239462Sdim 2441224145Sdim if (declSpecType->isObjCARCImplicitlyUnretainedType()) 2442224145Sdim qs.addObjCLifetime(Qualifiers::OCL_ExplicitNone); 2443224145Sdim else 2444224145Sdim qs.addObjCLifetime(Qualifiers::OCL_Autoreleasing); 2445224145Sdim declSpecType = S.Context.getQualifiedType(declSpecType, qs); 2446224145Sdim 2447224145Sdim // If we have *two* pointers, then we want to throw the qualifier on 2448224145Sdim // the outermost pointer. 2449224145Sdim } else if (numPointers == 2) { 2450224145Sdim // If we don't have a block pointer, we need to check whether the 2451224145Sdim // declaration-specifiers gave us something that will turn into a 2452224145Sdim // retainable object pointer after we slap the first pointer on it. 2453224145Sdim if (!isBlockPointer && !declSpecType->isObjCObjectType()) 2454224145Sdim return; 2455224145Sdim 2456224145Sdim // Look for an explicit lifetime attribute there. 2457224145Sdim DeclaratorChunk &chunk = declarator.getTypeObject(outermostPointerIndex); 2458224145Sdim if (chunk.Kind != DeclaratorChunk::Pointer && 2459224145Sdim chunk.Kind != DeclaratorChunk::BlockPointer) 2460224145Sdim return; 2461224145Sdim for (const AttributeList *attr = chunk.getAttrs(); attr; 2462224145Sdim attr = attr->getNext()) 2463239462Sdim if (attr->getKind() == AttributeList::AT_ObjCOwnership) 2464224145Sdim return; 2465224145Sdim 2466224145Sdim transferARCOwnershipToDeclaratorChunk(state, Qualifiers::OCL_Autoreleasing, 2467224145Sdim outermostPointerIndex); 2468224145Sdim 2469224145Sdim // Any other number of pointers/references does not trigger the rule. 2470224145Sdim } else return; 2471224145Sdim 2472224145Sdim // TODO: mark whether we did this inference? 2473224145Sdim} 2474224145Sdim 2475276479Sdimvoid Sema::diagnoseIgnoredQualifiers(unsigned DiagID, unsigned Quals, 2476276479Sdim SourceLocation FallbackLoc, 2477276479Sdim SourceLocation ConstQualLoc, 2478276479Sdim SourceLocation VolatileQualLoc, 2479276479Sdim SourceLocation RestrictQualLoc, 2480276479Sdim SourceLocation AtomicQualLoc) { 2481249423Sdim if (!Quals) 2482249423Sdim return; 2483249423Sdim 2484249423Sdim struct Qual { 2485296417Sdim const char *Name; 2486249423Sdim unsigned Mask; 2487249423Sdim SourceLocation Loc; 2488249423Sdim } const QualKinds[4] = { 2489296417Sdim { "const", DeclSpec::TQ_const, ConstQualLoc }, 2490296417Sdim { "volatile", DeclSpec::TQ_volatile, VolatileQualLoc }, 2491296417Sdim { "restrict", DeclSpec::TQ_restrict, RestrictQualLoc }, 2492296417Sdim { "_Atomic", DeclSpec::TQ_atomic, AtomicQualLoc } 2493249423Sdim }; 2494249423Sdim 2495261991Sdim SmallString<32> QualStr; 2496219077Sdim unsigned NumQuals = 0; 2497219077Sdim SourceLocation Loc; 2498249423Sdim FixItHint FixIts[4]; 2499219077Sdim 2500249423Sdim // Build a string naming the redundant qualifiers. 2501249423Sdim for (unsigned I = 0; I != 4; ++I) { 2502249423Sdim if (Quals & QualKinds[I].Mask) { 2503249423Sdim if (!QualStr.empty()) QualStr += ' '; 2504249423Sdim QualStr += QualKinds[I].Name; 2505219077Sdim 2506249423Sdim // If we have a location for the qualifier, offer a fixit. 2507249423Sdim SourceLocation QualLoc = QualKinds[I].Loc; 2508296417Sdim if (QualLoc.isValid()) { 2509249423Sdim FixIts[NumQuals] = FixItHint::CreateRemoval(QualLoc); 2510276479Sdim if (Loc.isInvalid() || 2511276479Sdim getSourceManager().isBeforeInTranslationUnit(QualLoc, Loc)) 2512249423Sdim Loc = QualLoc; 2513249423Sdim } 2514223017Sdim 2515249423Sdim ++NumQuals; 2516249423Sdim } 2517219077Sdim } 2518249423Sdim 2519276479Sdim Diag(Loc.isInvalid() ? FallbackLoc : Loc, DiagID) 2520249423Sdim << QualStr << NumQuals << FixIts[0] << FixIts[1] << FixIts[2] << FixIts[3]; 2521249423Sdim} 2522249423Sdim 2523249423Sdim// Diagnose pointless type qualifiers on the return type of a function. 2524276479Sdimstatic void diagnoseRedundantReturnTypeQualifiers(Sema &S, QualType RetTy, 2525276479Sdim Declarator &D, 2526276479Sdim unsigned FunctionChunkIndex) { 2527249423Sdim if (D.getTypeObject(FunctionChunkIndex).Fun.hasTrailingReturnType()) { 2528249423Sdim // FIXME: TypeSourceInfo doesn't preserve location information for 2529249423Sdim // qualifiers. 2530276479Sdim S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2531276479Sdim RetTy.getLocalCVRQualifiers(), 2532276479Sdim D.getIdentifierLoc()); 2533249423Sdim return; 2534219077Sdim } 2535249423Sdim 2536249423Sdim for (unsigned OuterChunkIndex = FunctionChunkIndex + 1, 2537249423Sdim End = D.getNumTypeObjects(); 2538249423Sdim OuterChunkIndex != End; ++OuterChunkIndex) { 2539249423Sdim DeclaratorChunk &OuterChunk = D.getTypeObject(OuterChunkIndex); 2540249423Sdim switch (OuterChunk.Kind) { 2541249423Sdim case DeclaratorChunk::Paren: 2542249423Sdim continue; 2543249423Sdim 2544249423Sdim case DeclaratorChunk::Pointer: { 2545249423Sdim DeclaratorChunk::PointerTypeInfo &PTI = OuterChunk.Ptr; 2546276479Sdim S.diagnoseIgnoredQualifiers( 2547276479Sdim diag::warn_qual_return_type, 2548276479Sdim PTI.TypeQuals, 2549249423Sdim SourceLocation(), 2550249423Sdim SourceLocation::getFromRawEncoding(PTI.ConstQualLoc), 2551249423Sdim SourceLocation::getFromRawEncoding(PTI.VolatileQualLoc), 2552249423Sdim SourceLocation::getFromRawEncoding(PTI.RestrictQualLoc), 2553249423Sdim SourceLocation::getFromRawEncoding(PTI.AtomicQualLoc)); 2554249423Sdim return; 2555249423Sdim } 2556249423Sdim 2557249423Sdim case DeclaratorChunk::Function: 2558249423Sdim case DeclaratorChunk::BlockPointer: 2559249423Sdim case DeclaratorChunk::Reference: 2560249423Sdim case DeclaratorChunk::Array: 2561249423Sdim case DeclaratorChunk::MemberPointer: 2562296417Sdim case DeclaratorChunk::Pipe: 2563249423Sdim // FIXME: We can't currently provide an accurate source location and a 2564249423Sdim // fix-it hint for these. 2565249423Sdim unsigned AtomicQual = RetTy->isAtomicType() ? DeclSpec::TQ_atomic : 0; 2566276479Sdim S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2567276479Sdim RetTy.getCVRQualifiers() | AtomicQual, 2568276479Sdim D.getIdentifierLoc()); 2569249423Sdim return; 2570249423Sdim } 2571249423Sdim 2572249423Sdim llvm_unreachable("unknown declarator chunk kind"); 2573219077Sdim } 2574219077Sdim 2575249423Sdim // If the qualifiers come from a conversion function type, don't diagnose 2576249423Sdim // them -- they're not necessarily redundant, since such a conversion 2577249423Sdim // operator can be explicitly called as "x.operator const int()". 2578249423Sdim if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) 2579249423Sdim return; 2580219077Sdim 2581249423Sdim // Just parens all the way out to the decl specifiers. Diagnose any qualifiers 2582249423Sdim // which are present there. 2583276479Sdim S.diagnoseIgnoredQualifiers(diag::warn_qual_return_type, 2584276479Sdim D.getDeclSpec().getTypeQualifiers(), 2585276479Sdim D.getIdentifierLoc(), 2586276479Sdim D.getDeclSpec().getConstSpecLoc(), 2587276479Sdim D.getDeclSpec().getVolatileSpecLoc(), 2588276479Sdim D.getDeclSpec().getRestrictSpecLoc(), 2589276479Sdim D.getDeclSpec().getAtomicSpecLoc()); 2590219077Sdim} 2591219077Sdim 2592224145Sdimstatic QualType GetDeclSpecTypeForDeclarator(TypeProcessingState &state, 2593224145Sdim TypeSourceInfo *&ReturnTypeInfo) { 2594224145Sdim Sema &SemaRef = state.getSema(); 2595224145Sdim Declarator &D = state.getDeclarator(); 2596193326Sed QualType T; 2597276479Sdim ReturnTypeInfo = nullptr; 2598203955Srdivacky 2599224145Sdim // The TagDecl owned by the DeclSpec. 2600276479Sdim TagDecl *OwnedTagDecl = nullptr; 2601218893Sdim 2602198893Srdivacky switch (D.getName().getKind()) { 2603224145Sdim case UnqualifiedId::IK_ImplicitSelfParam: 2604221345Sdim case UnqualifiedId::IK_OperatorFunctionId: 2605198893Srdivacky case UnqualifiedId::IK_Identifier: 2606199990Srdivacky case UnqualifiedId::IK_LiteralOperatorId: 2607198893Srdivacky case UnqualifiedId::IK_TemplateId: 2608224145Sdim T = ConvertDeclSpecToType(state); 2609239462Sdim 2610203955Srdivacky if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) { 2611224145Sdim OwnedTagDecl = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 2612221345Sdim // Owned declaration is embedded in declarator. 2613224145Sdim OwnedTagDecl->setEmbeddedInDeclarator(true); 2614203955Srdivacky } 2615193326Sed break; 2616193326Sed 2617198893Srdivacky case UnqualifiedId::IK_ConstructorName: 2618202379Srdivacky case UnqualifiedId::IK_ConstructorTemplateId: 2619198893Srdivacky case UnqualifiedId::IK_DestructorName: 2620193326Sed // Constructors and destructors don't have return types. Use 2621239462Sdim // "void" instead. 2622224145Sdim T = SemaRef.Context.VoidTy; 2623296417Sdim processTypeAttrs(state, T, TAL_DeclSpec, 2624296417Sdim D.getDeclSpec().getAttributes().getList()); 2625193326Sed break; 2626202379Srdivacky 2627202379Srdivacky case UnqualifiedId::IK_ConversionFunctionId: 2628202379Srdivacky // The result type of a conversion function is the type that it 2629202379Srdivacky // converts to. 2630239462Sdim T = SemaRef.GetTypeFromParser(D.getName().ConversionFunctionId, 2631224145Sdim &ReturnTypeInfo); 2632202379Srdivacky break; 2633193326Sed } 2634200583Srdivacky 2635218893Sdim if (D.getAttributes()) 2636218893Sdim distributeTypeAttrsFromDeclarator(state, T); 2637218893Sdim 2638234353Sdim // C++11 [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context. 2639296417Sdim if (D.getDeclSpec().containsPlaceholderType()) { 2640195099Sed int Error = -1; 2641198092Srdivacky 2642195099Sed switch (D.getContext()) { 2643234353Sdim case Declarator::LambdaExprContext: 2644234353Sdim llvm_unreachable("Can't specify a type specifier in lambda grammar"); 2645226633Sdim case Declarator::ObjCParameterContext: 2646226633Sdim case Declarator::ObjCResultContext: 2647195099Sed case Declarator::PrototypeContext: 2648261991Sdim Error = 0; 2649195099Sed break; 2650261991Sdim case Declarator::LambdaExprParameterContext: 2651296417Sdim // In C++14, generic lambdas allow 'auto' in their parameters. 2652280031Sdim if (!(SemaRef.getLangOpts().CPlusPlus14 2653261991Sdim && D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto)) 2654296417Sdim Error = 16; 2655261991Sdim break; 2656296417Sdim case Declarator::MemberContext: { 2657296417Sdim if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static || 2658296417Sdim D.isFunctionDeclarator()) 2659223017Sdim break; 2660296417Sdim bool Cxx = SemaRef.getLangOpts().CPlusPlus; 2661224145Sdim switch (cast<TagDecl>(SemaRef.CurContext)->getTagKind()) { 2662226633Sdim case TTK_Enum: llvm_unreachable("unhandled tag kind"); 2663296417Sdim case TTK_Struct: Error = Cxx ? 1 : 2; /* Struct member */ break; 2664296417Sdim case TTK_Union: Error = Cxx ? 3 : 4; /* Union member */ break; 2665296417Sdim case TTK_Class: Error = 5; /* Class member */ break; 2666296417Sdim case TTK_Interface: Error = 6; /* Interface member */ break; 2667198092Srdivacky } 2668195099Sed break; 2669296417Sdim } 2670195099Sed case Declarator::CXXCatchContext: 2671224145Sdim case Declarator::ObjCCatchContext: 2672296417Sdim Error = 7; // Exception declaration 2673195099Sed break; 2674195099Sed case Declarator::TemplateParamContext: 2675296417Sdim Error = 8; // Template parameter 2676195099Sed break; 2677195099Sed case Declarator::BlockLiteralContext: 2678296417Sdim Error = 9; // Block literal 2679195099Sed break; 2680218893Sdim case Declarator::TemplateTypeArgContext: 2681296417Sdim Error = 10; // Template type argument 2682218893Sdim break; 2683221345Sdim case Declarator::AliasDeclContext: 2684223017Sdim case Declarator::AliasTemplateContext: 2685296417Sdim Error = 12; // Type alias 2686221345Sdim break; 2687234353Sdim case Declarator::TrailingReturnContext: 2688296417Sdim if (!SemaRef.getLangOpts().CPlusPlus14 || 2689296417Sdim D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2690296417Sdim Error = 13; // Function return type 2691234353Sdim break; 2692251662Sdim case Declarator::ConversionIdContext: 2693296417Sdim if (!SemaRef.getLangOpts().CPlusPlus14 || 2694296417Sdim D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2695296417Sdim Error = 14; // conversion-type-id 2696251662Sdim break; 2697218893Sdim case Declarator::TypeNameContext: 2698296417Sdim Error = 15; // Generic 2699218893Sdim break; 2700195099Sed case Declarator::FileContext: 2701195099Sed case Declarator::BlockContext: 2702195099Sed case Declarator::ForContext: 2703195099Sed case Declarator::ConditionContext: 2704296417Sdim break; 2705224145Sdim case Declarator::CXXNewContext: 2706296417Sdim if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type) 2707296417Sdim Error = 17; // 'new' type 2708195099Sed break; 2709296417Sdim case Declarator::KNRTypeListContext: 2710296417Sdim Error = 18; // K&R function parameter 2711296417Sdim break; 2712195099Sed } 2713195099Sed 2714219077Sdim if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 2715243830Sdim Error = 11; 2716219077Sdim 2717296417Sdim // In Objective-C it is an error to use 'auto' on a function declarator 2718296417Sdim // (and everywhere for '__auto_type'). 2719296417Sdim if (D.isFunctionDeclarator() && 2720296417Sdim (!SemaRef.getLangOpts().CPlusPlus11 || 2721296417Sdim D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto_type)) 2722296417Sdim Error = 13; 2723296417Sdim 2724296417Sdim bool HaveTrailing = false; 2725296417Sdim 2726234353Sdim // C++11 [dcl.spec.auto]p2: 'auto' is always fine if the declarator 2727219077Sdim // contains a trailing return type. That is only legal at the outermost 2728219077Sdim // level. Check all declarator chunks (outermost first) anyway, to give 2729219077Sdim // better diagnostics. 2730296417Sdim // We don't support '__auto_type' with trailing return types. 2731296417Sdim if (SemaRef.getLangOpts().CPlusPlus11 && 2732296417Sdim D.getDeclSpec().getTypeSpecType() != DeclSpec::TST_auto_type) { 2733219077Sdim for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 2734219077Sdim unsigned chunkIndex = e - i - 1; 2735219077Sdim state.setCurrentChunkIndex(chunkIndex); 2736219077Sdim DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); 2737219077Sdim if (DeclType.Kind == DeclaratorChunk::Function) { 2738219077Sdim const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 2739239462Sdim if (FTI.hasTrailingReturnType()) { 2740296417Sdim HaveTrailing = true; 2741219077Sdim Error = -1; 2742219077Sdim break; 2743219077Sdim } 2744219077Sdim } 2745219077Sdim } 2746219077Sdim } 2747219077Sdim 2748251662Sdim SourceRange AutoRange = D.getDeclSpec().getTypeSpecTypeLoc(); 2749251662Sdim if (D.getName().getKind() == UnqualifiedId::IK_ConversionFunctionId) 2750251662Sdim AutoRange = D.getName().getSourceRange(); 2751251662Sdim 2752195099Sed if (Error != -1) { 2753296417Sdim unsigned Keyword; 2754296417Sdim switch (D.getDeclSpec().getTypeSpecType()) { 2755296417Sdim case DeclSpec::TST_auto: Keyword = 0; break; 2756296417Sdim case DeclSpec::TST_decltype_auto: Keyword = 1; break; 2757296417Sdim case DeclSpec::TST_auto_type: Keyword = 2; break; 2758296417Sdim default: llvm_unreachable("unknown auto TypeSpecType"); 2759296417Sdim } 2760251662Sdim SemaRef.Diag(AutoRange.getBegin(), diag::err_auto_not_allowed) 2761296417Sdim << Keyword << Error << AutoRange; 2762224145Sdim T = SemaRef.Context.IntTy; 2763195099Sed D.setInvalidType(true); 2764296417Sdim } else if (!HaveTrailing) { 2765296417Sdim // If there was a trailing return type, we already got 2766296417Sdim // warn_cxx98_compat_trailing_return_type in the parser. 2767251662Sdim SemaRef.Diag(AutoRange.getBegin(), 2768251662Sdim diag::warn_cxx98_compat_auto_type_specifier) 2769251662Sdim << AutoRange; 2770296417Sdim } 2771195099Sed } 2772218893Sdim 2773234353Sdim if (SemaRef.getLangOpts().CPlusPlus && 2774226633Sdim OwnedTagDecl && OwnedTagDecl->isCompleteDefinition()) { 2775224145Sdim // Check the contexts where C++ forbids the declaration of a new class 2776224145Sdim // or enumeration in a type-specifier-seq. 2777296417Sdim unsigned DiagID = 0; 2778224145Sdim switch (D.getContext()) { 2779234353Sdim case Declarator::TrailingReturnContext: 2780234353Sdim // Class and enumeration definitions are syntactically not allowed in 2781234353Sdim // trailing return types. 2782234353Sdim llvm_unreachable("parser should not have allowed this"); 2783234353Sdim break; 2784224145Sdim case Declarator::FileContext: 2785224145Sdim case Declarator::MemberContext: 2786224145Sdim case Declarator::BlockContext: 2787224145Sdim case Declarator::ForContext: 2788224145Sdim case Declarator::BlockLiteralContext: 2789234353Sdim case Declarator::LambdaExprContext: 2790234353Sdim // C++11 [dcl.type]p3: 2791224145Sdim // A type-specifier-seq shall not define a class or enumeration unless 2792224145Sdim // it appears in the type-id of an alias-declaration (7.1.3) that is not 2793224145Sdim // the declaration of a template-declaration. 2794224145Sdim case Declarator::AliasDeclContext: 2795224145Sdim break; 2796224145Sdim case Declarator::AliasTemplateContext: 2797296417Sdim DiagID = diag::err_type_defined_in_alias_template; 2798224145Sdim break; 2799224145Sdim case Declarator::TypeNameContext: 2800251662Sdim case Declarator::ConversionIdContext: 2801224145Sdim case Declarator::TemplateParamContext: 2802224145Sdim case Declarator::CXXNewContext: 2803224145Sdim case Declarator::CXXCatchContext: 2804224145Sdim case Declarator::ObjCCatchContext: 2805224145Sdim case Declarator::TemplateTypeArgContext: 2806296417Sdim DiagID = diag::err_type_defined_in_type_specifier; 2807224145Sdim break; 2808224145Sdim case Declarator::PrototypeContext: 2809261991Sdim case Declarator::LambdaExprParameterContext: 2810226633Sdim case Declarator::ObjCParameterContext: 2811226633Sdim case Declarator::ObjCResultContext: 2812224145Sdim case Declarator::KNRTypeListContext: 2813224145Sdim // C++ [dcl.fct]p6: 2814224145Sdim // Types shall not be defined in return or parameter types. 2815296417Sdim DiagID = diag::err_type_defined_in_param_type; 2816224145Sdim break; 2817224145Sdim case Declarator::ConditionContext: 2818224145Sdim // C++ 6.4p2: 2819224145Sdim // The type-specifier-seq shall not contain typedef and shall not declare 2820224145Sdim // a new class or enumeration. 2821296417Sdim DiagID = diag::err_type_defined_in_condition; 2822224145Sdim break; 2823224145Sdim } 2824296417Sdim 2825296417Sdim if (DiagID != 0) { 2826296417Sdim SemaRef.Diag(OwnedTagDecl->getLocation(), DiagID) 2827296417Sdim << SemaRef.Context.getTypeDeclType(OwnedTagDecl); 2828296417Sdim D.setInvalidType(true); 2829296417Sdim } 2830224145Sdim } 2831224145Sdim 2832280031Sdim assert(!T.isNull() && "This function should not return a null type"); 2833224145Sdim return T; 2834224145Sdim} 2835224145Sdim 2836276479Sdim/// Produce an appropriate diagnostic for an ambiguity between a function 2837239462Sdim/// declarator and a C++ direct-initializer. 2838239462Sdimstatic void warnAboutAmbiguousFunction(Sema &S, Declarator &D, 2839239462Sdim DeclaratorChunk &DeclType, QualType RT) { 2840239462Sdim const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 2841239462Sdim assert(FTI.isAmbiguous && "no direct-initializer / function ambiguity"); 2842239462Sdim 2843239462Sdim // If the return type is void there is no ambiguity. 2844239462Sdim if (RT->isVoidType()) 2845239462Sdim return; 2846239462Sdim 2847239462Sdim // An initializer for a non-class type can have at most one argument. 2848276479Sdim if (!RT->isRecordType() && FTI.NumParams > 1) 2849239462Sdim return; 2850239462Sdim 2851239462Sdim // An initializer for a reference must have exactly one argument. 2852276479Sdim if (RT->isReferenceType() && FTI.NumParams != 1) 2853239462Sdim return; 2854239462Sdim 2855239462Sdim // Only warn if this declarator is declaring a function at block scope, and 2856239462Sdim // doesn't have a storage class (such as 'extern') specified. 2857239462Sdim if (!D.isFunctionDeclarator() || 2858239462Sdim D.getFunctionDefinitionKind() != FDK_Declaration || 2859239462Sdim !S.CurContext->isFunctionOrMethod() || 2860249423Sdim D.getDeclSpec().getStorageClassSpec() 2861239462Sdim != DeclSpec::SCS_unspecified) 2862239462Sdim return; 2863239462Sdim 2864239462Sdim // Inside a condition, a direct initializer is not permitted. We allow one to 2865239462Sdim // be parsed in order to give better diagnostics in condition parsing. 2866239462Sdim if (D.getContext() == Declarator::ConditionContext) 2867239462Sdim return; 2868239462Sdim 2869239462Sdim SourceRange ParenRange(DeclType.Loc, DeclType.EndLoc); 2870239462Sdim 2871239462Sdim S.Diag(DeclType.Loc, 2872276479Sdim FTI.NumParams ? diag::warn_parens_disambiguated_as_function_declaration 2873276479Sdim : diag::warn_empty_parens_are_function_decl) 2874276479Sdim << ParenRange; 2875239462Sdim 2876239462Sdim // If the declaration looks like: 2877239462Sdim // T var1, 2878239462Sdim // f(); 2879239462Sdim // and name lookup finds a function named 'f', then the ',' was 2880239462Sdim // probably intended to be a ';'. 2881239462Sdim if (!D.isFirstDeclarator() && D.getIdentifier()) { 2882239462Sdim FullSourceLoc Comma(D.getCommaLoc(), S.SourceMgr); 2883239462Sdim FullSourceLoc Name(D.getIdentifierLoc(), S.SourceMgr); 2884239462Sdim if (Comma.getFileID() != Name.getFileID() || 2885239462Sdim Comma.getSpellingLineNumber() != Name.getSpellingLineNumber()) { 2886239462Sdim LookupResult Result(S, D.getIdentifier(), SourceLocation(), 2887239462Sdim Sema::LookupOrdinaryName); 2888239462Sdim if (S.LookupName(Result, S.getCurScope())) 2889239462Sdim S.Diag(D.getCommaLoc(), diag::note_empty_parens_function_call) 2890239462Sdim << FixItHint::CreateReplacement(D.getCommaLoc(), ";") 2891239462Sdim << D.getIdentifier(); 2892239462Sdim } 2893239462Sdim } 2894239462Sdim 2895276479Sdim if (FTI.NumParams > 0) { 2896276479Sdim // For a declaration with parameters, eg. "T var(T());", suggest adding 2897276479Sdim // parens around the first parameter to turn the declaration into a 2898276479Sdim // variable declaration. 2899276479Sdim SourceRange Range = FTI.Params[0].Param->getSourceRange(); 2900239462Sdim SourceLocation B = Range.getBegin(); 2901276479Sdim SourceLocation E = S.getLocForEndOfToken(Range.getEnd()); 2902239462Sdim // FIXME: Maybe we should suggest adding braces instead of parens 2903239462Sdim // in C++11 for classes that don't have an initializer_list constructor. 2904239462Sdim S.Diag(B, diag::note_additional_parens_for_variable_declaration) 2905239462Sdim << FixItHint::CreateInsertion(B, "(") 2906239462Sdim << FixItHint::CreateInsertion(E, ")"); 2907239462Sdim } else { 2908276479Sdim // For a declaration without parameters, eg. "T var();", suggest replacing 2909276479Sdim // the parens with an initializer to turn the declaration into a variable 2910239462Sdim // declaration. 2911239462Sdim const CXXRecordDecl *RD = RT->getAsCXXRecordDecl(); 2912239462Sdim 2913239462Sdim // Empty parens mean value-initialization, and no parens mean 2914239462Sdim // default initialization. These are equivalent if the default 2915239462Sdim // constructor is user-provided or if zero-initialization is a 2916239462Sdim // no-op. 2917239462Sdim if (RD && RD->hasDefinition() && 2918239462Sdim (RD->isEmpty() || RD->hasUserProvidedDefaultConstructor())) 2919239462Sdim S.Diag(DeclType.Loc, diag::note_empty_parens_default_ctor) 2920239462Sdim << FixItHint::CreateRemoval(ParenRange); 2921239462Sdim else { 2922261991Sdim std::string Init = 2923261991Sdim S.getFixItZeroInitializerForType(RT, ParenRange.getBegin()); 2924249423Sdim if (Init.empty() && S.LangOpts.CPlusPlus11) 2925239462Sdim Init = "{}"; 2926239462Sdim if (!Init.empty()) 2927239462Sdim S.Diag(DeclType.Loc, diag::note_empty_parens_zero_initialize) 2928239462Sdim << FixItHint::CreateReplacement(ParenRange, Init); 2929239462Sdim } 2930239462Sdim } 2931239462Sdim} 2932239462Sdim 2933261991Sdim/// Helper for figuring out the default CC for a function declarator type. If 2934261991Sdim/// this is the outermost chunk, then we can determine the CC from the 2935261991Sdim/// declarator context. If not, then this could be either a member function 2936261991Sdim/// type or normal function type. 2937261991Sdimstatic CallingConv 2938261991SdimgetCCForDeclaratorChunk(Sema &S, Declarator &D, 2939261991Sdim const DeclaratorChunk::FunctionTypeInfo &FTI, 2940261991Sdim unsigned ChunkIndex) { 2941261991Sdim assert(D.getTypeObject(ChunkIndex).Kind == DeclaratorChunk::Function); 2942261991Sdim 2943261991Sdim bool IsCXXInstanceMethod = false; 2944261991Sdim 2945261991Sdim if (S.getLangOpts().CPlusPlus) { 2946261991Sdim // Look inwards through parentheses to see if this chunk will form a 2947261991Sdim // member pointer type or if we're the declarator. Any type attributes 2948261991Sdim // between here and there will override the CC we choose here. 2949261991Sdim unsigned I = ChunkIndex; 2950261991Sdim bool FoundNonParen = false; 2951261991Sdim while (I && !FoundNonParen) { 2952261991Sdim --I; 2953261991Sdim if (D.getTypeObject(I).Kind != DeclaratorChunk::Paren) 2954261991Sdim FoundNonParen = true; 2955261991Sdim } 2956261991Sdim 2957261991Sdim if (FoundNonParen) { 2958261991Sdim // If we're not the declarator, we're a regular function type unless we're 2959261991Sdim // in a member pointer. 2960261991Sdim IsCXXInstanceMethod = 2961261991Sdim D.getTypeObject(I).Kind == DeclaratorChunk::MemberPointer; 2962288943Sdim } else if (D.getContext() == Declarator::LambdaExprContext) { 2963288943Sdim // This can only be a call operator for a lambda, which is an instance 2964288943Sdim // method. 2965288943Sdim IsCXXInstanceMethod = true; 2966261991Sdim } else { 2967261991Sdim // We're the innermost decl chunk, so must be a function declarator. 2968261991Sdim assert(D.isFunctionDeclarator()); 2969261991Sdim 2970261991Sdim // If we're inside a record, we're declaring a method, but it could be 2971261991Sdim // explicitly or implicitly static. 2972261991Sdim IsCXXInstanceMethod = 2973261991Sdim D.isFirstDeclarationOfMember() && 2974261991Sdim D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 2975261991Sdim !D.isStaticMember(); 2976261991Sdim } 2977261991Sdim } 2978261991Sdim 2979288943Sdim CallingConv CC = S.Context.getDefaultCallingConvention(FTI.isVariadic, 2980288943Sdim IsCXXInstanceMethod); 2981288943Sdim 2982288943Sdim // Attribute AT_OpenCLKernel affects the calling convention only on 2983288943Sdim // the SPIR target, hence it cannot be treated as a calling 2984288943Sdim // convention attribute. This is the simplest place to infer 2985288943Sdim // "spir_kernel" for OpenCL kernels on SPIR. 2986288943Sdim if (CC == CC_SpirFunction) { 2987288943Sdim for (const AttributeList *Attr = D.getDeclSpec().getAttributes().getList(); 2988288943Sdim Attr; Attr = Attr->getNext()) { 2989288943Sdim if (Attr->getKind() == AttributeList::AT_OpenCLKernel) { 2990288943Sdim CC = CC_SpirKernel; 2991288943Sdim break; 2992288943Sdim } 2993288943Sdim } 2994288943Sdim } 2995288943Sdim 2996288943Sdim return CC; 2997261991Sdim} 2998261991Sdim 2999288943Sdimnamespace { 3000288943Sdim /// A simple notion of pointer kinds, which matches up with the various 3001288943Sdim /// pointer declarators. 3002288943Sdim enum class SimplePointerKind { 3003288943Sdim Pointer, 3004288943Sdim BlockPointer, 3005288943Sdim MemberPointer, 3006288943Sdim }; 3007288943Sdim} 3008288943Sdim 3009288943SdimIdentifierInfo *Sema::getNullabilityKeyword(NullabilityKind nullability) { 3010288943Sdim switch (nullability) { 3011288943Sdim case NullabilityKind::NonNull: 3012288943Sdim if (!Ident__Nonnull) 3013288943Sdim Ident__Nonnull = PP.getIdentifierInfo("_Nonnull"); 3014288943Sdim return Ident__Nonnull; 3015288943Sdim 3016288943Sdim case NullabilityKind::Nullable: 3017288943Sdim if (!Ident__Nullable) 3018288943Sdim Ident__Nullable = PP.getIdentifierInfo("_Nullable"); 3019288943Sdim return Ident__Nullable; 3020288943Sdim 3021288943Sdim case NullabilityKind::Unspecified: 3022288943Sdim if (!Ident__Null_unspecified) 3023288943Sdim Ident__Null_unspecified = PP.getIdentifierInfo("_Null_unspecified"); 3024288943Sdim return Ident__Null_unspecified; 3025288943Sdim } 3026288943Sdim llvm_unreachable("Unknown nullability kind."); 3027288943Sdim} 3028288943Sdim 3029288943Sdim/// Retrieve the identifier "NSError". 3030288943SdimIdentifierInfo *Sema::getNSErrorIdent() { 3031288943Sdim if (!Ident_NSError) 3032288943Sdim Ident_NSError = PP.getIdentifierInfo("NSError"); 3033288943Sdim 3034288943Sdim return Ident_NSError; 3035288943Sdim} 3036288943Sdim 3037288943Sdim/// Check whether there is a nullability attribute of any kind in the given 3038288943Sdim/// attribute list. 3039288943Sdimstatic bool hasNullabilityAttr(const AttributeList *attrs) { 3040288943Sdim for (const AttributeList *attr = attrs; attr; 3041288943Sdim attr = attr->getNext()) { 3042288943Sdim if (attr->getKind() == AttributeList::AT_TypeNonNull || 3043288943Sdim attr->getKind() == AttributeList::AT_TypeNullable || 3044288943Sdim attr->getKind() == AttributeList::AT_TypeNullUnspecified) 3045288943Sdim return true; 3046288943Sdim } 3047288943Sdim 3048288943Sdim return false; 3049288943Sdim} 3050288943Sdim 3051288943Sdimnamespace { 3052288943Sdim /// Describes the kind of a pointer a declarator describes. 3053288943Sdim enum class PointerDeclaratorKind { 3054288943Sdim // Not a pointer. 3055288943Sdim NonPointer, 3056288943Sdim // Single-level pointer. 3057288943Sdim SingleLevelPointer, 3058288943Sdim // Multi-level pointer (of any pointer kind). 3059288943Sdim MultiLevelPointer, 3060288943Sdim // CFFooRef* 3061288943Sdim MaybePointerToCFRef, 3062288943Sdim // CFErrorRef* 3063288943Sdim CFErrorRefPointer, 3064288943Sdim // NSError** 3065288943Sdim NSErrorPointerPointer, 3066288943Sdim }; 3067288943Sdim} 3068288943Sdim 3069288943Sdim/// Classify the given declarator, whose type-specified is \c type, based on 3070288943Sdim/// what kind of pointer it refers to. 3071288943Sdim/// 3072288943Sdim/// This is used to determine the default nullability. 3073288943Sdimstatic PointerDeclaratorKind classifyPointerDeclarator(Sema &S, 3074288943Sdim QualType type, 3075288943Sdim Declarator &declarator) { 3076288943Sdim unsigned numNormalPointers = 0; 3077288943Sdim 3078288943Sdim // For any dependent type, we consider it a non-pointer. 3079288943Sdim if (type->isDependentType()) 3080288943Sdim return PointerDeclaratorKind::NonPointer; 3081288943Sdim 3082288943Sdim // Look through the declarator chunks to identify pointers. 3083288943Sdim for (unsigned i = 0, n = declarator.getNumTypeObjects(); i != n; ++i) { 3084288943Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i); 3085288943Sdim switch (chunk.Kind) { 3086288943Sdim case DeclaratorChunk::Array: 3087288943Sdim case DeclaratorChunk::Function: 3088296417Sdim case DeclaratorChunk::Pipe: 3089288943Sdim break; 3090288943Sdim 3091288943Sdim case DeclaratorChunk::BlockPointer: 3092288943Sdim case DeclaratorChunk::MemberPointer: 3093288943Sdim return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3094288943Sdim : PointerDeclaratorKind::SingleLevelPointer; 3095288943Sdim 3096288943Sdim case DeclaratorChunk::Paren: 3097288943Sdim case DeclaratorChunk::Reference: 3098288943Sdim continue; 3099288943Sdim 3100288943Sdim case DeclaratorChunk::Pointer: 3101288943Sdim ++numNormalPointers; 3102288943Sdim if (numNormalPointers > 2) 3103288943Sdim return PointerDeclaratorKind::MultiLevelPointer; 3104288943Sdim continue; 3105288943Sdim } 3106288943Sdim } 3107288943Sdim 3108288943Sdim // Then, dig into the type specifier itself. 3109288943Sdim unsigned numTypeSpecifierPointers = 0; 3110288943Sdim do { 3111288943Sdim // Decompose normal pointers. 3112288943Sdim if (auto ptrType = type->getAs<PointerType>()) { 3113288943Sdim ++numNormalPointers; 3114288943Sdim 3115288943Sdim if (numNormalPointers > 2) 3116288943Sdim return PointerDeclaratorKind::MultiLevelPointer; 3117288943Sdim 3118288943Sdim type = ptrType->getPointeeType(); 3119288943Sdim ++numTypeSpecifierPointers; 3120288943Sdim continue; 3121288943Sdim } 3122288943Sdim 3123288943Sdim // Decompose block pointers. 3124288943Sdim if (type->getAs<BlockPointerType>()) { 3125288943Sdim return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3126288943Sdim : PointerDeclaratorKind::SingleLevelPointer; 3127288943Sdim } 3128288943Sdim 3129288943Sdim // Decompose member pointers. 3130288943Sdim if (type->getAs<MemberPointerType>()) { 3131288943Sdim return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer 3132288943Sdim : PointerDeclaratorKind::SingleLevelPointer; 3133288943Sdim } 3134288943Sdim 3135288943Sdim // Look at Objective-C object pointers. 3136288943Sdim if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) { 3137288943Sdim ++numNormalPointers; 3138288943Sdim ++numTypeSpecifierPointers; 3139288943Sdim 3140288943Sdim // If this is NSError**, report that. 3141288943Sdim if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) { 3142288943Sdim if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() && 3143288943Sdim numNormalPointers == 2 && numTypeSpecifierPointers < 2) { 3144288943Sdim return PointerDeclaratorKind::NSErrorPointerPointer; 3145288943Sdim } 3146288943Sdim } 3147288943Sdim 3148288943Sdim break; 3149288943Sdim } 3150288943Sdim 3151288943Sdim // Look at Objective-C class types. 3152288943Sdim if (auto objcClass = type->getAs<ObjCInterfaceType>()) { 3153288943Sdim if (objcClass->getInterface()->getIdentifier() == S.getNSErrorIdent()) { 3154288943Sdim if (numNormalPointers == 2 && numTypeSpecifierPointers < 2) 3155288943Sdim return PointerDeclaratorKind::NSErrorPointerPointer;; 3156288943Sdim } 3157288943Sdim 3158288943Sdim break; 3159288943Sdim } 3160288943Sdim 3161288943Sdim // If at this point we haven't seen a pointer, we won't see one. 3162288943Sdim if (numNormalPointers == 0) 3163288943Sdim return PointerDeclaratorKind::NonPointer; 3164288943Sdim 3165288943Sdim if (auto recordType = type->getAs<RecordType>()) { 3166288943Sdim RecordDecl *recordDecl = recordType->getDecl(); 3167288943Sdim 3168288943Sdim bool isCFError = false; 3169288943Sdim if (S.CFError) { 3170288943Sdim // If we already know about CFError, test it directly. 3171288943Sdim isCFError = (S.CFError == recordDecl); 3172288943Sdim } else { 3173288943Sdim // Check whether this is CFError, which we identify based on its bridge 3174288943Sdim // to NSError. 3175288943Sdim if (recordDecl->getTagKind() == TTK_Struct && numNormalPointers > 0) { 3176288943Sdim if (auto bridgeAttr = recordDecl->getAttr<ObjCBridgeAttr>()) { 3177288943Sdim if (bridgeAttr->getBridgedType() == S.getNSErrorIdent()) { 3178288943Sdim S.CFError = recordDecl; 3179288943Sdim isCFError = true; 3180288943Sdim } 3181288943Sdim } 3182288943Sdim } 3183288943Sdim } 3184288943Sdim 3185288943Sdim // If this is CFErrorRef*, report it as such. 3186288943Sdim if (isCFError && numNormalPointers == 2 && numTypeSpecifierPointers < 2) { 3187288943Sdim return PointerDeclaratorKind::CFErrorRefPointer; 3188288943Sdim } 3189288943Sdim break; 3190288943Sdim } 3191288943Sdim 3192288943Sdim break; 3193288943Sdim } while (true); 3194288943Sdim 3195288943Sdim 3196288943Sdim switch (numNormalPointers) { 3197288943Sdim case 0: 3198288943Sdim return PointerDeclaratorKind::NonPointer; 3199288943Sdim 3200288943Sdim case 1: 3201288943Sdim return PointerDeclaratorKind::SingleLevelPointer; 3202288943Sdim 3203288943Sdim case 2: 3204288943Sdim return PointerDeclaratorKind::MaybePointerToCFRef; 3205288943Sdim 3206288943Sdim default: 3207288943Sdim return PointerDeclaratorKind::MultiLevelPointer; 3208288943Sdim } 3209288943Sdim} 3210288943Sdim 3211288943Sdimstatic FileID getNullabilityCompletenessCheckFileID(Sema &S, 3212288943Sdim SourceLocation loc) { 3213288943Sdim // If we're anywhere in a function, method, or closure context, don't perform 3214288943Sdim // completeness checks. 3215288943Sdim for (DeclContext *ctx = S.CurContext; ctx; ctx = ctx->getParent()) { 3216288943Sdim if (ctx->isFunctionOrMethod()) 3217288943Sdim return FileID(); 3218288943Sdim 3219288943Sdim if (ctx->isFileContext()) 3220288943Sdim break; 3221288943Sdim } 3222288943Sdim 3223288943Sdim // We only care about the expansion location. 3224288943Sdim loc = S.SourceMgr.getExpansionLoc(loc); 3225288943Sdim FileID file = S.SourceMgr.getFileID(loc); 3226288943Sdim if (file.isInvalid()) 3227288943Sdim return FileID(); 3228288943Sdim 3229288943Sdim // Retrieve file information. 3230288943Sdim bool invalid = false; 3231288943Sdim const SrcMgr::SLocEntry &sloc = S.SourceMgr.getSLocEntry(file, &invalid); 3232288943Sdim if (invalid || !sloc.isFile()) 3233288943Sdim return FileID(); 3234288943Sdim 3235288943Sdim // We don't want to perform completeness checks on the main file or in 3236288943Sdim // system headers. 3237288943Sdim const SrcMgr::FileInfo &fileInfo = sloc.getFile(); 3238288943Sdim if (fileInfo.getIncludeLoc().isInvalid()) 3239288943Sdim return FileID(); 3240288943Sdim if (fileInfo.getFileCharacteristic() != SrcMgr::C_User && 3241288943Sdim S.Diags.getSuppressSystemWarnings()) { 3242288943Sdim return FileID(); 3243288943Sdim } 3244288943Sdim 3245288943Sdim return file; 3246288943Sdim} 3247288943Sdim 3248288943Sdim/// Check for consistent use of nullability. 3249288943Sdimstatic void checkNullabilityConsistency(TypeProcessingState &state, 3250288943Sdim SimplePointerKind pointerKind, 3251288943Sdim SourceLocation pointerLoc) { 3252288943Sdim Sema &S = state.getSema(); 3253288943Sdim 3254288943Sdim // Determine which file we're performing consistency checking for. 3255288943Sdim FileID file = getNullabilityCompletenessCheckFileID(S, pointerLoc); 3256288943Sdim if (file.isInvalid()) 3257288943Sdim return; 3258288943Sdim 3259288943Sdim // If we haven't seen any type nullability in this file, we won't warn now 3260288943Sdim // about anything. 3261288943Sdim FileNullability &fileNullability = S.NullabilityMap[file]; 3262288943Sdim if (!fileNullability.SawTypeNullability) { 3263288943Sdim // If this is the first pointer declarator in the file, record it. 3264288943Sdim if (fileNullability.PointerLoc.isInvalid() && 3265288943Sdim !S.Context.getDiagnostics().isIgnored(diag::warn_nullability_missing, 3266288943Sdim pointerLoc)) { 3267288943Sdim fileNullability.PointerLoc = pointerLoc; 3268288943Sdim fileNullability.PointerKind = static_cast<unsigned>(pointerKind); 3269288943Sdim } 3270288943Sdim 3271288943Sdim return; 3272288943Sdim } 3273288943Sdim 3274288943Sdim // Complain about missing nullability. 3275288943Sdim S.Diag(pointerLoc, diag::warn_nullability_missing) 3276288943Sdim << static_cast<unsigned>(pointerKind); 3277288943Sdim} 3278288943Sdim 3279224145Sdimstatic TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, 3280224145Sdim QualType declSpecType, 3281224145Sdim TypeSourceInfo *TInfo) { 3282280031Sdim // The TypeSourceInfo that this function returns will not be a null type. 3283280031Sdim // If there is an error, this function will fill in a dummy type as fallback. 3284224145Sdim QualType T = declSpecType; 3285224145Sdim Declarator &D = state.getDeclarator(); 3286224145Sdim Sema &S = state.getSema(); 3287224145Sdim ASTContext &Context = S.Context; 3288234353Sdim const LangOptions &LangOpts = S.getLangOpts(); 3289224145Sdim 3290193326Sed // The name we're declaring, if any. 3291193326Sed DeclarationName Name; 3292193326Sed if (D.getIdentifier()) 3293193326Sed Name = D.getIdentifier(); 3294193326Sed 3295221345Sdim // Does this declaration declare a typedef-name? 3296221345Sdim bool IsTypedefName = 3297221345Sdim D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef || 3298223017Sdim D.getContext() == Declarator::AliasDeclContext || 3299223017Sdim D.getContext() == Declarator::AliasTemplateContext; 3300221345Sdim 3301234353Sdim // Does T refer to a function type with a cv-qualifier or a ref-qualifier? 3302234353Sdim bool IsQualifiedFunction = T->isFunctionProtoType() && 3303234353Sdim (T->castAs<FunctionProtoType>()->getTypeQuals() != 0 || 3304234353Sdim T->castAs<FunctionProtoType>()->getRefQualifier() != RQ_None); 3305234353Sdim 3306251662Sdim // If T is 'decltype(auto)', the only declarators we can have are parens 3307251662Sdim // and at most one function declarator if this is a function declaration. 3308251662Sdim if (const AutoType *AT = T->getAs<AutoType>()) { 3309251662Sdim if (AT->isDecltypeAuto()) { 3310251662Sdim for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) { 3311251662Sdim unsigned Index = E - I - 1; 3312251662Sdim DeclaratorChunk &DeclChunk = D.getTypeObject(Index); 3313251662Sdim unsigned DiagId = diag::err_decltype_auto_compound_type; 3314251662Sdim unsigned DiagKind = 0; 3315251662Sdim switch (DeclChunk.Kind) { 3316251662Sdim case DeclaratorChunk::Paren: 3317251662Sdim continue; 3318251662Sdim case DeclaratorChunk::Function: { 3319251662Sdim unsigned FnIndex; 3320251662Sdim if (D.isFunctionDeclarationContext() && 3321251662Sdim D.isFunctionDeclarator(FnIndex) && FnIndex == Index) 3322251662Sdim continue; 3323251662Sdim DiagId = diag::err_decltype_auto_function_declarator_not_declaration; 3324251662Sdim break; 3325251662Sdim } 3326251662Sdim case DeclaratorChunk::Pointer: 3327251662Sdim case DeclaratorChunk::BlockPointer: 3328251662Sdim case DeclaratorChunk::MemberPointer: 3329251662Sdim DiagKind = 0; 3330251662Sdim break; 3331251662Sdim case DeclaratorChunk::Reference: 3332251662Sdim DiagKind = 1; 3333251662Sdim break; 3334251662Sdim case DeclaratorChunk::Array: 3335251662Sdim DiagKind = 2; 3336251662Sdim break; 3337296417Sdim case DeclaratorChunk::Pipe: 3338296417Sdim break; 3339251662Sdim } 3340251662Sdim 3341251662Sdim S.Diag(DeclChunk.Loc, DiagId) << DiagKind; 3342251662Sdim D.setInvalidType(true); 3343251662Sdim break; 3344251662Sdim } 3345251662Sdim } 3346251662Sdim } 3347251662Sdim 3348288943Sdim // Determine whether we should infer _Nonnull on pointer types. 3349288943Sdim Optional<NullabilityKind> inferNullability; 3350288943Sdim bool inferNullabilityCS = false; 3351288943Sdim bool inferNullabilityInnerOnly = false; 3352288943Sdim bool inferNullabilityInnerOnlyComplete = false; 3353288943Sdim 3354288943Sdim // Are we in an assume-nonnull region? 3355288943Sdim bool inAssumeNonNullRegion = false; 3356296417Sdim if (S.PP.getPragmaAssumeNonNullLoc().isValid()) { 3357288943Sdim inAssumeNonNullRegion = true; 3358288943Sdim // Determine which file we saw the assume-nonnull region in. 3359288943Sdim FileID file = getNullabilityCompletenessCheckFileID( 3360288943Sdim S, S.PP.getPragmaAssumeNonNullLoc()); 3361296417Sdim if (file.isValid()) { 3362288943Sdim FileNullability &fileNullability = S.NullabilityMap[file]; 3363288943Sdim 3364288943Sdim // If we haven't seen any type nullability before, now we have. 3365288943Sdim if (!fileNullability.SawTypeNullability) { 3366288943Sdim if (fileNullability.PointerLoc.isValid()) { 3367288943Sdim S.Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) 3368288943Sdim << static_cast<unsigned>(fileNullability.PointerKind); 3369288943Sdim } 3370288943Sdim 3371288943Sdim fileNullability.SawTypeNullability = true; 3372288943Sdim } 3373288943Sdim } 3374288943Sdim } 3375288943Sdim 3376288943Sdim // Whether to complain about missing nullability specifiers or not. 3377288943Sdim enum { 3378288943Sdim /// Never complain. 3379288943Sdim CAMN_No, 3380288943Sdim /// Complain on the inner pointers (but not the outermost 3381288943Sdim /// pointer). 3382288943Sdim CAMN_InnerPointers, 3383288943Sdim /// Complain about any pointers that don't have nullability 3384288943Sdim /// specified or inferred. 3385288943Sdim CAMN_Yes 3386288943Sdim } complainAboutMissingNullability = CAMN_No; 3387288943Sdim unsigned NumPointersRemaining = 0; 3388288943Sdim 3389288943Sdim if (IsTypedefName) { 3390288943Sdim // For typedefs, we do not infer any nullability (the default), 3391288943Sdim // and we only complain about missing nullability specifiers on 3392288943Sdim // inner pointers. 3393288943Sdim complainAboutMissingNullability = CAMN_InnerPointers; 3394288943Sdim 3395288943Sdim if (T->canHaveNullability() && !T->getNullability(S.Context)) { 3396288943Sdim ++NumPointersRemaining; 3397288943Sdim } 3398288943Sdim 3399288943Sdim for (unsigned i = 0, n = D.getNumTypeObjects(); i != n; ++i) { 3400288943Sdim DeclaratorChunk &chunk = D.getTypeObject(i); 3401288943Sdim switch (chunk.Kind) { 3402288943Sdim case DeclaratorChunk::Array: 3403288943Sdim case DeclaratorChunk::Function: 3404296417Sdim case DeclaratorChunk::Pipe: 3405288943Sdim break; 3406288943Sdim 3407288943Sdim case DeclaratorChunk::BlockPointer: 3408288943Sdim case DeclaratorChunk::MemberPointer: 3409288943Sdim ++NumPointersRemaining; 3410288943Sdim break; 3411288943Sdim 3412288943Sdim case DeclaratorChunk::Paren: 3413288943Sdim case DeclaratorChunk::Reference: 3414288943Sdim continue; 3415288943Sdim 3416288943Sdim case DeclaratorChunk::Pointer: 3417288943Sdim ++NumPointersRemaining; 3418288943Sdim continue; 3419288943Sdim } 3420288943Sdim } 3421288943Sdim } else { 3422288943Sdim bool isFunctionOrMethod = false; 3423288943Sdim switch (auto context = state.getDeclarator().getContext()) { 3424288943Sdim case Declarator::ObjCParameterContext: 3425288943Sdim case Declarator::ObjCResultContext: 3426288943Sdim case Declarator::PrototypeContext: 3427288943Sdim case Declarator::TrailingReturnContext: 3428288943Sdim isFunctionOrMethod = true; 3429288943Sdim // fallthrough 3430288943Sdim 3431288943Sdim case Declarator::MemberContext: 3432288943Sdim if (state.getDeclarator().isObjCIvar() && !isFunctionOrMethod) { 3433288943Sdim complainAboutMissingNullability = CAMN_No; 3434288943Sdim break; 3435288943Sdim } 3436296417Sdim 3437296417Sdim // Weak properties are inferred to be nullable. 3438296417Sdim if (state.getDeclarator().isObjCWeakProperty() && inAssumeNonNullRegion) { 3439296417Sdim inferNullability = NullabilityKind::Nullable; 3440296417Sdim break; 3441296417Sdim } 3442296417Sdim 3443288943Sdim // fallthrough 3444288943Sdim 3445288943Sdim case Declarator::FileContext: 3446288943Sdim case Declarator::KNRTypeListContext: 3447288943Sdim complainAboutMissingNullability = CAMN_Yes; 3448288943Sdim 3449288943Sdim // Nullability inference depends on the type and declarator. 3450288943Sdim switch (classifyPointerDeclarator(S, T, D)) { 3451288943Sdim case PointerDeclaratorKind::NonPointer: 3452288943Sdim case PointerDeclaratorKind::MultiLevelPointer: 3453288943Sdim // Cannot infer nullability. 3454288943Sdim break; 3455288943Sdim 3456288943Sdim case PointerDeclaratorKind::SingleLevelPointer: 3457288943Sdim // Infer _Nonnull if we are in an assumes-nonnull region. 3458288943Sdim if (inAssumeNonNullRegion) { 3459288943Sdim inferNullability = NullabilityKind::NonNull; 3460288943Sdim inferNullabilityCS = (context == Declarator::ObjCParameterContext || 3461288943Sdim context == Declarator::ObjCResultContext); 3462288943Sdim } 3463288943Sdim break; 3464288943Sdim 3465288943Sdim case PointerDeclaratorKind::CFErrorRefPointer: 3466288943Sdim case PointerDeclaratorKind::NSErrorPointerPointer: 3467288943Sdim // Within a function or method signature, infer _Nullable at both 3468288943Sdim // levels. 3469288943Sdim if (isFunctionOrMethod && inAssumeNonNullRegion) 3470288943Sdim inferNullability = NullabilityKind::Nullable; 3471288943Sdim break; 3472288943Sdim 3473288943Sdim case PointerDeclaratorKind::MaybePointerToCFRef: 3474288943Sdim if (isFunctionOrMethod) { 3475288943Sdim // On pointer-to-pointer parameters marked cf_returns_retained or 3476288943Sdim // cf_returns_not_retained, if the outer pointer is explicit then 3477288943Sdim // infer the inner pointer as _Nullable. 3478288943Sdim auto hasCFReturnsAttr = [](const AttributeList *NextAttr) -> bool { 3479288943Sdim while (NextAttr) { 3480288943Sdim if (NextAttr->getKind() == AttributeList::AT_CFReturnsRetained || 3481288943Sdim NextAttr->getKind() == AttributeList::AT_CFReturnsNotRetained) 3482288943Sdim return true; 3483288943Sdim NextAttr = NextAttr->getNext(); 3484288943Sdim } 3485288943Sdim return false; 3486288943Sdim }; 3487288943Sdim if (const auto *InnermostChunk = D.getInnermostNonParenChunk()) { 3488288943Sdim if (hasCFReturnsAttr(D.getAttributes()) || 3489288943Sdim hasCFReturnsAttr(InnermostChunk->getAttrs()) || 3490288943Sdim hasCFReturnsAttr(D.getDeclSpec().getAttributes().getList())) { 3491288943Sdim inferNullability = NullabilityKind::Nullable; 3492288943Sdim inferNullabilityInnerOnly = true; 3493288943Sdim } 3494288943Sdim } 3495288943Sdim } 3496288943Sdim break; 3497288943Sdim } 3498288943Sdim break; 3499288943Sdim 3500288943Sdim case Declarator::ConversionIdContext: 3501288943Sdim complainAboutMissingNullability = CAMN_Yes; 3502288943Sdim break; 3503288943Sdim 3504288943Sdim case Declarator::AliasDeclContext: 3505288943Sdim case Declarator::AliasTemplateContext: 3506288943Sdim case Declarator::BlockContext: 3507288943Sdim case Declarator::BlockLiteralContext: 3508288943Sdim case Declarator::ConditionContext: 3509288943Sdim case Declarator::CXXCatchContext: 3510288943Sdim case Declarator::CXXNewContext: 3511288943Sdim case Declarator::ForContext: 3512288943Sdim case Declarator::LambdaExprContext: 3513288943Sdim case Declarator::LambdaExprParameterContext: 3514288943Sdim case Declarator::ObjCCatchContext: 3515288943Sdim case Declarator::TemplateParamContext: 3516288943Sdim case Declarator::TemplateTypeArgContext: 3517288943Sdim case Declarator::TypeNameContext: 3518288943Sdim // Don't infer in these contexts. 3519288943Sdim break; 3520288943Sdim } 3521288943Sdim } 3522288943Sdim 3523288943Sdim // Local function that checks the nullability for a given pointer declarator. 3524288943Sdim // Returns true if _Nonnull was inferred. 3525288943Sdim auto inferPointerNullability = [&](SimplePointerKind pointerKind, 3526288943Sdim SourceLocation pointerLoc, 3527288943Sdim AttributeList *&attrs) -> AttributeList * { 3528288943Sdim // We've seen a pointer. 3529288943Sdim if (NumPointersRemaining > 0) 3530288943Sdim --NumPointersRemaining; 3531288943Sdim 3532288943Sdim // If a nullability attribute is present, there's nothing to do. 3533288943Sdim if (hasNullabilityAttr(attrs)) 3534288943Sdim return nullptr; 3535288943Sdim 3536288943Sdim // If we're supposed to infer nullability, do so now. 3537288943Sdim if (inferNullability && !inferNullabilityInnerOnlyComplete) { 3538288943Sdim AttributeList::Syntax syntax 3539288943Sdim = inferNullabilityCS ? AttributeList::AS_ContextSensitiveKeyword 3540288943Sdim : AttributeList::AS_Keyword; 3541288943Sdim AttributeList *nullabilityAttr = state.getDeclarator().getAttributePool() 3542288943Sdim .create( 3543288943Sdim S.getNullabilityKeyword( 3544288943Sdim *inferNullability), 3545288943Sdim SourceRange(pointerLoc), 3546288943Sdim nullptr, SourceLocation(), 3547288943Sdim nullptr, 0, syntax); 3548288943Sdim 3549288943Sdim spliceAttrIntoList(*nullabilityAttr, attrs); 3550288943Sdim 3551288943Sdim if (inferNullabilityCS) { 3552288943Sdim state.getDeclarator().getMutableDeclSpec().getObjCQualifiers() 3553288943Sdim ->setObjCDeclQualifier(ObjCDeclSpec::DQ_CSNullability); 3554288943Sdim } 3555288943Sdim 3556288943Sdim if (inferNullabilityInnerOnly) 3557288943Sdim inferNullabilityInnerOnlyComplete = true; 3558288943Sdim return nullabilityAttr; 3559288943Sdim } 3560288943Sdim 3561288943Sdim // If we're supposed to complain about missing nullability, do so 3562288943Sdim // now if it's truly missing. 3563288943Sdim switch (complainAboutMissingNullability) { 3564288943Sdim case CAMN_No: 3565288943Sdim break; 3566288943Sdim 3567288943Sdim case CAMN_InnerPointers: 3568288943Sdim if (NumPointersRemaining == 0) 3569288943Sdim break; 3570288943Sdim // Fallthrough. 3571288943Sdim 3572288943Sdim case CAMN_Yes: 3573288943Sdim checkNullabilityConsistency(state, pointerKind, pointerLoc); 3574288943Sdim } 3575288943Sdim return nullptr; 3576288943Sdim }; 3577288943Sdim 3578288943Sdim // If the type itself could have nullability but does not, infer pointer 3579288943Sdim // nullability and perform consistency checking. 3580288943Sdim if (T->canHaveNullability() && S.ActiveTemplateInstantiations.empty() && 3581288943Sdim !T->getNullability(S.Context)) { 3582288943Sdim SimplePointerKind pointerKind = SimplePointerKind::Pointer; 3583288943Sdim if (T->isBlockPointerType()) 3584288943Sdim pointerKind = SimplePointerKind::BlockPointer; 3585288943Sdim else if (T->isMemberPointerType()) 3586288943Sdim pointerKind = SimplePointerKind::MemberPointer; 3587288943Sdim 3588288943Sdim if (auto *attr = inferPointerNullability( 3589288943Sdim pointerKind, D.getDeclSpec().getTypeSpecTypeLoc(), 3590288943Sdim D.getMutableDeclSpec().getAttributes().getListRef())) { 3591288943Sdim T = Context.getAttributedType( 3592288943Sdim AttributedType::getNullabilityAttrKind(*inferNullability), T, T); 3593288943Sdim attr->setUsedAsTypeAttr(); 3594288943Sdim } 3595288943Sdim } 3596288943Sdim 3597193326Sed // Walk the DeclTypeInfo, building the recursive type as we go. 3598193326Sed // DeclTypeInfos are ordered from the identifier out, which is 3599193326Sed // opposite of what we want :). 3600198893Srdivacky for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 3601218893Sdim unsigned chunkIndex = e - i - 1; 3602218893Sdim state.setCurrentChunkIndex(chunkIndex); 3603218893Sdim DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex); 3604276479Sdim IsQualifiedFunction &= DeclType.Kind == DeclaratorChunk::Paren; 3605193326Sed switch (DeclType.Kind) { 3606218893Sdim case DeclaratorChunk::Paren: 3607224145Sdim T = S.BuildParenType(T); 3608218893Sdim break; 3609193326Sed case DeclaratorChunk::BlockPointer: 3610193326Sed // If blocks are disabled, emit an error. 3611193326Sed if (!LangOpts.Blocks) 3612224145Sdim S.Diag(DeclType.Loc, diag::err_blocks_disable); 3613198092Srdivacky 3614288943Sdim // Handle pointer nullability. 3615288943Sdim inferPointerNullability(SimplePointerKind::BlockPointer, 3616288943Sdim DeclType.Loc, DeclType.getAttrListRef()); 3617288943Sdim 3618224145Sdim T = S.BuildBlockPointerType(T, D.getIdentifierLoc(), Name); 3619210299Sed if (DeclType.Cls.TypeQuals) 3620224145Sdim T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals); 3621193326Sed break; 3622193326Sed case DeclaratorChunk::Pointer: 3623193326Sed // Verify that we're not building a pointer to pointer to function with 3624193326Sed // exception specification. 3625224145Sdim if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3626224145Sdim S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3627193326Sed D.setInvalidType(true); 3628193326Sed // Build the type anyway. 3629193326Sed } 3630288943Sdim 3631288943Sdim // Handle pointer nullability 3632288943Sdim inferPointerNullability(SimplePointerKind::Pointer, DeclType.Loc, 3633288943Sdim DeclType.getAttrListRef()); 3634288943Sdim 3635224145Sdim if (LangOpts.ObjC1 && T->getAs<ObjCObjectType>()) { 3636208600Srdivacky T = Context.getObjCObjectPointerType(T); 3637210299Sed if (DeclType.Ptr.TypeQuals) 3638224145Sdim T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals); 3639198092Srdivacky break; 3640198092Srdivacky } 3641224145Sdim T = S.BuildPointerType(T, DeclType.Loc, Name); 3642210299Sed if (DeclType.Ptr.TypeQuals) 3643224145Sdim T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals); 3644218893Sdim 3645193326Sed break; 3646198092Srdivacky case DeclaratorChunk::Reference: { 3647193326Sed // Verify that we're not building a reference to pointer to function with 3648193326Sed // exception specification. 3649224145Sdim if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3650224145Sdim S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3651193326Sed D.setInvalidType(true); 3652193326Sed // Build the type anyway. 3653193326Sed } 3654224145Sdim T = S.BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name); 3655210299Sed 3656210299Sed if (DeclType.Ref.HasRestrict) 3657224145Sdim T = S.BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict); 3658193326Sed break; 3659198092Srdivacky } 3660193326Sed case DeclaratorChunk::Array: { 3661193326Sed // Verify that we're not building an array of pointers to function with 3662193326Sed // exception specification. 3663224145Sdim if (LangOpts.CPlusPlus && S.CheckDistantExceptionSpec(T)) { 3664224145Sdim S.Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 3665193326Sed D.setInvalidType(true); 3666193326Sed // Build the type anyway. 3667193326Sed } 3668193326Sed DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr; 3669193326Sed Expr *ArraySize = static_cast<Expr*>(ATI.NumElts); 3670193326Sed ArrayType::ArraySizeModifier ASM; 3671193326Sed if (ATI.isStar) 3672193326Sed ASM = ArrayType::Star; 3673193326Sed else if (ATI.hasStatic) 3674193326Sed ASM = ArrayType::Static; 3675193326Sed else 3676193326Sed ASM = ArrayType::Normal; 3677221345Sdim if (ASM == ArrayType::Star && !D.isPrototypeContext()) { 3678193326Sed // FIXME: This check isn't quite right: it allows star in prototypes 3679193326Sed // for function definitions, and disallows some edge cases detailed 3680193326Sed // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html 3681224145Sdim S.Diag(DeclType.Loc, diag::err_array_star_outside_prototype); 3682193326Sed ASM = ArrayType::Normal; 3683193326Sed D.setInvalidType(true); 3684193326Sed } 3685239462Sdim 3686239462Sdim // C99 6.7.5.2p1: The optional type qualifiers and the keyword static 3687239462Sdim // shall appear only in a declaration of a function parameter with an 3688239462Sdim // array type, ... 3689239462Sdim if (ASM == ArrayType::Static || ATI.TypeQuals) { 3690239462Sdim if (!(D.isPrototypeContext() || 3691239462Sdim D.getContext() == Declarator::KNRTypeListContext)) { 3692239462Sdim S.Diag(DeclType.Loc, diag::err_array_static_outside_prototype) << 3693239462Sdim (ASM == ArrayType::Static ? "'static'" : "type qualifier"); 3694239462Sdim // Remove the 'static' and the type qualifiers. 3695239462Sdim if (ASM == ArrayType::Static) 3696239462Sdim ASM = ArrayType::Normal; 3697239462Sdim ATI.TypeQuals = 0; 3698239462Sdim D.setInvalidType(true); 3699239462Sdim } 3700239462Sdim 3701239462Sdim // C99 6.7.5.2p1: ... and then only in the outermost array type 3702239462Sdim // derivation. 3703239462Sdim unsigned x = chunkIndex; 3704239462Sdim while (x != 0) { 3705239462Sdim // Walk outwards along the declarator chunks. 3706239462Sdim x--; 3707239462Sdim const DeclaratorChunk &DC = D.getTypeObject(x); 3708239462Sdim switch (DC.Kind) { 3709239462Sdim case DeclaratorChunk::Paren: 3710239462Sdim continue; 3711239462Sdim case DeclaratorChunk::Array: 3712239462Sdim case DeclaratorChunk::Pointer: 3713239462Sdim case DeclaratorChunk::Reference: 3714239462Sdim case DeclaratorChunk::MemberPointer: 3715239462Sdim S.Diag(DeclType.Loc, diag::err_array_static_not_outermost) << 3716239462Sdim (ASM == ArrayType::Static ? "'static'" : "type qualifier"); 3717239462Sdim if (ASM == ArrayType::Static) 3718239462Sdim ASM = ArrayType::Normal; 3719239462Sdim ATI.TypeQuals = 0; 3720239462Sdim D.setInvalidType(true); 3721239462Sdim break; 3722239462Sdim case DeclaratorChunk::Function: 3723239462Sdim case DeclaratorChunk::BlockPointer: 3724296417Sdim case DeclaratorChunk::Pipe: 3725239462Sdim // These are invalid anyway, so just ignore. 3726239462Sdim break; 3727239462Sdim } 3728239462Sdim } 3729239462Sdim } 3730261991Sdim const AutoType *AT = T->getContainedAutoType(); 3731261991Sdim // Allow arrays of auto if we are a generic lambda parameter. 3732261991Sdim // i.e. [](auto (&array)[5]) { return array[0]; }; OK 3733261991Sdim if (AT && D.getContext() != Declarator::LambdaExprParameterContext) { 3734251662Sdim // We've already diagnosed this for decltype(auto). 3735251662Sdim if (!AT->isDecltypeAuto()) 3736251662Sdim S.Diag(DeclType.Loc, diag::err_illegal_decl_array_of_auto) 3737251662Sdim << getPrintableNameForEntity(Name) << T; 3738251662Sdim T = QualType(); 3739251662Sdim break; 3740251662Sdim } 3741251662Sdim 3742234353Sdim T = S.BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals, 3743224145Sdim SourceRange(DeclType.Loc, DeclType.EndLoc), Name); 3744193326Sed break; 3745193326Sed } 3746193326Sed case DeclaratorChunk::Function: { 3747193326Sed // If the function declarator has a prototype (i.e. it is not () and 3748193326Sed // does not have a K&R-style identifier list), then the arguments are part 3749193326Sed // of the type, otherwise the argument list is (). 3750193326Sed const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 3751234353Sdim IsQualifiedFunction = FTI.TypeQuals || FTI.hasRefQualifier(); 3752193326Sed 3753218893Sdim // Check for auto functions and trailing return type and adjust the 3754218893Sdim // return type accordingly. 3755218893Sdim if (!D.isInvalidType()) { 3756218893Sdim // trailing-return-type is only required if we're declaring a function, 3757218893Sdim // and not, for instance, a pointer to a function. 3758276479Sdim if (D.getDeclSpec().containsPlaceholderType() && 3759251662Sdim !FTI.hasTrailingReturnType() && chunkIndex == 0 && 3760280031Sdim !S.getLangOpts().CPlusPlus14) { 3761224145Sdim S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 3762276479Sdim D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto 3763276479Sdim ? diag::err_auto_missing_trailing_return 3764276479Sdim : diag::err_deduced_return_type); 3765218893Sdim T = Context.IntTy; 3766218893Sdim D.setInvalidType(true); 3767239462Sdim } else if (FTI.hasTrailingReturnType()) { 3768219077Sdim // T must be exactly 'auto' at this point. See CWG issue 681. 3769219077Sdim if (isa<ParenType>(T)) { 3770224145Sdim S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 3771219077Sdim diag::err_trailing_return_in_parens) 3772219077Sdim << T << D.getDeclSpec().getSourceRange(); 3773219077Sdim D.setInvalidType(true); 3774234353Sdim } else if (D.getContext() != Declarator::LambdaExprContext && 3775251662Sdim (T.hasQualifiers() || !isa<AutoType>(T) || 3776296417Sdim cast<AutoType>(T)->getKeyword() != AutoTypeKeyword::Auto)) { 3777224145Sdim S.Diag(D.getDeclSpec().getTypeSpecTypeLoc(), 3778218893Sdim diag::err_trailing_return_without_auto) 3779218893Sdim << T << D.getDeclSpec().getSourceRange(); 3780218893Sdim D.setInvalidType(true); 3781218893Sdim } 3782239462Sdim T = S.GetTypeFromParser(FTI.getTrailingReturnType(), &TInfo); 3783239462Sdim if (T.isNull()) { 3784239462Sdim // An error occurred parsing the trailing return type. 3785239462Sdim T = Context.IntTy; 3786239462Sdim D.setInvalidType(true); 3787239462Sdim } 3788218893Sdim } 3789218893Sdim } 3790218893Sdim 3791219077Sdim // C99 6.7.5.3p1: The return type may not be a function or array type. 3792219077Sdim // For conversion functions, we'll diagnose this particular error later. 3793219077Sdim if ((T->isArrayType() || T->isFunctionType()) && 3794219077Sdim (D.getName().getKind() != UnqualifiedId::IK_ConversionFunctionId)) { 3795219077Sdim unsigned diagID = diag::err_func_returning_array_function; 3796219077Sdim // Last processing chunk in block context means this function chunk 3797219077Sdim // represents the block. 3798219077Sdim if (chunkIndex == 0 && 3799219077Sdim D.getContext() == Declarator::BlockLiteralContext) 3800219077Sdim diagID = diag::err_block_returning_array_function; 3801224145Sdim S.Diag(DeclType.Loc, diagID) << T->isFunctionType() << T; 3802219077Sdim T = Context.IntTy; 3803219077Sdim D.setInvalidType(true); 3804219077Sdim } 3805219077Sdim 3806226633Sdim // Do not allow returning half FP value. 3807226633Sdim // FIXME: This really should be in BuildFunctionType. 3808226633Sdim if (T->isHalfType()) { 3809249423Sdim if (S.getLangOpts().OpenCL) { 3810249423Sdim if (!S.getOpenCLOptions().cl_khr_fp16) { 3811249423Sdim S.Diag(D.getIdentifierLoc(), diag::err_opencl_half_return) << T; 3812249423Sdim D.setInvalidType(true); 3813249423Sdim } 3814280031Sdim } else if (!S.getLangOpts().HalfArgsAndReturns) { 3815249423Sdim S.Diag(D.getIdentifierLoc(), 3816249423Sdim diag::err_parameters_retval_cannot_have_fp16_type) << 1; 3817249423Sdim D.setInvalidType(true); 3818249423Sdim } 3819226633Sdim } 3820226633Sdim 3821261991Sdim // Methods cannot return interface types. All ObjC objects are 3822261991Sdim // passed by reference. 3823261991Sdim if (T->isObjCObjectType()) { 3824261991Sdim SourceLocation DiagLoc, FixitLoc; 3825261991Sdim if (TInfo) { 3826261991Sdim DiagLoc = TInfo->getTypeLoc().getLocStart(); 3827276479Sdim FixitLoc = S.getLocForEndOfToken(TInfo->getTypeLoc().getLocEnd()); 3828261991Sdim } else { 3829261991Sdim DiagLoc = D.getDeclSpec().getTypeSpecTypeLoc(); 3830276479Sdim FixitLoc = S.getLocForEndOfToken(D.getDeclSpec().getLocEnd()); 3831261991Sdim } 3832261991Sdim S.Diag(DiagLoc, diag::err_object_cannot_be_passed_returned_by_value) 3833261991Sdim << 0 << T 3834261991Sdim << FixItHint::CreateInsertion(FixitLoc, "*"); 3835261991Sdim 3836261991Sdim T = Context.getObjCObjectPointerType(T); 3837261991Sdim if (TInfo) { 3838261991Sdim TypeLocBuilder TLB; 3839261991Sdim TLB.pushFullCopy(TInfo->getTypeLoc()); 3840261991Sdim ObjCObjectPointerTypeLoc TLoc = TLB.push<ObjCObjectPointerTypeLoc>(T); 3841261991Sdim TLoc.setStarLoc(FixitLoc); 3842261991Sdim TInfo = TLB.getTypeSourceInfo(Context, T); 3843261991Sdim } 3844261991Sdim 3845261991Sdim D.setInvalidType(true); 3846261991Sdim } 3847261991Sdim 3848210299Sed // cv-qualifiers on return types are pointless except when the type is a 3849210299Sed // class type in C++. 3850249423Sdim if ((T.getCVRQualifiers() || T->isAtomicType()) && 3851249423Sdim !(S.getLangOpts().CPlusPlus && 3852288943Sdim (T->isDependentType() || T->isRecordType()))) { 3853288943Sdim if (T->isVoidType() && !S.getLangOpts().CPlusPlus && 3854288943Sdim D.getFunctionDefinitionKind() == FDK_Definition) { 3855288943Sdim // [6.9.1/3] qualified void return is invalid on a C 3856288943Sdim // function definition. Apparently ok on declarations and 3857288943Sdim // in C++ though (!) 3858288943Sdim S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T; 3859288943Sdim } else 3860288943Sdim diagnoseRedundantReturnTypeQualifiers(S, T, D, chunkIndex); 3861288943Sdim } 3862219077Sdim 3863249423Sdim // Objective-C ARC ownership qualifiers are ignored on the function 3864249423Sdim // return type (by type canonicalization). Complain if this attribute 3865249423Sdim // was written here. 3866249423Sdim if (T.getQualifiers().hasObjCLifetime()) { 3867249423Sdim SourceLocation AttrLoc; 3868249423Sdim if (chunkIndex + 1 < D.getNumTypeObjects()) { 3869249423Sdim DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1); 3870249423Sdim for (const AttributeList *Attr = ReturnTypeChunk.getAttrs(); 3871249423Sdim Attr; Attr = Attr->getNext()) { 3872249423Sdim if (Attr->getKind() == AttributeList::AT_ObjCOwnership) { 3873249423Sdim AttrLoc = Attr->getLoc(); 3874249423Sdim break; 3875249423Sdim } 3876249423Sdim } 3877249423Sdim } 3878249423Sdim if (AttrLoc.isInvalid()) { 3879249423Sdim for (const AttributeList *Attr 3880249423Sdim = D.getDeclSpec().getAttributes().getList(); 3881249423Sdim Attr; Attr = Attr->getNext()) { 3882249423Sdim if (Attr->getKind() == AttributeList::AT_ObjCOwnership) { 3883249423Sdim AttrLoc = Attr->getLoc(); 3884249423Sdim break; 3885249423Sdim } 3886249423Sdim } 3887249423Sdim } 3888219077Sdim 3889249423Sdim if (AttrLoc.isValid()) { 3890249423Sdim // The ownership attributes are almost always written via 3891249423Sdim // the predefined 3892249423Sdim // __strong/__weak/__autoreleasing/__unsafe_unretained. 3893249423Sdim if (AttrLoc.isMacroID()) 3894249423Sdim AttrLoc = S.SourceMgr.getImmediateExpansionRange(AttrLoc).first; 3895219077Sdim 3896249423Sdim S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type) 3897249423Sdim << T.getQualifiers().getObjCLifetime(); 3898249423Sdim } 3899210299Sed } 3900219077Sdim 3901261991Sdim if (LangOpts.CPlusPlus && D.getDeclSpec().hasTagDefinition()) { 3902193326Sed // C++ [dcl.fct]p6: 3903193326Sed // Types shall not be defined in return or parameter types. 3904212904Sdim TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl()); 3905261991Sdim S.Diag(Tag->getLocation(), diag::err_type_defined_in_result_type) 3906261991Sdim << Context.getTypeDeclType(Tag); 3907193326Sed } 3908193326Sed 3909193326Sed // Exception specs are not allowed in typedefs. Complain, but add it 3910193326Sed // anyway. 3911221345Sdim if (IsTypedefName && FTI.getExceptionSpecType()) 3912296417Sdim S.Diag(FTI.getExceptionSpecLocBeg(), 3913296417Sdim diag::err_exception_spec_in_typedef) 3914296417Sdim << (D.getContext() == Declarator::AliasDeclContext || 3915296417Sdim D.getContext() == Declarator::AliasTemplateContext); 3916193326Sed 3917239462Sdim // If we see "T var();" or "T var(T());" at block scope, it is probably 3918239462Sdim // an attempt to initialize a variable, not a function declaration. 3919239462Sdim if (FTI.isAmbiguous) 3920239462Sdim warnAboutAmbiguousFunction(S, D, DeclType, T); 3921239462Sdim 3922261991Sdim FunctionType::ExtInfo EI(getCCForDeclaratorChunk(S, D, FTI, chunkIndex)); 3923261991Sdim 3924276479Sdim if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.CPlusPlus) { 3925210299Sed // Simple void foo(), where the incoming T is the result type. 3926261991Sdim T = Context.getFunctionNoProtoType(T, EI); 3927210299Sed } else { 3928210299Sed // We allow a zero-parameter variadic function in C if the 3929210299Sed // function is marked with the "overloadable" attribute. Scan 3930210299Sed // for this attribute now. 3931276479Sdim if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus) { 3932193326Sed bool Overloadable = false; 3933193326Sed for (const AttributeList *Attrs = D.getAttributes(); 3934193326Sed Attrs; Attrs = Attrs->getNext()) { 3935239462Sdim if (Attrs->getKind() == AttributeList::AT_Overloadable) { 3936193326Sed Overloadable = true; 3937193326Sed break; 3938193326Sed } 3939193326Sed } 3940193326Sed 3941193326Sed if (!Overloadable) 3942276479Sdim S.Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_param); 3943193326Sed } 3944210299Sed 3945276479Sdim if (FTI.NumParams && FTI.Params[0].Param == nullptr) { 3946210299Sed // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function 3947210299Sed // definition. 3948276479Sdim S.Diag(FTI.Params[0].IdentLoc, 3949276479Sdim diag::err_ident_list_in_fn_declaration); 3950210299Sed D.setInvalidType(true); 3951249423Sdim // Recover by creating a K&R-style function type. 3952261991Sdim T = Context.getFunctionNoProtoType(T, EI); 3953210299Sed break; 3954210299Sed } 3955210299Sed 3956218893Sdim FunctionProtoType::ExtProtoInfo EPI; 3957261991Sdim EPI.ExtInfo = EI; 3958218893Sdim EPI.Variadic = FTI.isVariadic; 3959239462Sdim EPI.HasTrailingReturn = FTI.hasTrailingReturnType(); 3960218893Sdim EPI.TypeQuals = FTI.TypeQuals; 3961218893Sdim EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None 3962218893Sdim : FTI.RefQualifierIsLValueRef? RQ_LValue 3963218893Sdim : RQ_RValue; 3964239462Sdim 3965276479Sdim // Otherwise, we have a function with a parameter list that is 3966193326Sed // potentially variadic. 3967276479Sdim SmallVector<QualType, 16> ParamTys; 3968276479Sdim ParamTys.reserve(FTI.NumParams); 3969198092Srdivacky 3970276479Sdim SmallVector<bool, 16> ConsumedParameters; 3971276479Sdim ConsumedParameters.reserve(FTI.NumParams); 3972276479Sdim bool HasAnyConsumedParameters = false; 3973224145Sdim 3974276479Sdim for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) { 3975276479Sdim ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 3976276479Sdim QualType ParamTy = Param->getType(); 3977276479Sdim assert(!ParamTy.isNull() && "Couldn't parse type?"); 3978193326Sed 3979276479Sdim // Look for 'void'. void is allowed only as a single parameter to a 3980193326Sed // function with no other parameters (C99 6.7.5.3p10). We record 3981276479Sdim // int(void) as a FunctionProtoType with an empty parameter list. 3982276479Sdim if (ParamTy->isVoidType()) { 3983193326Sed // If this is something like 'float(int, void)', reject it. 'void' 3984193326Sed // is an incomplete type (C99 6.2.5p19) and function decls cannot 3985276479Sdim // have parameters of incomplete type. 3986276479Sdim if (FTI.NumParams != 1 || FTI.isVariadic) { 3987224145Sdim S.Diag(DeclType.Loc, diag::err_void_only_param); 3988276479Sdim ParamTy = Context.IntTy; 3989276479Sdim Param->setType(ParamTy); 3990276479Sdim } else if (FTI.Params[i].Ident) { 3991193326Sed // Reject, but continue to parse 'int(void abc)'. 3992276479Sdim S.Diag(FTI.Params[i].IdentLoc, diag::err_param_with_void_type); 3993276479Sdim ParamTy = Context.IntTy; 3994276479Sdim Param->setType(ParamTy); 3995193326Sed } else { 3996193326Sed // Reject, but continue to parse 'float(const void)'. 3997276479Sdim if (ParamTy.hasQualifiers()) 3998224145Sdim S.Diag(DeclType.Loc, diag::err_void_param_qualified); 3999198092Srdivacky 4000276479Sdim // Do not add 'void' to the list. 4001193326Sed break; 4002193326Sed } 4003276479Sdim } else if (ParamTy->isHalfType()) { 4004276479Sdim // Disallow half FP parameters. 4005226633Sdim // FIXME: This really should be in BuildFunctionType. 4006249423Sdim if (S.getLangOpts().OpenCL) { 4007249423Sdim if (!S.getOpenCLOptions().cl_khr_fp16) { 4008249423Sdim S.Diag(Param->getLocation(), 4009276479Sdim diag::err_opencl_half_param) << ParamTy; 4010249423Sdim D.setInvalidType(); 4011249423Sdim Param->setInvalidDecl(); 4012249423Sdim } 4013280031Sdim } else if (!S.getLangOpts().HalfArgsAndReturns) { 4014249423Sdim S.Diag(Param->getLocation(), 4015249423Sdim diag::err_parameters_retval_cannot_have_fp16_type) << 0; 4016249423Sdim D.setInvalidType(); 4017249423Sdim } 4018193326Sed } else if (!FTI.hasPrototype) { 4019276479Sdim if (ParamTy->isPromotableIntegerType()) { 4020276479Sdim ParamTy = Context.getPromotedIntegerType(ParamTy); 4021221345Sdim Param->setKNRPromoted(true); 4022276479Sdim } else if (const BuiltinType* BTy = ParamTy->getAs<BuiltinType>()) { 4023221345Sdim if (BTy->getKind() == BuiltinType::Float) { 4024276479Sdim ParamTy = Context.DoubleTy; 4025221345Sdim Param->setKNRPromoted(true); 4026221345Sdim } 4027193326Sed } 4028193326Sed } 4029198092Srdivacky 4030224145Sdim if (LangOpts.ObjCAutoRefCount) { 4031224145Sdim bool Consumed = Param->hasAttr<NSConsumedAttr>(); 4032276479Sdim ConsumedParameters.push_back(Consumed); 4033276479Sdim HasAnyConsumedParameters |= Consumed; 4034224145Sdim } 4035224145Sdim 4036276479Sdim ParamTys.push_back(ParamTy); 4037193326Sed } 4038193326Sed 4039276479Sdim if (HasAnyConsumedParameters) 4040276479Sdim EPI.ConsumedParameters = ConsumedParameters.data(); 4041224145Sdim 4042226633Sdim SmallVector<QualType, 4> Exceptions; 4043234982Sdim SmallVector<ParsedType, 2> DynamicExceptions; 4044234982Sdim SmallVector<SourceRange, 2> DynamicExceptionRanges; 4045276479Sdim Expr *NoexceptExpr = nullptr; 4046239462Sdim 4047221345Sdim if (FTI.getExceptionSpecType() == EST_Dynamic) { 4048234982Sdim // FIXME: It's rather inefficient to have to split into two vectors 4049234982Sdim // here. 4050234982Sdim unsigned N = FTI.NumExceptions; 4051234982Sdim DynamicExceptions.reserve(N); 4052234982Sdim DynamicExceptionRanges.reserve(N); 4053234982Sdim for (unsigned I = 0; I != N; ++I) { 4054234982Sdim DynamicExceptions.push_back(FTI.Exceptions[I].Ty); 4055234982Sdim DynamicExceptionRanges.push_back(FTI.Exceptions[I].Range); 4056218893Sdim } 4057221345Sdim } else if (FTI.getExceptionSpecType() == EST_ComputedNoexcept) { 4058234982Sdim NoexceptExpr = FTI.NoexceptExpr; 4059234982Sdim } 4060239462Sdim 4061280031Sdim S.checkExceptionSpecification(D.isFunctionDeclarationContext(), 4062280031Sdim FTI.getExceptionSpecType(), 4063234982Sdim DynamicExceptions, 4064234982Sdim DynamicExceptionRanges, 4065234982Sdim NoexceptExpr, 4066234982Sdim Exceptions, 4067280031Sdim EPI.ExceptionSpec); 4068239462Sdim 4069276479Sdim T = Context.getFunctionType(T, ParamTys, EPI); 4070193326Sed } 4071203955Srdivacky 4072193326Sed break; 4073193326Sed } 4074296417Sdim case DeclaratorChunk::MemberPointer: { 4075193326Sed // The scope spec must refer to a class, or be dependent. 4076212904Sdim CXXScopeSpec &SS = DeclType.Mem.Scope(); 4077193326Sed QualType ClsType; 4078288943Sdim 4079288943Sdim // Handle pointer nullability. 4080288943Sdim inferPointerNullability(SimplePointerKind::MemberPointer, 4081288943Sdim DeclType.Loc, DeclType.getAttrListRef()); 4082288943Sdim 4083212904Sdim if (SS.isInvalid()) { 4084207619Srdivacky // Avoid emitting extra errors if we already errored on the scope. 4085207619Srdivacky D.setInvalidType(true); 4086224145Sdim } else if (S.isDependentScopeSpecifier(SS) || 4087224145Sdim dyn_cast_or_null<CXXRecordDecl>(S.computeDeclContext(SS))) { 4088276479Sdim NestedNameSpecifier *NNS = SS.getScopeRep(); 4089198954Srdivacky NestedNameSpecifier *NNSPrefix = NNS->getPrefix(); 4090198954Srdivacky switch (NNS->getKind()) { 4091198954Srdivacky case NestedNameSpecifier::Identifier: 4092212904Sdim ClsType = Context.getDependentNameType(ETK_None, NNSPrefix, 4093206084Srdivacky NNS->getAsIdentifier()); 4094198954Srdivacky break; 4095198954Srdivacky 4096198954Srdivacky case NestedNameSpecifier::Namespace: 4097219077Sdim case NestedNameSpecifier::NamespaceAlias: 4098198954Srdivacky case NestedNameSpecifier::Global: 4099280031Sdim case NestedNameSpecifier::Super: 4100200583Srdivacky llvm_unreachable("Nested-name-specifier must name a type"); 4101212904Sdim 4102198954Srdivacky case NestedNameSpecifier::TypeSpec: 4103198954Srdivacky case NestedNameSpecifier::TypeSpecWithTemplate: 4104198954Srdivacky ClsType = QualType(NNS->getAsType(), 0); 4105221345Sdim // Note: if the NNS has a prefix and ClsType is a nondependent 4106221345Sdim // TemplateSpecializationType, then the NNS prefix is NOT included 4107221345Sdim // in ClsType; hence we wrap ClsType into an ElaboratedType. 4108221345Sdim // NOTE: in particular, no wrap occurs if ClsType already is an 4109221345Sdim // Elaborated, DependentName, or DependentTemplateSpecialization. 4110221345Sdim if (NNSPrefix && isa<TemplateSpecializationType>(NNS->getAsType())) 4111208600Srdivacky ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType); 4112198954Srdivacky break; 4113198954Srdivacky } 4114193326Sed } else { 4115224145Sdim S.Diag(DeclType.Mem.Scope().getBeginLoc(), 4116194179Sed diag::err_illegal_decl_mempointer_in_nonclass) 4117194179Sed << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name") 4118194179Sed << DeclType.Mem.Scope().getRange(); 4119193326Sed D.setInvalidType(true); 4120193326Sed } 4121193326Sed 4122194179Sed if (!ClsType.isNull()) 4123280031Sdim T = S.BuildMemberPointerType(T, ClsType, DeclType.Loc, 4124280031Sdim D.getIdentifier()); 4125194179Sed if (T.isNull()) { 4126194179Sed T = Context.IntTy; 4127193326Sed D.setInvalidType(true); 4128210299Sed } else if (DeclType.Mem.TypeQuals) { 4129224145Sdim T = S.BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals); 4130193326Sed } 4131193326Sed break; 4132193326Sed } 4133193326Sed 4134296417Sdim case DeclaratorChunk::Pipe: { 4135296417Sdim T = S.BuildPipeType(T, DeclType.Loc ); 4136296417Sdim break; 4137296417Sdim } 4138296417Sdim } 4139296417Sdim 4140193326Sed if (T.isNull()) { 4141193326Sed D.setInvalidType(true); 4142193326Sed T = Context.IntTy; 4143193326Sed } 4144193326Sed 4145193326Sed // See if there are any attributes on this declarator chunk. 4146296417Sdim processTypeAttrs(state, T, TAL_DeclChunk, 4147296417Sdim const_cast<AttributeList *>(DeclType.getAttrs())); 4148193326Sed } 4149193326Sed 4150280031Sdim assert(!T.isNull() && "T must not be null after this point"); 4151280031Sdim 4152224145Sdim if (LangOpts.CPlusPlus && T->isFunctionType()) { 4153198092Srdivacky const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>(); 4154198893Srdivacky assert(FnTy && "Why oh why is there not a FunctionProtoType here?"); 4155193326Sed 4156239462Sdim // C++ 8.3.5p4: 4157218893Sdim // A cv-qualifier-seq shall only be part of the function type 4158218893Sdim // for a nonstatic member function, the function type to which a pointer 4159218893Sdim // to member refers, or the top-level function type of a function typedef 4160218893Sdim // declaration. 4161218893Sdim // 4162218893Sdim // Core issue 547 also allows cv-qualifiers on function types that are 4163218893Sdim // top-level template type arguments. 4164218893Sdim bool FreeFunction; 4165218893Sdim if (!D.getCXXScopeSpec().isSet()) { 4166234353Sdim FreeFunction = ((D.getContext() != Declarator::MemberContext && 4167234353Sdim D.getContext() != Declarator::LambdaExprContext) || 4168218893Sdim D.getDeclSpec().isFriendSpecified()); 4169218893Sdim } else { 4170224145Sdim DeclContext *DC = S.computeDeclContext(D.getCXXScopeSpec()); 4171218893Sdim FreeFunction = (DC && !DC->isRecord()); 4172218893Sdim } 4173218893Sdim 4174234353Sdim // C++11 [dcl.fct]p6 (w/DR1417): 4175234353Sdim // An attempt to specify a function type with a cv-qualifier-seq or a 4176234353Sdim // ref-qualifier (including by typedef-name) is ill-formed unless it is: 4177234353Sdim // - the function type for a non-static member function, 4178234353Sdim // - the function type to which a pointer to member refers, 4179234353Sdim // - the top-level function type of a function typedef declaration or 4180234353Sdim // alias-declaration, 4181234353Sdim // - the type-id in the default argument of a type-parameter, or 4182234353Sdim // - the type-id of a template-argument for a type-parameter 4183276479Sdim // 4184276479Sdim // FIXME: Checking this here is insufficient. We accept-invalid on: 4185276479Sdim // 4186276479Sdim // template<typename T> struct S { void f(T); }; 4187276479Sdim // S<int() const> s; 4188276479Sdim // 4189276479Sdim // ... for instance. 4190234353Sdim if (IsQualifiedFunction && 4191234353Sdim !(!FreeFunction && 4192234353Sdim D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static) && 4193234353Sdim !IsTypedefName && 4194234353Sdim D.getContext() != Declarator::TemplateTypeArgContext) { 4195234353Sdim SourceLocation Loc = D.getLocStart(); 4196234353Sdim SourceRange RemovalRange; 4197234353Sdim unsigned I; 4198234353Sdim if (D.isFunctionDeclarator(I)) { 4199234353Sdim SmallVector<SourceLocation, 4> RemovalLocs; 4200234353Sdim const DeclaratorChunk &Chunk = D.getTypeObject(I); 4201234353Sdim assert(Chunk.Kind == DeclaratorChunk::Function); 4202234353Sdim if (Chunk.Fun.hasRefQualifier()) 4203234353Sdim RemovalLocs.push_back(Chunk.Fun.getRefQualifierLoc()); 4204234353Sdim if (Chunk.Fun.TypeQuals & Qualifiers::Const) 4205234353Sdim RemovalLocs.push_back(Chunk.Fun.getConstQualifierLoc()); 4206234353Sdim if (Chunk.Fun.TypeQuals & Qualifiers::Volatile) 4207234353Sdim RemovalLocs.push_back(Chunk.Fun.getVolatileQualifierLoc()); 4208280031Sdim if (Chunk.Fun.TypeQuals & Qualifiers::Restrict) 4209280031Sdim RemovalLocs.push_back(Chunk.Fun.getRestrictQualifierLoc()); 4210234353Sdim if (!RemovalLocs.empty()) { 4211234353Sdim std::sort(RemovalLocs.begin(), RemovalLocs.end(), 4212239462Sdim BeforeThanCompare<SourceLocation>(S.getSourceManager())); 4213234353Sdim RemovalRange = SourceRange(RemovalLocs.front(), RemovalLocs.back()); 4214234353Sdim Loc = RemovalLocs.front(); 4215218893Sdim } 4216234353Sdim } 4217193326Sed 4218234353Sdim S.Diag(Loc, diag::err_invalid_qualified_function_type) 4219234353Sdim << FreeFunction << D.isFunctionDeclarator() << T 4220234353Sdim << getFunctionQualifiersAsString(FnTy) 4221234353Sdim << FixItHint::CreateRemoval(RemovalRange); 4222234353Sdim 4223234353Sdim // Strip the cv-qualifiers and ref-qualifiers from the type. 4224234353Sdim FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo(); 4225234353Sdim EPI.TypeQuals = 0; 4226234353Sdim EPI.RefQualifier = RQ_None; 4227234353Sdim 4228276479Sdim T = Context.getFunctionType(FnTy->getReturnType(), FnTy->getParamTypes(), 4229249423Sdim EPI); 4230243830Sdim // Rebuild any parens around the identifier in the function type. 4231243830Sdim for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 4232243830Sdim if (D.getTypeObject(i).Kind != DeclaratorChunk::Paren) 4233243830Sdim break; 4234243830Sdim T = S.BuildParenType(T); 4235243830Sdim } 4236193326Sed } 4237193326Sed } 4238198092Srdivacky 4239218893Sdim // Apply any undistributed attributes from the declarator. 4240296417Sdim processTypeAttrs(state, T, TAL_DeclName, D.getAttributes()); 4241218893Sdim 4242218893Sdim // Diagnose any ignored type attributes. 4243280031Sdim state.diagnoseIgnoredTypeAttrs(T); 4244218893Sdim 4245221345Sdim // C++0x [dcl.constexpr]p9: 4246221345Sdim // A constexpr specifier used in an object declaration declares the object 4247239462Sdim // as const. 4248221345Sdim if (D.getDeclSpec().isConstexprSpecified() && T->isObjectType()) { 4249210299Sed T.addConst(); 4250210299Sed } 4251210299Sed 4252239462Sdim // If there was an ellipsis in the declarator, the declaration declares a 4253218893Sdim // parameter pack whose type may be a pack expansion type. 4254280031Sdim if (D.hasEllipsis()) { 4255218893Sdim // C++0x [dcl.fct]p13: 4256239462Sdim // A declarator-id or abstract-declarator containing an ellipsis shall 4257218893Sdim // only be used in a parameter-declaration. Such a parameter-declaration 4258218893Sdim // is a parameter pack (14.5.3). [...] 4259218893Sdim switch (D.getContext()) { 4260218893Sdim case Declarator::PrototypeContext: 4261261991Sdim case Declarator::LambdaExprParameterContext: 4262218893Sdim // C++0x [dcl.fct]p13: 4263239462Sdim // [...] When it is part of a parameter-declaration-clause, the 4264239462Sdim // parameter pack is a function parameter pack (14.5.3). The type T 4265218893Sdim // of the declarator-id of the function parameter pack shall contain 4266239462Sdim // a template parameter pack; each template parameter pack in T is 4267218893Sdim // expanded by the function parameter pack. 4268218893Sdim // 4269218893Sdim // We represent function parameter packs as function parameters whose 4270218893Sdim // type is a pack expansion. 4271218893Sdim if (!T->containsUnexpandedParameterPack()) { 4272239462Sdim S.Diag(D.getEllipsisLoc(), 4273218893Sdim diag::err_function_parameter_pack_without_parameter_packs) 4274218893Sdim << T << D.getSourceRange(); 4275218893Sdim D.setEllipsisLoc(SourceLocation()); 4276218893Sdim } else { 4277249423Sdim T = Context.getPackExpansionType(T, None); 4278218893Sdim } 4279218893Sdim break; 4280218893Sdim case Declarator::TemplateParamContext: 4281218893Sdim // C++0x [temp.param]p15: 4282239462Sdim // If a template-parameter is a [...] is a parameter-declaration that 4283218893Sdim // declares a parameter pack (8.3.5), then the template-parameter is a 4284218893Sdim // template parameter pack (14.5.3). 4285218893Sdim // 4286218893Sdim // Note: core issue 778 clarifies that, if there are any unexpanded 4287218893Sdim // parameter packs in the type of the non-type template parameter, then 4288218893Sdim // it expands those parameter packs. 4289218893Sdim if (T->containsUnexpandedParameterPack()) 4290249423Sdim T = Context.getPackExpansionType(T, None); 4291226633Sdim else 4292226633Sdim S.Diag(D.getEllipsisLoc(), 4293249423Sdim LangOpts.CPlusPlus11 4294226633Sdim ? diag::warn_cxx98_compat_variadic_templates 4295226633Sdim : diag::ext_variadic_templates); 4296218893Sdim break; 4297239462Sdim 4298218893Sdim case Declarator::FileContext: 4299218893Sdim case Declarator::KNRTypeListContext: 4300226633Sdim case Declarator::ObjCParameterContext: // FIXME: special diagnostic here? 4301226633Sdim case Declarator::ObjCResultContext: // FIXME: special diagnostic here? 4302218893Sdim case Declarator::TypeNameContext: 4303224145Sdim case Declarator::CXXNewContext: 4304221345Sdim case Declarator::AliasDeclContext: 4305223017Sdim case Declarator::AliasTemplateContext: 4306218893Sdim case Declarator::MemberContext: 4307218893Sdim case Declarator::BlockContext: 4308218893Sdim case Declarator::ForContext: 4309218893Sdim case Declarator::ConditionContext: 4310218893Sdim case Declarator::CXXCatchContext: 4311224145Sdim case Declarator::ObjCCatchContext: 4312218893Sdim case Declarator::BlockLiteralContext: 4313234353Sdim case Declarator::LambdaExprContext: 4314251662Sdim case Declarator::ConversionIdContext: 4315234353Sdim case Declarator::TrailingReturnContext: 4316218893Sdim case Declarator::TemplateTypeArgContext: 4317218893Sdim // FIXME: We may want to allow parameter packs in block-literal contexts 4318218893Sdim // in the future. 4319280031Sdim S.Diag(D.getEllipsisLoc(), 4320280031Sdim diag::err_ellipsis_in_declarator_not_parameter); 4321218893Sdim D.setEllipsisLoc(SourceLocation()); 4322218893Sdim break; 4323218893Sdim } 4324218893Sdim } 4325219077Sdim 4326280031Sdim assert(!T.isNull() && "T must not be null at the end of this function"); 4327280031Sdim if (D.isInvalidType()) 4328210299Sed return Context.getTrivialTypeSourceInfo(T); 4329224145Sdim 4330224145Sdim return S.GetTypeSourceInfoForDeclarator(D, T, TInfo); 4331193326Sed} 4332193326Sed 4333224145Sdim/// GetTypeForDeclarator - Convert the type for the specified 4334224145Sdim/// declarator to Type instances. 4335224145Sdim/// 4336224145Sdim/// The result of this call will never be null, but the associated 4337224145Sdim/// type may be a null type if there's an unrecoverable error. 4338224145SdimTypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D, Scope *S) { 4339224145Sdim // Determine the type of the declarator. Not all forms of declarator 4340224145Sdim // have a type. 4341224145Sdim 4342224145Sdim TypeProcessingState state(*this, D); 4343224145Sdim 4344276479Sdim TypeSourceInfo *ReturnTypeInfo = nullptr; 4345224145Sdim QualType T = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo); 4346224145Sdim 4347234353Sdim if (D.isPrototypeContext() && getLangOpts().ObjCAutoRefCount) 4348224145Sdim inferARCWriteback(state, T); 4349239462Sdim 4350224145Sdim return GetFullTypeForDeclarator(state, T, ReturnTypeInfo); 4351224145Sdim} 4352224145Sdim 4353224145Sdimstatic void transferARCOwnershipToDeclSpec(Sema &S, 4354224145Sdim QualType &declSpecTy, 4355224145Sdim Qualifiers::ObjCLifetime ownership) { 4356224145Sdim if (declSpecTy->isObjCRetainableType() && 4357224145Sdim declSpecTy.getObjCLifetime() == Qualifiers::OCL_None) { 4358224145Sdim Qualifiers qs; 4359224145Sdim qs.addObjCLifetime(ownership); 4360224145Sdim declSpecTy = S.Context.getQualifiedType(declSpecTy, qs); 4361224145Sdim } 4362224145Sdim} 4363224145Sdim 4364224145Sdimstatic void transferARCOwnershipToDeclaratorChunk(TypeProcessingState &state, 4365224145Sdim Qualifiers::ObjCLifetime ownership, 4366224145Sdim unsigned chunkIndex) { 4367224145Sdim Sema &S = state.getSema(); 4368224145Sdim Declarator &D = state.getDeclarator(); 4369224145Sdim 4370224145Sdim // Look for an explicit lifetime attribute. 4371224145Sdim DeclaratorChunk &chunk = D.getTypeObject(chunkIndex); 4372224145Sdim for (const AttributeList *attr = chunk.getAttrs(); attr; 4373224145Sdim attr = attr->getNext()) 4374239462Sdim if (attr->getKind() == AttributeList::AT_ObjCOwnership) 4375224145Sdim return; 4376224145Sdim 4377276479Sdim const char *attrStr = nullptr; 4378224145Sdim switch (ownership) { 4379234353Sdim case Qualifiers::OCL_None: llvm_unreachable("no ownership!"); 4380224145Sdim case Qualifiers::OCL_ExplicitNone: attrStr = "none"; break; 4381224145Sdim case Qualifiers::OCL_Strong: attrStr = "strong"; break; 4382224145Sdim case Qualifiers::OCL_Weak: attrStr = "weak"; break; 4383224145Sdim case Qualifiers::OCL_Autoreleasing: attrStr = "autoreleasing"; break; 4384224145Sdim } 4385224145Sdim 4386261991Sdim IdentifierLoc *Arg = new (S.Context) IdentifierLoc; 4387261991Sdim Arg->Ident = &S.Context.Idents.get(attrStr); 4388261991Sdim Arg->Loc = SourceLocation(); 4389261991Sdim 4390261991Sdim ArgsUnion Args(Arg); 4391261991Sdim 4392224145Sdim // If there wasn't one, add one (with an invalid source location 4393224145Sdim // so that we don't make an AttributedType for it). 4394224145Sdim AttributeList *attr = D.getAttributePool() 4395224145Sdim .create(&S.Context.Idents.get("objc_ownership"), SourceLocation(), 4396276479Sdim /*scope*/ nullptr, SourceLocation(), 4397261991Sdim /*args*/ &Args, 1, AttributeList::AS_GNU); 4398224145Sdim spliceAttrIntoList(*attr, chunk.getAttrListRef()); 4399224145Sdim 4400224145Sdim // TODO: mark whether we did this inference? 4401224145Sdim} 4402224145Sdim 4403239462Sdim/// \brief Used for transferring ownership in casts resulting in l-values. 4404224145Sdimstatic void transferARCOwnership(TypeProcessingState &state, 4405224145Sdim QualType &declSpecTy, 4406224145Sdim Qualifiers::ObjCLifetime ownership) { 4407224145Sdim Sema &S = state.getSema(); 4408224145Sdim Declarator &D = state.getDeclarator(); 4409224145Sdim 4410224145Sdim int inner = -1; 4411234353Sdim bool hasIndirection = false; 4412224145Sdim for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 4413224145Sdim DeclaratorChunk &chunk = D.getTypeObject(i); 4414224145Sdim switch (chunk.Kind) { 4415224145Sdim case DeclaratorChunk::Paren: 4416224145Sdim // Ignore parens. 4417224145Sdim break; 4418224145Sdim 4419224145Sdim case DeclaratorChunk::Array: 4420224145Sdim case DeclaratorChunk::Reference: 4421224145Sdim case DeclaratorChunk::Pointer: 4422234353Sdim if (inner != -1) 4423234353Sdim hasIndirection = true; 4424224145Sdim inner = i; 4425224145Sdim break; 4426224145Sdim 4427224145Sdim case DeclaratorChunk::BlockPointer: 4428234353Sdim if (inner != -1) 4429234353Sdim transferARCOwnershipToDeclaratorChunk(state, ownership, i); 4430234353Sdim return; 4431224145Sdim 4432224145Sdim case DeclaratorChunk::Function: 4433224145Sdim case DeclaratorChunk::MemberPointer: 4434296417Sdim case DeclaratorChunk::Pipe: 4435224145Sdim return; 4436224145Sdim } 4437224145Sdim } 4438224145Sdim 4439224145Sdim if (inner == -1) 4440234353Sdim return; 4441224145Sdim 4442239462Sdim DeclaratorChunk &chunk = D.getTypeObject(inner); 4443224145Sdim if (chunk.Kind == DeclaratorChunk::Pointer) { 4444224145Sdim if (declSpecTy->isObjCRetainableType()) 4445224145Sdim return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership); 4446234353Sdim if (declSpecTy->isObjCObjectType() && hasIndirection) 4447224145Sdim return transferARCOwnershipToDeclaratorChunk(state, ownership, inner); 4448224145Sdim } else { 4449224145Sdim assert(chunk.Kind == DeclaratorChunk::Array || 4450224145Sdim chunk.Kind == DeclaratorChunk::Reference); 4451224145Sdim return transferARCOwnershipToDeclSpec(S, declSpecTy, ownership); 4452224145Sdim } 4453224145Sdim} 4454224145Sdim 4455224145SdimTypeSourceInfo *Sema::GetTypeForDeclaratorCast(Declarator &D, QualType FromTy) { 4456224145Sdim TypeProcessingState state(*this, D); 4457224145Sdim 4458276479Sdim TypeSourceInfo *ReturnTypeInfo = nullptr; 4459224145Sdim QualType declSpecTy = GetDeclSpecTypeForDeclarator(state, ReturnTypeInfo); 4460224145Sdim 4461296417Sdim if (getLangOpts().ObjC1) { 4462224145Sdim Qualifiers::ObjCLifetime ownership = Context.getInnerObjCOwnership(FromTy); 4463224145Sdim if (ownership != Qualifiers::OCL_None) 4464224145Sdim transferARCOwnership(state, declSpecTy, ownership); 4465224145Sdim } 4466224145Sdim 4467224145Sdim return GetFullTypeForDeclarator(state, declSpecTy, ReturnTypeInfo); 4468224145Sdim} 4469224145Sdim 4470221345Sdim/// Map an AttributedType::Kind to an AttributeList::Kind. 4471221345Sdimstatic AttributeList::Kind getAttrListKind(AttributedType::Kind kind) { 4472221345Sdim switch (kind) { 4473221345Sdim case AttributedType::attr_address_space: 4474239462Sdim return AttributeList::AT_AddressSpace; 4475221345Sdim case AttributedType::attr_regparm: 4476239462Sdim return AttributeList::AT_Regparm; 4477221345Sdim case AttributedType::attr_vector_size: 4478239462Sdim return AttributeList::AT_VectorSize; 4479221345Sdim case AttributedType::attr_neon_vector_type: 4480239462Sdim return AttributeList::AT_NeonVectorType; 4481221345Sdim case AttributedType::attr_neon_polyvector_type: 4482239462Sdim return AttributeList::AT_NeonPolyVectorType; 4483221345Sdim case AttributedType::attr_objc_gc: 4484239462Sdim return AttributeList::AT_ObjCGC; 4485224145Sdim case AttributedType::attr_objc_ownership: 4486296417Sdim case AttributedType::attr_objc_inert_unsafe_unretained: 4487239462Sdim return AttributeList::AT_ObjCOwnership; 4488221345Sdim case AttributedType::attr_noreturn: 4489239462Sdim return AttributeList::AT_NoReturn; 4490221345Sdim case AttributedType::attr_cdecl: 4491239462Sdim return AttributeList::AT_CDecl; 4492221345Sdim case AttributedType::attr_fastcall: 4493239462Sdim return AttributeList::AT_FastCall; 4494221345Sdim case AttributedType::attr_stdcall: 4495239462Sdim return AttributeList::AT_StdCall; 4496221345Sdim case AttributedType::attr_thiscall: 4497239462Sdim return AttributeList::AT_ThisCall; 4498221345Sdim case AttributedType::attr_pascal: 4499239462Sdim return AttributeList::AT_Pascal; 4500280031Sdim case AttributedType::attr_vectorcall: 4501280031Sdim return AttributeList::AT_VectorCall; 4502221345Sdim case AttributedType::attr_pcs: 4503261991Sdim case AttributedType::attr_pcs_vfp: 4504239462Sdim return AttributeList::AT_Pcs; 4505249423Sdim case AttributedType::attr_inteloclbicc: 4506249423Sdim return AttributeList::AT_IntelOclBicc; 4507256030Sdim case AttributedType::attr_ms_abi: 4508256030Sdim return AttributeList::AT_MSABI; 4509256030Sdim case AttributedType::attr_sysv_abi: 4510256030Sdim return AttributeList::AT_SysVABI; 4511261991Sdim case AttributedType::attr_ptr32: 4512261991Sdim return AttributeList::AT_Ptr32; 4513261991Sdim case AttributedType::attr_ptr64: 4514261991Sdim return AttributeList::AT_Ptr64; 4515261991Sdim case AttributedType::attr_sptr: 4516261991Sdim return AttributeList::AT_SPtr; 4517261991Sdim case AttributedType::attr_uptr: 4518261991Sdim return AttributeList::AT_UPtr; 4519288943Sdim case AttributedType::attr_nonnull: 4520288943Sdim return AttributeList::AT_TypeNonNull; 4521288943Sdim case AttributedType::attr_nullable: 4522288943Sdim return AttributeList::AT_TypeNullable; 4523288943Sdim case AttributedType::attr_null_unspecified: 4524288943Sdim return AttributeList::AT_TypeNullUnspecified; 4525288943Sdim case AttributedType::attr_objc_kindof: 4526288943Sdim return AttributeList::AT_ObjCKindOf; 4527221345Sdim } 4528221345Sdim llvm_unreachable("unexpected attribute kind!"); 4529221345Sdim} 4530221345Sdim 4531221345Sdimstatic void fillAttributedTypeLoc(AttributedTypeLoc TL, 4532288943Sdim const AttributeList *attrs, 4533288943Sdim const AttributeList *DeclAttrs = nullptr) { 4534288943Sdim // DeclAttrs and attrs cannot be both empty. 4535288943Sdim assert((attrs || DeclAttrs) && 4536288943Sdim "no type attributes in the expected location!"); 4537221345Sdim 4538288943Sdim AttributeList::Kind parsedKind = getAttrListKind(TL.getAttrKind()); 4539288943Sdim // Try to search for an attribute of matching kind in attrs list. 4540288943Sdim while (attrs && attrs->getKind() != parsedKind) 4541221345Sdim attrs = attrs->getNext(); 4542288943Sdim if (!attrs) { 4543288943Sdim // No matching type attribute in attrs list found. 4544288943Sdim // Try searching through C++11 attributes in the declarator attribute list. 4545288943Sdim while (DeclAttrs && (!DeclAttrs->isCXX11Attribute() || 4546288943Sdim DeclAttrs->getKind() != parsedKind)) 4547288943Sdim DeclAttrs = DeclAttrs->getNext(); 4548288943Sdim attrs = DeclAttrs; 4549221345Sdim } 4550221345Sdim 4551288943Sdim assert(attrs && "no matching type attribute in expected location!"); 4552288943Sdim 4553221345Sdim TL.setAttrNameLoc(attrs->getLoc()); 4554276479Sdim if (TL.hasAttrExprOperand()) { 4555276479Sdim assert(attrs->isArgExpr(0) && "mismatched attribute operand kind"); 4556261991Sdim TL.setAttrExprOperand(attrs->getArgAsExpr(0)); 4557276479Sdim } else if (TL.hasAttrEnumOperand()) { 4558276479Sdim assert((attrs->isArgIdent(0) || attrs->isArgExpr(0)) && 4559276479Sdim "unexpected attribute operand kind"); 4560276479Sdim if (attrs->isArgIdent(0)) 4561276479Sdim TL.setAttrEnumOperandLoc(attrs->getArgAsIdent(0)->Loc); 4562276479Sdim else 4563276479Sdim TL.setAttrEnumOperandLoc(attrs->getArgAsExpr(0)->getExprLoc()); 4564276479Sdim } 4565221345Sdim 4566221345Sdim // FIXME: preserve this information to here. 4567221345Sdim if (TL.hasAttrOperand()) 4568221345Sdim TL.setAttrOperandParensRange(SourceRange()); 4569221345Sdim} 4570221345Sdim 4571198398Srdivackynamespace { 4572198398Srdivacky class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> { 4573218893Sdim ASTContext &Context; 4574198398Srdivacky const DeclSpec &DS; 4575193326Sed 4576198398Srdivacky public: 4577239462Sdim TypeSpecLocFiller(ASTContext &Context, const DeclSpec &DS) 4578218893Sdim : Context(Context), DS(DS) {} 4579193326Sed 4580221345Sdim void VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4581221345Sdim fillAttributedTypeLoc(TL, DS.getAttributes().getList()); 4582221345Sdim Visit(TL.getModifiedLoc()); 4583221345Sdim } 4584198398Srdivacky void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4585198398Srdivacky Visit(TL.getUnqualifiedLoc()); 4586198398Srdivacky } 4587198398Srdivacky void VisitTypedefTypeLoc(TypedefTypeLoc TL) { 4588198398Srdivacky TL.setNameLoc(DS.getTypeSpecTypeLoc()); 4589198398Srdivacky } 4590198398Srdivacky void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 4591198398Srdivacky TL.setNameLoc(DS.getTypeSpecTypeLoc()); 4592239462Sdim // FIXME. We should have DS.getTypeSpecTypeEndLoc(). But, it requires 4593239462Sdim // addition field. What we have is good enough for dispay of location 4594239462Sdim // of 'fixit' on interface name. 4595239462Sdim TL.setNameEndLoc(DS.getLocEnd()); 4596208600Srdivacky } 4597208600Srdivacky void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) { 4598288943Sdim TypeSourceInfo *RepTInfo = nullptr; 4599288943Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo); 4600288943Sdim TL.copy(RepTInfo->getTypeLoc()); 4601198398Srdivacky } 4602198398Srdivacky void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4603288943Sdim TypeSourceInfo *RepTInfo = nullptr; 4604288943Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo); 4605288943Sdim TL.copy(RepTInfo->getTypeLoc()); 4606198092Srdivacky } 4607198893Srdivacky void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { 4608276479Sdim TypeSourceInfo *TInfo = nullptr; 4609212904Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4610198893Srdivacky 4611198893Srdivacky // If we got no declarator info from previous Sema routines, 4612198893Srdivacky // just fill with the typespec loc. 4613200583Srdivacky if (!TInfo) { 4614221345Sdim TL.initialize(Context, DS.getTypeSpecTypeNameLoc()); 4615198893Srdivacky return; 4616198893Srdivacky } 4617198893Srdivacky 4618208600Srdivacky TypeLoc OldTL = TInfo->getTypeLoc(); 4619208600Srdivacky if (TInfo->getType()->getAs<ElaboratedType>()) { 4620249423Sdim ElaboratedTypeLoc ElabTL = OldTL.castAs<ElaboratedTypeLoc>(); 4621249423Sdim TemplateSpecializationTypeLoc NamedTL = ElabTL.getNamedTypeLoc() 4622249423Sdim .castAs<TemplateSpecializationTypeLoc>(); 4623208600Srdivacky TL.copy(NamedTL); 4624261991Sdim } else { 4625261991Sdim TL.copy(OldTL.castAs<TemplateSpecializationTypeLoc>()); 4626261991Sdim assert(TL.getRAngleLoc() == OldTL.castAs<TemplateSpecializationTypeLoc>().getRAngleLoc()); 4627208600Srdivacky } 4628261991Sdim 4629198893Srdivacky } 4630202379Srdivacky void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 4631202379Srdivacky assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr); 4632202379Srdivacky TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 4633202379Srdivacky TL.setParensRange(DS.getTypeofParensRange()); 4634202379Srdivacky } 4635202379Srdivacky void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 4636202379Srdivacky assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType); 4637202379Srdivacky TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 4638202379Srdivacky TL.setParensRange(DS.getTypeofParensRange()); 4639212904Sdim assert(DS.getRepAsType()); 4640276479Sdim TypeSourceInfo *TInfo = nullptr; 4641212904Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4642202379Srdivacky TL.setUnderlyingTInfo(TInfo); 4643202379Srdivacky } 4644223017Sdim void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) { 4645223017Sdim // FIXME: This holds only because we only have one unary transform. 4646223017Sdim assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType); 4647223017Sdim TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4648223017Sdim TL.setParensRange(DS.getTypeofParensRange()); 4649223017Sdim assert(DS.getRepAsType()); 4650276479Sdim TypeSourceInfo *TInfo = nullptr; 4651223017Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4652223017Sdim TL.setUnderlyingTInfo(TInfo); 4653223017Sdim } 4654202879Srdivacky void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 4655202879Srdivacky // By default, use the source location of the type specifier. 4656202879Srdivacky TL.setBuiltinLoc(DS.getTypeSpecTypeLoc()); 4657202879Srdivacky if (TL.needsExtraLocalData()) { 4658202879Srdivacky // Set info for the written builtin specifiers. 4659202879Srdivacky TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs(); 4660202879Srdivacky // Try to have a meaningful source location. 4661202879Srdivacky if (TL.getWrittenSignSpec() != TSS_unspecified) 4662202879Srdivacky // Sign spec loc overrides the others (e.g., 'unsigned long'). 4663202879Srdivacky TL.setBuiltinLoc(DS.getTypeSpecSignLoc()); 4664202879Srdivacky else if (TL.getWrittenWidthSpec() != TSW_unspecified) 4665202879Srdivacky // Width spec loc overrides type spec loc (e.g., 'short int'). 4666202879Srdivacky TL.setBuiltinLoc(DS.getTypeSpecWidthLoc()); 4667202879Srdivacky } 4668202879Srdivacky } 4669208600Srdivacky void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) { 4670208600Srdivacky ElaboratedTypeKeyword Keyword 4671208600Srdivacky = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType()); 4672218893Sdim if (DS.getTypeSpecType() == TST_typename) { 4673276479Sdim TypeSourceInfo *TInfo = nullptr; 4674212904Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4675208600Srdivacky if (TInfo) { 4676249423Sdim TL.copy(TInfo->getTypeLoc().castAs<ElaboratedTypeLoc>()); 4677208600Srdivacky return; 4678208600Srdivacky } 4679208600Srdivacky } 4680234353Sdim TL.setElaboratedKeywordLoc(Keyword != ETK_None 4681234353Sdim ? DS.getTypeSpecTypeLoc() 4682234353Sdim : SourceLocation()); 4683208600Srdivacky const CXXScopeSpec& SS = DS.getTypeSpecScope(); 4684221345Sdim TL.setQualifierLoc(SS.getWithLocInContext(Context)); 4685208600Srdivacky Visit(TL.getNextTypeLoc().getUnqualifiedLoc()); 4686208600Srdivacky } 4687208600Srdivacky void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) { 4688234353Sdim assert(DS.getTypeSpecType() == TST_typename); 4689276479Sdim TypeSourceInfo *TInfo = nullptr; 4690234353Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4691234353Sdim assert(TInfo); 4692249423Sdim TL.copy(TInfo->getTypeLoc().castAs<DependentNameTypeLoc>()); 4693208600Srdivacky } 4694210299Sed void VisitDependentTemplateSpecializationTypeLoc( 4695210299Sed DependentTemplateSpecializationTypeLoc TL) { 4696234353Sdim assert(DS.getTypeSpecType() == TST_typename); 4697276479Sdim TypeSourceInfo *TInfo = nullptr; 4698234353Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4699234353Sdim assert(TInfo); 4700249423Sdim TL.copy( 4701249423Sdim TInfo->getTypeLoc().castAs<DependentTemplateSpecializationTypeLoc>()); 4702210299Sed } 4703221345Sdim void VisitTagTypeLoc(TagTypeLoc TL) { 4704221345Sdim TL.setNameLoc(DS.getTypeSpecTypeNameLoc()); 4705221345Sdim } 4706226633Sdim void VisitAtomicTypeLoc(AtomicTypeLoc TL) { 4707249423Sdim // An AtomicTypeLoc can come from either an _Atomic(...) type specifier 4708249423Sdim // or an _Atomic qualifier. 4709249423Sdim if (DS.getTypeSpecType() == DeclSpec::TST_atomic) { 4710249423Sdim TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4711249423Sdim TL.setParensRange(DS.getTypeofParensRange()); 4712239462Sdim 4713276479Sdim TypeSourceInfo *TInfo = nullptr; 4714249423Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4715249423Sdim assert(TInfo); 4716249423Sdim TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc()); 4717249423Sdim } else { 4718249423Sdim TL.setKWLoc(DS.getAtomicSpecLoc()); 4719249423Sdim // No parens, to indicate this was spelled as an _Atomic qualifier. 4720249423Sdim TL.setParensRange(SourceRange()); 4721249423Sdim Visit(TL.getValueLoc()); 4722249423Sdim } 4723226633Sdim } 4724208600Srdivacky 4725296417Sdim void VisitPipeTypeLoc(PipeTypeLoc TL) { 4726296417Sdim TL.setKWLoc(DS.getTypeSpecTypeLoc()); 4727296417Sdim 4728296417Sdim TypeSourceInfo *TInfo = 0; 4729296417Sdim Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo); 4730296417Sdim TL.getValueLoc().initializeFullCopy(TInfo->getTypeLoc()); 4731296417Sdim } 4732296417Sdim 4733198398Srdivacky void VisitTypeLoc(TypeLoc TL) { 4734198398Srdivacky // FIXME: add other typespec types and change this to an assert. 4735218893Sdim TL.initialize(Context, DS.getTypeSpecTypeLoc()); 4736198092Srdivacky } 4737198398Srdivacky }; 4738198398Srdivacky 4739198398Srdivacky class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> { 4740221345Sdim ASTContext &Context; 4741198398Srdivacky const DeclaratorChunk &Chunk; 4742198398Srdivacky 4743198398Srdivacky public: 4744221345Sdim DeclaratorLocFiller(ASTContext &Context, const DeclaratorChunk &Chunk) 4745221345Sdim : Context(Context), Chunk(Chunk) {} 4746198398Srdivacky 4747198398Srdivacky void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 4748200583Srdivacky llvm_unreachable("qualified type locs not expected here!"); 4749198092Srdivacky } 4750261991Sdim void VisitDecayedTypeLoc(DecayedTypeLoc TL) { 4751261991Sdim llvm_unreachable("decayed type locs not expected here!"); 4752261991Sdim } 4753198398Srdivacky 4754224145Sdim void VisitAttributedTypeLoc(AttributedTypeLoc TL) { 4755224145Sdim fillAttributedTypeLoc(TL, Chunk.getAttrs()); 4756224145Sdim } 4757276479Sdim void VisitAdjustedTypeLoc(AdjustedTypeLoc TL) { 4758276479Sdim // nothing 4759276479Sdim } 4760198398Srdivacky void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 4761198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::BlockPointer); 4762198398Srdivacky TL.setCaretLoc(Chunk.Loc); 4763198092Srdivacky } 4764198398Srdivacky void VisitPointerTypeLoc(PointerTypeLoc TL) { 4765198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Pointer); 4766198398Srdivacky TL.setStarLoc(Chunk.Loc); 4767198398Srdivacky } 4768198398Srdivacky void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 4769198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Pointer); 4770198398Srdivacky TL.setStarLoc(Chunk.Loc); 4771198398Srdivacky } 4772198398Srdivacky void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 4773198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::MemberPointer); 4774221345Sdim const CXXScopeSpec& SS = Chunk.Mem.Scope(); 4775221345Sdim NestedNameSpecifierLoc NNSLoc = SS.getWithLocInContext(Context); 4776221345Sdim 4777221345Sdim const Type* ClsTy = TL.getClass(); 4778221345Sdim QualType ClsQT = QualType(ClsTy, 0); 4779221345Sdim TypeSourceInfo *ClsTInfo = Context.CreateTypeSourceInfo(ClsQT, 0); 4780221345Sdim // Now copy source location info into the type loc component. 4781221345Sdim TypeLoc ClsTL = ClsTInfo->getTypeLoc(); 4782221345Sdim switch (NNSLoc.getNestedNameSpecifier()->getKind()) { 4783221345Sdim case NestedNameSpecifier::Identifier: 4784221345Sdim assert(isa<DependentNameType>(ClsTy) && "Unexpected TypeLoc"); 4785221345Sdim { 4786249423Sdim DependentNameTypeLoc DNTLoc = ClsTL.castAs<DependentNameTypeLoc>(); 4787234353Sdim DNTLoc.setElaboratedKeywordLoc(SourceLocation()); 4788221345Sdim DNTLoc.setQualifierLoc(NNSLoc.getPrefix()); 4789221345Sdim DNTLoc.setNameLoc(NNSLoc.getLocalBeginLoc()); 4790221345Sdim } 4791221345Sdim break; 4792221345Sdim 4793221345Sdim case NestedNameSpecifier::TypeSpec: 4794221345Sdim case NestedNameSpecifier::TypeSpecWithTemplate: 4795221345Sdim if (isa<ElaboratedType>(ClsTy)) { 4796249423Sdim ElaboratedTypeLoc ETLoc = ClsTL.castAs<ElaboratedTypeLoc>(); 4797234353Sdim ETLoc.setElaboratedKeywordLoc(SourceLocation()); 4798221345Sdim ETLoc.setQualifierLoc(NNSLoc.getPrefix()); 4799221345Sdim TypeLoc NamedTL = ETLoc.getNamedTypeLoc(); 4800221345Sdim NamedTL.initializeFullCopy(NNSLoc.getTypeLoc()); 4801221345Sdim } else { 4802221345Sdim ClsTL.initializeFullCopy(NNSLoc.getTypeLoc()); 4803221345Sdim } 4804221345Sdim break; 4805221345Sdim 4806221345Sdim case NestedNameSpecifier::Namespace: 4807221345Sdim case NestedNameSpecifier::NamespaceAlias: 4808221345Sdim case NestedNameSpecifier::Global: 4809280031Sdim case NestedNameSpecifier::Super: 4810221345Sdim llvm_unreachable("Nested-name-specifier must name a type"); 4811221345Sdim } 4812221345Sdim 4813221345Sdim // Finally fill in MemberPointerLocInfo fields. 4814198398Srdivacky TL.setStarLoc(Chunk.Loc); 4815221345Sdim TL.setClassTInfo(ClsTInfo); 4816198398Srdivacky } 4817198398Srdivacky void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 4818198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Reference); 4819198398Srdivacky // 'Amp' is misleading: this might have been originally 4820198398Srdivacky /// spelled with AmpAmp. 4821198398Srdivacky TL.setAmpLoc(Chunk.Loc); 4822198398Srdivacky } 4823198398Srdivacky void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 4824198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Reference); 4825198398Srdivacky assert(!Chunk.Ref.LValueRef); 4826198398Srdivacky TL.setAmpAmpLoc(Chunk.Loc); 4827198398Srdivacky } 4828198398Srdivacky void VisitArrayTypeLoc(ArrayTypeLoc TL) { 4829198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Array); 4830198398Srdivacky TL.setLBracketLoc(Chunk.Loc); 4831198398Srdivacky TL.setRBracketLoc(Chunk.EndLoc); 4832198398Srdivacky TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts)); 4833198398Srdivacky } 4834198398Srdivacky void VisitFunctionTypeLoc(FunctionTypeLoc TL) { 4835198398Srdivacky assert(Chunk.Kind == DeclaratorChunk::Function); 4836221345Sdim TL.setLocalRangeBegin(Chunk.Loc); 4837221345Sdim TL.setLocalRangeEnd(Chunk.EndLoc); 4838198398Srdivacky 4839198398Srdivacky const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun; 4840243830Sdim TL.setLParenLoc(FTI.getLParenLoc()); 4841243830Sdim TL.setRParenLoc(FTI.getRParenLoc()); 4842276479Sdim for (unsigned i = 0, e = TL.getNumParams(), tpi = 0; i != e; ++i) { 4843276479Sdim ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param); 4844276479Sdim TL.setParam(tpi++, Param); 4845198092Srdivacky } 4846198398Srdivacky // FIXME: exception specs 4847198092Srdivacky } 4848218893Sdim void VisitParenTypeLoc(ParenTypeLoc TL) { 4849218893Sdim assert(Chunk.Kind == DeclaratorChunk::Paren); 4850218893Sdim TL.setLParenLoc(Chunk.Loc); 4851218893Sdim TL.setRParenLoc(Chunk.EndLoc); 4852218893Sdim } 4853296417Sdim void VisitPipeTypeLoc(PipeTypeLoc TL) { 4854296417Sdim assert(Chunk.Kind == DeclaratorChunk::Pipe); 4855296417Sdim TL.setKWLoc(Chunk.Loc); 4856296417Sdim } 4857193326Sed 4858198398Srdivacky void VisitTypeLoc(TypeLoc TL) { 4859200583Srdivacky llvm_unreachable("unsupported TypeLoc kind in declarator!"); 4860198092Srdivacky } 4861198398Srdivacky }; 4862198398Srdivacky} 4863198092Srdivacky 4864249423Sdimstatic void fillAtomicQualLoc(AtomicTypeLoc ATL, const DeclaratorChunk &Chunk) { 4865249423Sdim SourceLocation Loc; 4866249423Sdim switch (Chunk.Kind) { 4867249423Sdim case DeclaratorChunk::Function: 4868249423Sdim case DeclaratorChunk::Array: 4869249423Sdim case DeclaratorChunk::Paren: 4870296417Sdim case DeclaratorChunk::Pipe: 4871249423Sdim llvm_unreachable("cannot be _Atomic qualified"); 4872249423Sdim 4873249423Sdim case DeclaratorChunk::Pointer: 4874249423Sdim Loc = SourceLocation::getFromRawEncoding(Chunk.Ptr.AtomicQualLoc); 4875249423Sdim break; 4876249423Sdim 4877249423Sdim case DeclaratorChunk::BlockPointer: 4878249423Sdim case DeclaratorChunk::Reference: 4879249423Sdim case DeclaratorChunk::MemberPointer: 4880249423Sdim // FIXME: Provide a source location for the _Atomic keyword. 4881249423Sdim break; 4882249423Sdim } 4883249423Sdim 4884249423Sdim ATL.setKWLoc(Loc); 4885249423Sdim ATL.setParensRange(SourceRange()); 4886249423Sdim} 4887249423Sdim 4888200583Srdivacky/// \brief Create and instantiate a TypeSourceInfo with type source information. 4889198398Srdivacky/// 4890198398Srdivacky/// \param T QualType referring to the type as written in source code. 4891207619Srdivacky/// 4892207619Srdivacky/// \param ReturnTypeInfo For declarators whose return type does not show 4893207619Srdivacky/// up in the normal place in the declaration specifiers (such as a C++ 4894207619Srdivacky/// conversion function), this pointer will refer to a type source information 4895207619Srdivacky/// for that return type. 4896200583SrdivackyTypeSourceInfo * 4897207619SrdivackySema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, 4898207619Srdivacky TypeSourceInfo *ReturnTypeInfo) { 4899200583Srdivacky TypeSourceInfo *TInfo = Context.CreateTypeSourceInfo(T); 4900200583Srdivacky UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc(); 4901288943Sdim const AttributeList *DeclAttrs = D.getAttributes(); 4902198398Srdivacky 4903218893Sdim // Handle parameter packs whose type is a pack expansion. 4904218893Sdim if (isa<PackExpansionType>(T)) { 4905249423Sdim CurrTL.castAs<PackExpansionTypeLoc>().setEllipsisLoc(D.getEllipsisLoc()); 4906239462Sdim CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc(); 4907218893Sdim } 4908239462Sdim 4909198893Srdivacky for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 4910249423Sdim // An AtomicTypeLoc might be produced by an atomic qualifier in this 4911249423Sdim // declarator chunk. 4912249423Sdim if (AtomicTypeLoc ATL = CurrTL.getAs<AtomicTypeLoc>()) { 4913249423Sdim fillAtomicQualLoc(ATL, D.getTypeObject(i)); 4914249423Sdim CurrTL = ATL.getValueLoc().getUnqualifiedLoc(); 4915249423Sdim } 4916249423Sdim 4917249423Sdim while (AttributedTypeLoc TL = CurrTL.getAs<AttributedTypeLoc>()) { 4918288943Sdim fillAttributedTypeLoc(TL, D.getTypeObject(i).getAttrs(), DeclAttrs); 4919221345Sdim CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc(); 4920221345Sdim } 4921221345Sdim 4922276479Sdim // FIXME: Ordering here? 4923276479Sdim while (AdjustedTypeLoc TL = CurrTL.getAs<AdjustedTypeLoc>()) 4924276479Sdim CurrTL = TL.getNextTypeLoc().getUnqualifiedLoc(); 4925276479Sdim 4926221345Sdim DeclaratorLocFiller(Context, D.getTypeObject(i)).Visit(CurrTL); 4927198398Srdivacky CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc(); 4928195341Sed } 4929239462Sdim 4930212904Sdim // If we have different source information for the return type, use 4931212904Sdim // that. This really only applies to C++ conversion functions. 4932212904Sdim if (ReturnTypeInfo) { 4933207619Srdivacky TypeLoc TL = ReturnTypeInfo->getTypeLoc(); 4934207619Srdivacky assert(TL.getFullDataSize() == CurrTL.getFullDataSize()); 4935207619Srdivacky memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize()); 4936212904Sdim } else { 4937218893Sdim TypeSpecLocFiller(Context, D.getDeclSpec()).Visit(CurrTL); 4938207619Srdivacky } 4939239462Sdim 4940200583Srdivacky return TInfo; 4941198092Srdivacky} 4942195341Sed 4943200583Srdivacky/// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo. 4944212904SdimParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) { 4945198092Srdivacky // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser 4946198092Srdivacky // and Sema during declaration parsing. Try deallocating/caching them when 4947198092Srdivacky // it's appropriate, instead of allocating them and keeping them around. 4948239462Sdim LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType), 4949218893Sdim TypeAlignment); 4950200583Srdivacky new (LocT) LocInfoType(T, TInfo); 4951198092Srdivacky assert(LocT->getTypeClass() != T->getTypeClass() && 4952198092Srdivacky "LocInfoType's TypeClass conflicts with an existing Type class"); 4953212904Sdim return ParsedType::make(QualType(LocT, 0)); 4954198092Srdivacky} 4955195341Sed 4956198092Srdivackyvoid LocInfoType::getAsStringInternal(std::string &Str, 4957198092Srdivacky const PrintingPolicy &Policy) const { 4958226633Sdim llvm_unreachable("LocInfoType leaked into the type system; an opaque TypeTy*" 4959198092Srdivacky " was used directly instead of getting the QualType through" 4960198092Srdivacky " GetTypeFromParser"); 4961195341Sed} 4962195341Sed 4963212904SdimTypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) { 4964193326Sed // C99 6.7.6: Type names have no identifier. This is already validated by 4965193326Sed // the parser. 4966276479Sdim assert(D.getIdentifier() == nullptr && 4967276479Sdim "Type name should have no identifier!"); 4968198092Srdivacky 4969224145Sdim TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S); 4970210299Sed QualType T = TInfo->getType(); 4971193326Sed if (D.isInvalidType()) 4972193326Sed return true; 4973193326Sed 4974226633Sdim // Make sure there are no unused decl attributes on the declarator. 4975226633Sdim // We don't want to do this for ObjC parameters because we're going 4976226633Sdim // to apply them to the actual parameter declaration. 4977249423Sdim // Likewise, we don't want to do this for alias declarations, because 4978249423Sdim // we are actually going to build a declaration from this eventually. 4979249423Sdim if (D.getContext() != Declarator::ObjCParameterContext && 4980249423Sdim D.getContext() != Declarator::AliasDeclContext && 4981249423Sdim D.getContext() != Declarator::AliasTemplateContext) 4982226633Sdim checkUnusedDeclAttributes(D); 4983226633Sdim 4984234353Sdim if (getLangOpts().CPlusPlus) { 4985193326Sed // Check that there are no default arguments (C++ only). 4986193326Sed CheckExtraCXXDefaultArguments(D); 4987193326Sed } 4988193326Sed 4989212904Sdim return CreateParsedType(T, TInfo); 4990193326Sed} 4991193326Sed 4992226633SdimParsedType Sema::ActOnObjCInstanceType(SourceLocation Loc) { 4993226633Sdim QualType T = Context.getObjCInstanceType(); 4994226633Sdim TypeSourceInfo *TInfo = Context.getTrivialTypeSourceInfo(T, Loc); 4995226633Sdim return CreateParsedType(T, TInfo); 4996226633Sdim} 4997226633Sdim 4998226633Sdim 4999193326Sed//===----------------------------------------------------------------------===// 5000193326Sed// Type Attribute Processing 5001193326Sed//===----------------------------------------------------------------------===// 5002193326Sed 5003193326Sed/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the 5004193326Sed/// specified type. The attribute contains 1 argument, the id of the address 5005193326Sed/// space for the type. 5006198092Srdivackystatic void HandleAddressSpaceTypeAttribute(QualType &Type, 5007193326Sed const AttributeList &Attr, Sema &S){ 5008198092Srdivacky 5009193326Sed // If this type is already address space qualified, reject it. 5010226633Sdim // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "No type shall be qualified by 5011226633Sdim // qualifiers for two or more different address spaces." 5012193326Sed if (Type.getAddressSpace()) { 5013193326Sed S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers); 5014207619Srdivacky Attr.setInvalid(); 5015193326Sed return; 5016193326Sed } 5017198092Srdivacky 5018226633Sdim // ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): "A function type shall not be 5019226633Sdim // qualified by an address-space qualifier." 5020226633Sdim if (Type->isFunctionType()) { 5021226633Sdim S.Diag(Attr.getLoc(), diag::err_attribute_address_function_type); 5022226633Sdim Attr.setInvalid(); 5023226633Sdim return; 5024226633Sdim } 5025226633Sdim 5026276479Sdim unsigned ASIdx; 5027276479Sdim if (Attr.getKind() == AttributeList::AT_AddressSpace) { 5028276479Sdim // Check the attribute arguments. 5029276479Sdim if (Attr.getNumArgs() != 1) { 5030276479Sdim S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 5031276479Sdim << Attr.getName() << 1; 5032276479Sdim Attr.setInvalid(); 5033276479Sdim return; 5034276479Sdim } 5035276479Sdim Expr *ASArgExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 5036276479Sdim llvm::APSInt addrSpace(32); 5037276479Sdim if (ASArgExpr->isTypeDependent() || ASArgExpr->isValueDependent() || 5038276479Sdim !ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) { 5039276479Sdim S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 5040276479Sdim << Attr.getName() << AANT_ArgumentIntegerConstant 5041198092Srdivacky << ASArgExpr->getSourceRange(); 5042207619Srdivacky Attr.setInvalid(); 5043198092Srdivacky return; 5044198092Srdivacky } 5045276479Sdim 5046276479Sdim // Bounds checking. 5047276479Sdim if (addrSpace.isSigned()) { 5048276479Sdim if (addrSpace.isNegative()) { 5049276479Sdim S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative) 5050276479Sdim << ASArgExpr->getSourceRange(); 5051276479Sdim Attr.setInvalid(); 5052276479Sdim return; 5053276479Sdim } 5054276479Sdim addrSpace.setIsSigned(false); 5055276479Sdim } 5056276479Sdim llvm::APSInt max(addrSpace.getBitWidth()); 5057276479Sdim max = Qualifiers::MaxAddressSpace; 5058276479Sdim if (addrSpace > max) { 5059276479Sdim S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high) 5060276479Sdim << int(Qualifiers::MaxAddressSpace) << ASArgExpr->getSourceRange(); 5061276479Sdim Attr.setInvalid(); 5062276479Sdim return; 5063276479Sdim } 5064276479Sdim ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()); 5065276479Sdim } else { 5066276479Sdim // The keyword-based type attributes imply which address space to use. 5067276479Sdim switch (Attr.getKind()) { 5068276479Sdim case AttributeList::AT_OpenCLGlobalAddressSpace: 5069276479Sdim ASIdx = LangAS::opencl_global; break; 5070276479Sdim case AttributeList::AT_OpenCLLocalAddressSpace: 5071276479Sdim ASIdx = LangAS::opencl_local; break; 5072276479Sdim case AttributeList::AT_OpenCLConstantAddressSpace: 5073276479Sdim ASIdx = LangAS::opencl_constant; break; 5074280031Sdim case AttributeList::AT_OpenCLGenericAddressSpace: 5075280031Sdim ASIdx = LangAS::opencl_generic; break; 5076276479Sdim default: 5077276479Sdim assert(Attr.getKind() == AttributeList::AT_OpenCLPrivateAddressSpace); 5078276479Sdim ASIdx = 0; break; 5079276479Sdim } 5080198092Srdivacky } 5081276479Sdim 5082193326Sed Type = S.Context.getAddrSpaceQualType(Type, ASIdx); 5083193326Sed} 5084193326Sed 5085234353Sdim/// Does this type have a "direct" ownership qualifier? That is, 5086234353Sdim/// is it written like "__strong id", as opposed to something like 5087234353Sdim/// "typeof(foo)", where that happens to be strong? 5088234353Sdimstatic bool hasDirectOwnershipQualifier(QualType type) { 5089234353Sdim // Fast path: no qualifier at all. 5090234353Sdim assert(type.getQualifiers().hasObjCLifetime()); 5091234353Sdim 5092234353Sdim while (true) { 5093234353Sdim // __strong id 5094234353Sdim if (const AttributedType *attr = dyn_cast<AttributedType>(type)) { 5095234353Sdim if (attr->getAttrKind() == AttributedType::attr_objc_ownership) 5096234353Sdim return true; 5097234353Sdim 5098234353Sdim type = attr->getModifiedType(); 5099234353Sdim 5100234353Sdim // X *__strong (...) 5101234353Sdim } else if (const ParenType *paren = dyn_cast<ParenType>(type)) { 5102234353Sdim type = paren->getInnerType(); 5103239462Sdim 5104234353Sdim // That's it for things we want to complain about. In particular, 5105234353Sdim // we do not want to look through typedefs, typeof(expr), 5106234353Sdim // typeof(type), or any other way that the type is somehow 5107234353Sdim // abstracted. 5108234353Sdim } else { 5109239462Sdim 5110234353Sdim return false; 5111234353Sdim } 5112234353Sdim } 5113234353Sdim} 5114234353Sdim 5115224145Sdim/// handleObjCOwnershipTypeAttr - Process an objc_ownership 5116224145Sdim/// attribute on the specified type. 5117224145Sdim/// 5118224145Sdim/// Returns 'true' if the attribute was handled. 5119224145Sdimstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, 5120224145Sdim AttributeList &attr, 5121224145Sdim QualType &type) { 5122234353Sdim bool NonObjCPointer = false; 5123224145Sdim 5124251662Sdim if (!type->isDependentType() && !type->isUndeducedType()) { 5125234353Sdim if (const PointerType *ptr = type->getAs<PointerType>()) { 5126234353Sdim QualType pointee = ptr->getPointeeType(); 5127234353Sdim if (pointee->isObjCRetainableType() || pointee->isPointerType()) 5128234353Sdim return false; 5129234353Sdim // It is important not to lose the source info that there was an attribute 5130234353Sdim // applied to non-objc pointer. We will create an attributed type but 5131234353Sdim // its type will be the same as the original type. 5132234353Sdim NonObjCPointer = true; 5133234353Sdim } else if (!type->isObjCRetainableType()) { 5134234353Sdim return false; 5135234353Sdim } 5136249423Sdim 5137249423Sdim // Don't accept an ownership attribute in the declspec if it would 5138249423Sdim // just be the return type of a block pointer. 5139249423Sdim if (state.isProcessingDeclSpec()) { 5140249423Sdim Declarator &D = state.getDeclarator(); 5141288943Sdim if (maybeMovePastReturnType(D, D.getNumTypeObjects(), 5142288943Sdim /*onlyBlockPointers=*/true)) 5143249423Sdim return false; 5144249423Sdim } 5145234353Sdim } 5146234353Sdim 5147224145Sdim Sema &S = state.getSema(); 5148226633Sdim SourceLocation AttrLoc = attr.getLoc(); 5149226633Sdim if (AttrLoc.isMacroID()) 5150226633Sdim AttrLoc = S.getSourceManager().getImmediateExpansionRange(AttrLoc).first; 5151224145Sdim 5152261991Sdim if (!attr.isArgIdent(0)) { 5153261991Sdim S.Diag(AttrLoc, diag::err_attribute_argument_type) 5154261991Sdim << attr.getName() << AANT_ArgumentString; 5155224145Sdim attr.setInvalid(); 5156224145Sdim return true; 5157224145Sdim } 5158224145Sdim 5159261991Sdim IdentifierInfo *II = attr.getArgAsIdent(0)->Ident; 5160224145Sdim Qualifiers::ObjCLifetime lifetime; 5161261991Sdim if (II->isStr("none")) 5162224145Sdim lifetime = Qualifiers::OCL_ExplicitNone; 5163261991Sdim else if (II->isStr("strong")) 5164224145Sdim lifetime = Qualifiers::OCL_Strong; 5165261991Sdim else if (II->isStr("weak")) 5166224145Sdim lifetime = Qualifiers::OCL_Weak; 5167261991Sdim else if (II->isStr("autoreleasing")) 5168224145Sdim lifetime = Qualifiers::OCL_Autoreleasing; 5169224145Sdim else { 5170226633Sdim S.Diag(AttrLoc, diag::warn_attribute_type_not_supported) 5171261991Sdim << attr.getName() << II; 5172224145Sdim attr.setInvalid(); 5173224145Sdim return true; 5174224145Sdim } 5175224145Sdim 5176296417Sdim // Just ignore lifetime attributes other than __weak and __unsafe_unretained 5177296417Sdim // outside of ARC mode. 5178296417Sdim if (!S.getLangOpts().ObjCAutoRefCount && 5179296417Sdim lifetime != Qualifiers::OCL_Weak && 5180296417Sdim lifetime != Qualifiers::OCL_ExplicitNone) { 5181296417Sdim return true; 5182296417Sdim } 5183296417Sdim 5184234353Sdim SplitQualType underlyingType = type.split(); 5185224145Sdim 5186234353Sdim // Check for redundant/conflicting ownership qualifiers. 5187234353Sdim if (Qualifiers::ObjCLifetime previousLifetime 5188234353Sdim = type.getQualifiers().getObjCLifetime()) { 5189234353Sdim // If it's written directly, that's an error. 5190234353Sdim if (hasDirectOwnershipQualifier(type)) { 5191234353Sdim S.Diag(AttrLoc, diag::err_attr_objc_ownership_redundant) 5192234353Sdim << type; 5193234353Sdim return true; 5194234353Sdim } 5195234353Sdim 5196234353Sdim // Otherwise, if the qualifiers actually conflict, pull sugar off 5197234353Sdim // until we reach a type that is directly qualified. 5198234353Sdim if (previousLifetime != lifetime) { 5199234353Sdim // This should always terminate: the canonical type is 5200234353Sdim // qualified, so some bit of sugar must be hiding it. 5201234353Sdim while (!underlyingType.Quals.hasObjCLifetime()) { 5202234353Sdim underlyingType = underlyingType.getSingleStepDesugaredType(); 5203234353Sdim } 5204234353Sdim underlyingType.Quals.removeObjCLifetime(); 5205234353Sdim } 5206234353Sdim } 5207234353Sdim 5208234353Sdim underlyingType.Quals.addObjCLifetime(lifetime); 5209234353Sdim 5210234353Sdim if (NonObjCPointer) { 5211234353Sdim StringRef name = attr.getName()->getName(); 5212234353Sdim switch (lifetime) { 5213234353Sdim case Qualifiers::OCL_None: 5214234353Sdim case Qualifiers::OCL_ExplicitNone: 5215234353Sdim break; 5216234353Sdim case Qualifiers::OCL_Strong: name = "__strong"; break; 5217234353Sdim case Qualifiers::OCL_Weak: name = "__weak"; break; 5218234353Sdim case Qualifiers::OCL_Autoreleasing: name = "__autoreleasing"; break; 5219234353Sdim } 5220261991Sdim S.Diag(AttrLoc, diag::warn_type_attribute_wrong_type) << name 5221261991Sdim << TDS_ObjCObjOrBlock << type; 5222234353Sdim } 5223234353Sdim 5224296417Sdim // Don't actually add the __unsafe_unretained qualifier in non-ARC files, 5225296417Sdim // because having both 'T' and '__unsafe_unretained T' exist in the type 5226296417Sdim // system causes unfortunate widespread consistency problems. (For example, 5227296417Sdim // they're not considered compatible types, and we mangle them identicially 5228296417Sdim // as template arguments.) These problems are all individually fixable, 5229296417Sdim // but it's easier to just not add the qualifier and instead sniff it out 5230296417Sdim // in specific places using isObjCInertUnsafeUnretainedType(). 5231296417Sdim // 5232296417Sdim // Doing this does means we miss some trivial consistency checks that 5233296417Sdim // would've triggered in ARC, but that's better than trying to solve all 5234296417Sdim // the coexistence problems with __unsafe_unretained. 5235296417Sdim if (!S.getLangOpts().ObjCAutoRefCount && 5236296417Sdim lifetime == Qualifiers::OCL_ExplicitNone) { 5237296417Sdim type = S.Context.getAttributedType( 5238296417Sdim AttributedType::attr_objc_inert_unsafe_unretained, 5239296417Sdim type, type); 5240296417Sdim return true; 5241296417Sdim } 5242296417Sdim 5243224145Sdim QualType origType = type; 5244234353Sdim if (!NonObjCPointer) 5245234353Sdim type = S.Context.getQualifiedType(underlyingType); 5246224145Sdim 5247224145Sdim // If we have a valid source location for the attribute, use an 5248224145Sdim // AttributedType instead. 5249226633Sdim if (AttrLoc.isValid()) 5250224145Sdim type = S.Context.getAttributedType(AttributedType::attr_objc_ownership, 5251224145Sdim origType, type); 5252224145Sdim 5253296417Sdim auto diagnoseOrDelay = [](Sema &S, SourceLocation loc, 5254296417Sdim unsigned diagnostic, QualType type) { 5255224145Sdim if (S.DelayedDiagnostics.shouldDelayDiagnostics()) { 5256224145Sdim S.DelayedDiagnostics.add( 5257226633Sdim sema::DelayedDiagnostic::makeForbiddenType( 5258296417Sdim S.getSourceManager().getExpansionLoc(loc), 5259296417Sdim diagnostic, type, /*ignored*/ 0)); 5260224145Sdim } else { 5261296417Sdim S.Diag(loc, diagnostic); 5262224145Sdim } 5263296417Sdim }; 5264224145Sdim 5265296417Sdim // Sometimes, __weak isn't allowed. 5266296417Sdim if (lifetime == Qualifiers::OCL_Weak && 5267296417Sdim !S.getLangOpts().ObjCWeak && !NonObjCPointer) { 5268296417Sdim 5269296417Sdim // Use a specialized diagnostic if the runtime just doesn't support them. 5270296417Sdim unsigned diagnostic = 5271296417Sdim (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled 5272296417Sdim : diag::err_arc_weak_no_runtime); 5273296417Sdim 5274296417Sdim // In any case, delay the diagnostic until we know what we're parsing. 5275296417Sdim diagnoseOrDelay(S, AttrLoc, diagnostic, type); 5276296417Sdim 5277224145Sdim attr.setInvalid(); 5278224145Sdim return true; 5279224145Sdim } 5280239462Sdim 5281239462Sdim // Forbid __weak for class objects marked as 5282224145Sdim // objc_arc_weak_reference_unavailable 5283224145Sdim if (lifetime == Qualifiers::OCL_Weak) { 5284249423Sdim if (const ObjCObjectPointerType *ObjT = 5285249423Sdim type->getAs<ObjCObjectPointerType>()) { 5286243830Sdim if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) { 5287243830Sdim if (Class->isArcWeakrefUnavailable()) { 5288296417Sdim S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class); 5289296417Sdim S.Diag(ObjT->getInterfaceDecl()->getLocation(), 5290296417Sdim diag::note_class_declared); 5291243830Sdim } 5292224145Sdim } 5293224145Sdim } 5294224145Sdim } 5295239462Sdim 5296224145Sdim return true; 5297224145Sdim} 5298224145Sdim 5299218893Sdim/// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type 5300218893Sdim/// attribute on the specified type. Returns true to indicate that 5301218893Sdim/// the attribute was handled, false to indicate that the type does 5302218893Sdim/// not permit the attribute. 5303218893Sdimstatic bool handleObjCGCTypeAttr(TypeProcessingState &state, 5304218893Sdim AttributeList &attr, 5305218893Sdim QualType &type) { 5306218893Sdim Sema &S = state.getSema(); 5307218893Sdim 5308218893Sdim // Delay if this isn't some kind of pointer. 5309218893Sdim if (!type->isPointerType() && 5310218893Sdim !type->isObjCObjectPointerType() && 5311218893Sdim !type->isBlockPointerType()) 5312218893Sdim return false; 5313218893Sdim 5314218893Sdim if (type.getObjCGCAttr() != Qualifiers::GCNone) { 5315218893Sdim S.Diag(attr.getLoc(), diag::err_attribute_multiple_objc_gc); 5316218893Sdim attr.setInvalid(); 5317218893Sdim return true; 5318193326Sed } 5319261991Sdim 5320193326Sed // Check the attribute arguments. 5321261991Sdim if (!attr.isArgIdent(0)) { 5322261991Sdim S.Diag(attr.getLoc(), diag::err_attribute_argument_type) 5323261991Sdim << attr.getName() << AANT_ArgumentString; 5324218893Sdim attr.setInvalid(); 5325218893Sdim return true; 5326193326Sed } 5327198092Srdivacky Qualifiers::GC GCAttr; 5328261991Sdim if (attr.getNumArgs() > 1) { 5329261991Sdim S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) 5330261991Sdim << attr.getName() << 1; 5331218893Sdim attr.setInvalid(); 5332218893Sdim return true; 5333193326Sed } 5334261991Sdim 5335261991Sdim IdentifierInfo *II = attr.getArgAsIdent(0)->Ident; 5336261991Sdim if (II->isStr("weak")) 5337198092Srdivacky GCAttr = Qualifiers::Weak; 5338261991Sdim else if (II->isStr("strong")) 5339198092Srdivacky GCAttr = Qualifiers::Strong; 5340193326Sed else { 5341218893Sdim S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported) 5342261991Sdim << attr.getName() << II; 5343218893Sdim attr.setInvalid(); 5344218893Sdim return true; 5345193326Sed } 5346198092Srdivacky 5347221345Sdim QualType origType = type; 5348221345Sdim type = S.Context.getObjCGCQualType(origType, GCAttr); 5349221345Sdim 5350221345Sdim // Make an attributed type to preserve the source information. 5351221345Sdim if (attr.getLoc().isValid()) 5352221345Sdim type = S.Context.getAttributedType(AttributedType::attr_objc_gc, 5353221345Sdim origType, type); 5354221345Sdim 5355218893Sdim return true; 5356193326Sed} 5357193326Sed 5358218893Sdimnamespace { 5359218893Sdim /// A helper class to unwrap a type down to a function for the 5360218893Sdim /// purposes of applying attributes there. 5361218893Sdim /// 5362218893Sdim /// Use: 5363218893Sdim /// FunctionTypeUnwrapper unwrapped(SemaRef, T); 5364218893Sdim /// if (unwrapped.isFunctionType()) { 5365218893Sdim /// const FunctionType *fn = unwrapped.get(); 5366218893Sdim /// // change fn somehow 5367218893Sdim /// T = unwrapped.wrap(fn); 5368218893Sdim /// } 5369218893Sdim struct FunctionTypeUnwrapper { 5370218893Sdim enum WrapKind { 5371218893Sdim Desugar, 5372218893Sdim Parens, 5373218893Sdim Pointer, 5374218893Sdim BlockPointer, 5375218893Sdim Reference, 5376218893Sdim MemberPointer 5377218893Sdim }; 5378218893Sdim 5379218893Sdim QualType Original; 5380218893Sdim const FunctionType *Fn; 5381226633Sdim SmallVector<unsigned char /*WrapKind*/, 8> Stack; 5382218893Sdim 5383218893Sdim FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) { 5384218893Sdim while (true) { 5385218893Sdim const Type *Ty = T.getTypePtr(); 5386218893Sdim if (isa<FunctionType>(Ty)) { 5387218893Sdim Fn = cast<FunctionType>(Ty); 5388218893Sdim return; 5389218893Sdim } else if (isa<ParenType>(Ty)) { 5390218893Sdim T = cast<ParenType>(Ty)->getInnerType(); 5391218893Sdim Stack.push_back(Parens); 5392218893Sdim } else if (isa<PointerType>(Ty)) { 5393218893Sdim T = cast<PointerType>(Ty)->getPointeeType(); 5394218893Sdim Stack.push_back(Pointer); 5395218893Sdim } else if (isa<BlockPointerType>(Ty)) { 5396218893Sdim T = cast<BlockPointerType>(Ty)->getPointeeType(); 5397218893Sdim Stack.push_back(BlockPointer); 5398218893Sdim } else if (isa<MemberPointerType>(Ty)) { 5399218893Sdim T = cast<MemberPointerType>(Ty)->getPointeeType(); 5400218893Sdim Stack.push_back(MemberPointer); 5401218893Sdim } else if (isa<ReferenceType>(Ty)) { 5402218893Sdim T = cast<ReferenceType>(Ty)->getPointeeType(); 5403218893Sdim Stack.push_back(Reference); 5404218893Sdim } else { 5405218893Sdim const Type *DTy = Ty->getUnqualifiedDesugaredType(); 5406218893Sdim if (Ty == DTy) { 5407276479Sdim Fn = nullptr; 5408218893Sdim return; 5409218893Sdim } 5410218893Sdim 5411218893Sdim T = QualType(DTy, 0); 5412218893Sdim Stack.push_back(Desugar); 5413218893Sdim } 5414218893Sdim } 5415203955Srdivacky } 5416198092Srdivacky 5417276479Sdim bool isFunctionType() const { return (Fn != nullptr); } 5418218893Sdim const FunctionType *get() const { return Fn; } 5419203955Srdivacky 5420218893Sdim QualType wrap(Sema &S, const FunctionType *New) { 5421218893Sdim // If T wasn't modified from the unwrapped type, do nothing. 5422218893Sdim if (New == get()) return Original; 5423218893Sdim 5424218893Sdim Fn = New; 5425218893Sdim return wrap(S.Context, Original, 0); 5426206084Srdivacky } 5427206084Srdivacky 5428218893Sdim private: 5429218893Sdim QualType wrap(ASTContext &C, QualType Old, unsigned I) { 5430218893Sdim if (I == Stack.size()) 5431218893Sdim return C.getQualifiedType(Fn, Old.getQualifiers()); 5432218893Sdim 5433218893Sdim // Build up the inner type, applying the qualifiers from the old 5434218893Sdim // type to the new type. 5435218893Sdim SplitQualType SplitOld = Old.split(); 5436218893Sdim 5437218893Sdim // As a special case, tail-recurse if there are no qualifiers. 5438234353Sdim if (SplitOld.Quals.empty()) 5439234353Sdim return wrap(C, SplitOld.Ty, I); 5440234353Sdim return C.getQualifiedType(wrap(C, SplitOld.Ty, I), SplitOld.Quals); 5441218893Sdim } 5442218893Sdim 5443218893Sdim QualType wrap(ASTContext &C, const Type *Old, unsigned I) { 5444218893Sdim if (I == Stack.size()) return QualType(Fn, 0); 5445218893Sdim 5446218893Sdim switch (static_cast<WrapKind>(Stack[I++])) { 5447218893Sdim case Desugar: 5448218893Sdim // This is the point at which we potentially lose source 5449218893Sdim // information. 5450218893Sdim return wrap(C, Old->getUnqualifiedDesugaredType(), I); 5451218893Sdim 5452218893Sdim case Parens: { 5453218893Sdim QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I); 5454218893Sdim return C.getParenType(New); 5455218893Sdim } 5456218893Sdim 5457218893Sdim case Pointer: { 5458218893Sdim QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I); 5459218893Sdim return C.getPointerType(New); 5460218893Sdim } 5461218893Sdim 5462218893Sdim case BlockPointer: { 5463218893Sdim QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I); 5464218893Sdim return C.getBlockPointerType(New); 5465218893Sdim } 5466218893Sdim 5467218893Sdim case MemberPointer: { 5468218893Sdim const MemberPointerType *OldMPT = cast<MemberPointerType>(Old); 5469218893Sdim QualType New = wrap(C, OldMPT->getPointeeType(), I); 5470218893Sdim return C.getMemberPointerType(New, OldMPT->getClass()); 5471218893Sdim } 5472218893Sdim 5473218893Sdim case Reference: { 5474218893Sdim const ReferenceType *OldRef = cast<ReferenceType>(Old); 5475218893Sdim QualType New = wrap(C, OldRef->getPointeeType(), I); 5476218893Sdim if (isa<LValueReferenceType>(OldRef)) 5477218893Sdim return C.getLValueReferenceType(New, OldRef->isSpelledAsLValue()); 5478218893Sdim else 5479218893Sdim return C.getRValueReferenceType(New); 5480218893Sdim } 5481218893Sdim } 5482218893Sdim 5483218893Sdim llvm_unreachable("unknown wrapping kind"); 5484218893Sdim } 5485218893Sdim }; 5486218893Sdim} 5487218893Sdim 5488261991Sdimstatic bool handleMSPointerTypeQualifierAttr(TypeProcessingState &State, 5489261991Sdim AttributeList &Attr, 5490261991Sdim QualType &Type) { 5491261991Sdim Sema &S = State.getSema(); 5492261991Sdim 5493261991Sdim AttributeList::Kind Kind = Attr.getKind(); 5494261991Sdim QualType Desugared = Type; 5495261991Sdim const AttributedType *AT = dyn_cast<AttributedType>(Type); 5496261991Sdim while (AT) { 5497261991Sdim AttributedType::Kind CurAttrKind = AT->getAttrKind(); 5498261991Sdim 5499261991Sdim // You cannot specify duplicate type attributes, so if the attribute has 5500261991Sdim // already been applied, flag it. 5501261991Sdim if (getAttrListKind(CurAttrKind) == Kind) { 5502261991Sdim S.Diag(Attr.getLoc(), diag::warn_duplicate_attribute_exact) 5503261991Sdim << Attr.getName(); 5504261991Sdim return true; 5505261991Sdim } 5506261991Sdim 5507261991Sdim // You cannot have both __sptr and __uptr on the same type, nor can you 5508261991Sdim // have __ptr32 and __ptr64. 5509261991Sdim if ((CurAttrKind == AttributedType::attr_ptr32 && 5510261991Sdim Kind == AttributeList::AT_Ptr64) || 5511261991Sdim (CurAttrKind == AttributedType::attr_ptr64 && 5512261991Sdim Kind == AttributeList::AT_Ptr32)) { 5513261991Sdim S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 5514261991Sdim << "'__ptr32'" << "'__ptr64'"; 5515261991Sdim return true; 5516261991Sdim } else if ((CurAttrKind == AttributedType::attr_sptr && 5517261991Sdim Kind == AttributeList::AT_UPtr) || 5518261991Sdim (CurAttrKind == AttributedType::attr_uptr && 5519261991Sdim Kind == AttributeList::AT_SPtr)) { 5520261991Sdim S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 5521261991Sdim << "'__sptr'" << "'__uptr'"; 5522261991Sdim return true; 5523261991Sdim } 5524261991Sdim 5525261991Sdim Desugared = AT->getEquivalentType(); 5526261991Sdim AT = dyn_cast<AttributedType>(Desugared); 5527261991Sdim } 5528261991Sdim 5529261991Sdim // Pointer type qualifiers can only operate on pointer types, but not 5530261991Sdim // pointer-to-member types. 5531261991Sdim if (!isa<PointerType>(Desugared)) { 5532296417Sdim if (Type->isMemberPointerType()) 5533296417Sdim S.Diag(Attr.getLoc(), diag::err_attribute_no_member_pointers) 5534296417Sdim << Attr.getName(); 5535296417Sdim else 5536296417Sdim S.Diag(Attr.getLoc(), diag::err_attribute_pointers_only) 5537296417Sdim << Attr.getName() << 0; 5538261991Sdim return true; 5539261991Sdim } 5540261991Sdim 5541261991Sdim AttributedType::Kind TAK; 5542261991Sdim switch (Kind) { 5543261991Sdim default: llvm_unreachable("Unknown attribute kind"); 5544261991Sdim case AttributeList::AT_Ptr32: TAK = AttributedType::attr_ptr32; break; 5545261991Sdim case AttributeList::AT_Ptr64: TAK = AttributedType::attr_ptr64; break; 5546261991Sdim case AttributeList::AT_SPtr: TAK = AttributedType::attr_sptr; break; 5547261991Sdim case AttributeList::AT_UPtr: TAK = AttributedType::attr_uptr; break; 5548261991Sdim } 5549261991Sdim 5550261991Sdim Type = S.Context.getAttributedType(TAK, Type, Type); 5551261991Sdim return false; 5552261991Sdim} 5553261991Sdim 5554288943Sdimbool Sema::checkNullabilityTypeSpecifier(QualType &type, 5555288943Sdim NullabilityKind nullability, 5556288943Sdim SourceLocation nullabilityLoc, 5557288943Sdim bool isContextSensitive) { 5558288943Sdim // We saw a nullability type specifier. If this is the first one for 5559288943Sdim // this file, note that. 5560288943Sdim FileID file = getNullabilityCompletenessCheckFileID(*this, nullabilityLoc); 5561288943Sdim if (!file.isInvalid()) { 5562288943Sdim FileNullability &fileNullability = NullabilityMap[file]; 5563288943Sdim if (!fileNullability.SawTypeNullability) { 5564288943Sdim // If we have already seen a pointer declarator without a nullability 5565288943Sdim // annotation, complain about it. 5566288943Sdim if (fileNullability.PointerLoc.isValid()) { 5567288943Sdim Diag(fileNullability.PointerLoc, diag::warn_nullability_missing) 5568288943Sdim << static_cast<unsigned>(fileNullability.PointerKind); 5569288943Sdim } 5570288943Sdim 5571288943Sdim fileNullability.SawTypeNullability = true; 5572288943Sdim } 5573288943Sdim } 5574288943Sdim 5575288943Sdim // Check for existing nullability attributes on the type. 5576288943Sdim QualType desugared = type; 5577288943Sdim while (auto attributed = dyn_cast<AttributedType>(desugared.getTypePtr())) { 5578288943Sdim // Check whether there is already a null 5579288943Sdim if (auto existingNullability = attributed->getImmediateNullability()) { 5580288943Sdim // Duplicated nullability. 5581288943Sdim if (nullability == *existingNullability) { 5582288943Sdim Diag(nullabilityLoc, diag::warn_nullability_duplicate) 5583288943Sdim << DiagNullabilityKind(nullability, isContextSensitive) 5584288943Sdim << FixItHint::CreateRemoval(nullabilityLoc); 5585288943Sdim 5586288943Sdim break; 5587288943Sdim } 5588288943Sdim 5589288943Sdim // Conflicting nullability. 5590288943Sdim Diag(nullabilityLoc, diag::err_nullability_conflicting) 5591288943Sdim << DiagNullabilityKind(nullability, isContextSensitive) 5592288943Sdim << DiagNullabilityKind(*existingNullability, false); 5593288943Sdim return true; 5594288943Sdim } 5595288943Sdim 5596288943Sdim desugared = attributed->getModifiedType(); 5597288943Sdim } 5598288943Sdim 5599288943Sdim // If there is already a different nullability specifier, complain. 5600288943Sdim // This (unlike the code above) looks through typedefs that might 5601288943Sdim // have nullability specifiers on them, which means we cannot 5602288943Sdim // provide a useful Fix-It. 5603288943Sdim if (auto existingNullability = desugared->getNullability(Context)) { 5604288943Sdim if (nullability != *existingNullability) { 5605288943Sdim Diag(nullabilityLoc, diag::err_nullability_conflicting) 5606288943Sdim << DiagNullabilityKind(nullability, isContextSensitive) 5607288943Sdim << DiagNullabilityKind(*existingNullability, false); 5608288943Sdim 5609288943Sdim // Try to find the typedef with the existing nullability specifier. 5610288943Sdim if (auto typedefType = desugared->getAs<TypedefType>()) { 5611288943Sdim TypedefNameDecl *typedefDecl = typedefType->getDecl(); 5612288943Sdim QualType underlyingType = typedefDecl->getUnderlyingType(); 5613288943Sdim if (auto typedefNullability 5614288943Sdim = AttributedType::stripOuterNullability(underlyingType)) { 5615288943Sdim if (*typedefNullability == *existingNullability) { 5616288943Sdim Diag(typedefDecl->getLocation(), diag::note_nullability_here) 5617288943Sdim << DiagNullabilityKind(*existingNullability, false); 5618288943Sdim } 5619288943Sdim } 5620288943Sdim } 5621288943Sdim 5622288943Sdim return true; 5623288943Sdim } 5624288943Sdim } 5625288943Sdim 5626288943Sdim // If this definitely isn't a pointer type, reject the specifier. 5627288943Sdim if (!desugared->canHaveNullability()) { 5628288943Sdim Diag(nullabilityLoc, diag::err_nullability_nonpointer) 5629288943Sdim << DiagNullabilityKind(nullability, isContextSensitive) << type; 5630288943Sdim return true; 5631288943Sdim } 5632288943Sdim 5633288943Sdim // For the context-sensitive keywords/Objective-C property 5634288943Sdim // attributes, require that the type be a single-level pointer. 5635288943Sdim if (isContextSensitive) { 5636288943Sdim // Make sure that the pointee isn't itself a pointer type. 5637288943Sdim QualType pointeeType = desugared->getPointeeType(); 5638288943Sdim if (pointeeType->isAnyPointerType() || 5639288943Sdim pointeeType->isObjCObjectPointerType() || 5640288943Sdim pointeeType->isMemberPointerType()) { 5641288943Sdim Diag(nullabilityLoc, diag::err_nullability_cs_multilevel) 5642288943Sdim << DiagNullabilityKind(nullability, true) 5643288943Sdim << type; 5644288943Sdim Diag(nullabilityLoc, diag::note_nullability_type_specifier) 5645288943Sdim << DiagNullabilityKind(nullability, false) 5646288943Sdim << type 5647288943Sdim << FixItHint::CreateReplacement(nullabilityLoc, 5648288943Sdim getNullabilitySpelling(nullability)); 5649288943Sdim return true; 5650288943Sdim } 5651288943Sdim } 5652288943Sdim 5653288943Sdim // Form the attributed type. 5654288943Sdim type = Context.getAttributedType( 5655288943Sdim AttributedType::getNullabilityAttrKind(nullability), type, type); 5656288943Sdim return false; 5657288943Sdim} 5658288943Sdim 5659288943Sdimbool Sema::checkObjCKindOfType(QualType &type, SourceLocation loc) { 5660288943Sdim // Find out if it's an Objective-C object or object pointer type; 5661288943Sdim const ObjCObjectPointerType *ptrType = type->getAs<ObjCObjectPointerType>(); 5662288943Sdim const ObjCObjectType *objType = ptrType ? ptrType->getObjectType() 5663288943Sdim : type->getAs<ObjCObjectType>(); 5664288943Sdim 5665288943Sdim // If not, we can't apply __kindof. 5666288943Sdim if (!objType) { 5667288943Sdim // FIXME: Handle dependent types that aren't yet object types. 5668288943Sdim Diag(loc, diag::err_objc_kindof_nonobject) 5669288943Sdim << type; 5670288943Sdim return true; 5671288943Sdim } 5672288943Sdim 5673288943Sdim // Rebuild the "equivalent" type, which pushes __kindof down into 5674288943Sdim // the object type. 5675288943Sdim QualType equivType = Context.getObjCObjectType(objType->getBaseType(), 5676288943Sdim objType->getTypeArgsAsWritten(), 5677288943Sdim objType->getProtocols(), 5678288943Sdim /*isKindOf=*/true); 5679288943Sdim 5680288943Sdim // If we started with an object pointer type, rebuild it. 5681288943Sdim if (ptrType) { 5682288943Sdim equivType = Context.getObjCObjectPointerType(equivType); 5683288943Sdim if (auto nullability = type->getNullability(Context)) { 5684288943Sdim auto attrKind = AttributedType::getNullabilityAttrKind(*nullability); 5685288943Sdim equivType = Context.getAttributedType(attrKind, equivType, equivType); 5686288943Sdim } 5687288943Sdim } 5688288943Sdim 5689288943Sdim // Build the attributed type to record where __kindof occurred. 5690288943Sdim type = Context.getAttributedType(AttributedType::attr_objc_kindof, 5691288943Sdim type, 5692288943Sdim equivType); 5693288943Sdim 5694288943Sdim return false; 5695288943Sdim} 5696288943Sdim 5697288943Sdim/// Map a nullability attribute kind to a nullability kind. 5698288943Sdimstatic NullabilityKind mapNullabilityAttrKind(AttributeList::Kind kind) { 5699288943Sdim switch (kind) { 5700288943Sdim case AttributeList::AT_TypeNonNull: 5701288943Sdim return NullabilityKind::NonNull; 5702288943Sdim 5703288943Sdim case AttributeList::AT_TypeNullable: 5704288943Sdim return NullabilityKind::Nullable; 5705288943Sdim 5706288943Sdim case AttributeList::AT_TypeNullUnspecified: 5707288943Sdim return NullabilityKind::Unspecified; 5708288943Sdim 5709288943Sdim default: 5710288943Sdim llvm_unreachable("not a nullability attribute kind"); 5711288943Sdim } 5712288943Sdim} 5713288943Sdim 5714288943Sdim/// Distribute a nullability type attribute that cannot be applied to 5715288943Sdim/// the type specifier to a pointer, block pointer, or member pointer 5716288943Sdim/// declarator, complaining if necessary. 5717288943Sdim/// 5718288943Sdim/// \returns true if the nullability annotation was distributed, false 5719288943Sdim/// otherwise. 5720288943Sdimstatic bool distributeNullabilityTypeAttr(TypeProcessingState &state, 5721288943Sdim QualType type, 5722288943Sdim AttributeList &attr) { 5723288943Sdim Declarator &declarator = state.getDeclarator(); 5724288943Sdim 5725288943Sdim /// Attempt to move the attribute to the specified chunk. 5726288943Sdim auto moveToChunk = [&](DeclaratorChunk &chunk, bool inFunction) -> bool { 5727288943Sdim // If there is already a nullability attribute there, don't add 5728288943Sdim // one. 5729288943Sdim if (hasNullabilityAttr(chunk.getAttrListRef())) 5730288943Sdim return false; 5731288943Sdim 5732288943Sdim // Complain about the nullability qualifier being in the wrong 5733288943Sdim // place. 5734288943Sdim enum { 5735288943Sdim PK_Pointer, 5736288943Sdim PK_BlockPointer, 5737288943Sdim PK_MemberPointer, 5738288943Sdim PK_FunctionPointer, 5739288943Sdim PK_MemberFunctionPointer, 5740288943Sdim } pointerKind 5741288943Sdim = chunk.Kind == DeclaratorChunk::Pointer ? (inFunction ? PK_FunctionPointer 5742288943Sdim : PK_Pointer) 5743288943Sdim : chunk.Kind == DeclaratorChunk::BlockPointer ? PK_BlockPointer 5744288943Sdim : inFunction? PK_MemberFunctionPointer : PK_MemberPointer; 5745288943Sdim 5746288943Sdim auto diag = state.getSema().Diag(attr.getLoc(), 5747288943Sdim diag::warn_nullability_declspec) 5748288943Sdim << DiagNullabilityKind(mapNullabilityAttrKind(attr.getKind()), 5749288943Sdim attr.isContextSensitiveKeywordAttribute()) 5750288943Sdim << type 5751288943Sdim << static_cast<unsigned>(pointerKind); 5752288943Sdim 5753288943Sdim // FIXME: MemberPointer chunks don't carry the location of the *. 5754288943Sdim if (chunk.Kind != DeclaratorChunk::MemberPointer) { 5755288943Sdim diag << FixItHint::CreateRemoval(attr.getLoc()) 5756288943Sdim << FixItHint::CreateInsertion( 5757288943Sdim state.getSema().getPreprocessor() 5758288943Sdim .getLocForEndOfToken(chunk.Loc), 5759288943Sdim " " + attr.getName()->getName().str() + " "); 5760288943Sdim } 5761288943Sdim 5762288943Sdim moveAttrFromListToList(attr, state.getCurrentAttrListRef(), 5763288943Sdim chunk.getAttrListRef()); 5764288943Sdim return true; 5765288943Sdim }; 5766288943Sdim 5767288943Sdim // Move it to the outermost pointer, member pointer, or block 5768288943Sdim // pointer declarator. 5769288943Sdim for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) { 5770288943Sdim DeclaratorChunk &chunk = declarator.getTypeObject(i-1); 5771288943Sdim switch (chunk.Kind) { 5772288943Sdim case DeclaratorChunk::Pointer: 5773288943Sdim case DeclaratorChunk::BlockPointer: 5774288943Sdim case DeclaratorChunk::MemberPointer: 5775288943Sdim return moveToChunk(chunk, false); 5776288943Sdim 5777288943Sdim case DeclaratorChunk::Paren: 5778288943Sdim case DeclaratorChunk::Array: 5779288943Sdim continue; 5780288943Sdim 5781288943Sdim case DeclaratorChunk::Function: 5782288943Sdim // Try to move past the return type to a function/block/member 5783288943Sdim // function pointer. 5784288943Sdim if (DeclaratorChunk *dest = maybeMovePastReturnType( 5785288943Sdim declarator, i, 5786288943Sdim /*onlyBlockPointers=*/false)) { 5787288943Sdim return moveToChunk(*dest, true); 5788288943Sdim } 5789288943Sdim 5790288943Sdim return false; 5791288943Sdim 5792288943Sdim // Don't walk through these. 5793288943Sdim case DeclaratorChunk::Reference: 5794296417Sdim case DeclaratorChunk::Pipe: 5795288943Sdim return false; 5796288943Sdim } 5797288943Sdim } 5798288943Sdim 5799288943Sdim return false; 5800288943Sdim} 5801288943Sdim 5802261991Sdimstatic AttributedType::Kind getCCTypeAttrKind(AttributeList &Attr) { 5803261991Sdim assert(!Attr.isInvalid()); 5804261991Sdim switch (Attr.getKind()) { 5805261991Sdim default: 5806261991Sdim llvm_unreachable("not a calling convention attribute"); 5807261991Sdim case AttributeList::AT_CDecl: 5808261991Sdim return AttributedType::attr_cdecl; 5809261991Sdim case AttributeList::AT_FastCall: 5810261991Sdim return AttributedType::attr_fastcall; 5811261991Sdim case AttributeList::AT_StdCall: 5812261991Sdim return AttributedType::attr_stdcall; 5813261991Sdim case AttributeList::AT_ThisCall: 5814261991Sdim return AttributedType::attr_thiscall; 5815261991Sdim case AttributeList::AT_Pascal: 5816261991Sdim return AttributedType::attr_pascal; 5817280031Sdim case AttributeList::AT_VectorCall: 5818280031Sdim return AttributedType::attr_vectorcall; 5819261991Sdim case AttributeList::AT_Pcs: { 5820261991Sdim // The attribute may have had a fixit applied where we treated an 5821261991Sdim // identifier as a string literal. The contents of the string are valid, 5822261991Sdim // but the form may not be. 5823261991Sdim StringRef Str; 5824261991Sdim if (Attr.isArgExpr(0)) 5825261991Sdim Str = cast<StringLiteral>(Attr.getArgAsExpr(0))->getString(); 5826261991Sdim else 5827261991Sdim Str = Attr.getArgAsIdent(0)->Ident->getName(); 5828261991Sdim return llvm::StringSwitch<AttributedType::Kind>(Str) 5829261991Sdim .Case("aapcs", AttributedType::attr_pcs) 5830261991Sdim .Case("aapcs-vfp", AttributedType::attr_pcs_vfp); 5831261991Sdim } 5832261991Sdim case AttributeList::AT_IntelOclBicc: 5833261991Sdim return AttributedType::attr_inteloclbicc; 5834261991Sdim case AttributeList::AT_MSABI: 5835261991Sdim return AttributedType::attr_ms_abi; 5836261991Sdim case AttributeList::AT_SysVABI: 5837261991Sdim return AttributedType::attr_sysv_abi; 5838261991Sdim } 5839261991Sdim llvm_unreachable("unexpected attribute kind!"); 5840261991Sdim} 5841261991Sdim 5842218893Sdim/// Process an individual function attribute. Returns true to 5843218893Sdim/// indicate that the attribute was handled, false if it wasn't. 5844218893Sdimstatic bool handleFunctionTypeAttr(TypeProcessingState &state, 5845218893Sdim AttributeList &attr, 5846218893Sdim QualType &type) { 5847218893Sdim Sema &S = state.getSema(); 5848218893Sdim 5849218893Sdim FunctionTypeUnwrapper unwrapped(S, type); 5850218893Sdim 5851239462Sdim if (attr.getKind() == AttributeList::AT_NoReturn) { 5852218893Sdim if (S.CheckNoReturnAttr(attr)) 5853206084Srdivacky return true; 5854206084Srdivacky 5855218893Sdim // Delay if this is not a function type. 5856218893Sdim if (!unwrapped.isFunctionType()) 5857218893Sdim return false; 5858218893Sdim 5859206084Srdivacky // Otherwise we can process right away. 5860218893Sdim FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withNoReturn(true); 5861218893Sdim type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 5862218893Sdim return true; 5863218893Sdim } 5864206084Srdivacky 5865224145Sdim // ns_returns_retained is not always a type attribute, but if we got 5866224145Sdim // here, we're treating it as one right now. 5867239462Sdim if (attr.getKind() == AttributeList::AT_NSReturnsRetained) { 5868234353Sdim assert(S.getLangOpts().ObjCAutoRefCount && 5869224145Sdim "ns_returns_retained treated as type attribute in non-ARC"); 5870224145Sdim if (attr.getNumArgs()) return true; 5871224145Sdim 5872224145Sdim // Delay if this is not a function type. 5873224145Sdim if (!unwrapped.isFunctionType()) 5874224145Sdim return false; 5875224145Sdim 5876224145Sdim FunctionType::ExtInfo EI 5877224145Sdim = unwrapped.get()->getExtInfo().withProducesResult(true); 5878224145Sdim type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 5879224145Sdim return true; 5880224145Sdim } 5881224145Sdim 5882239462Sdim if (attr.getKind() == AttributeList::AT_Regparm) { 5883218893Sdim unsigned value; 5884218893Sdim if (S.CheckRegparmAttr(attr, value)) 5885218893Sdim return true; 5886218893Sdim 5887218893Sdim // Delay if this is not a function type. 5888218893Sdim if (!unwrapped.isFunctionType()) 5889206084Srdivacky return false; 5890206084Srdivacky 5891218893Sdim // Diagnose regparm with fastcall. 5892218893Sdim const FunctionType *fn = unwrapped.get(); 5893218893Sdim CallingConv CC = fn->getCallConv(); 5894218893Sdim if (CC == CC_X86FastCall) { 5895218893Sdim S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 5896218893Sdim << FunctionType::getNameForCallConv(CC) 5897218893Sdim << "regparm"; 5898218893Sdim attr.setInvalid(); 5899218893Sdim return true; 5900218893Sdim } 5901218893Sdim 5902239462Sdim FunctionType::ExtInfo EI = 5903218893Sdim unwrapped.get()->getExtInfo().withRegParm(value); 5904218893Sdim type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 5905218893Sdim return true; 5906206084Srdivacky } 5907206084Srdivacky 5908243830Sdim // Delay if the type didn't work out to a function. 5909243830Sdim if (!unwrapped.isFunctionType()) return false; 5910243830Sdim 5911203955Srdivacky // Otherwise, a calling convention. 5912218893Sdim CallingConv CC; 5913218893Sdim if (S.CheckCallingConvAttr(attr, CC)) 5914218893Sdim return true; 5915203955Srdivacky 5916218893Sdim const FunctionType *fn = unwrapped.get(); 5917218893Sdim CallingConv CCOld = fn->getCallConv(); 5918261991Sdim AttributedType::Kind CCAttrKind = getCCTypeAttrKind(attr); 5919261991Sdim 5920261991Sdim if (CCOld != CC) { 5921261991Sdim // Error out on when there's already an attribute on the type 5922261991Sdim // and the CCs don't match. 5923261991Sdim const AttributedType *AT = S.getCallingConvAttributedType(type); 5924261991Sdim if (AT && AT->getAttrKind() != CCAttrKind) { 5925261991Sdim S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 5926261991Sdim << FunctionType::getNameForCallConv(CC) 5927261991Sdim << FunctionType::getNameForCallConv(CCOld); 5928261991Sdim attr.setInvalid(); 5929261991Sdim return true; 5930261991Sdim } 5931207619Srdivacky } 5932203955Srdivacky 5933261991Sdim // Diagnose use of callee-cleanup calling convention on variadic functions. 5934280031Sdim if (!supportsVariadicCall(CC)) { 5935261991Sdim const FunctionProtoType *FnP = dyn_cast<FunctionProtoType>(fn); 5936261991Sdim if (FnP && FnP->isVariadic()) { 5937261991Sdim unsigned DiagID = diag::err_cconv_varargs; 5938261991Sdim // stdcall and fastcall are ignored with a warning for GCC and MS 5939261991Sdim // compatibility. 5940261991Sdim if (CC == CC_X86StdCall || CC == CC_X86FastCall) 5941261991Sdim DiagID = diag::warn_cconv_varargs; 5942261991Sdim 5943261991Sdim S.Diag(attr.getLoc(), DiagID) << FunctionType::getNameForCallConv(CC); 5944261991Sdim attr.setInvalid(); 5945261991Sdim return true; 5946261991Sdim } 5947203955Srdivacky } 5948203955Srdivacky 5949280031Sdim // Also diagnose fastcall with regparm. 5950280031Sdim if (CC == CC_X86FastCall && fn->getHasRegParm()) { 5951280031Sdim S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible) 5952280031Sdim << "regparm" << FunctionType::getNameForCallConv(CC_X86FastCall); 5953280031Sdim attr.setInvalid(); 5954280031Sdim return true; 5955203955Srdivacky } 5956203955Srdivacky 5957261991Sdim // Modify the CC from the wrapped function type, wrap it all back, and then 5958261991Sdim // wrap the whole thing in an AttributedType as written. The modified type 5959261991Sdim // might have a different CC if we ignored the attribute. 5960218893Sdim FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withCallingConv(CC); 5961261991Sdim QualType Equivalent = 5962261991Sdim unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI)); 5963261991Sdim type = S.Context.getAttributedType(CCAttrKind, type, Equivalent); 5964218893Sdim return true; 5965198092Srdivacky} 5966198092Srdivacky 5967276479Sdimbool Sema::hasExplicitCallingConv(QualType &T) { 5968276479Sdim QualType R = T.IgnoreParens(); 5969276479Sdim while (const AttributedType *AT = dyn_cast<AttributedType>(R)) { 5970276479Sdim if (AT->isCallingConv()) 5971276479Sdim return true; 5972276479Sdim R = AT->getModifiedType().IgnoreParens(); 5973276479Sdim } 5974276479Sdim return false; 5975276479Sdim} 5976276479Sdim 5977296417Sdimvoid Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, 5978296417Sdim SourceLocation Loc) { 5979276479Sdim FunctionTypeUnwrapper Unwrapped(*this, T); 5980276479Sdim const FunctionType *FT = Unwrapped.get(); 5981261991Sdim bool IsVariadic = (isa<FunctionProtoType>(FT) && 5982261991Sdim cast<FunctionProtoType>(FT)->isVariadic()); 5983276479Sdim CallingConv CurCC = FT->getCallConv(); 5984276479Sdim CallingConv ToCC = Context.getDefaultCallingConvention(IsVariadic, !IsStatic); 5985261991Sdim 5986296417Sdim if (CurCC == ToCC) 5987276479Sdim return; 5988261991Sdim 5989296417Sdim // MS compiler ignores explicit calling convention attributes on structors. We 5990296417Sdim // should do the same. 5991296417Sdim if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) { 5992296417Sdim // Issue a warning on ignored calling convention -- except of __stdcall. 5993296417Sdim // Again, this is what MS compiler does. 5994296417Sdim if (CurCC != CC_X86StdCall) 5995296417Sdim Diag(Loc, diag::warn_cconv_structors) 5996296417Sdim << FunctionType::getNameForCallConv(CurCC); 5997296417Sdim // Default adjustment. 5998296417Sdim } else { 5999296417Sdim // Only adjust types with the default convention. For example, on Windows 6000296417Sdim // we should adjust a __cdecl type to __thiscall for instance methods, and a 6001296417Sdim // __thiscall type to __cdecl for static methods. 6002296417Sdim CallingConv DefaultCC = 6003296417Sdim Context.getDefaultCallingConvention(IsVariadic, IsStatic); 6004296417Sdim 6005296417Sdim if (CurCC != DefaultCC || DefaultCC == ToCC) 6006296417Sdim return; 6007296417Sdim 6008296417Sdim if (hasExplicitCallingConv(T)) 6009296417Sdim return; 6010296417Sdim } 6011296417Sdim 6012276479Sdim FT = Context.adjustFunctionType(FT, FT->getExtInfo().withCallingConv(ToCC)); 6013276479Sdim QualType Wrapped = Unwrapped.wrap(*this, FT); 6014276479Sdim T = Context.getAdjustedType(T, Wrapped); 6015261991Sdim} 6016261991Sdim 6017200583Srdivacky/// HandleVectorSizeAttribute - this attribute is only applicable to integral 6018200583Srdivacky/// and float scalars, although arrays, pointers, and function return values are 6019200583Srdivacky/// allowed in conjunction with this construct. Aggregates with this attribute 6020200583Srdivacky/// are invalid, even if they are of the same size as a corresponding scalar. 6021200583Srdivacky/// The raw attribute should contain precisely 1 argument, the vector size for 6022200583Srdivacky/// the variable, measured in bytes. If curType and rawAttr are well formed, 6023200583Srdivacky/// this routine will return a new vector type. 6024210299Sedstatic void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr, 6025210299Sed Sema &S) { 6026218893Sdim // Check the attribute arguments. 6027200583Srdivacky if (Attr.getNumArgs() != 1) { 6028261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6029261991Sdim << Attr.getName() << 1; 6030207619Srdivacky Attr.setInvalid(); 6031200583Srdivacky return; 6032200583Srdivacky } 6033261991Sdim Expr *sizeExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 6034200583Srdivacky llvm::APSInt vecSize(32); 6035208600Srdivacky if (sizeExpr->isTypeDependent() || sizeExpr->isValueDependent() || 6036208600Srdivacky !sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) { 6037261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 6038261991Sdim << Attr.getName() << AANT_ArgumentIntegerConstant 6039261991Sdim << sizeExpr->getSourceRange(); 6040207619Srdivacky Attr.setInvalid(); 6041200583Srdivacky return; 6042200583Srdivacky } 6043261991Sdim // The base type must be integer (not Boolean or enumeration) or float, and 6044261991Sdim // can't already be a vector. 6045261991Sdim if (!CurType->isBuiltinType() || CurType->isBooleanType() || 6046261991Sdim (!CurType->isIntegerType() && !CurType->isRealFloatingType())) { 6047200583Srdivacky S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType; 6048207619Srdivacky Attr.setInvalid(); 6049200583Srdivacky return; 6050200583Srdivacky } 6051200583Srdivacky unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType)); 6052200583Srdivacky // vecSize is specified in bytes - convert to bits. 6053200583Srdivacky unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8); 6054200583Srdivacky 6055200583Srdivacky // the vector size needs to be an integral multiple of the type size. 6056200583Srdivacky if (vectorSize % typeSize) { 6057200583Srdivacky S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size) 6058200583Srdivacky << sizeExpr->getSourceRange(); 6059207619Srdivacky Attr.setInvalid(); 6060200583Srdivacky return; 6061200583Srdivacky } 6062261991Sdim if (VectorType::isVectorSizeTooLarge(vectorSize / typeSize)) { 6063261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_size_too_large) 6064261991Sdim << sizeExpr->getSourceRange(); 6065261991Sdim Attr.setInvalid(); 6066261991Sdim return; 6067261991Sdim } 6068200583Srdivacky if (vectorSize == 0) { 6069200583Srdivacky S.Diag(Attr.getLoc(), diag::err_attribute_zero_size) 6070200583Srdivacky << sizeExpr->getSourceRange(); 6071207619Srdivacky Attr.setInvalid(); 6072200583Srdivacky return; 6073200583Srdivacky } 6074200583Srdivacky 6075200583Srdivacky // Success! Instantiate the vector type, the number of elements is > 0, and 6076200583Srdivacky // not required to be a power of 2, unlike GCC. 6077210299Sed CurType = S.Context.getVectorType(CurType, vectorSize/typeSize, 6078218893Sdim VectorType::GenericVector); 6079200583Srdivacky} 6080200583Srdivacky 6081224145Sdim/// \brief Process the OpenCL-like ext_vector_type attribute when it occurs on 6082224145Sdim/// a type. 6083239462Sdimstatic void HandleExtVectorTypeAttr(QualType &CurType, 6084239462Sdim const AttributeList &Attr, 6085224145Sdim Sema &S) { 6086261991Sdim // check the attribute arguments. 6087261991Sdim if (Attr.getNumArgs() != 1) { 6088261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6089261991Sdim << Attr.getName() << 1; 6090261991Sdim return; 6091261991Sdim } 6092261991Sdim 6093224145Sdim Expr *sizeExpr; 6094239462Sdim 6095224145Sdim // Special case where the argument is a template id. 6096261991Sdim if (Attr.isArgIdent(0)) { 6097224145Sdim CXXScopeSpec SS; 6098234353Sdim SourceLocation TemplateKWLoc; 6099224145Sdim UnqualifiedId id; 6100261991Sdim id.setIdentifier(Attr.getArgAsIdent(0)->Ident, Attr.getLoc()); 6101234353Sdim 6102234353Sdim ExprResult Size = S.ActOnIdExpression(S.getCurScope(), SS, TemplateKWLoc, 6103234353Sdim id, false, false); 6104224145Sdim if (Size.isInvalid()) 6105224145Sdim return; 6106239462Sdim 6107224145Sdim sizeExpr = Size.get(); 6108224145Sdim } else { 6109261991Sdim sizeExpr = Attr.getArgAsExpr(0); 6110224145Sdim } 6111239462Sdim 6112224145Sdim // Create the vector type. 6113224145Sdim QualType T = S.BuildExtVectorType(CurType, sizeExpr, Attr.getLoc()); 6114224145Sdim if (!T.isNull()) 6115224145Sdim CurType = T; 6116224145Sdim} 6117224145Sdim 6118261991Sdimstatic bool isPermittedNeonBaseType(QualType &Ty, 6119276479Sdim VectorType::VectorKind VecKind, Sema &S) { 6120261991Sdim const BuiltinType *BTy = Ty->getAs<BuiltinType>(); 6121261991Sdim if (!BTy) 6122261991Sdim return false; 6123261991Sdim 6124276479Sdim llvm::Triple Triple = S.Context.getTargetInfo().getTriple(); 6125276479Sdim 6126276479Sdim // Signed poly is mathematically wrong, but has been baked into some ABIs by 6127276479Sdim // now. 6128276479Sdim bool IsPolyUnsigned = Triple.getArch() == llvm::Triple::aarch64 || 6129280031Sdim Triple.getArch() == llvm::Triple::aarch64_be; 6130261991Sdim if (VecKind == VectorType::NeonPolyVector) { 6131276479Sdim if (IsPolyUnsigned) { 6132261991Sdim // AArch64 polynomial vectors are unsigned and support poly64. 6133261991Sdim return BTy->getKind() == BuiltinType::UChar || 6134261991Sdim BTy->getKind() == BuiltinType::UShort || 6135276479Sdim BTy->getKind() == BuiltinType::ULong || 6136261991Sdim BTy->getKind() == BuiltinType::ULongLong; 6137261991Sdim } else { 6138261991Sdim // AArch32 polynomial vector are signed. 6139261991Sdim return BTy->getKind() == BuiltinType::SChar || 6140261991Sdim BTy->getKind() == BuiltinType::Short; 6141261991Sdim } 6142261991Sdim } 6143261991Sdim 6144261991Sdim // Non-polynomial vector types: the usual suspects are allowed, as well as 6145261991Sdim // float64_t on AArch64. 6146276479Sdim bool Is64Bit = Triple.getArch() == llvm::Triple::aarch64 || 6147280031Sdim Triple.getArch() == llvm::Triple::aarch64_be; 6148276479Sdim 6149276479Sdim if (Is64Bit && BTy->getKind() == BuiltinType::Double) 6150261991Sdim return true; 6151261991Sdim 6152261991Sdim return BTy->getKind() == BuiltinType::SChar || 6153261991Sdim BTy->getKind() == BuiltinType::UChar || 6154261991Sdim BTy->getKind() == BuiltinType::Short || 6155261991Sdim BTy->getKind() == BuiltinType::UShort || 6156261991Sdim BTy->getKind() == BuiltinType::Int || 6157261991Sdim BTy->getKind() == BuiltinType::UInt || 6158276479Sdim BTy->getKind() == BuiltinType::Long || 6159276479Sdim BTy->getKind() == BuiltinType::ULong || 6160261991Sdim BTy->getKind() == BuiltinType::LongLong || 6161261991Sdim BTy->getKind() == BuiltinType::ULongLong || 6162261991Sdim BTy->getKind() == BuiltinType::Float || 6163261991Sdim BTy->getKind() == BuiltinType::Half; 6164261991Sdim} 6165261991Sdim 6166218893Sdim/// HandleNeonVectorTypeAttr - The "neon_vector_type" and 6167218893Sdim/// "neon_polyvector_type" attributes are used to create vector types that 6168218893Sdim/// are mangled according to ARM's ABI. Otherwise, these types are identical 6169218893Sdim/// to those created with the "vector_size" attribute. Unlike "vector_size" 6170218893Sdim/// the argument to these Neon attributes is the number of vector elements, 6171218893Sdim/// not the vector size in bytes. The vector width and element type must 6172218893Sdim/// match one of the standard Neon vector types. 6173218893Sdimstatic void HandleNeonVectorTypeAttr(QualType& CurType, 6174218893Sdim const AttributeList &Attr, Sema &S, 6175261991Sdim VectorType::VectorKind VecKind) { 6176261991Sdim // Target must have NEON 6177261991Sdim if (!S.Context.getTargetInfo().hasFeature("neon")) { 6178261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_unsupported) << Attr.getName(); 6179261991Sdim Attr.setInvalid(); 6180261991Sdim return; 6181261991Sdim } 6182218893Sdim // Check the attribute arguments. 6183218893Sdim if (Attr.getNumArgs() != 1) { 6184261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) 6185261991Sdim << Attr.getName() << 1; 6186218893Sdim Attr.setInvalid(); 6187218893Sdim return; 6188218893Sdim } 6189218893Sdim // The number of elements must be an ICE. 6190261991Sdim Expr *numEltsExpr = static_cast<Expr *>(Attr.getArgAsExpr(0)); 6191218893Sdim llvm::APSInt numEltsInt(32); 6192218893Sdim if (numEltsExpr->isTypeDependent() || numEltsExpr->isValueDependent() || 6193218893Sdim !numEltsExpr->isIntegerConstantExpr(numEltsInt, S.Context)) { 6194261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_argument_type) 6195261991Sdim << Attr.getName() << AANT_ArgumentIntegerConstant 6196261991Sdim << numEltsExpr->getSourceRange(); 6197218893Sdim Attr.setInvalid(); 6198218893Sdim return; 6199218893Sdim } 6200218893Sdim // Only certain element types are supported for Neon vectors. 6201276479Sdim if (!isPermittedNeonBaseType(CurType, VecKind, S)) { 6202261991Sdim S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType; 6203218893Sdim Attr.setInvalid(); 6204218893Sdim return; 6205218893Sdim } 6206261991Sdim 6207218893Sdim // The total size of the vector must be 64 or 128 bits. 6208218893Sdim unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType)); 6209218893Sdim unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue()); 6210218893Sdim unsigned vecSize = typeSize * numElts; 6211218893Sdim if (vecSize != 64 && vecSize != 128) { 6212218893Sdim S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType; 6213218893Sdim Attr.setInvalid(); 6214218893Sdim return; 6215218893Sdim } 6216218893Sdim 6217218893Sdim CurType = S.Context.getVectorType(CurType, numElts, VecKind); 6218218893Sdim} 6219218893Sdim 6220218893Sdimstatic void processTypeAttrs(TypeProcessingState &state, QualType &type, 6221249423Sdim TypeAttrLocation TAL, AttributeList *attrs) { 6222193326Sed // Scan through and apply attributes to this type where it makes sense. Some 6223193326Sed // attributes (such as __address_space__, __vector_size__, etc) apply to the 6224193326Sed // type, but others can be present in the type specifiers even though they 6225193326Sed // apply to the decl. Here we apply type attributes and ignore the rest. 6226218893Sdim 6227296417Sdim bool hasOpenCLAddressSpace = false; 6228296417Sdim while (attrs) { 6229218893Sdim AttributeList &attr = *attrs; 6230296417Sdim attrs = attr.getNext(); // reset to the next here due to early loop continue 6231296417Sdim // stmts 6232218893Sdim 6233207619Srdivacky // Skip attributes that were marked to be invalid. 6234218893Sdim if (attr.isInvalid()) 6235207619Srdivacky continue; 6236207619Srdivacky 6237249423Sdim if (attr.isCXX11Attribute()) { 6238249423Sdim // [[gnu::...]] attributes are treated as declaration attributes, so may 6239249423Sdim // not appertain to a DeclaratorChunk, even if we handle them as type 6240249423Sdim // attributes. 6241249423Sdim if (attr.getScopeName() && attr.getScopeName()->isStr("gnu")) { 6242249423Sdim if (TAL == TAL_DeclChunk) { 6243249423Sdim state.getSema().Diag(attr.getLoc(), 6244249423Sdim diag::warn_cxx11_gnu_attribute_on_type) 6245249423Sdim << attr.getName(); 6246249423Sdim continue; 6247249423Sdim } 6248249423Sdim } else if (TAL != TAL_DeclChunk) { 6249249423Sdim // Otherwise, only consider type processing for a C++11 attribute if 6250249423Sdim // it's actually been applied to a type. 6251249423Sdim continue; 6252249423Sdim } 6253249423Sdim } 6254249423Sdim 6255207619Srdivacky // If this is an attribute we can handle, do so now, 6256207619Srdivacky // otherwise, add it to the FnAttrs list for rechaining. 6257218893Sdim switch (attr.getKind()) { 6258249423Sdim default: 6259249423Sdim // A C++11 attribute on a declarator chunk must appertain to a type. 6260249423Sdim if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk) { 6261249423Sdim state.getSema().Diag(attr.getLoc(), diag::err_attribute_not_type_attr) 6262249423Sdim << attr.getName(); 6263249423Sdim attr.setUsedAsTypeAttr(); 6264249423Sdim } 6265249423Sdim break; 6266203955Srdivacky 6267249423Sdim case AttributeList::UnknownAttribute: 6268249423Sdim if (attr.isCXX11Attribute() && TAL == TAL_DeclChunk) 6269249423Sdim state.getSema().Diag(attr.getLoc(), 6270249423Sdim diag::warn_unknown_attribute_ignored) 6271249423Sdim << attr.getName(); 6272249423Sdim break; 6273249423Sdim 6274249423Sdim case AttributeList::IgnoredAttribute: 6275249423Sdim break; 6276249423Sdim 6277239462Sdim case AttributeList::AT_MayAlias: 6278226633Sdim // FIXME: This attribute needs to actually be handled, but if we ignore 6279226633Sdim // it it breaks large amounts of Linux software. 6280226633Sdim attr.setUsedAsTypeAttr(); 6281226633Sdim break; 6282276479Sdim case AttributeList::AT_OpenCLPrivateAddressSpace: 6283276479Sdim case AttributeList::AT_OpenCLGlobalAddressSpace: 6284276479Sdim case AttributeList::AT_OpenCLLocalAddressSpace: 6285276479Sdim case AttributeList::AT_OpenCLConstantAddressSpace: 6286280031Sdim case AttributeList::AT_OpenCLGenericAddressSpace: 6287239462Sdim case AttributeList::AT_AddressSpace: 6288218893Sdim HandleAddressSpaceTypeAttribute(type, attr, state.getSema()); 6289226633Sdim attr.setUsedAsTypeAttr(); 6290296417Sdim hasOpenCLAddressSpace = true; 6291193326Sed break; 6292218893Sdim OBJC_POINTER_TYPE_ATTRS_CASELIST: 6293218893Sdim if (!handleObjCPointerTypeAttr(state, attr, type)) 6294218893Sdim distributeObjCPointerTypeAttr(state, attr, type); 6295226633Sdim attr.setUsedAsTypeAttr(); 6296193326Sed break; 6297239462Sdim case AttributeList::AT_VectorSize: 6298218893Sdim HandleVectorSizeAttr(type, attr, state.getSema()); 6299226633Sdim attr.setUsedAsTypeAttr(); 6300203955Srdivacky break; 6301239462Sdim case AttributeList::AT_ExtVectorType: 6302249423Sdim HandleExtVectorTypeAttr(type, attr, state.getSema()); 6303226633Sdim attr.setUsedAsTypeAttr(); 6304224145Sdim break; 6305239462Sdim case AttributeList::AT_NeonVectorType: 6306218893Sdim HandleNeonVectorTypeAttr(type, attr, state.getSema(), 6307261991Sdim VectorType::NeonVector); 6308226633Sdim attr.setUsedAsTypeAttr(); 6309218893Sdim break; 6310239462Sdim case AttributeList::AT_NeonPolyVectorType: 6311218893Sdim HandleNeonVectorTypeAttr(type, attr, state.getSema(), 6312261991Sdim VectorType::NeonPolyVector); 6313226633Sdim attr.setUsedAsTypeAttr(); 6314218893Sdim break; 6315239462Sdim case AttributeList::AT_OpenCLImageAccess: 6316276479Sdim // FIXME: there should be some type checking happening here, I would 6317276479Sdim // imagine, but the original handler's checking was entirely superfluous. 6318226633Sdim attr.setUsedAsTypeAttr(); 6319221345Sdim break; 6320221345Sdim 6321261991Sdim MS_TYPE_ATTRS_CASELIST: 6322261991Sdim if (!handleMSPointerTypeQualifierAttr(state, attr, type)) 6323261991Sdim attr.setUsedAsTypeAttr(); 6324261991Sdim break; 6325239462Sdim 6326288943Sdim 6327288943Sdim NULLABILITY_TYPE_ATTRS_CASELIST: 6328288943Sdim // Either add nullability here or try to distribute it. We 6329288943Sdim // don't want to distribute the nullability specifier past any 6330288943Sdim // dependent type, because that complicates the user model. 6331288943Sdim if (type->canHaveNullability() || type->isDependentType() || 6332288943Sdim !distributeNullabilityTypeAttr(state, type, attr)) { 6333288943Sdim if (state.getSema().checkNullabilityTypeSpecifier( 6334288943Sdim type, 6335288943Sdim mapNullabilityAttrKind(attr.getKind()), 6336288943Sdim attr.getLoc(), 6337288943Sdim attr.isContextSensitiveKeywordAttribute())) { 6338288943Sdim attr.setInvalid(); 6339288943Sdim } 6340288943Sdim 6341288943Sdim attr.setUsedAsTypeAttr(); 6342288943Sdim } 6343288943Sdim break; 6344288943Sdim 6345288943Sdim case AttributeList::AT_ObjCKindOf: 6346288943Sdim // '__kindof' must be part of the decl-specifiers. 6347288943Sdim switch (TAL) { 6348288943Sdim case TAL_DeclSpec: 6349288943Sdim break; 6350288943Sdim 6351288943Sdim case TAL_DeclChunk: 6352288943Sdim case TAL_DeclName: 6353288943Sdim state.getSema().Diag(attr.getLoc(), 6354288943Sdim diag::err_objc_kindof_wrong_position) 6355288943Sdim << FixItHint::CreateRemoval(attr.getLoc()) 6356288943Sdim << FixItHint::CreateInsertion( 6357288943Sdim state.getDeclarator().getDeclSpec().getLocStart(), "__kindof "); 6358288943Sdim break; 6359288943Sdim } 6360288943Sdim 6361288943Sdim // Apply it regardless. 6362288943Sdim if (state.getSema().checkObjCKindOfType(type, attr.getLoc())) 6363288943Sdim attr.setInvalid(); 6364288943Sdim attr.setUsedAsTypeAttr(); 6365288943Sdim break; 6366288943Sdim 6367239462Sdim case AttributeList::AT_NSReturnsRetained: 6368234353Sdim if (!state.getSema().getLangOpts().ObjCAutoRefCount) 6369249423Sdim break; 6370224145Sdim // fallthrough into the function attrs 6371224145Sdim 6372218893Sdim FUNCTION_TYPE_ATTRS_CASELIST: 6373226633Sdim attr.setUsedAsTypeAttr(); 6374226633Sdim 6375218893Sdim // Never process function type attributes as part of the 6376218893Sdim // declaration-specifiers. 6377249423Sdim if (TAL == TAL_DeclSpec) 6378218893Sdim distributeFunctionTypeAttrFromDeclSpec(state, attr, type); 6379218893Sdim 6380218893Sdim // Otherwise, handle the possible delays. 6381218893Sdim else if (!handleFunctionTypeAttr(state, attr, type)) 6382218893Sdim distributeFunctionTypeAttr(state, attr, type); 6383198092Srdivacky break; 6384193326Sed } 6385296417Sdim } 6386296417Sdim 6387296417Sdim // If address space is not set, OpenCL 2.0 defines non private default 6388296417Sdim // address spaces for some cases: 6389296417Sdim // OpenCL 2.0, section 6.5: 6390296417Sdim // The address space for a variable at program scope or a static variable 6391296417Sdim // inside a function can either be __global or __constant, but defaults to 6392296417Sdim // __global if not specified. 6393296417Sdim // (...) 6394296417Sdim // Pointers that are declared without pointing to a named address space point 6395296417Sdim // to the generic address space. 6396296417Sdim if (state.getSema().getLangOpts().OpenCLVersion >= 200 && 6397296417Sdim !hasOpenCLAddressSpace && type.getAddressSpace() == 0 && 6398296417Sdim (TAL == TAL_DeclSpec || TAL == TAL_DeclChunk)) { 6399296417Sdim Declarator &D = state.getDeclarator(); 6400296417Sdim if (state.getCurrentChunkIndex() > 0 && 6401296417Sdim D.getTypeObject(state.getCurrentChunkIndex() - 1).Kind == 6402296417Sdim DeclaratorChunk::Pointer) { 6403296417Sdim type = state.getSema().Context.getAddrSpaceQualType( 6404296417Sdim type, LangAS::opencl_generic); 6405296417Sdim } else if (state.getCurrentChunkIndex() == 0 && 6406296417Sdim D.getContext() == Declarator::FileContext && 6407296417Sdim !D.isFunctionDeclarator() && !D.isFunctionDefinition() && 6408296417Sdim D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 6409296417Sdim !type->isSamplerT()) 6410296417Sdim type = state.getSema().Context.getAddrSpaceQualType( 6411296417Sdim type, LangAS::opencl_global); 6412296417Sdim else if (state.getCurrentChunkIndex() == 0 && 6413296417Sdim D.getContext() == Declarator::BlockContext && 6414296417Sdim D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static) 6415296417Sdim type = state.getSema().Context.getAddrSpaceQualType( 6416296417Sdim type, LangAS::opencl_global); 6417296417Sdim } 6418193326Sed} 6419193326Sed 6420296417Sdimvoid Sema::completeExprArrayBound(Expr *E) { 6421296417Sdim if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 6422296417Sdim if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 6423296417Sdim if (isTemplateInstantiation(Var->getTemplateSpecializationKind())) { 6424296417Sdim SourceLocation PointOfInstantiation = E->getExprLoc(); 6425296417Sdim 6426296417Sdim if (MemberSpecializationInfo *MSInfo = 6427296417Sdim Var->getMemberSpecializationInfo()) { 6428296417Sdim // If we don't already have a point of instantiation, this is it. 6429296417Sdim if (MSInfo->getPointOfInstantiation().isInvalid()) { 6430296417Sdim MSInfo->setPointOfInstantiation(PointOfInstantiation); 6431296417Sdim 6432296417Sdim // This is a modification of an existing AST node. Notify 6433296417Sdim // listeners. 6434296417Sdim if (ASTMutationListener *L = getASTMutationListener()) 6435296417Sdim L->StaticDataMemberInstantiated(Var); 6436296417Sdim } 6437296417Sdim } else { 6438296417Sdim VarTemplateSpecializationDecl *VarSpec = 6439296417Sdim cast<VarTemplateSpecializationDecl>(Var); 6440296417Sdim if (VarSpec->getPointOfInstantiation().isInvalid()) 6441296417Sdim VarSpec->setPointOfInstantiation(PointOfInstantiation); 6442296417Sdim } 6443296417Sdim 6444296417Sdim InstantiateVariableDefinition(PointOfInstantiation, Var); 6445296417Sdim 6446296417Sdim // Update the type to the newly instantiated definition's type both 6447296417Sdim // here and within the expression. 6448296417Sdim if (VarDecl *Def = Var->getDefinition()) { 6449296417Sdim DRE->setDecl(Def); 6450296417Sdim QualType T = Def->getType(); 6451296417Sdim DRE->setType(T); 6452296417Sdim // FIXME: Update the type on all intervening expressions. 6453296417Sdim E->setType(T); 6454296417Sdim } 6455296417Sdim 6456296417Sdim // We still go on to try to complete the type independently, as it 6457296417Sdim // may also require instantiations or diagnostics if it remains 6458296417Sdim // incomplete. 6459296417Sdim } 6460296417Sdim } 6461296417Sdim } 6462296417Sdim} 6463296417Sdim 6464223017Sdim/// \brief Ensure that the type of the given expression is complete. 6465223017Sdim/// 6466223017Sdim/// This routine checks whether the expression \p E has a complete type. If the 6467223017Sdim/// expression refers to an instantiable construct, that instantiation is 6468223017Sdim/// performed as needed to complete its type. Furthermore 6469223017Sdim/// Sema::RequireCompleteType is called for the expression's type (or in the 6470223017Sdim/// case of a reference type, the referred-to type). 6471223017Sdim/// 6472223017Sdim/// \param E The expression whose type is required to be complete. 6473239462Sdim/// \param Diagnoser The object that will emit a diagnostic if the type is 6474239462Sdim/// incomplete. 6475223017Sdim/// 6476223017Sdim/// \returns \c true if the type of \p E is incomplete and diagnosed, \c false 6477223017Sdim/// otherwise. 6478296417Sdimbool Sema::RequireCompleteExprType(Expr *E, TypeDiagnoser &Diagnoser) { 6479223017Sdim QualType T = E->getType(); 6480223017Sdim 6481223017Sdim // Incomplete array types may be completed by the initializer attached to 6482261991Sdim // their definitions. For static data members of class templates and for 6483261991Sdim // variable templates, we need to instantiate the definition to get this 6484261991Sdim // initializer and complete the type. 6485223017Sdim if (T->isIncompleteArrayType()) { 6486296417Sdim completeExprArrayBound(E); 6487296417Sdim T = E->getType(); 6488223017Sdim } 6489223017Sdim 6490223017Sdim // FIXME: Are there other cases which require instantiating something other 6491223017Sdim // than the type to complete the type of an expression? 6492223017Sdim 6493239462Sdim return RequireCompleteType(E->getExprLoc(), T, Diagnoser); 6494223017Sdim} 6495223017Sdim 6496239462Sdimbool Sema::RequireCompleteExprType(Expr *E, unsigned DiagID) { 6497296417Sdim BoundTypeDiagnoser<> Diagnoser(DiagID); 6498239462Sdim return RequireCompleteExprType(E, Diagnoser); 6499239462Sdim} 6500239462Sdim 6501198092Srdivacky/// @brief Ensure that the type T is a complete type. 6502193326Sed/// 6503193326Sed/// This routine checks whether the type @p T is complete in any 6504193326Sed/// context where a complete type is required. If @p T is a complete 6505193326Sed/// type, returns false. If @p T is a class template specialization, 6506193326Sed/// this routine then attempts to perform class template 6507193326Sed/// instantiation. If instantiation fails, or if @p T is incomplete 6508193326Sed/// and cannot be completed, issues the diagnostic @p diag (giving it 6509193326Sed/// the type @p T) and returns true. 6510193326Sed/// 6511193326Sed/// @param Loc The location in the source that the incomplete type 6512193326Sed/// diagnostic should refer to. 6513193326Sed/// 6514193326Sed/// @param T The type that this routine is examining for completeness. 6515193326Sed/// 6516193326Sed/// @returns @c true if @p T is incomplete and a diagnostic was emitted, 6517193326Sed/// @c false otherwise. 6518198092Srdivackybool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 6519239462Sdim TypeDiagnoser &Diagnoser) { 6520296417Sdim if (RequireCompleteTypeImpl(Loc, T, &Diagnoser)) 6521261991Sdim return true; 6522261991Sdim if (const TagType *Tag = T->getAs<TagType>()) { 6523261991Sdim if (!Tag->getDecl()->isCompleteDefinitionRequired()) { 6524261991Sdim Tag->getDecl()->setCompleteDefinitionRequired(); 6525261991Sdim Consumer.HandleTagDeclRequiredDefinition(Tag->getDecl()); 6526261991Sdim } 6527261991Sdim } 6528261991Sdim return false; 6529261991Sdim} 6530261991Sdim 6531276479Sdim/// \brief Determine whether there is any declaration of \p D that was ever a 6532276479Sdim/// definition (perhaps before module merging) and is currently visible. 6533276479Sdim/// \param D The definition of the entity. 6534276479Sdim/// \param Suggested Filled in with the declaration that should be made visible 6535276479Sdim/// in order to provide a definition of this entity. 6536288943Sdim/// \param OnlyNeedComplete If \c true, we only need the type to be complete, 6537288943Sdim/// not defined. This only matters for enums with a fixed underlying 6538288943Sdim/// type, since in all other cases, a type is complete if and only if it 6539288943Sdim/// is defined. 6540288943Sdimbool Sema::hasVisibleDefinition(NamedDecl *D, NamedDecl **Suggested, 6541288943Sdim bool OnlyNeedComplete) { 6542276479Sdim // Easy case: if we don't have modules, all declarations are visible. 6543288943Sdim if (!getLangOpts().Modules && !getLangOpts().ModulesLocalVisibility) 6544276479Sdim return true; 6545276479Sdim 6546276479Sdim // If this definition was instantiated from a template, map back to the 6547276479Sdim // pattern from which it was instantiated. 6548288943Sdim if (isa<TagDecl>(D) && cast<TagDecl>(D)->isBeingDefined()) { 6549288943Sdim // We're in the middle of defining it; this definition should be treated 6550288943Sdim // as visible. 6551288943Sdim return true; 6552288943Sdim } else if (auto *RD = dyn_cast<CXXRecordDecl>(D)) { 6553280031Sdim if (auto *Pattern = RD->getTemplateInstantiationPattern()) 6554280031Sdim RD = Pattern; 6555276479Sdim D = RD->getDefinition(); 6556276479Sdim } else if (auto *ED = dyn_cast<EnumDecl>(D)) { 6557276479Sdim while (auto *NewED = ED->getInstantiatedFromMemberEnum()) 6558276479Sdim ED = NewED; 6559288943Sdim if (OnlyNeedComplete && ED->isFixed()) { 6560288943Sdim // If the enum has a fixed underlying type, and we're only looking for a 6561288943Sdim // complete type (not a definition), any visible declaration of it will 6562288943Sdim // do. 6563276479Sdim *Suggested = nullptr; 6564276479Sdim for (auto *Redecl : ED->redecls()) { 6565288943Sdim if (isVisible(Redecl)) 6566276479Sdim return true; 6567276479Sdim if (Redecl->isThisDeclarationADefinition() || 6568276479Sdim (Redecl->isCanonicalDecl() && !*Suggested)) 6569276479Sdim *Suggested = Redecl; 6570276479Sdim } 6571276479Sdim return false; 6572276479Sdim } 6573276479Sdim D = ED->getDefinition(); 6574276479Sdim } 6575276479Sdim assert(D && "missing definition for pattern of instantiated definition"); 6576276479Sdim 6577276479Sdim *Suggested = D; 6578288943Sdim if (isVisible(D)) 6579288943Sdim return true; 6580288943Sdim 6581288943Sdim // The external source may have additional definitions of this type that are 6582288943Sdim // visible, so complete the redeclaration chain now and ask again. 6583288943Sdim if (auto *Source = Context.getExternalSource()) { 6584288943Sdim Source->CompleteRedeclChain(D); 6585288943Sdim return isVisible(D); 6586288943Sdim } 6587288943Sdim 6588288943Sdim return false; 6589276479Sdim} 6590276479Sdim 6591276479Sdim/// Locks in the inheritance model for the given class and all of its bases. 6592276479Sdimstatic void assignInheritanceModel(Sema &S, CXXRecordDecl *RD) { 6593276479Sdim RD = RD->getMostRecentDecl(); 6594276479Sdim if (!RD->hasAttr<MSInheritanceAttr>()) { 6595276479Sdim MSInheritanceAttr::Spelling IM; 6596276479Sdim 6597276479Sdim switch (S.MSPointerToMemberRepresentationMethod) { 6598276479Sdim case LangOptions::PPTMK_BestCase: 6599276479Sdim IM = RD->calculateInheritanceModel(); 6600276479Sdim break; 6601276479Sdim case LangOptions::PPTMK_FullGeneralitySingleInheritance: 6602276479Sdim IM = MSInheritanceAttr::Keyword_single_inheritance; 6603276479Sdim break; 6604276479Sdim case LangOptions::PPTMK_FullGeneralityMultipleInheritance: 6605276479Sdim IM = MSInheritanceAttr::Keyword_multiple_inheritance; 6606276479Sdim break; 6607276479Sdim case LangOptions::PPTMK_FullGeneralityVirtualInheritance: 6608276479Sdim IM = MSInheritanceAttr::Keyword_unspecified_inheritance; 6609276479Sdim break; 6610276479Sdim } 6611276479Sdim 6612276479Sdim RD->addAttr(MSInheritanceAttr::CreateImplicit( 6613276479Sdim S.getASTContext(), IM, 6614276479Sdim /*BestCase=*/S.MSPointerToMemberRepresentationMethod == 6615276479Sdim LangOptions::PPTMK_BestCase, 6616276479Sdim S.ImplicitMSInheritanceAttrLoc.isValid() 6617276479Sdim ? S.ImplicitMSInheritanceAttrLoc 6618276479Sdim : RD->getSourceRange())); 6619276479Sdim } 6620276479Sdim} 6621276479Sdim 6622261991Sdim/// \brief The implementation of RequireCompleteType 6623261991Sdimbool Sema::RequireCompleteTypeImpl(SourceLocation Loc, QualType T, 6624296417Sdim TypeDiagnoser *Diagnoser) { 6625198398Srdivacky // FIXME: Add this assertion to make sure we always get instantiation points. 6626198398Srdivacky // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType"); 6627193326Sed // FIXME: Add this assertion to help us flush out problems with 6628193326Sed // checking for dependent types and type-dependent expressions. 6629193326Sed // 6630198092Srdivacky // assert(!T->isDependentType() && 6631193326Sed // "Can't ask whether a dependent type is complete"); 6632193326Sed 6633296417Sdim // We lock in the inheritance model once somebody has asked us to ensure 6634296417Sdim // that a pointer-to-member type is complete. 6635296417Sdim if (Context.getTargetInfo().getCXXABI().isMicrosoft()) { 6636296417Sdim if (const MemberPointerType *MPTy = T->getAs<MemberPointerType>()) { 6637296417Sdim if (!MPTy->getClass()->isDependentType()) { 6638296417Sdim (void)isCompleteType(Loc, QualType(MPTy->getClass(), 0)); 6639296417Sdim assignInheritanceModel(*this, MPTy->getMostRecentCXXRecordDecl()); 6640296417Sdim } 6641296417Sdim } 6642296417Sdim } 6643296417Sdim 6644193326Sed // If we have a complete type, we're done. 6645276479Sdim NamedDecl *Def = nullptr; 6646234353Sdim if (!T->isIncompleteType(&Def)) { 6647234353Sdim // If we know about the definition but it is not visible, complain. 6648276479Sdim NamedDecl *SuggestedDef = nullptr; 6649296417Sdim if (Def && 6650296417Sdim !hasVisibleDefinition(Def, &SuggestedDef, /*OnlyNeedComplete*/true)) { 6651296417Sdim // If the user is going to see an error here, recover by making the 6652296417Sdim // definition visible. 6653296417Sdim bool TreatAsComplete = Diagnoser && !isSFINAEContext(); 6654296417Sdim if (Diagnoser) 6655296417Sdim diagnoseMissingImport(Loc, SuggestedDef, /*NeedDefinition*/true, 6656296417Sdim /*Recover*/TreatAsComplete); 6657296417Sdim return !TreatAsComplete; 6658234353Sdim } 6659239462Sdim 6660193326Sed return false; 6661234353Sdim } 6662193326Sed 6663276479Sdim const TagType *Tag = T->getAs<TagType>(); 6664276479Sdim const ObjCInterfaceType *IFace = T->getAs<ObjCInterfaceType>(); 6665276479Sdim 6666276479Sdim // If there's an unimported definition of this type in a module (for 6667261991Sdim // instance, because we forward declared it, then imported the definition), 6668261991Sdim // import that definition now. 6669276479Sdim // 6670261991Sdim // FIXME: What about other cases where an import extends a redeclaration 6671261991Sdim // chain for a declaration that can be accessed through a mechanism other 6672261991Sdim // than name lookup (eg, referenced in a template, or a variable whose type 6673261991Sdim // could be completed by the module)? 6674296417Sdim // 6675296417Sdim // FIXME: Should we map through to the base array element type before 6676296417Sdim // checking for a tag type? 6677276479Sdim if (Tag || IFace) { 6678276479Sdim NamedDecl *D = 6679276479Sdim Tag ? static_cast<NamedDecl *>(Tag->getDecl()) : IFace->getDecl(); 6680261991Sdim 6681234353Sdim // Avoid diagnosing invalid decls as incomplete. 6682276479Sdim if (D->isInvalidDecl()) 6683234353Sdim return true; 6684234353Sdim 6685234353Sdim // Give the external AST source a chance to complete the type. 6686276479Sdim if (auto *Source = Context.getExternalSource()) { 6687276479Sdim if (Tag) 6688276479Sdim Source->CompleteType(Tag->getDecl()); 6689276479Sdim else 6690276479Sdim Source->CompleteType(IFace->getDecl()); 6691239462Sdim 6692276479Sdim // If the external source completed the type, go through the motions 6693276479Sdim // again to ensure we're allowed to use the completed type. 6694276479Sdim if (!T->isIncompleteType()) 6695276479Sdim return RequireCompleteTypeImpl(Loc, T, Diagnoser); 6696234353Sdim } 6697234353Sdim } 6698239462Sdim 6699193326Sed // If we have a class template specialization or a class member of a 6700198954Srdivacky // class template specialization, or an array with known size of such, 6701198954Srdivacky // try to instantiate it. 6702198954Srdivacky QualType MaybeTemplate = T; 6703235864Sdim while (const ConstantArrayType *Array 6704235864Sdim = Context.getAsConstantArrayType(MaybeTemplate)) 6705198954Srdivacky MaybeTemplate = Array->getElementType(); 6706198954Srdivacky if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) { 6707296417Sdim bool Instantiated = false; 6708296417Sdim bool Diagnosed = false; 6709193326Sed if (ClassTemplateSpecializationDecl *ClassTemplateSpec 6710193326Sed = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) { 6711296417Sdim if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) { 6712296417Sdim Diagnosed = InstantiateClassTemplateSpecialization( 6713296417Sdim Loc, ClassTemplateSpec, TSK_ImplicitInstantiation, 6714296417Sdim /*Complain=*/Diagnoser); 6715296417Sdim Instantiated = true; 6716296417Sdim } 6717198092Srdivacky } else if (CXXRecordDecl *Rec 6718193326Sed = dyn_cast<CXXRecordDecl>(Record->getDecl())) { 6719234353Sdim CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass(); 6720234353Sdim if (!Rec->isBeingDefined() && Pattern) { 6721234353Sdim MemberSpecializationInfo *MSI = Rec->getMemberSpecializationInfo(); 6722234353Sdim assert(MSI && "Missing member specialization information?"); 6723198092Srdivacky // This record was instantiated from a class within a template. 6724296417Sdim if (MSI->getTemplateSpecializationKind() != 6725296417Sdim TSK_ExplicitSpecialization) { 6726296417Sdim Diagnosed = InstantiateClass(Loc, Rec, Pattern, 6727296417Sdim getTemplateInstantiationArgs(Rec), 6728296417Sdim TSK_ImplicitInstantiation, 6729296417Sdim /*Complain=*/Diagnoser); 6730296417Sdim Instantiated = true; 6731296417Sdim } 6732193326Sed } 6733193326Sed } 6734296417Sdim 6735296417Sdim if (Instantiated) { 6736296417Sdim // Instantiate* might have already complained that the template is not 6737296417Sdim // defined, if we asked it to. 6738296417Sdim if (Diagnoser && Diagnosed) 6739296417Sdim return true; 6740296417Sdim // If we instantiated a definition, check that it's usable, even if 6741296417Sdim // instantiation produced an error, so that repeated calls to this 6742296417Sdim // function give consistent answers. 6743296417Sdim if (!T->isIncompleteType()) 6744296417Sdim return RequireCompleteTypeImpl(Loc, T, Diagnoser); 6745296417Sdim } 6746193326Sed } 6747193326Sed 6748296417Sdim if (!Diagnoser) 6749198092Srdivacky return true; 6750239462Sdim 6751193326Sed // We have an incomplete type. Produce a diagnostic. 6752261991Sdim if (Ident___float128 && 6753261991Sdim T == Context.getTypeDeclType(Context.getFloat128StubType())) { 6754261991Sdim Diag(Loc, diag::err_typecheck_decl_incomplete_type___float128); 6755261991Sdim return true; 6756261991Sdim } 6757261991Sdim 6758296417Sdim Diagnoser->diagnose(*this, Loc, T); 6759239462Sdim 6760193326Sed // If the type was a forward declaration of a class/struct/union 6761206084Srdivacky // type, produce a note. 6762193326Sed if (Tag && !Tag->getDecl()->isInvalidDecl()) 6763198092Srdivacky Diag(Tag->getDecl()->getLocation(), 6764193326Sed Tag->isBeingDefined() ? diag::note_type_being_defined 6765193326Sed : diag::note_forward_declaration) 6766234353Sdim << QualType(Tag, 0); 6767239462Sdim 6768234353Sdim // If the Objective-C class was a forward declaration, produce a note. 6769234353Sdim if (IFace && !IFace->getDecl()->isInvalidDecl()) 6770234353Sdim Diag(IFace->getDecl()->getLocation(), diag::note_forward_class); 6771193326Sed 6772261991Sdim // If we have external information that we can use to suggest a fix, 6773261991Sdim // produce a note. 6774261991Sdim if (ExternalSource) 6775261991Sdim ExternalSource->MaybeDiagnoseMissingCompleteType(Loc, T); 6776261991Sdim 6777193326Sed return true; 6778193326Sed} 6779193326Sed 6780206084Srdivackybool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 6781206084Srdivacky unsigned DiagID) { 6782296417Sdim BoundTypeDiagnoser<> Diagnoser(DiagID); 6783239462Sdim return RequireCompleteType(Loc, T, Diagnoser); 6784206084Srdivacky} 6785206084Srdivacky 6786243830Sdim/// \brief Get diagnostic %select index for tag kind for 6787243830Sdim/// literal type diagnostic message. 6788243830Sdim/// WARNING: Indexes apply to particular diagnostics only! 6789243830Sdim/// 6790243830Sdim/// \returns diagnostic %select index. 6791243830Sdimstatic unsigned getLiteralDiagFromTagKind(TagTypeKind Tag) { 6792243830Sdim switch (Tag) { 6793243830Sdim case TTK_Struct: return 0; 6794243830Sdim case TTK_Interface: return 1; 6795243830Sdim case TTK_Class: return 2; 6796243830Sdim default: llvm_unreachable("Invalid tag kind for literal type diagnostic!"); 6797243830Sdim } 6798243830Sdim} 6799243830Sdim 6800226633Sdim/// @brief Ensure that the type T is a literal type. 6801226633Sdim/// 6802226633Sdim/// This routine checks whether the type @p T is a literal type. If @p T is an 6803226633Sdim/// incomplete type, an attempt is made to complete it. If @p T is a literal 6804226633Sdim/// type, or @p AllowIncompleteType is true and @p T is an incomplete type, 6805226633Sdim/// returns false. Otherwise, this routine issues the diagnostic @p PD (giving 6806226633Sdim/// it the type @p T), along with notes explaining why the type is not a 6807226633Sdim/// literal type, and returns true. 6808226633Sdim/// 6809226633Sdim/// @param Loc The location in the source that the non-literal type 6810226633Sdim/// diagnostic should refer to. 6811226633Sdim/// 6812226633Sdim/// @param T The type that this routine is examining for literalness. 6813226633Sdim/// 6814239462Sdim/// @param Diagnoser Emits a diagnostic if T is not a literal type. 6815226633Sdim/// 6816226633Sdim/// @returns @c true if @p T is not a literal type and a diagnostic was emitted, 6817226633Sdim/// @c false otherwise. 6818226633Sdimbool Sema::RequireLiteralType(SourceLocation Loc, QualType T, 6819239462Sdim TypeDiagnoser &Diagnoser) { 6820226633Sdim assert(!T->isDependentType() && "type should not be dependent"); 6821226633Sdim 6822234353Sdim QualType ElemType = Context.getBaseElementType(T); 6823296417Sdim if ((isCompleteType(Loc, ElemType) || ElemType->isVoidType()) && 6824296417Sdim T->isLiteralType(Context)) 6825226633Sdim return false; 6826226633Sdim 6827239462Sdim Diagnoser.diagnose(*this, Loc, T); 6828226633Sdim 6829226633Sdim if (T->isVariableArrayType()) 6830226633Sdim return true; 6831226633Sdim 6832234353Sdim const RecordType *RT = ElemType->getAs<RecordType>(); 6833226633Sdim if (!RT) 6834226633Sdim return true; 6835226633Sdim 6836226633Sdim const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl()); 6837226633Sdim 6838239462Sdim // A partially-defined class type can't be a literal type, because a literal 6839239462Sdim // class type must have a trivial destructor (which can't be checked until 6840239462Sdim // the class definition is complete). 6841296417Sdim if (RequireCompleteType(Loc, ElemType, diag::note_non_literal_incomplete, T)) 6842234353Sdim return true; 6843234353Sdim 6844226633Sdim // If the class has virtual base classes, then it's not an aggregate, and 6845234353Sdim // cannot have any constexpr constructors or a trivial default constructor, 6846234353Sdim // so is non-literal. This is better to diagnose than the resulting absence 6847234353Sdim // of constexpr constructors. 6848226633Sdim if (RD->getNumVBases()) { 6849226633Sdim Diag(RD->getLocation(), diag::note_non_literal_virtual_base) 6850243830Sdim << getLiteralDiagFromTagKind(RD->getTagKind()) << RD->getNumVBases(); 6851276479Sdim for (const auto &I : RD->vbases()) 6852276479Sdim Diag(I.getLocStart(), diag::note_constexpr_virtual_base_here) 6853276479Sdim << I.getSourceRange(); 6854234353Sdim } else if (!RD->isAggregate() && !RD->hasConstexprNonCopyMoveConstructor() && 6855234353Sdim !RD->hasTrivialDefaultConstructor()) { 6856226633Sdim Diag(RD->getLocation(), diag::note_non_literal_no_constexpr_ctors) << RD; 6857226633Sdim } else if (RD->hasNonLiteralTypeFieldsOrBases()) { 6858276479Sdim for (const auto &I : RD->bases()) { 6859276479Sdim if (!I.getType()->isLiteralType(Context)) { 6860276479Sdim Diag(I.getLocStart(), 6861226633Sdim diag::note_non_literal_base_class) 6862276479Sdim << RD << I.getType() << I.getSourceRange(); 6863226633Sdim return true; 6864226633Sdim } 6865226633Sdim } 6866276479Sdim for (const auto *I : RD->fields()) { 6867251662Sdim if (!I->getType()->isLiteralType(Context) || 6868239462Sdim I->getType().isVolatileQualified()) { 6869239462Sdim Diag(I->getLocation(), diag::note_non_literal_field) 6870276479Sdim << RD << I << I->getType() 6871239462Sdim << I->getType().isVolatileQualified(); 6872226633Sdim return true; 6873226633Sdim } 6874226633Sdim } 6875226633Sdim } else if (!RD->hasTrivialDestructor()) { 6876226633Sdim // All fields and bases are of literal types, so have trivial destructors. 6877226633Sdim // If this class's destructor is non-trivial it must be user-declared. 6878226633Sdim CXXDestructorDecl *Dtor = RD->getDestructor(); 6879226633Sdim assert(Dtor && "class has literal fields and bases but no dtor?"); 6880226633Sdim if (!Dtor) 6881226633Sdim return true; 6882226633Sdim 6883226633Sdim Diag(Dtor->getLocation(), Dtor->isUserProvided() ? 6884226633Sdim diag::note_non_literal_user_provided_dtor : 6885226633Sdim diag::note_non_literal_nontrivial_dtor) << RD; 6886249423Sdim if (!Dtor->isUserProvided()) 6887249423Sdim SpecialMemberIsTrivial(Dtor, CXXDestructor, /*Diagnose*/true); 6888226633Sdim } 6889226633Sdim 6890226633Sdim return true; 6891226633Sdim} 6892226633Sdim 6893239462Sdimbool Sema::RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID) { 6894296417Sdim BoundTypeDiagnoser<> Diagnoser(DiagID); 6895239462Sdim return RequireLiteralType(Loc, T, Diagnoser); 6896239462Sdim} 6897239462Sdim 6898208600Srdivacky/// \brief Retrieve a version of the type 'T' that is elaborated by Keyword 6899208600Srdivacky/// and qualified by the nested-name-specifier contained in SS. 6900208600SrdivackyQualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword, 6901208600Srdivacky const CXXScopeSpec &SS, QualType T) { 6902208600Srdivacky if (T.isNull()) 6903193326Sed return T; 6904208600Srdivacky NestedNameSpecifier *NNS; 6905208600Srdivacky if (SS.isValid()) 6906276479Sdim NNS = SS.getScopeRep(); 6907208600Srdivacky else { 6908208600Srdivacky if (Keyword == ETK_None) 6909208600Srdivacky return T; 6910276479Sdim NNS = nullptr; 6911208600Srdivacky } 6912208600Srdivacky return Context.getElaboratedType(Keyword, NNS, T); 6913193326Sed} 6914195341Sed 6915218893SdimQualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) { 6916221345Sdim ExprResult ER = CheckPlaceholderExpr(E); 6917218893Sdim if (ER.isInvalid()) return QualType(); 6918276479Sdim E = ER.get(); 6919218893Sdim 6920296417Sdim if (!getLangOpts().CPlusPlus && E->refersToBitField()) 6921296417Sdim Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2; 6922296417Sdim 6923218893Sdim if (!E->isTypeDependent()) { 6924218893Sdim QualType T = E->getType(); 6925218893Sdim if (const TagType *TT = T->getAs<TagType>()) 6926218893Sdim DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc()); 6927201361Srdivacky } 6928195341Sed return Context.getTypeOfExprType(E); 6929195341Sed} 6930195341Sed 6931234353Sdim/// getDecltypeForExpr - Given an expr, will return the decltype for 6932234353Sdim/// that expression, according to the rules in C++11 6933234353Sdim/// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18. 6934234353Sdimstatic QualType getDecltypeForExpr(Sema &S, Expr *E) { 6935234353Sdim if (E->isTypeDependent()) 6936234353Sdim return S.Context.DependentTy; 6937234353Sdim 6938234353Sdim // C++11 [dcl.type.simple]p4: 6939234353Sdim // The type denoted by decltype(e) is defined as follows: 6940234353Sdim // 6941234353Sdim // - if e is an unparenthesized id-expression or an unparenthesized class 6942239462Sdim // member access (5.2.5), decltype(e) is the type of the entity named 6943239462Sdim // by e. If there is no such entity, or if e names a set of overloaded 6944234353Sdim // functions, the program is ill-formed; 6945243830Sdim // 6946243830Sdim // We apply the same rules for Objective-C ivar and property references. 6947234353Sdim if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) { 6948234353Sdim if (const ValueDecl *VD = dyn_cast<ValueDecl>(DRE->getDecl())) 6949234353Sdim return VD->getType(); 6950243830Sdim } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 6951234353Sdim if (const FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl())) 6952234353Sdim return FD->getType(); 6953243830Sdim } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) { 6954243830Sdim return IR->getDecl()->getType(); 6955243830Sdim } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) { 6956243830Sdim if (PR->isExplicitProperty()) 6957243830Sdim return PR->getExplicitProperty()->getType(); 6958280031Sdim } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) { 6959280031Sdim return PE->getType(); 6960234353Sdim } 6961243830Sdim 6962234353Sdim // C++11 [expr.lambda.prim]p18: 6963234353Sdim // Every occurrence of decltype((x)) where x is a possibly 6964234353Sdim // parenthesized id-expression that names an entity of automatic 6965234353Sdim // storage duration is treated as if x were transformed into an 6966234353Sdim // access to a corresponding data member of the closure type that 6967234353Sdim // would have been declared if x were an odr-use of the denoted 6968234353Sdim // entity. 6969234353Sdim using namespace sema; 6970234353Sdim if (S.getCurLambda()) { 6971234353Sdim if (isa<ParenExpr>(E)) { 6972234353Sdim if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) { 6973234353Sdim if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) { 6974234353Sdim QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation()); 6975234353Sdim if (!T.isNull()) 6976234353Sdim return S.Context.getLValueReferenceType(T); 6977234353Sdim } 6978234353Sdim } 6979234353Sdim } 6980234353Sdim } 6981234353Sdim 6982234353Sdim 6983234353Sdim // C++11 [dcl.type.simple]p4: 6984234353Sdim // [...] 6985234353Sdim QualType T = E->getType(); 6986234353Sdim switch (E->getValueKind()) { 6987239462Sdim // - otherwise, if e is an xvalue, decltype(e) is T&&, where T is the 6988234353Sdim // type of e; 6989234353Sdim case VK_XValue: T = S.Context.getRValueReferenceType(T); break; 6990239462Sdim // - otherwise, if e is an lvalue, decltype(e) is T&, where T is the 6991234353Sdim // type of e; 6992234353Sdim case VK_LValue: T = S.Context.getLValueReferenceType(T); break; 6993234353Sdim // - otherwise, decltype(e) is the type of e. 6994234353Sdim case VK_RValue: break; 6995234353Sdim } 6996239462Sdim 6997234353Sdim return T; 6998234353Sdim} 6999234353Sdim 7000280031SdimQualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc, 7001280031Sdim bool AsUnevaluated) { 7002221345Sdim ExprResult ER = CheckPlaceholderExpr(E); 7003218893Sdim if (ER.isInvalid()) return QualType(); 7004276479Sdim E = ER.get(); 7005239462Sdim 7006280031Sdim if (AsUnevaluated && ActiveTemplateInstantiations.empty() && 7007280031Sdim E->HasSideEffects(Context, false)) { 7008280031Sdim // The expression operand for decltype is in an unevaluated expression 7009280031Sdim // context, so side effects could result in unintended consequences. 7010280031Sdim Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context); 7011280031Sdim } 7012280031Sdim 7013234353Sdim return Context.getDecltypeType(E, getDecltypeForExpr(*this, E)); 7014195341Sed} 7015223017Sdim 7016223017SdimQualType Sema::BuildUnaryTransformType(QualType BaseType, 7017223017Sdim UnaryTransformType::UTTKind UKind, 7018223017Sdim SourceLocation Loc) { 7019223017Sdim switch (UKind) { 7020223017Sdim case UnaryTransformType::EnumUnderlyingType: 7021223017Sdim if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) { 7022223017Sdim Diag(Loc, diag::err_only_enums_have_underlying_types); 7023223017Sdim return QualType(); 7024223017Sdim } else { 7025223017Sdim QualType Underlying = BaseType; 7026223017Sdim if (!BaseType->isDependentType()) { 7027276479Sdim // The enum could be incomplete if we're parsing its definition or 7028276479Sdim // recovering from an error. 7029276479Sdim NamedDecl *FwdDecl = nullptr; 7030276479Sdim if (BaseType->isIncompleteType(&FwdDecl)) { 7031276479Sdim Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType; 7032276479Sdim Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl; 7033276479Sdim return QualType(); 7034276479Sdim } 7035276479Sdim 7036223017Sdim EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl(); 7037223017Sdim assert(ED && "EnumType has no EnumDecl"); 7038276479Sdim 7039223017Sdim DiagnoseUseOfDecl(ED, Loc); 7040276479Sdim 7041223017Sdim Underlying = ED->getIntegerType(); 7042276479Sdim assert(!Underlying.isNull()); 7043223017Sdim } 7044223017Sdim return Context.getUnaryTransformType(BaseType, Underlying, 7045223017Sdim UnaryTransformType::EnumUnderlyingType); 7046223017Sdim } 7047223017Sdim } 7048223017Sdim llvm_unreachable("unknown unary transform type"); 7049223017Sdim} 7050226633Sdim 7051226633SdimQualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) { 7052226633Sdim if (!T->isDependentType()) { 7053234353Sdim // FIXME: It isn't entirely clear whether incomplete atomic types 7054234353Sdim // are allowed or not; for simplicity, ban them for the moment. 7055239462Sdim if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0)) 7056234353Sdim return QualType(); 7057234353Sdim 7058226633Sdim int DisallowedKind = -1; 7059234353Sdim if (T->isArrayType()) 7060226633Sdim DisallowedKind = 1; 7061226633Sdim else if (T->isFunctionType()) 7062226633Sdim DisallowedKind = 2; 7063226633Sdim else if (T->isReferenceType()) 7064226633Sdim DisallowedKind = 3; 7065226633Sdim else if (T->isAtomicType()) 7066226633Sdim DisallowedKind = 4; 7067226633Sdim else if (T.hasQualifiers()) 7068226633Sdim DisallowedKind = 5; 7069226633Sdim else if (!T.isTriviallyCopyableType(Context)) 7070226633Sdim // Some other non-trivially-copyable type (probably a C++ class) 7071226633Sdim DisallowedKind = 6; 7072226633Sdim 7073226633Sdim if (DisallowedKind != -1) { 7074226633Sdim Diag(Loc, diag::err_atomic_specifier_bad_type) << DisallowedKind << T; 7075226633Sdim return QualType(); 7076226633Sdim } 7077226633Sdim 7078226633Sdim // FIXME: Do we need any handling for ARC here? 7079226633Sdim } 7080226633Sdim 7081226633Sdim // Build the pointer type. 7082226633Sdim return Context.getAtomicType(T); 7083226633Sdim} 7084