SemaType.cpp revision cb421fa690da545b58a720abe5f1c49b166dbde7
15f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===// 25f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 35f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// The LLVM Compiler Infrastructure 45f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 75f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 85f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 95f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 105f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// This file implements type-related semantic analysis. 115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer// 125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer//===----------------------------------------------------------------------===// 135f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 145f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "Sema.h" 155f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer#include "clang/AST/ASTContext.h" 16a8f32e0965ee19ecc53cd796e34268377a20357cDouglas Gregor#include "clang/AST/CXXInheritance.h" 17980e508ca70d6de75d2abfd96b4681fc98bb2698Steve Naroff#include "clang/AST/DeclObjC.h" 182943aed177b33ae3f14273b11a7b398e5276ec62Douglas Gregor#include "clang/AST/DeclTemplate.h" 194adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis#include "clang/AST/TypeLoc.h" 2051bd803fbdade51d674598ed45da3d54190a656cJohn McCall#include "clang/AST/TypeLocVisitor.h" 21e91593ef084479340582b2ba177b44be50a717b7Daniel Dunbar#include "clang/AST/Expr.h" 2291a0cc913ecc5619b76d2e40742fd09725be8c56Anders Carlsson#include "clang/Basic/PartialDiagnostic.h" 23e4858a65a93fb36c099d8dd2ea0a98e33e77687eDaniel Dunbar#include "clang/Parse/DeclSpec.h" 244994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl#include "llvm/ADT/SmallPtrSet.h" 2587c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor#include "llvm/Support/ErrorHandling.h" 265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencerusing namespace clang; 275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 282dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor/// \brief Perform adjustment on the parameter type of a function. 292dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor/// 302dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor/// This routine adjusts the given parameter type @p T to the actual 311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// parameter type used by semantic analysis (C99 6.7.5.3p[7,8], 321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// C++ [dcl.fct]p3). The adjusted parameter type is returned. 332dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas GregorQualType Sema::adjustParameterType(QualType T) { 342dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor // C99 6.7.5.3p7: 35778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // A declaration of a parameter as "array of type" shall be 36778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // adjusted to "qualified pointer to type", where the type 37778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // qualifiers (if any) are those specified within the [ and ] of 38778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // the array type derivation. 39778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner if (T->isArrayType()) 402dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor return Context.getArrayDecayedType(T); 41778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner 42778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // C99 6.7.5.3p8: 43778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // A declaration of a parameter as "function returning type" 44778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // shall be adjusted to "pointer to function returning type", as 45778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner // in 6.3.2.1. 46778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner if (T->isFunctionType()) 472dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor return Context.getPointerType(T); 482dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor 492dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor return T; 502dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor} 512dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor 525db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 535db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 545db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner/// isOmittedBlockReturnType - Return true if this declarator is missing a 555db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner/// return type because this is a omitted return type on a block literal. 568ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redlstatic bool isOmittedBlockReturnType(const Declarator &D) { 575db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner if (D.getContext() != Declarator::BlockLiteralContext || 588ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl D.getDeclSpec().hasTypeSpecifier()) 595db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner return false; 605db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 615db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner if (D.getNumTypeObjects() == 0) 62a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner return true; // ^{ ... } 635db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 645db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner if (D.getNumTypeObjects() == 1 && 655db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner D.getTypeObject(0).Kind == DeclaratorChunk::Function) 66a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner return true; // ^(int X, float Y) { ... } 675db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 685db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner return false; 695db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner} 705db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 7104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCalltypedef std::pair<const AttributeList*,QualType> DelayedAttribute; 7204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCalltypedef llvm::SmallVectorImpl<DelayedAttribute> DelayedAttributeSet; 7304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 7404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallstatic void ProcessTypeAttributeList(Sema &S, QualType &Type, 75328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis bool IsDeclSpec, 7604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall const AttributeList *Attrs, 7704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DelayedAttributeSet &DelayedFnAttrs); 7804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallstatic bool ProcessFnAttr(Sema &S, QualType &Type, const AttributeList &Attr); 7904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 8004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallstatic void ProcessDelayedFnAttrs(Sema &S, QualType &Type, 8104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DelayedAttributeSet &Attrs) { 8204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall for (DelayedAttributeSet::iterator I = Attrs.begin(), 8304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall E = Attrs.end(); I != E; ++I) 8404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (ProcessFnAttr(S, Type, *I->first)) 8504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(I->first->getLoc(), diag::warn_function_attribute_wrong_type) 8604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << I->first->getName() << I->second; 8704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall Attrs.clear(); 8804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall} 8904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 9004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallstatic void DiagnoseDelayedFnAttrs(Sema &S, DelayedAttributeSet &Attrs) { 9104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall for (DelayedAttributeSet::iterator I = Attrs.begin(), 9204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall E = Attrs.end(); I != E; ++I) { 9304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(I->first->getLoc(), diag::warn_function_attribute_wrong_type) 9404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << I->first->getName() << I->second; 9504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 9604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall Attrs.clear(); 9704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall} 9804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 99930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor/// \brief Convert the specified declspec to the appropriate type 100930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor/// object. 1015db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner/// \param D the declarator containing the declaration specifier. 1025153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner/// \returns The type described by the declaration specifiers. This function 1035153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner/// never returns null. 10404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallstatic QualType ConvertDeclSpecToType(Sema &TheSema, 10504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall Declarator &TheDeclarator, 10604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DelayedAttributeSet &Delayed) { 1075f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // FIXME: Should move the logic from DeclSpec::Finish to here for validity 1085f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // checking. 1095db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner const DeclSpec &DS = TheDeclarator.getDeclSpec(); 1105db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner SourceLocation DeclLoc = TheDeclarator.getIdentifierLoc(); 1115db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner if (DeclLoc.isInvalid()) 1125db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner DeclLoc = DS.getSourceRange().getBegin(); 1131564e3906cad604a42bd131e584751a75589a9c4Chris Lattner 1141564e3906cad604a42bd131e584751a75589a9c4Chris Lattner ASTContext &Context = TheSema.Context; 1151eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1165db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner QualType Result; 1175f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (DS.getTypeSpecType()) { 11896b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner case DeclSpec::TST_void: 11996b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner Result = Context.VoidTy; 12096b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner break; 1215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_char: 1225f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 123fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.CharTy; 1245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) 125fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.SignedCharTy; 1265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else { 1275f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 1285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "Unknown TSS value"); 129fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.UnsignedCharTy; 1305f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 131958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 13264c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis case DeclSpec::TST_wchar: 13364c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified) 13464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis Result = Context.WCharTy; 13564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) { 1361564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 137f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner << DS.getSpecifierName(DS.getTypeSpecType()); 13864c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis Result = Context.getSignedWCharType(); 13964c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } else { 14064c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned && 14164c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis "Unknown TSS value"); 1421564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec) 143f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner << DS.getSpecifierName(DS.getTypeSpecType()); 14464c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis Result = Context.getUnsignedWCharType(); 14564c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis } 14664c438a4be2a871fa43c78264663ba1e9788b94dArgyrios Kyrtzidis break; 147f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case DeclSpec::TST_char16: 148f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 149f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith "Unknown TSS value"); 150f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Result = Context.Char16Ty; 151f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 152f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith case DeclSpec::TST_char32: 153f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified && 154f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith "Unknown TSS value"); 155f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith Result = Context.Char32Ty; 156f5c209d23b20ada4a9b6235db50317239cbf6ae1Alisdair Meredith break; 157d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner case DeclSpec::TST_unspecified: 15862f5f7ffad57e0c2af2b308af3735351505937cbChris Lattner // "<proto1,proto2>" is an objc qualified ID with a missing id. 159097e916b617bb4a069a03764024c310ed42a6424Chris Lattner if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) { 1601eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy, 16114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff (ObjCProtocolDecl**)PQ, 162683087ffcf21d2a22cd2d0424b7f119168b47a8eSteve Naroff DS.getNumProtocolQualifiers()); 16362f5f7ffad57e0c2af2b308af3735351505937cbChris Lattner break; 16462f5f7ffad57e0c2af2b308af3735351505937cbChris Lattner } 1655db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 1665db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner // If this is a missing declspec in a block literal return context, then it 1675db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner // is inferred from the return statements inside the block. 1688ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl if (isOmittedBlockReturnType(TheDeclarator)) { 1695db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner Result = Context.DependentTy; 1705db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner break; 1715db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner } 1721eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 173d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // Unspecified typespec defaults to int in C90. However, the C90 grammar 174d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // [C90 6.5] only allows a decl-spec if there was *some* type-specifier, 175d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // type-qualifier, or storage-class-specifier. If not, emit an extwarn. 176d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // Note that the one exception to this is function definitions, which are 177d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // allowed to be completely missing a declspec. This is handled in the 178d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // parser already though by it pretending to have seen an 'int' in this 179d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // case. 1801564e3906cad604a42bd131e584751a75589a9c4Chris Lattner if (TheSema.getLangOptions().ImplicitInt) { 18135d276f443462249b436951c1c663820569e1768Chris Lattner // In C89 mode, we only warn if there is a completely missing declspec 18235d276f443462249b436951c1c663820569e1768Chris Lattner // when one is not allowed. 1833f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner if (DS.isEmpty()) { 1841564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DeclLoc, diag::ext_missing_declspec) 1853f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner << DS.getSourceRange() 186849b243d4065f56742a4677d6dc8277609a151f8Douglas Gregor << FixItHint::CreateInsertion(DS.getSourceRange().getBegin(), "int"); 1873f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner } 1884310f4ee260e6c7ceeaf299e240f4d789ecc730dDouglas Gregor } else if (!DS.hasTypeSpecifier()) { 189d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says: 190d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // "At least one type specifier shall be given in the declaration 191d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // specifiers in each declaration, and in the specifier-qualifier list in 192d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner // each struct declaration and type name." 1934310f4ee260e6c7ceeaf299e240f4d789ecc730dDouglas Gregor // FIXME: Does Microsoft really have the implicit int extension in C++? 1941564e3906cad604a42bd131e584751a75589a9c4Chris Lattner if (TheSema.getLangOptions().CPlusPlus && 1951564e3906cad604a42bd131e584751a75589a9c4Chris Lattner !TheSema.getLangOptions().Microsoft) { 1961564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DeclLoc, diag::err_missing_type_specifier) 1973f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner << DS.getSourceRange(); 1981eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 199b78d833b12f7c4baab138f305f72efd49455a3f9Chris Lattner // When this occurs in C++ code, often something is very broken with the 200b78d833b12f7c4baab138f305f72efd49455a3f9Chris Lattner // value being declared, poison it as invalid so we don't get chains of 201b78d833b12f7c4baab138f305f72efd49455a3f9Chris Lattner // errors. 2025db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 203b78d833b12f7c4baab138f305f72efd49455a3f9Chris Lattner } else { 2041564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DeclLoc, diag::ext_missing_type_specifier) 2053f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner << DS.getSourceRange(); 206b78d833b12f7c4baab138f305f72efd49455a3f9Chris Lattner } 207d658b562e80d6ef7a1118e34ff12802c6e2fccedChris Lattner } 2081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2091eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // FALL THROUGH. 2103cbc38bd3569d37f53bd76fa89d24803f48f5036Chris Lattner case DeclSpec::TST_int: { 2115f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) { 2125f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (DS.getTypeSpecWidth()) { 213fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_unspecified: Result = Context.IntTy; break; 214fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_short: Result = Context.ShortTy; break; 215fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_long: Result = Context.LongTy; break; 216311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner case DeclSpec::TSW_longlong: 217311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner Result = Context.LongLongTy; 218311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner 219311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner // long long is a C99 feature. 220311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner if (!TheSema.getLangOptions().C99 && 221311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner !TheSema.getLangOptions().CPlusPlus0x) 222311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner TheSema.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong); 223311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner break; 2245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 2265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (DS.getTypeSpecWidth()) { 227fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break; 228fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break; 229fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break; 230311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner case DeclSpec::TSW_longlong: 231311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner Result = Context.UnsignedLongLongTy; 232311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner 233311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner // long long is a C99 feature. 234311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner if (!TheSema.getLangOptions().C99 && 235311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner !TheSema.getLangOptions().CPlusPlus0x) 236311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner TheSema.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong); 237311157fa6be96e2769bf317390dc9fb85087d5faChris Lattner break; 2385f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 2395f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 240958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 2413cbc38bd3569d37f53bd76fa89d24803f48f5036Chris Lattner } 242fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TST_float: Result = Context.FloatTy; break; 243958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner case DeclSpec::TST_double: 244958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner if (DS.getTypeSpecWidth() == DeclSpec::TSW_long) 245fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.LongDoubleTy; 246958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner else 247fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.DoubleTy; 248958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 249fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool 2505f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_decimal32: // _Decimal32 2515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_decimal64: // _Decimal64 2525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_decimal128: // _Decimal128 2531564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported); 2548f12f65fad7bfbbdbd4234efe0d484f68c3924b6Chris Lattner Result = Context.IntTy; 2555db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 2568f12f65fad7bfbbdbd4234efe0d484f68c3924b6Chris Lattner break; 25799dc91422144483c20d1c7381bc9ac634b646b04Chris Lattner case DeclSpec::TST_class: 2585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_enum: 2595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_union: 2605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclSpec::TST_struct: { 261c7621a64717203e1f7d5d79dbf548e590b32596cDouglas Gregor TypeDecl *D 262c7621a64717203e1f7d5d79dbf548e590b32596cDouglas Gregor = dyn_cast_or_null<TypeDecl>(static_cast<Decl *>(DS.getTypeRep())); 2636e24726524c2b51b31bb4b622aa678a46b024f42John McCall if (!D) { 2646e24726524c2b51b31bb4b622aa678a46b024f42John McCall // This can happen in C++ with ambiguous lookups. 2656e24726524c2b51b31bb4b622aa678a46b024f42John McCall Result = Context.IntTy; 2665db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 2676e24726524c2b51b31bb4b622aa678a46b024f42John McCall break; 2686e24726524c2b51b31bb4b622aa678a46b024f42John McCall } 2696e24726524c2b51b31bb4b622aa678a46b024f42John McCall 270a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner // If the type is deprecated or unavailable, diagnose it. 27154abf7d4fa3123b8324c09d2a4dfb789fd818403John McCall TheSema.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeLoc()); 272a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner 2735f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 274a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!"); 275a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner 2765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // TypeQuals handled by caller. 277a64ef0ab5cb6ac9cfb7d40661a9152c4aa488386Chris Lattner Result = Context.getTypeDeclType(D); 2782191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall 2792191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall // In C++, make an ElaboratedType. 2801564e3906cad604a42bd131e584751a75589a9c4Chris Lattner if (TheSema.getLangOptions().CPlusPlus) { 2812191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall TagDecl::TagKind Tag 2822191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall = TagDecl::getTagKindForTypeSpec(DS.getTypeSpecType()); 2832191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall Result = Context.getElaboratedType(Result, Tag); 2842191b20bfb31fc0e22a158f6b4204cd0b7dbd0fdJohn McCall } 2851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2865153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner if (D->isInvalidDecl()) 2875db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 288958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 2891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 2901a51b4a11b7db25cac2134249711ecaaf9d1c0a8Douglas Gregor case DeclSpec::TST_typename: { 2915f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 && 2925f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer DS.getTypeSpecSign() == 0 && 2935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer "Can't handle qualifiers on typedef names yet!"); 2941564e3906cad604a42bd131e584751a75589a9c4Chris Lattner Result = TheSema.GetTypeFromParser(DS.getTypeRep()); 2952ce52f3fb95bf544db6bd3d91a72bce7d9cceb6cDouglas Gregor 2961a51b4a11b7db25cac2134249711ecaaf9d1c0a8Douglas Gregor if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) { 297f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis if (const ObjCInterfaceType * 298f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis Interface = Result->getAs<ObjCInterfaceType>()) { 29967ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // It would be nice if protocol qualifiers were only stored with the 30067ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // ObjCObjectPointerType. Unfortunately, this isn't possible due 30167ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // to the following typedef idiom (which is uncommon, but allowed): 3021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // 30367ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // typedef Foo<P> T; 30467ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // static void func() { 30567ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // Foo<P> *yy; 30667ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // T *zz; 30767ef8eaea8a0a2073147a8d863f0e3f30d525802Steve Naroff // } 308c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff Result = Context.getObjCInterfaceType(Interface->getDecl(), 309c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff (ObjCProtocolDecl**)PQ, 310c15cb2af27514ecc879daba9aa01389c5203685dSteve Naroff DS.getNumProtocolQualifiers()); 311f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis } else if (Result->isObjCIdType()) 312ae4da6150bb837311a2f0f958b01a2989066ba90Chris Lattner // id<protocol-list> 3131eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy, 31414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff (ObjCProtocolDecl**)PQ, DS.getNumProtocolQualifiers()); 31514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff else if (Result->isObjCClassType()) { 3164262a07621043c19292f5fd90b1e426d65cd366cSteve Naroff // Class<protocol-list> 3171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Result = Context.getObjCObjectPointerType(Context.ObjCBuiltinClassTy, 318470301bac9c8abfc6b451b3b669c6695a9fd1518Steve Naroff (ObjCProtocolDecl**)PQ, DS.getNumProtocolQualifiers()); 3193f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner } else { 3201564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DeclLoc, diag::err_invalid_protocol_qualifiers) 3213f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner << DS.getSourceRange(); 3225db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 3233f84ad22acc25353a47ee88f55ab05dffef5d9a9Chris Lattner } 324c569249ca0ab755ac79d8cbbfcb2bcae19743624Fariborz Jahanian } 3251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 3265f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // TypeQuals handled by caller. 327958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 3285f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 329958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner case DeclSpec::TST_typeofType: 330e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis // FIXME: Preserve type source info. 3311564e3906cad604a42bd131e584751a75589a9c4Chris Lattner Result = TheSema.GetTypeFromParser(DS.getTypeRep()); 332958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner assert(!Result.isNull() && "Didn't get a type for typeof?"); 333d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff // TypeQuals handled by caller. 334fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.getTypeOfType(Result); 335958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 336d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff case DeclSpec::TST_typeofExpr: { 337d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff Expr *E = static_cast<Expr *>(DS.getTypeRep()); 338d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff assert(E && "Didn't get an expression for typeof?"); 339d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff // TypeQuals handled by caller. 3404b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Result = TheSema.BuildTypeofExprType(E); 3414b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (Result.isNull()) { 3424b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Result = Context.IntTy; 3434b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor TheDeclarator.setInvalidType(true); 3444b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 345958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner break; 346d1861fd633d5096a00777c918eb8575ea7162fe7Steve Naroff } 3476fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson case DeclSpec::TST_decltype: { 3486fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson Expr *E = static_cast<Expr *>(DS.getTypeRep()); 3496fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson assert(E && "Didn't get an expression for decltype?"); 3506fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson // TypeQuals handled by caller. 3511564e3906cad604a42bd131e584751a75589a9c4Chris Lattner Result = TheSema.BuildDecltypeType(E); 352af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson if (Result.isNull()) { 353af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson Result = Context.IntTy; 3545db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 355af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson } 3566fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson break; 3576fd634f4ac59f5923cffadadb99d19f23c18707aAnders Carlsson } 358e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson case DeclSpec::TST_auto: { 359e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson // TypeQuals handled by caller. 360e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson Result = Context.UndeducedAutoTy; 361e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson break; 362e89d15944dd3be750a09805ad21222d2fa9321faAnders Carlsson } 3631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 364809070a886684cb5b92eb0e00a6581ab1fa6b17aDouglas Gregor case DeclSpec::TST_error: 3655153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner Result = Context.IntTy; 3665db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner TheDeclarator.setInvalidType(true); 3675153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner break; 3685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 3691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 370958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner // Handle complex types. 371f244cd7e54753caf6edb76df430dea2f43bb82a8Douglas Gregor if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) { 3721564e3906cad604a42bd131e584751a75589a9c4Chris Lattner if (TheSema.getLangOptions().Freestanding) 3731564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex); 374fab5b45729db4e24ba43bb94d1bce5f73106be78Chris Lattner Result = Context.getComplexType(Result); 37582287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson } else if (DS.isTypeAltiVecVector()) { 37682287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result)); 37782287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson assert(typeSize > 0 && "type size for vector must be greater than 0 bits"); 37882287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson Result = Context.getVectorType(Result, 128/typeSize, true, 37982287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson DS.isTypeAltiVecPixel()); 380f244cd7e54753caf6edb76df430dea2f43bb82a8Douglas Gregor } 3811eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 382958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner assert(DS.getTypeSpecComplex() != DeclSpec::TSC_imaginary && 383958858e04e9f98a42031ba69779e49c21f01ca6cChris Lattner "FIXME: imaginary types not supported yet!"); 3841eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 38538d8b98803ac354dba15578d65ea99a83dead046Chris Lattner // See if there are any attributes on the declspec that apply to the type (as 38638d8b98803ac354dba15578d65ea99a83dead046Chris Lattner // opposed to the decl). 387fca0ddd42965e0b7ae821213486d4e0dd71fb439Chris Lattner if (const AttributeList *AL = DS.getAttributes()) 388328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis ProcessTypeAttributeList(TheSema, Result, true, AL, Delayed); 3891eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 39096b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // Apply const/volatile/restrict qualifiers to T. 39196b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner if (unsigned TypeQuals = DS.getTypeQualifiers()) { 39296b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner 39396b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // Enforce C99 6.7.3p2: "Types other than pointer types derived from object 39496b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // or incomplete types shall not be restrict-qualified." C++ also allows 39596b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // restrict-qualified references. 3960953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (TypeQuals & DeclSpec::TQ_restrict) { 3972b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian if (Result->isAnyPointerType() || Result->isReferenceType()) { 3982b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian QualType EltTy; 3992b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian if (Result->isObjCObjectPointerType()) 4002b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian EltTy = Result; 4012b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian else 4022b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian EltTy = Result->isPointerType() ? 4032b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian Result->getAs<PointerType>()->getPointeeType() : 4042b5ff1a1471819192ae805b51b888030ecb52914Fariborz Jahanian Result->getAs<ReferenceType>()->getPointeeType(); 4051eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 406bad0e656c3732e3539a9cd6525de721d7e47408bDouglas Gregor // If we have a pointer or reference, the pointee must have an object 407bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner // incomplete type. 408bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner if (!EltTy->isIncompleteOrObjectType()) { 4091564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getRestrictSpecLoc(), 410d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner diag::err_typecheck_invalid_restrict_invalid_pointee) 411d162584991885ab004a02573a73ce06422b921fcChris Lattner << EltTy << DS.getSourceRange(); 4120953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier. 413bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner } 414bdcd637c29ec1540f912ea6860c88b910e78c329Chris Lattner } else { 4151564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(DS.getRestrictSpecLoc(), 416d3a94e24ddf3fb90de76b17bd176d9ed61e66f2cChris Lattner diag::err_typecheck_invalid_restrict_not_pointer) 417d162584991885ab004a02573a73ce06422b921fcChris Lattner << Result << DS.getSourceRange(); 4180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier. 41996b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner } 42096b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner } 4211eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 42296b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification 42396b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // of a function type includes any type qualifiers, the behavior is 42496b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // undefined." 42596b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner if (Result->isFunctionType() && TypeQuals) { 42696b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner // Get some location to point at, either the C or V location. 42796b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner SourceLocation Loc; 4280953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (TypeQuals & DeclSpec::TQ_const) 42996b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner Loc = DS.getConstSpecLoc(); 4300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall else if (TypeQuals & DeclSpec::TQ_volatile) 43196b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner Loc = DS.getVolatileSpecLoc(); 4320953e767ff7817f97b3ab20896b229891eeff45bJohn McCall else { 4330953e767ff7817f97b3ab20896b229891eeff45bJohn McCall assert((TypeQuals & DeclSpec::TQ_restrict) && 4340953e767ff7817f97b3ab20896b229891eeff45bJohn McCall "Has CVR quals but not C, V, or R?"); 4350953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Loc = DS.getRestrictSpecLoc(); 43696b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner } 4371564e3906cad604a42bd131e584751a75589a9c4Chris Lattner TheSema.Diag(Loc, diag::warn_typecheck_function_qualifiers) 438d162584991885ab004a02573a73ce06422b921fcChris Lattner << Result << DS.getSourceRange(); 43996b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner } 4401eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 441f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor // C++ [dcl.ref]p1: 442f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor // Cv-qualified references are ill-formed except when the 443f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor // cv-qualifiers are introduced through the use of a typedef 444f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor // (7.1.3) or of a template type argument (14.3), in which 445f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor // case the cv-qualifiers are ignored. 4461a51b4a11b7db25cac2134249711ecaaf9d1c0a8Douglas Gregor // FIXME: Shouldn't we be checking SCS_typedef here? 4471a51b4a11b7db25cac2134249711ecaaf9d1c0a8Douglas Gregor if (DS.getTypeSpecType() == DeclSpec::TST_typename && 448f1f9b4e5c7fd087e78f2e387c01098d49d41e784Douglas Gregor TypeQuals && Result->isReferenceType()) { 4490953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TypeQuals &= ~DeclSpec::TQ_const; 4500953e767ff7817f97b3ab20896b229891eeff45bJohn McCall TypeQuals &= ~DeclSpec::TQ_volatile; 4511eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 4521eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 4530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals = Qualifiers::fromCVRMask(TypeQuals); 4540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Result = Context.getQualifiedType(Result, Quals); 45596b77fc05ed4a052a9e614f72b0e83572408ce48Chris Lattner } 4560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 457f1d705c3e2276f7f5b97b8b3394b9b3068fdf25bChris Lattner return Result; 458f1d705c3e2276f7f5b97b8b3394b9b3068fdf25bChris Lattner} 459f1d705c3e2276f7f5b97b8b3394b9b3068fdf25bChris Lattner 460cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregorstatic std::string getPrintableNameForEntity(DeclarationName Entity) { 461cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (Entity) 462cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return Entity.getAsString(); 4631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 464cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return "type name"; 465cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor} 466cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 467cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \brief Build a pointer type. 468cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 469cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param T The type to which we'll be building a pointer. 470cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 471cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Quals The cvr-qualifiers to be applied to the pointer type. 472cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 473cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Loc The location of the entity whose type involves this 474cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// pointer type or, if there is no such entity, the location of the 475cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type that will have pointer type. 476cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 477cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Entity The name of the entity that involves the pointer 478cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type, if known. 479cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 480cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \returns A suitable pointer type, if there are no 481cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// errors. Otherwise, returns a NULL type. 4821eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType Sema::BuildPointerType(QualType T, unsigned Quals, 483cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor SourceLocation Loc, DeclarationName Entity) { 484cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (T->isReferenceType()) { 485cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C++ 8.3.2p4: There shall be no ... pointers to references ... 486cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_illegal_decl_pointer_to_reference) 487ac406052f7b980f8caa6b07b4a8d0867d53852c4John McCall << getPrintableNameForEntity(Entity) << T; 488cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return QualType(); 489cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 490cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 4910953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Qs = Qualifiers::fromCVRMask(Quals); 4920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 493cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // Enforce C99 6.7.3p2: "Types other than pointer types derived from 494cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // object or incomplete types shall not be restrict-qualified." 4950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Qs.hasRestrict() && !T->isIncompleteOrObjectType()) { 496cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee) 497cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor << T; 4980953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qs.removeRestrict(); 499cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 500cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 501cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // Build the pointer type. 5020953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Context.getQualifiedType(Context.getPointerType(T), Qs); 503cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor} 504cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 505cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \brief Build a reference type. 506cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 507cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param T The type to which we'll be building a reference. 508cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 5090953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// \param CVR The cvr-qualifiers to be applied to the reference type. 510cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 511cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Loc The location of the entity whose type involves this 512cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// reference type or, if there is no such entity, the location of the 513cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type that will have reference type. 514cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 515cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Entity The name of the entity that involves the reference 516cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type, if known. 517cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 518cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \returns A suitable reference type, if there are no 519cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// errors. Otherwise, returns a NULL type. 52054e14c4db764c0636160d26c5bbf491637c83a76John McCallQualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, 52154e14c4db764c0636160d26c5bbf491637c83a76John McCall unsigned CVR, SourceLocation Loc, 52254e14c4db764c0636160d26c5bbf491637c83a76John McCall DeclarationName Entity) { 5230953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals = Qualifiers::fromCVRMask(CVR); 52454e14c4db764c0636160d26c5bbf491637c83a76John McCall 52554e14c4db764c0636160d26c5bbf491637c83a76John McCall bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>(); 52654e14c4db764c0636160d26c5bbf491637c83a76John McCall 52754e14c4db764c0636160d26c5bbf491637c83a76John McCall // C++0x [dcl.typedef]p9: If a typedef TD names a type that is a 52854e14c4db764c0636160d26c5bbf491637c83a76John McCall // reference to a type T, and attempt to create the type "lvalue 52954e14c4db764c0636160d26c5bbf491637c83a76John McCall // reference to cv TD" creates the type "lvalue reference to T". 53054e14c4db764c0636160d26c5bbf491637c83a76John McCall // We use the qualifiers (restrict or none) of the original reference, 53154e14c4db764c0636160d26c5bbf491637c83a76John McCall // not the new ones. This is consistent with GCC. 53254e14c4db764c0636160d26c5bbf491637c83a76John McCall 53354e14c4db764c0636160d26c5bbf491637c83a76John McCall // C++ [dcl.ref]p4: There shall be no references to references. 53454e14c4db764c0636160d26c5bbf491637c83a76John McCall // 53554e14c4db764c0636160d26c5bbf491637c83a76John McCall // According to C++ DR 106, references to references are only 53654e14c4db764c0636160d26c5bbf491637c83a76John McCall // diagnosed when they are written directly (e.g., "int & &"), 53754e14c4db764c0636160d26c5bbf491637c83a76John McCall // but not when they happen via a typedef: 53854e14c4db764c0636160d26c5bbf491637c83a76John McCall // 53954e14c4db764c0636160d26c5bbf491637c83a76John McCall // typedef int& intref; 54054e14c4db764c0636160d26c5bbf491637c83a76John McCall // typedef intref& intref2; 54154e14c4db764c0636160d26c5bbf491637c83a76John McCall // 54254e14c4db764c0636160d26c5bbf491637c83a76John McCall // Parser::ParseDeclaratorInternal diagnoses the case where 54354e14c4db764c0636160d26c5bbf491637c83a76John McCall // references are written directly; here, we handle the 54454e14c4db764c0636160d26c5bbf491637c83a76John McCall // collapsing of references-to-references as described in C++ 54554e14c4db764c0636160d26c5bbf491637c83a76John McCall // DR 106 and amended by C++ DR 540. 546cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 547cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C++ [dcl.ref]p1: 54833a3138a0862cafdd9ff1332b834454a79cd2cdcEli Friedman // A declarator that specifies the type "reference to cv void" 549cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // is ill-formed. 550cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (T->isVoidType()) { 551cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_reference_to_void); 552cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return QualType(); 553cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 554cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 555cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // Enforce C99 6.7.3p2: "Types other than pointer types derived from 556cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // object or incomplete types shall not be restrict-qualified." 5570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals.hasRestrict() && !T->isIncompleteOrObjectType()) { 558cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee) 559cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor << T; 5600953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.removeRestrict(); 561cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 562cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 563cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C++ [dcl.ref]p1: 564cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // [...] Cv-qualified references are ill-formed except when the 565cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // cv-qualifiers are introduced through the use of a typedef 566cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // (7.1.3) or of a template type argument (14.3), in which case 567cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // the cv-qualifiers are ignored. 568cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // 569cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // We diagnose extraneous cv-qualifiers for the non-typedef, 570cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // non-template type argument case within the parser. Here, we just 571cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // ignore any extraneous cv-qualifiers. 5720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.removeConst(); 5730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.removeVolatile(); 574cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 575cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // Handle restrict on references. 5767c80bd64032e610c0dbd74fc0ef6ea334447f2fdSebastian Redl if (LValueRef) 57754e14c4db764c0636160d26c5bbf491637c83a76John McCall return Context.getQualifiedType( 57854e14c4db764c0636160d26c5bbf491637c83a76John McCall Context.getLValueReferenceType(T, SpelledAsLValue), Quals); 5790953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Context.getQualifiedType(Context.getRValueReferenceType(T), Quals); 580cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor} 581cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 582cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \brief Build an array type. 583cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 584cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param T The type of each element in the array. 585cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 586cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param ASM C99 array size modifier (e.g., '*', 'static'). 5871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// 5881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// \param ArraySize Expression describing the size of the array. 589cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 590cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Quals The cvr-qualifiers to be applied to the array's 591cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// element type. 592cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 593cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Loc The location of the entity whose type involves this 594cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// array type or, if there is no such entity, the location of the 595cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type that will have array type. 596cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 597cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \param Entity The name of the entity that involves the array 598cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// type, if known. 599cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// 600cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// \returns A suitable array type, if there are no errors. Otherwise, 601cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor/// returns a NULL type. 602cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas GregorQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, 603cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Expr *ArraySize, unsigned Quals, 6047e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor SourceRange Brackets, DeclarationName Entity) { 6050953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 6067e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor SourceLocation Loc = Brackets.getBegin(); 6071eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // C99 6.7.5.2p1: If the element type is an incomplete or function type, 608cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]()) 609923d56d436f750bc1f29db50e641078725558a1bSebastian Redl // Not in C++, though. There we only dislike void. 610923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (getLangOptions().CPlusPlus) { 611923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (T->isVoidType()) { 612923d56d436f750bc1f29db50e641078725558a1bSebastian Redl Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T; 613923d56d436f750bc1f29db50e641078725558a1bSebastian Redl return QualType(); 614923d56d436f750bc1f29db50e641078725558a1bSebastian Redl } 615923d56d436f750bc1f29db50e641078725558a1bSebastian Redl } else { 616923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (RequireCompleteType(Loc, T, 617923d56d436f750bc1f29db50e641078725558a1bSebastian Redl diag::err_illegal_decl_array_incomplete_type)) 618923d56d436f750bc1f29db50e641078725558a1bSebastian Redl return QualType(); 619923d56d436f750bc1f29db50e641078725558a1bSebastian Redl } 620cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 621cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (T->isFunctionType()) { 622cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_illegal_decl_array_of_functions) 623ac406052f7b980f8caa6b07b4a8d0867d53852c4John McCall << getPrintableNameForEntity(Entity) << T; 624cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return QualType(); 625cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 6261eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 627cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C++ 8.3.2p4: There shall be no ... arrays of references ... 628cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (T->isReferenceType()) { 629cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::err_illegal_decl_array_of_references) 630ac406052f7b980f8caa6b07b4a8d0867d53852c4John McCall << getPrintableNameForEntity(Entity) << T; 631cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return QualType(); 6321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 633cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 634e7cf07d8df83e083505c7105c50b2797493008a6Anders Carlsson if (Context.getCanonicalType(T) == Context.UndeducedAutoTy) { 6351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(Loc, diag::err_illegal_decl_array_of_auto) 636e7cf07d8df83e083505c7105c50b2797493008a6Anders Carlsson << getPrintableNameForEntity(Entity); 637e7cf07d8df83e083505c7105c50b2797493008a6Anders Carlsson return QualType(); 638e7cf07d8df83e083505c7105c50b2797493008a6Anders Carlsson } 6391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 6406217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek if (const RecordType *EltTy = T->getAs<RecordType>()) { 641cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // If the element type is a struct or union that contains a variadic 642cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // array, accept it as a GNU extension: C99 6.7.2.1p2. 643cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (EltTy->getDecl()->hasFlexibleArrayMember()) 644cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(Loc, diag::ext_flexible_array_in_array) << T; 645cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } else if (T->isObjCInterfaceType()) { 646c7c11b1ba6a110f2416889cc3576fe33277b2a33Chris Lattner Diag(Loc, diag::err_objc_array_of_interfaces) << T; 647c7c11b1ba6a110f2416889cc3576fe33277b2a33Chris Lattner return QualType(); 648cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 6491eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 650cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C99 6.7.5.2p1: The size expression shall have integer type. 651cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (ArraySize && !ArraySize->isTypeDependent() && 652cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor !ArraySize->getType()->isIntegerType()) { 653cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Diag(ArraySize->getLocStart(), diag::err_array_size_non_int) 654cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor << ArraySize->getType() << ArraySize->getSourceRange(); 655cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor ArraySize->Destroy(Context); 656cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return QualType(); 657cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 658cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor llvm::APSInt ConstVal(32); 659cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (!ArraySize) { 660f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman if (ASM == ArrayType::Star) 6617e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor T = Context.getVariableArrayType(T, 0, ASM, Quals, Brackets); 662f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman else 663f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman T = Context.getIncompleteArrayType(T, ASM, Quals); 664cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } else if (ArraySize->isValueDependent()) { 6657e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets); 666cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context) || 667923d56d436f750bc1f29db50e641078725558a1bSebastian Redl (!T->isDependentType() && !T->isIncompleteType() && 668923d56d436f750bc1f29db50e641078725558a1bSebastian Redl !T->isConstantSizeType())) { 669cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // Per C99, a variable array is an array with either a non-constant 670cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // size or an element type that has a non-constant-size 6717e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets); 672cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } else { 673cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // C99 6.7.5.2p1: If the expression is a constant expression, it shall 674cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // have a value greater than zero. 675923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (ConstVal.isSigned() && ConstVal.isNegative()) { 676923d56d436f750bc1f29db50e641078725558a1bSebastian Redl Diag(ArraySize->getLocStart(), 677923d56d436f750bc1f29db50e641078725558a1bSebastian Redl diag::err_typecheck_negative_array_size) 678923d56d436f750bc1f29db50e641078725558a1bSebastian Redl << ArraySize->getSourceRange(); 679923d56d436f750bc1f29db50e641078725558a1bSebastian Redl return QualType(); 680923d56d436f750bc1f29db50e641078725558a1bSebastian Redl } 681923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (ConstVal == 0) { 68202024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // GCC accepts zero sized static arrays. We allow them when 68302024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor // we're not in a SFINAE context. 68402024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor Diag(ArraySize->getLocStart(), 68502024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor isSFINAEContext()? diag::err_typecheck_zero_array_size 68602024a9f0d8e6c898de276193af604c42ee41269Douglas Gregor : diag::ext_typecheck_zero_array_size) 687923d56d436f750bc1f29db50e641078725558a1bSebastian Redl << ArraySize->getSourceRange(); 6881eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 68946a617a792bfab0d9b1e057371ea3b9540802226John McCall T = Context.getConstantArrayType(T, ConstVal, ASM, Quals); 690cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 691af40776922bc5c28e740adb0342faa09f35b0068David Chisnall // If this is not C99, extwarn about VLA's and C99 array size modifiers. 692af40776922bc5c28e740adb0342faa09f35b0068David Chisnall if (!getLangOptions().C99) { 6931eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (ArraySize && !ArraySize->isTypeDependent() && 6941eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump !ArraySize->isValueDependent() && 695cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor !ArraySize->isIntegerConstantExpr(Context)) 696043cad21b78c6b02597cdc7b6ead32388e27ebc7Douglas Gregor Diag(Loc, getLangOptions().CPlusPlus? diag::err_vla_cxx : diag::ext_vla); 697cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor else if (ASM != ArrayType::Normal || Quals != 0) 698043cad21b78c6b02597cdc7b6ead32388e27ebc7Douglas Gregor Diag(Loc, 699043cad21b78c6b02597cdc7b6ead32388e27ebc7Douglas Gregor getLangOptions().CPlusPlus? diag::err_c99_array_usage_cxx 700043cad21b78c6b02597cdc7b6ead32388e27ebc7Douglas Gregor : diag::ext_c99_array_usage); 701cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 702cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 703cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor return T; 704cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor} 7059cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 7069cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor/// \brief Build an ext-vector type. 7079cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor/// 7089cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor/// Run the required checks for the extended vector type. 7091eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType Sema::BuildExtVectorType(QualType T, ExprArg ArraySize, 7109cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor SourceLocation AttrLoc) { 7119cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 7129cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Expr *Arg = (Expr *)ArraySize.get(); 7139cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 7149cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor // unlike gcc's vector_size attribute, we do not allow vectors to be defined 7159cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor // in conjunction with complex types (pointers, arrays, functions, etc.). 7161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!T->isDependentType() && 7179cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor !T->isIntegerType() && !T->isRealFloatingType()) { 7189cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T; 7199cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(); 7209cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 7219cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor 7229cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor if (!Arg->isTypeDependent() && !Arg->isValueDependent()) { 7239cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor llvm::APSInt vecSize(32); 7249cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor if (!Arg->isIntegerConstantExpr(vecSize, Context)) { 7259cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Diag(AttrLoc, diag::err_attribute_argument_not_int) 7269cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor << "ext_vector_type" << Arg->getSourceRange(); 7279cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(); 7289cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 7291eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // unlike gcc's vector_size attribute, the size is specified as the 7319cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor // number of elements, not the number of bytes. 7321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue()); 7331eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7349cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor if (vectorSize == 0) { 7359cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor Diag(AttrLoc, diag::err_attribute_zero_size) 7369cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor << Arg->getSourceRange(); 7379cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return QualType(); 7389cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor } 7391eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7409cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor if (!T->isDependentType()) 7419cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor return Context.getExtVectorType(T, vectorSize); 7421eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 7431eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 7441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Context.getDependentSizedExtVectorType(T, ArraySize.takeAs<Expr>(), 7459cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor AttrLoc); 7469cdda0cf8528e3d595be9bfa002f0450074beb4dDouglas Gregor} 7471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 748724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \brief Build a function type. 749724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 750724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// This routine checks the function type according to C++ rules and 751724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// under the assumption that the result type and parameter types have 752724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// just been instantiated from a template. It therefore duplicates 7532943aed177b33ae3f14273b11a7b398e5276ec62Douglas Gregor/// some of the behavior of GetTypeForDeclarator, but in a much 754724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// simpler form that is only suitable for this narrow use case. 755724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 756724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param T The return type of the function. 757724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 758724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param ParamTypes The parameter types of the function. This array 759724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// will be modified to account for adjustments to the types of the 760724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// function parameters. 761724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 762724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param NumParamTypes The number of parameter types in ParamTypes. 763724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 764724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param Variadic Whether this is a variadic function type. 765724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 766724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param Quals The cvr-qualifiers to be applied to the function type. 767724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 768724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param Loc The location of the entity whose type involves this 769724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// function type or, if there is no such entity, the location of the 770724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// type that will have function type. 771724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 772724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \param Entity The name of the entity that involves the function 773724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// type, if known. 774724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// 775724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// \returns A suitable function type, if there are no 776724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor/// errors. Otherwise, returns a NULL type. 777724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas GregorQualType Sema::BuildFunctionType(QualType T, 7781eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump QualType *ParamTypes, 779724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor unsigned NumParamTypes, 780724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor bool Variadic, unsigned Quals, 781724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor SourceLocation Loc, DeclarationName Entity) { 782724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor if (T->isArrayType() || T->isFunctionType()) { 78358408bc4ead86b08af56cd06fc966fd858b48b2dDouglas Gregor Diag(Loc, diag::err_func_returning_array_function) 78458408bc4ead86b08af56cd06fc966fd858b48b2dDouglas Gregor << T->isFunctionType() << T; 785724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor return QualType(); 786724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor } 7871eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 788724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor bool Invalid = false; 789724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor for (unsigned Idx = 0; Idx < NumParamTypes; ++Idx) { 7902dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor QualType ParamType = adjustParameterType(ParamTypes[Idx]); 7912dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor if (ParamType->isVoidType()) { 792724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor Diag(Loc, diag::err_param_with_void_type); 793724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor Invalid = true; 794724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor } 795cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 79654e14c4db764c0636160d26c5bbf491637c83a76John McCall ParamTypes[Idx] = ParamType; 797724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor } 798724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor 799724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor if (Invalid) 800724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor return QualType(); 801724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor 8021eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump return Context.getFunctionType(T, ParamTypes, NumParamTypes, Variadic, 803264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola Quals, false, false, 0, 0, 804264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 805724651c3523e25fbf2f6cd0419bc3466e0afdb07Douglas Gregor} 8061eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 807949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \brief Build a member pointer type \c T Class::*. 808949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// 809949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \param T the type to which the member pointer refers. 810949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \param Class the class type into which the member pointer points. 8110953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// \param CVR Qualifiers applied to the member pointer type 812949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \param Loc the location where this type begins 813949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \param Entity the name of the entity that will have this member pointer type 814949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// 815949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// \returns a member pointer type, if successful, or a NULL type if there was 816949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor/// an error. 8171eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpQualType Sema::BuildMemberPointerType(QualType T, QualType Class, 8180953e767ff7817f97b3ab20896b229891eeff45bJohn McCall unsigned CVR, SourceLocation Loc, 819949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor DeclarationName Entity) { 8200953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals = Qualifiers::fromCVRMask(CVR); 8210953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 822949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // Verify that we're not building a pointer to pointer to function with 823949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // exception specification. 824949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (CheckDistantExceptionSpec(T)) { 825949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor Diag(Loc, diag::err_distant_exception_spec); 826949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 827949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // FIXME: If we're doing this as part of template instantiation, 828949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // we should return immediately. 829949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 830949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // Build the type anyway, but use the canonical type so that the 831949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // exception specifiers are stripped off. 832949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor T = Context.getCanonicalType(T); 833949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor } 834949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 835949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // C++ 8.3.3p3: A pointer to member shall not pointer to ... a member 836949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // with reference type, or "cv void." 837949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (T->isReferenceType()) { 8388d4655d3b966da02fe0588767160448594cddd61Anders Carlsson Diag(Loc, diag::err_illegal_decl_mempointer_to_reference) 839ac406052f7b980f8caa6b07b4a8d0867d53852c4John McCall << (Entity? Entity.getAsString() : "type name") << T; 840949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor return QualType(); 841949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor } 842949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 843949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (T->isVoidType()) { 844949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor Diag(Loc, diag::err_illegal_decl_mempointer_to_void) 845949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor << (Entity? Entity.getAsString() : "type name"); 846949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor return QualType(); 847949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor } 848949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 849949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // Enforce C99 6.7.3p2: "Types other than pointer types derived from 850949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // object or incomplete types shall not be restrict-qualified." 8510953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Quals.hasRestrict() && !T->isIncompleteOrObjectType()) { 852949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee) 853949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor << T; 854949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 855949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // FIXME: If we're doing this as part of template instantiation, 856949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor // we should return immediately. 8570953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Quals.removeRestrict(); 858949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor } 859949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 860949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (!Class->isDependentType() && !Class->isRecordType()) { 861949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class; 862949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor return QualType(); 863949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor } 864949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor 8650953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Context.getQualifiedType( 8660953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Context.getMemberPointerType(T, Class.getTypePtr()), Quals); 867949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor} 8681eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8699a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// \brief Build a block pointer type. 8709a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// 8719a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// \param T The type to which we'll be building a block pointer. 8729a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// 8730953e767ff7817f97b3ab20896b229891eeff45bJohn McCall/// \param CVR The cvr-qualifiers to be applied to the block pointer type. 8749a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// 8759a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// \param Loc The location of the entity whose type involves this 8769a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// block pointer type or, if there is no such entity, the location of the 8779a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// type that will have block pointer type. 8789a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// 8799a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// \param Entity The name of the entity that involves the block pointer 8809a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// type, if known. 8819a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// 8829a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// \returns A suitable block pointer type, if there are no 8839a917e4fac79aba20fbd25983c78396475078918Anders Carlsson/// errors. Otherwise, returns a NULL type. 8840953e767ff7817f97b3ab20896b229891eeff45bJohn McCallQualType Sema::BuildBlockPointerType(QualType T, unsigned CVR, 8851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump SourceLocation Loc, 8869a917e4fac79aba20fbd25983c78396475078918Anders Carlsson DeclarationName Entity) { 8870953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (!T->isFunctionType()) { 8889a917e4fac79aba20fbd25983c78396475078918Anders Carlsson Diag(Loc, diag::err_nonfunction_block_type); 8899a917e4fac79aba20fbd25983c78396475078918Anders Carlsson return QualType(); 8909a917e4fac79aba20fbd25983c78396475078918Anders Carlsson } 8911eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 8920953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals = Qualifiers::fromCVRMask(CVR); 8930953e767ff7817f97b3ab20896b229891eeff45bJohn McCall return Context.getQualifiedType(Context.getBlockPointerType(T), Quals); 8949a917e4fac79aba20fbd25983c78396475078918Anders Carlsson} 8959a917e4fac79aba20fbd25983c78396475078918Anders Carlsson 896a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallQualType Sema::GetTypeFromParser(TypeTy *Ty, TypeSourceInfo **TInfo) { 897e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis QualType QT = QualType::getFromOpaquePtr(Ty); 8983f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor if (QT.isNull()) { 899a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (TInfo) *TInfo = 0; 9003f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor return QualType(); 9013f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor } 9023f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor 903a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *DI = 0; 904e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis if (LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) { 905e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis QT = LIT->getType(); 906a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall DI = LIT->getTypeSourceInfo(); 907e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis } 9081eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 909a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (TInfo) *TInfo = DI; 910e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis return QT; 911e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis} 912e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis 91398eb8a7a702b95183ed015706b1f1c66f5cb27a4Mike Stump/// GetTypeForDeclarator - Convert the type for the specified 9148ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl/// declarator to Type instances. 915402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor/// 916402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor/// If OwnedDecl is non-NULL, and this declarator's decl-specifier-seq 917402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor/// owns the declaration of a type (e.g., the definition of a struct 918402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor/// type), then *OwnedDecl will receive the owned declaration. 919a1d5662d96465f0fddf8819d245da4d19b892effArgyrios KyrtzidisQualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, 920a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo **TInfo, 921402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor TagDecl **OwnedDecl) { 922930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor // Determine the type of the declarator. Not all forms of declarator 923930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor // have a type. 924930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor QualType T; 92505baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor TypeSourceInfo *ReturnTypeInfo = 0; 92605baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor 92704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall llvm::SmallVector<DelayedAttribute,4> FnAttrsFromDeclSpec; 92804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 9293f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor switch (D.getName().getKind()) { 9303f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor case UnqualifiedId::IK_Identifier: 9313f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor case UnqualifiedId::IK_OperatorFunctionId: 9320486d746019f8310589b1f0d92edcc4bb3916b33Sean Hunt case UnqualifiedId::IK_LiteralOperatorId: 9333f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor case UnqualifiedId::IK_TemplateId: 93404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall T = ConvertDeclSpecToType(*this, D, FnAttrsFromDeclSpec); 9355db2bb1cb0c040dcbca1b5000f091d6d225b4bfeChris Lattner 936591bd3cb605f1f0229b4b1d8a4b8183377064ec5Douglas Gregor if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) { 937591bd3cb605f1f0229b4b1d8a4b8183377064ec5Douglas Gregor TagDecl* Owned = cast<TagDecl>((Decl *)D.getDeclSpec().getTypeRep()); 938b37b648b3f2bba4c557a1604ced19b526b25a372Douglas Gregor // Owned is embedded if it was defined here, or if it is the 939b37b648b3f2bba4c557a1604ced19b526b25a372Douglas Gregor // very first (i.e., canonical) declaration of this tag type. 940b37b648b3f2bba4c557a1604ced19b526b25a372Douglas Gregor Owned->setEmbeddedInDeclarator(Owned->isDefinition() || 941b37b648b3f2bba4c557a1604ced19b526b25a372Douglas Gregor Owned->isCanonicalDecl()); 942591bd3cb605f1f0229b4b1d8a4b8183377064ec5Douglas Gregor if (OwnedDecl) *OwnedDecl = Owned; 943591bd3cb605f1f0229b4b1d8a4b8183377064ec5Douglas Gregor } 944930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor break; 945930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor 9463f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor case UnqualifiedId::IK_ConstructorName: 9470efc2c1716be4f1c5f1343cad3b047e74861f030Douglas Gregor case UnqualifiedId::IK_ConstructorTemplateId: 9483f9a0566e6793151b99a65ab936220971cf96c1bDouglas Gregor case UnqualifiedId::IK_DestructorName: 949930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor // Constructors and destructors don't have return types. Use 95048026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor // "void" instead. 951930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor T = Context.VoidTy; 95205baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor 95305baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor if (TInfo) 95405baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor ReturnTypeInfo = Context.getTrivialTypeSourceInfo(T, 95505baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor D.getName().StartLocation); 956930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor break; 95748026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor 95848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor case UnqualifiedId::IK_ConversionFunctionId: 95948026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor // The result type of a conversion function is the type that it 96048026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor // converts to. 96105baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor T = GetTypeFromParser(D.getName().ConversionFunctionId, 96205baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor TInfo? &ReturnTypeInfo : 0); 96348026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor break; 964930d8b5ecc074cca01ecd9a522a55f55f3b72396Douglas Gregor } 965f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis 9661f5f3a4d58a1c7c50c331b33329fc14563533c04Douglas Gregor if (T.isNull()) 9671f5f3a4d58a1c7c50c331b33329fc14563533c04Douglas Gregor return T; 9681f5f3a4d58a1c7c50c331b33329fc14563533c04Douglas Gregor 969baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson if (T == Context.UndeducedAutoTy) { 970baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson int Error = -1; 9711eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 972baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson switch (D.getContext()) { 973baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::KNRTypeListContext: 974baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson assert(0 && "K&R type lists aren't allowed in C++"); 975baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 976baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::PrototypeContext: 977baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson Error = 0; // Function prototype 978baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 979baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::MemberContext: 980baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson switch (cast<TagDecl>(CurContext)->getTagKind()) { 981baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case TagDecl::TK_enum: assert(0 && "unhandled tag kind"); break; 982baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case TagDecl::TK_struct: Error = 1; /* Struct member */ break; 983baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case TagDecl::TK_union: Error = 2; /* Union member */ break; 984baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case TagDecl::TK_class: Error = 3; /* Class member */ break; 9851eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } 986baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 987baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::CXXCatchContext: 988baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson Error = 4; // Exception declaration 989baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 990baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::TemplateParamContext: 991baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson Error = 5; // Template parameter 992baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 993baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::BlockLiteralContext: 994baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson Error = 6; // Block literal 995baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 996baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::FileContext: 997baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::BlockContext: 998baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::ForContext: 999baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::ConditionContext: 1000baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson case Declarator::TypeNameContext: 1001baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson break; 1002baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson } 1003baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson 1004baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson if (Error != -1) { 1005baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson Diag(D.getDeclSpec().getTypeSpecTypeLoc(), diag::err_auto_not_allowed) 1006baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson << Error; 1007baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson T = Context.IntTy; 1008baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson D.setInvalidType(true); 1009baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson } 1010baf45d31f18e6d5b3d2a33695c2af6e6cbc4ee29Anders Carlsson } 10111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1012cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor // The name we're declaring, if any. 1013cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor DeclarationName Name; 1014cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (D.getIdentifier()) 1015cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor Name = D.getIdentifier(); 10161eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 101704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall llvm::SmallVector<DelayedAttribute,4> FnAttrsFromPreviousChunk; 101804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 101998eb8a7a702b95183ed015706b1f1c66f5cb27a4Mike Stump // Walk the DeclTypeInfo, building the recursive type as we go. 102098eb8a7a702b95183ed015706b1f1c66f5cb27a4Mike Stump // DeclTypeInfos are ordered from the identifier out, which is 102198eb8a7a702b95183ed015706b1f1c66f5cb27a4Mike Stump // opposite of what we want :). 10228ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 10238ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl DeclaratorChunk &DeclType = D.getTypeObject(e-i-1); 10245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer switch (DeclType.Kind) { 10255f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer default: assert(0 && "Unknown decltype!"); 10265618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff case DeclaratorChunk::BlockPointer: 10279af5500f3f132f9a2f9abbe82113a7c7bb751472Chris Lattner // If blocks are disabled, emit an error. 10289af5500f3f132f9a2f9abbe82113a7c7bb751472Chris Lattner if (!LangOpts.Blocks) 10299af5500f3f132f9a2f9abbe82113a7c7bb751472Chris Lattner Diag(DeclType.Loc, diag::err_blocks_disable); 10301eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 10311eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump T = BuildBlockPointerType(T, DeclType.Cls.TypeQuals, D.getIdentifierLoc(), 10329a917e4fac79aba20fbd25983c78396475078918Anders Carlsson Name); 10335618bd4a52c45fbbb605e3ba885663b2164db8a3Steve Naroff break; 10345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclaratorChunk::Pointer: 10356a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Verify that we're not building a pointer to pointer to function with 10366a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // exception specification. 10376a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) { 10386a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 10396a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl D.setInvalidType(true); 10406a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Build the type anyway. 10416a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl } 104214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (getLangOptions().ObjC1 && T->isObjCInterfaceType()) { 1043183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const ObjCInterfaceType *OIT = T->getAs<ObjCInterfaceType>(); 104414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff T = Context.getObjCObjectPointerType(T, 1045cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman const_cast<ObjCProtocolDecl **>( 1046cb421fa690da545b58a720abe5f1c49b166dbde7Dan Gohman OIT->qual_begin()), 1047a42286486c85402c65f9d30df17e6b1b037a6adeFariborz Jahanian OIT->getNumProtocols(), 1048a42286486c85402c65f9d30df17e6b1b037a6adeFariborz Jahanian DeclType.Ptr.TypeQuals); 104914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff break; 105014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } 1051cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor T = BuildPointerType(T, DeclType.Ptr.TypeQuals, DeclType.Loc, Name); 10525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10530953e767ff7817f97b3ab20896b229891eeff45bJohn McCall case DeclaratorChunk::Reference: { 10540953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers Quals; 10550953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (DeclType.Ref.HasRestrict) Quals.addRestrict(); 10560953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 10576a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Verify that we're not building a reference to pointer to function with 10586a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // exception specification. 10596a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) { 10606a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 10616a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl D.setInvalidType(true); 10626a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Build the type anyway. 10636a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl } 10640953e767ff7817f97b3ab20896b229891eeff45bJohn McCall T = BuildReferenceType(T, DeclType.Ref.LValueRef, Quals, 1065cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor DeclType.Loc, Name); 10665f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10670953e767ff7817f97b3ab20896b229891eeff45bJohn McCall } 10685f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer case DeclaratorChunk::Array: { 10696a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Verify that we're not building an array of pointers to function with 10706a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // exception specification. 10716a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) { 10726a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 10736a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl D.setInvalidType(true); 10746a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl // Build the type anyway. 10756a7330c20cabf1cf1cd46f5dfc183ec3a72add66Sebastian Redl } 1076fd89bc825026e44c68a68db72d4012fd6752e70fChris Lattner DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr; 107794f81fd0b0f81a99d215b225c8c5616295b063f6Chris Lattner Expr *ArraySize = static_cast<Expr*>(ATI.NumElts); 10785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ArrayType::ArraySizeModifier ASM; 10795f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (ATI.isStar) 10805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ASM = ArrayType::Star; 10815f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else if (ATI.hasStatic) 10825f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ASM = ArrayType::Static; 10835f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer else 10845f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer ASM = ArrayType::Normal; 1085f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman if (ASM == ArrayType::Star && 1086f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman D.getContext() != Declarator::PrototypeContext) { 1087f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman // FIXME: This check isn't quite right: it allows star in prototypes 1088f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman // for function definitions, and disallows some edge cases detailed 1089f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html 1090f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman Diag(DeclType.Loc, diag::err_array_star_outside_prototype); 1091f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman ASM = ArrayType::Normal; 1092f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman D.setInvalidType(true); 1093f91f5c8a66ffd812f61819836529f8ad437f7e2bEli Friedman } 10940953e767ff7817f97b3ab20896b229891eeff45bJohn McCall T = BuildArrayType(T, ASM, ArraySize, 10950953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::fromCVRMask(ATI.TypeQuals), 10967e7eb3da052a6d80ddf2377cab0384c798f73f75Douglas Gregor SourceRange(DeclType.Loc, DeclType.EndLoc), Name); 10975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 10985f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1099f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case DeclaratorChunk::Function: { 11005f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If the function declarator has a prototype (i.e. it is not () and 11015f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // does not have a K&R-style identifier list), then the arguments are part 11025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // of the type, otherwise the argument list is (). 11035f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun; 11043cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl 1105cd8812948bc8a65dcf10c541c1775e5ba44def6cChris Lattner // C99 6.7.5.3p1: The return type may not be a function or array type. 110658408bc4ead86b08af56cd06fc966fd858b48b2dDouglas Gregor // For conversion functions, we'll diagnose this particular error later. 110748026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor if ((T->isArrayType() || T->isFunctionType()) && 110848026d26fb58e413544874eead5491b1452e2ebfDouglas Gregor (D.getName().getKind() != UnqualifiedId::IK_ConversionFunctionId)) { 110958408bc4ead86b08af56cd06fc966fd858b48b2dDouglas Gregor Diag(DeclType.Loc, diag::err_func_returning_array_function) 111058408bc4ead86b08af56cd06fc966fd858b48b2dDouglas Gregor << T->isFunctionType() << T; 1111cd8812948bc8a65dcf10c541c1775e5ba44def6cChris Lattner T = Context.IntTy; 1112cd8812948bc8a65dcf10c541c1775e5ba44def6cChris Lattner D.setInvalidType(true); 1113cd8812948bc8a65dcf10c541c1775e5ba44def6cChris Lattner } 1114465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 1115402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor if (getLangOptions().CPlusPlus && D.getDeclSpec().isTypeSpecOwned()) { 1116402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // C++ [dcl.fct]p6: 1117402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // Types shall not be defined in return or parameter types. 1118402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor TagDecl *Tag = cast<TagDecl>((Decl *)D.getDeclSpec().getTypeRep()); 1119402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor if (Tag->isDefinition()) 1120402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor Diag(Tag->getLocation(), diag::err_type_defined_in_result_type) 1121402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor << Context.getTypeDeclType(Tag); 1122402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor } 1123402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor 11243cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl // Exception specs are not allowed in typedefs. Complain, but add it 11253cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl // anyway. 11263cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl if (FTI.hasExceptionSpec && 11273cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) 11283cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl Diag(FTI.getThrowLoc(), diag::err_exception_spec_in_typedef); 11293cc9726a493d90bd8faf094986a59352fd3461cbSebastian Redl 1130eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (FTI.NumArgs == 0) { 1131c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis if (getLangOptions().CPlusPlus) { 1132c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis // C++ 8.3.5p2: If the parameter-declaration-clause is empty, the 1133c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis // function takes no arguments. 1134465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl llvm::SmallVector<QualType, 4> Exceptions; 1135465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl Exceptions.reserve(FTI.NumExceptions); 11361eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) { 1137e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis // FIXME: Preserve type source info. 1138e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis QualType ET = GetTypeFromParser(FTI.Exceptions[ei].Ty); 1139ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl // Check that the type is valid for an exception spec, and drop it 1140ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl // if not. 1141ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range)) 1142ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl Exceptions.push_back(ET); 1143ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl } 1144465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, FTI.TypeQuals, 1145465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl FTI.hasExceptionSpec, 1146465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl FTI.hasAnyExceptionSpec, 1147ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor Exceptions.size(), Exceptions.data(), 1148264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 1149965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor } else if (FTI.isVariadic) { 1150965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor // We allow a zero-parameter variadic function in C if the 1151965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor // function is marked with the "overloadable" 1152965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor // attribute. Scan for this attribute now. 1153965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor bool Overloadable = false; 1154965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor for (const AttributeList *Attrs = D.getAttributes(); 1155965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor Attrs; Attrs = Attrs->getNext()) { 1156965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor if (Attrs->getKind() == AttributeList::AT_overloadable) { 1157965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor Overloadable = true; 1158965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor break; 1159965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor } 1160965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor } 1161965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor 1162965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor if (!Overloadable) 1163965acbb321e94e36aa5365126eee46b97745fdbbDouglas Gregor Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_arg); 1164ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0, 1165264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola false, false, 0, 0, 1166264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 1167c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis } else { 1168c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis // Simple void foo(), where the incoming T is the result type. 116972564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor T = Context.getFunctionNoProtoType(T); 1170c6f7345e44e079f373d6bdecaa06c7e06574dc27Argyrios Kyrtzidis } 1171eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman } else if (FTI.ArgInfo[0].Param == 0) { 11725f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition. 11731eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration); 117454e14c4db764c0636160d26c5bbf491637c83a76John McCall D.setInvalidType(true); 11755f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } else { 11765f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Otherwise, we have a function with an argument list that is 11775f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // potentially variadic. 11785f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer llvm::SmallVector<QualType, 16> ArgTys; 11791eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 11805f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) { 1181b28317a8e5e0e2953d1e5406d753d6c3c7f1e7d2Chris Lattner ParmVarDecl *Param = 1182b28317a8e5e0e2953d1e5406d753d6c3c7f1e7d2Chris Lattner cast<ParmVarDecl>(FTI.ArgInfo[i].Param.getAs<Decl>()); 11838123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner QualType ArgTy = Param->getType(); 118478c75fb3d275079c5fab30eeb33077958f2b0265Chris Lattner assert(!ArgTy.isNull() && "Couldn't parse type?"); 11852dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor 11862dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor // Adjust the parameter type. 1187beb58cb83bd53b79b80fc6f9952efd985934cbfcDouglas Gregor assert((ArgTy == adjustParameterType(ArgTy)) && "Unadjusted type?"); 11882dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor 11895f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // Look for 'void'. void is allowed only as a single argument to a 11905f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // function with no other parameters (C99 6.7.5.3p10). We record 119172564e73277e29f6db3305d1f27ba408abb7ed88Douglas Gregor // int(void) as a FunctionProtoType with an empty argument list. 11922dc0e64e57b2a1786fa53a7dbd1d5c8e255eadb0Douglas Gregor if (ArgTy->isVoidType()) { 11935f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // If this is something like 'float(int, void)', reject it. 'void' 11945f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // is an incomplete type (C99 6.2.5p19) and function decls cannot 11955f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // have arguments of incomplete type. 11965f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer if (FTI.NumArgs != 1 || FTI.isVariadic) { 11975f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(DeclType.Loc, diag::err_void_only_param); 11982ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner ArgTy = Context.IntTy; 11998123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner Param->setType(ArgTy); 12002ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner } else if (FTI.ArgInfo[i].Ident) { 12012ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner // Reject, but continue to parse 'int(void abc)'. 12025f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer Diag(FTI.ArgInfo[i].IdentLoc, 12034565d4e83cec55356fe9c75929579eacced9da36Chris Lattner diag::err_param_with_void_type); 12042ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner ArgTy = Context.IntTy; 12058123a95c33b792d35c2e4992ba6e27882748fb0dChris Lattner Param->setType(ArgTy); 12062ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner } else { 12072ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner // Reject, but continue to parse 'float(const void)'. 12080953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (ArgTy.hasQualifiers()) 12092ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner Diag(DeclType.Loc, diag::err_void_param_qualified); 12101eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 12112ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner // Do not add 'void' to the ArgTys list. 12122ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner break; 12132ff5426cd83ae02378efacdfeb70d6785eb09a30Chris Lattner } 1214eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman } else if (!FTI.hasPrototype) { 1215eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (ArgTy->isPromotableIntegerType()) { 1216a95d75769edae299816ec7fd9bbcdf1ef617c5c9Eli Friedman ArgTy = Context.getPromotedIntegerType(ArgTy); 1217183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall } else if (const BuiltinType* BTy = ArgTy->getAs<BuiltinType>()) { 1218eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman if (BTy->getKind() == BuiltinType::Float) 1219eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman ArgTy = Context.DoubleTy; 1220eb4b7051a596560ef4a1846e3714707f44e9dc30Eli Friedman } 12215f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 12221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 122354e14c4db764c0636160d26c5bbf491637c83a76John McCall ArgTys.push_back(ArgTy); 12245f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1225465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 1226465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl llvm::SmallVector<QualType, 4> Exceptions; 1227465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl Exceptions.reserve(FTI.NumExceptions); 12281eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump for (unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) { 1229e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis // FIXME: Preserve type source info. 1230e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis QualType ET = GetTypeFromParser(FTI.Exceptions[ei].Ty); 1231ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl // Check that the type is valid for an exception spec, and drop it if 1232ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl // not. 1233ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range)) 1234ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl Exceptions.push_back(ET); 1235ef65f06e8e440aec541442cfd73a8a836e9bc842Sebastian Redl } 1236465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl 1237beaaccd8e2a8748f77b66e2b330fb9136937e14cJay Foad T = Context.getFunctionType(T, ArgTys.data(), ArgTys.size(), 1238465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl FTI.isVariadic, FTI.TypeQuals, 1239465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl FTI.hasExceptionSpec, 1240465226e23a3008bd68973513dda1f9e3cd27dbddSebastian Redl FTI.hasAnyExceptionSpec, 1241ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor Exceptions.size(), Exceptions.data(), 1242264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola FunctionType::ExtInfo()); 12435f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 124404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 124504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // For GCC compatibility, we allow attributes that apply only to 124604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // function types to be placed on a function's return type 124704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // instead (as long as that type doesn't happen to be function 124804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // or function-pointer itself). 124904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall ProcessDelayedFnAttrs(*this, T, FnAttrsFromPreviousChunk); 125004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 12515f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer break; 12525f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1253f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl case DeclaratorChunk::MemberPointer: 12544994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl // Verify that we're not building a pointer to pointer to function with 12554994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl // exception specification. 12564994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) { 12574994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec); 12584994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl D.setInvalidType(true); 12594994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl // Build the type anyway. 12604994d2d50ceacdc8908f750c55589c0a20942a0aSebastian Redl } 1261f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl // The scope spec must refer to a class, or be dependent. 1262f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl QualType ClsType; 1263edc287751a4b05e3b4d8ff2b38fa30c5b59a548bJeffrey Yasskin if (DeclType.Mem.Scope().isInvalid()) { 1264edc287751a4b05e3b4d8ff2b38fa30c5b59a548bJeffrey Yasskin // Avoid emitting extra errors if we already errored on the scope. 1265edc287751a4b05e3b4d8ff2b38fa30c5b59a548bJeffrey Yasskin D.setInvalidType(true); 1266edc287751a4b05e3b4d8ff2b38fa30c5b59a548bJeffrey Yasskin } else if (isDependentScopeSpecifier(DeclType.Mem.Scope()) 1267edc287751a4b05e3b4d8ff2b38fa30c5b59a548bJeffrey Yasskin || dyn_cast_or_null<CXXRecordDecl>( 126887c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor computeDeclContext(DeclType.Mem.Scope()))) { 12691eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump NestedNameSpecifier *NNS 1270949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor = (NestedNameSpecifier *)DeclType.Mem.Scope().getScopeRep(); 127187c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor NestedNameSpecifier *NNSPrefix = NNS->getPrefix(); 127287c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor switch (NNS->getKind()) { 127387c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor case NestedNameSpecifier::Identifier: 12744a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor ClsType = Context.getDependentNameType(ETK_None, NNSPrefix, 12754a2023f5014e82389d5980d307b89c545dbbac81Douglas Gregor NNS->getAsIdentifier()); 127687c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor break; 127787c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor 127887c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor case NestedNameSpecifier::Namespace: 127987c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor case NestedNameSpecifier::Global: 12809f61aa9e280adea9fbf3365f0e4f6ed568c9885aJeffrey Yasskin llvm_unreachable("Nested-name-specifier must name a type"); 128187c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor break; 128287c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor 128387c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor case NestedNameSpecifier::TypeSpec: 128487c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor case NestedNameSpecifier::TypeSpecWithTemplate: 128587c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor ClsType = QualType(NNS->getAsType(), 0); 128687c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor if (NNSPrefix) 128787c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor ClsType = Context.getQualifiedNameType(NNSPrefix, ClsType); 128887c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor break; 128987c12c4a4667279dacb3d4a93c64b49148a0ff79Douglas Gregor } 1290f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } else { 1291949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor Diag(DeclType.Mem.Scope().getBeginLoc(), 1292949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor diag::err_illegal_decl_mempointer_in_nonclass) 1293949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name") 1294949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor << DeclType.Mem.Scope().getRange(); 1295f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl D.setInvalidType(true); 1296f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 1297f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1298949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (!ClsType.isNull()) 1299949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor T = BuildMemberPointerType(T, ClsType, DeclType.Mem.TypeQuals, 1300949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor DeclType.Loc, D.getIdentifier()); 1301949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor if (T.isNull()) { 1302f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl T = Context.IntTy; 1303949bf69136e07fb7968d84bc21d9272ff343ffdbDouglas Gregor D.setInvalidType(true); 1304f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 1305f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl break; 1306f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl } 1307f30208ad5b334e93582e846a2a0c92f38a607b8aSebastian Redl 1308cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor if (T.isNull()) { 1309cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor D.setInvalidType(true); 1310cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor T = Context.IntTy; 1311cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor } 1312cd281c3ded486ced5aad29dd7c3fa22b7514c3d8Douglas Gregor 131304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DiagnoseDelayedFnAttrs(*this, FnAttrsFromPreviousChunk); 131404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 1315c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // See if there are any attributes on this declarator chunk. 1316c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner if (const AttributeList *AL = DeclType.getAttrs()) 1317328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis ProcessTypeAttributeList(*this, T, false, AL, FnAttrsFromPreviousChunk); 13185f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer } 1319971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis 1320971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis if (getLangOptions().CPlusPlus && T->isFunctionType()) { 1321183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>(); 1322778ed741de8ada0049b89608af0abdb5ae6e106eChris Lattner assert(FnTy && "Why oh why is there not a FunctionProtoType here?"); 1323971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis 1324971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis // C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type 1325971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis // for a nonstatic member function, the function type to which a pointer 1326971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis // to member refers, or the top-level function type of a function typedef 1327971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis // declaration. 1328971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis if (FnTy->getTypeQuals() != 0 && 1329971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef && 1330584049d49d956add7bce5669e9823491f7d8de78Douglas Gregor ((D.getContext() != Declarator::MemberContext && 1331584049d49d956add7bce5669e9823491f7d8de78Douglas Gregor (!D.getCXXScopeSpec().isSet() || 1332f59a56e180bf54528d7d1d5afa68fcc13300965aDouglas Gregor !computeDeclContext(D.getCXXScopeSpec(), /*FIXME:*/true) 1333f59a56e180bf54528d7d1d5afa68fcc13300965aDouglas Gregor ->isRecord())) || 1334971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)) { 1335971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis if (D.isFunctionDeclarator()) 1336971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_function_type); 1337971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis else 1338971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis Diag(D.getIdentifierLoc(), 1339971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis diag::err_invalid_qualified_typedef_function_type_use); 1340971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis 1341971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis // Strip the cv-quals from the type. 1342971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis T = Context.getFunctionType(FnTy->getResultType(), FnTy->arg_type_begin(), 1343ce056bcaa1c97b89a4b2de2112c62d060863be2bDouglas Gregor FnTy->getNumArgs(), FnTy->isVariadic(), 0, 1344264ba48dc98f3f843935a485d5b086f7e0fdc4f1Rafael Espindola false, false, 0, 0, FunctionType::ExtInfo()); 1345971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis } 1346971c4fae6092976338b755af1d47dac07c8f16e3Argyrios Kyrtzidis } 13471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 134804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Process any function attributes we might have delayed from the 134904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // declaration-specifiers. 135004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall ProcessDelayedFnAttrs(*this, T, FnAttrsFromDeclSpec); 135104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 135204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // If there were any type attributes applied to the decl itself, not 135304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // the type, apply them to the result type. But don't do this for 135404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // block-literal expressions, which are parsed wierdly. 135504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (D.getContext() != Declarator::BlockLiteralContext) 135604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (const AttributeList *Attrs = D.getAttributes()) 1357328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis ProcessTypeAttributeList(*this, T, false, Attrs, 1358328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis FnAttrsFromPreviousChunk); 135904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 136004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DiagnoseDelayedFnAttrs(*this, FnAttrsFromPreviousChunk); 13614adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 1362a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (TInfo) { 136354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (D.isInvalidType()) 1364a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall *TInfo = 0; 136554e14c4db764c0636160d26c5bbf491637c83a76John McCall else 136605baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor *TInfo = GetTypeSourceInfoForDeclarator(D, T, ReturnTypeInfo); 136754e14c4db764c0636160d26c5bbf491637c83a76John McCall } 13684adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 13695f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return T; 13705f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 13715f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 137251bd803fbdade51d674598ed45da3d54190a656cJohn McCallnamespace { 137351bd803fbdade51d674598ed45da3d54190a656cJohn McCall class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> { 137451bd803fbdade51d674598ed45da3d54190a656cJohn McCall const DeclSpec &DS; 1375f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis 137651bd803fbdade51d674598ed45da3d54190a656cJohn McCall public: 137751bd803fbdade51d674598ed45da3d54190a656cJohn McCall TypeSpecLocFiller(const DeclSpec &DS) : DS(DS) {} 1378f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis 137951bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 138051bd803fbdade51d674598ed45da3d54190a656cJohn McCall Visit(TL.getUnqualifiedLoc()); 138151bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 138251bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitTypedefTypeLoc(TypedefTypeLoc TL) { 138351bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setNameLoc(DS.getTypeSpecTypeLoc()); 138451bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 138551bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) { 138651bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setNameLoc(DS.getTypeSpecTypeLoc()); 138754e14c4db764c0636160d26c5bbf491637c83a76John McCall 138854e14c4db764c0636160d26c5bbf491637c83a76John McCall if (DS.getProtocolQualifiers()) { 138954e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() > 0); 139054e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers()); 139154e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setLAngleLoc(DS.getProtocolLAngleLoc()); 139254e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setRAngleLoc(DS.getSourceRange().getEnd()); 139354e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 0, e = DS.getNumProtocolQualifiers(); i != e; ++i) 139454e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setProtocolLoc(i, DS.getProtocolLocs()[i]); 139554e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 139654e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() == 0); 139754e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setLAngleLoc(SourceLocation()); 139854e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setRAngleLoc(SourceLocation()); 139954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 140051bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 140154e14c4db764c0636160d26c5bbf491637c83a76John McCall void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 140251bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers()); 140351bd803fbdade51d674598ed45da3d54190a656cJohn McCall 140454e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setStarLoc(SourceLocation()); 140554e14c4db764c0636160d26c5bbf491637c83a76John McCall 140654e14c4db764c0636160d26c5bbf491637c83a76John McCall if (DS.getProtocolQualifiers()) { 140754e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() > 0); 140854e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers()); 140954e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasProtocolsAsWritten(true); 141054e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setLAngleLoc(DS.getProtocolLAngleLoc()); 141154e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setRAngleLoc(DS.getSourceRange().getEnd()); 141254e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 0, e = DS.getNumProtocolQualifiers(); i != e; ++i) 141354e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setProtocolLoc(i, DS.getProtocolLocs()[i]); 141454e14c4db764c0636160d26c5bbf491637c83a76John McCall 141554e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 141654e14c4db764c0636160d26c5bbf491637c83a76John McCall assert(TL.getNumProtocols() == 0); 141754e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasProtocolsAsWritten(false); 141854e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setLAngleLoc(SourceLocation()); 141954e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setRAngleLoc(SourceLocation()); 142054e14c4db764c0636160d26c5bbf491637c83a76John McCall } 142154e14c4db764c0636160d26c5bbf491637c83a76John McCall 142254e14c4db764c0636160d26c5bbf491637c83a76John McCall // This might not have been written with an inner type. 142354e14c4db764c0636160d26c5bbf491637c83a76John McCall if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) { 142454e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasBaseTypeAsWritten(false); 142554e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.getBaseTypeLoc().initialize(SourceLocation()); 142654e14c4db764c0636160d26c5bbf491637c83a76John McCall } else { 142754e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasBaseTypeAsWritten(true); 142851bd803fbdade51d674598ed45da3d54190a656cJohn McCall Visit(TL.getBaseTypeLoc()); 142954e14c4db764c0636160d26c5bbf491637c83a76John McCall } 143051bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 1431833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) { 1432a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 0; 1433a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall Sema::GetTypeFromParser(DS.getTypeRep(), &TInfo); 1434833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 1435833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall // If we got no declarator info from previous Sema routines, 1436833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall // just fill with the typespec loc. 1437a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (!TInfo) { 1438833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall TL.initialize(DS.getTypeSpecTypeLoc()); 1439833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall return; 1440833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 1441833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall 1442833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall TemplateSpecializationTypeLoc OldTL = 1443a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall cast<TemplateSpecializationTypeLoc>(TInfo->getTypeLoc()); 1444833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall TL.copy(OldTL); 1445833ca991c1bfc967f0995974ca86f66ba1f666b5John McCall } 1446cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) { 1447cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr); 1448cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 1449cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TL.setParensRange(DS.getTypeofParensRange()); 1450cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall } 1451cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) { 1452cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType); 1453cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TL.setTypeofLoc(DS.getTypeSpecTypeLoc()); 1454cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TL.setParensRange(DS.getTypeofParensRange()); 1455cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall assert(DS.getTypeRep()); 1456cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TypeSourceInfo *TInfo = 0; 1457cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall Sema::GetTypeFromParser(DS.getTypeRep(), &TInfo); 1458cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall TL.setUnderlyingTInfo(TInfo); 1459cfb708c354e2f30ccc5cba9d644650f408a1ec3eJohn McCall } 1460ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) { 1461ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor // By default, use the source location of the type specifier. 1462ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor TL.setBuiltinLoc(DS.getTypeSpecTypeLoc()); 1463ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor if (TL.needsExtraLocalData()) { 1464ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor // Set info for the written builtin specifiers. 1465ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs(); 1466ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor // Try to have a meaningful source location. 1467ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor if (TL.getWrittenSignSpec() != TSS_unspecified) 1468ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor // Sign spec loc overrides the others (e.g., 'unsigned long'). 1469ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor TL.setBuiltinLoc(DS.getTypeSpecSignLoc()); 1470ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor else if (TL.getWrittenWidthSpec() != TSW_unspecified) 1471ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor // Width spec loc overrides type spec loc (e.g., 'short int'). 1472ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor TL.setBuiltinLoc(DS.getTypeSpecWidthLoc()); 1473ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor } 1474ddf889a2ad2888f1dea573987bbe952d9912c1a0Douglas Gregor } 147551bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitTypeLoc(TypeLoc TL) { 147651bd803fbdade51d674598ed45da3d54190a656cJohn McCall // FIXME: add other typespec types and change this to an assert. 147751bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.initialize(DS.getTypeSpecTypeLoc()); 147851bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 147951bd803fbdade51d674598ed45da3d54190a656cJohn McCall }; 1480eb66759e9a1d7c041354d132a14674b2d948059bArgyrios Kyrtzidis 148151bd803fbdade51d674598ed45da3d54190a656cJohn McCall class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> { 148251bd803fbdade51d674598ed45da3d54190a656cJohn McCall const DeclaratorChunk &Chunk; 1483f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis 148451bd803fbdade51d674598ed45da3d54190a656cJohn McCall public: 148551bd803fbdade51d674598ed45da3d54190a656cJohn McCall DeclaratorLocFiller(const DeclaratorChunk &Chunk) : Chunk(Chunk) {} 14864adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 148751bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) { 14889f61aa9e280adea9fbf3365f0e4f6ed568c9885aJeffrey Yasskin llvm_unreachable("qualified type locs not expected here!"); 148951bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 14904adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 149151bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) { 149251bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::BlockPointer); 149351bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setCaretLoc(Chunk.Loc); 14944adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 149551bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitPointerTypeLoc(PointerTypeLoc TL) { 149651bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Pointer); 149751bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setStarLoc(Chunk.Loc); 14984adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 149951bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) { 150051bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Pointer); 150151bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setStarLoc(Chunk.Loc); 150254e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasBaseTypeAsWritten(true); 150354e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setHasProtocolsAsWritten(false); 150454e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setLAngleLoc(SourceLocation()); 150554e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setRAngleLoc(SourceLocation()); 15064adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 150751bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) { 150851bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::MemberPointer); 150951bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setStarLoc(Chunk.Loc); 151051bd803fbdade51d674598ed45da3d54190a656cJohn McCall // FIXME: nested name specifier 15114adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 151251bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) { 151351bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Reference); 151454e14c4db764c0636160d26c5bbf491637c83a76John McCall // 'Amp' is misleading: this might have been originally 151554e14c4db764c0636160d26c5bbf491637c83a76John McCall /// spelled with AmpAmp. 151651bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setAmpLoc(Chunk.Loc); 151751bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 151851bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) { 151951bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Reference); 152051bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(!Chunk.Ref.LValueRef); 152151bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setAmpAmpLoc(Chunk.Loc); 152251bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 152351bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitArrayTypeLoc(ArrayTypeLoc TL) { 152451bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Array); 152551bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setLBracketLoc(Chunk.Loc); 152651bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setRBracketLoc(Chunk.EndLoc); 152751bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts)); 152851bd803fbdade51d674598ed45da3d54190a656cJohn McCall } 152951bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitFunctionTypeLoc(FunctionTypeLoc TL) { 153051bd803fbdade51d674598ed45da3d54190a656cJohn McCall assert(Chunk.Kind == DeclaratorChunk::Function); 153151bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setLParenLoc(Chunk.Loc); 153251bd803fbdade51d674598ed45da3d54190a656cJohn McCall TL.setRParenLoc(Chunk.EndLoc); 153351bd803fbdade51d674598ed45da3d54190a656cJohn McCall 153451bd803fbdade51d674598ed45da3d54190a656cJohn McCall const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun; 153554e14c4db764c0636160d26c5bbf491637c83a76John McCall for (unsigned i = 0, e = TL.getNumArgs(), tpi = 0; i != e; ++i) { 15364adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis ParmVarDecl *Param = FTI.ArgInfo[i].Param.getAs<ParmVarDecl>(); 153754e14c4db764c0636160d26c5bbf491637c83a76John McCall TL.setArg(tpi++, Param); 15384adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 153951bd803fbdade51d674598ed45da3d54190a656cJohn McCall // FIXME: exception specs 15404adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 15411eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 154251bd803fbdade51d674598ed45da3d54190a656cJohn McCall void VisitTypeLoc(TypeLoc TL) { 15439f61aa9e280adea9fbf3365f0e4f6ed568c9885aJeffrey Yasskin llvm_unreachable("unsupported TypeLoc kind in declarator!"); 15444adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 154551bd803fbdade51d674598ed45da3d54190a656cJohn McCall }; 154651bd803fbdade51d674598ed45da3d54190a656cJohn McCall} 15474adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 1548a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Create and instantiate a TypeSourceInfo with type source information. 154951bd803fbdade51d674598ed45da3d54190a656cJohn McCall/// 155051bd803fbdade51d674598ed45da3d54190a656cJohn McCall/// \param T QualType referring to the type as written in source code. 155105baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor/// 155205baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor/// \param ReturnTypeInfo For declarators whose return type does not show 155305baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor/// up in the normal place in the declaration specifiers (such as a C++ 155405baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor/// conversion function), this pointer will refer to a type source information 155505baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor/// for that return type. 1556a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallTypeSourceInfo * 155705baacbfd67017b2724f3e0503fd23609f5d32bcDouglas GregorSema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T, 155805baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor TypeSourceInfo *ReturnTypeInfo) { 1559a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = Context.CreateTypeSourceInfo(T); 1560a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc(); 156151bd803fbdade51d674598ed45da3d54190a656cJohn McCall 15628ce35b095e8fca45e04c1bda14ed0548ce7536adSebastian Redl for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) { 156351bd803fbdade51d674598ed45da3d54190a656cJohn McCall DeclaratorLocFiller(D.getTypeObject(i)).Visit(CurrTL); 156451bd803fbdade51d674598ed45da3d54190a656cJohn McCall CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc(); 15654adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis } 1566f352bddf015e537350416c296dd2963524f554f9Argyrios Kyrtzidis 156751bd803fbdade51d674598ed45da3d54190a656cJohn McCall TypeSpecLocFiller(D.getDeclSpec()).Visit(CurrTL); 156805baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor 156905baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor // We have source information for the return type that was not in the 157005baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor // declaration specifiers; copy that information into the current type 157105baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor // location so that it will be retained. This occurs, for example, with 157205baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor // a C++ conversion function, where the return type occurs within the 157305baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor // declarator-id rather than in the declaration specifiers. 157405baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor if (ReturnTypeInfo && D.getDeclSpec().getTypeSpecType() == TST_unspecified) { 157505baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor TypeLoc TL = ReturnTypeInfo->getTypeLoc(); 157605baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor assert(TL.getFullDataSize() == CurrTL.getFullDataSize()); 157705baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize()); 157805baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor } 157905baacbfd67017b2724f3e0503fd23609f5d32bcDouglas Gregor 1580a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall return TInfo; 15814adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis} 15824adab7fcb4cb1e23622f4849f7ef7981ff169616Argyrios Kyrtzidis 1583a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall/// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo. 1584a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCallQualType Sema::CreateLocInfoType(QualType T, TypeSourceInfo *TInfo) { 15851bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser 15861bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis // and Sema during declaration parsing. Try deallocating/caching them when 15871bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis // it's appropriate, instead of allocating them and keeping them around. 15881bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType), 8); 1589a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall new (LocT) LocInfoType(T, TInfo); 15901bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis assert(LocT->getTypeClass() != T->getTypeClass() && 15911bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis "LocInfoType's TypeClass conflicts with an existing Type class"); 15921bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis return QualType(LocT, 0); 15931bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis} 15941bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis 15951bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidisvoid LocInfoType::getAsStringInternal(std::string &Str, 15961bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis const PrintingPolicy &Policy) const { 159735d44e5673e772d1cc7eab66818de8d9796b89caArgyrios Kyrtzidis assert(false && "LocInfoType leaked into the type system; an opaque TypeTy*" 159835d44e5673e772d1cc7eab66818de8d9796b89caArgyrios Kyrtzidis " was used directly instead of getting the QualType through" 159935d44e5673e772d1cc7eab66818de8d9796b89caArgyrios Kyrtzidis " GetTypeFromParser"); 16001bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis} 16011bb8a45f7386a23871598d05141a07af03067925Argyrios Kyrtzidis 16029e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that 16039e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// may be similar (C++ 4.4), replaces T1 and T2 with the type that 16049e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// they point to and return true. If T1 and T2 aren't pointer types 16059e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// or pointer-to-member types, or if they are not similar at this 16069e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// level, returns false and leaves T1 and T2 unchanged. Top-level 16079e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// qualifiers on T1 and T2 are ignored. This function will typically 16089e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// be called in a loop that successively "unwraps" pointer and 16099e5e4aaf8b8835b552819d68d29b6d94115d8a0bSebastian Redl/// pointer-to-member types to compare them at each level. 1610ecb81f28cb279b7d8e84296445a4131fa80b69a9Chris Lattnerbool Sema::UnwrapSimilarPointerTypes(QualType& T1, QualType& T2) { 16116217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const PointerType *T1PtrType = T1->getAs<PointerType>(), 16126217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek *T2PtrType = T2->getAs<PointerType>(); 161357373266011f73418381b736015d8d2bb0381176Douglas Gregor if (T1PtrType && T2PtrType) { 161457373266011f73418381b736015d8d2bb0381176Douglas Gregor T1 = T1PtrType->getPointeeType(); 161557373266011f73418381b736015d8d2bb0381176Douglas Gregor T2 = T2PtrType->getPointeeType(); 161657373266011f73418381b736015d8d2bb0381176Douglas Gregor return true; 161757373266011f73418381b736015d8d2bb0381176Douglas Gregor } 161857373266011f73418381b736015d8d2bb0381176Douglas Gregor 16196217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const MemberPointerType *T1MPType = T1->getAs<MemberPointerType>(), 16206217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek *T2MPType = T2->getAs<MemberPointerType>(); 162121593acb933324b439bc68b68e7cc7d1c3e3484dSebastian Redl if (T1MPType && T2MPType && 162221593acb933324b439bc68b68e7cc7d1c3e3484dSebastian Redl Context.getCanonicalType(T1MPType->getClass()) == 162321593acb933324b439bc68b68e7cc7d1c3e3484dSebastian Redl Context.getCanonicalType(T2MPType->getClass())) { 16244433aafbc2591b82e4ea2fc39c723b21d2497f4dSebastian Redl T1 = T1MPType->getPointeeType(); 16254433aafbc2591b82e4ea2fc39c723b21d2497f4dSebastian Redl T2 = T2MPType->getPointeeType(); 16264433aafbc2591b82e4ea2fc39c723b21d2497f4dSebastian Redl return true; 16274433aafbc2591b82e4ea2fc39c723b21d2497f4dSebastian Redl } 162857373266011f73418381b736015d8d2bb0381176Douglas Gregor return false; 162957373266011f73418381b736015d8d2bb0381176Douglas Gregor} 163057373266011f73418381b736015d8d2bb0381176Douglas Gregor 1631cee63fbf0e64ac526582312bf8cf33263fc5c16eSebastian RedlSema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) { 16325f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // C99 6.7.6: Type names have no identifier. This is already validated by 16335f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer // the parser. 16345f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer assert(D.getIdentifier() == 0 && "Type name should have no identifier!"); 16351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1636a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall TypeSourceInfo *TInfo = 0; 1637402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor TagDecl *OwnedTag = 0; 1638a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall QualType T = GetTypeForDeclarator(D, S, &TInfo, &OwnedTag); 16395153ee66d6d4fb37b02f85df38e48dc8b46660dfChris Lattner if (D.isInvalidType()) 1640809070a886684cb5b92eb0e00a6581ab1fa6b17aDouglas Gregor return true; 16415912a3544e438a92832b8c52c13f48d4f54795dcSteve Naroff 1642402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor if (getLangOptions().CPlusPlus) { 1643402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // Check that there are no default arguments (C++ only). 16446d6eb57225b53fb627c565861d1d0e90645400d1Douglas Gregor CheckExtraCXXDefaultArguments(D); 16456d6eb57225b53fb627c565861d1d0e90645400d1Douglas Gregor 1646402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // C++0x [dcl.type]p3: 1647402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // A type-specifier-seq shall not define a class or enumeration 1648402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // unless it appears in the type-id of an alias-declaration 1649402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor // (7.1.3). 1650402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor if (OwnedTag && OwnedTag->isDefinition()) 1651402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor Diag(OwnedTag->getLocation(), diag::err_type_defined_in_type_specifier) 1652402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor << Context.getTypeDeclType(OwnedTag); 1653402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor } 1654402abb55fc2e0cdda5fb1ac90009b1f5f6774906Douglas Gregor 1655a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall if (TInfo) 1656a93c934af4fbf97cbe8e649d82e68ccacfe57c95John McCall T = CreateLocInfoType(T, TInfo); 1657e8661906d49ef6c9694a9cc845ca62a85dbc016dArgyrios Kyrtzidis 16585f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer return T.getAsOpaquePtr(); 16595f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer} 16605f016e2cb5d11daeb237544de1c5d59f20fe1a6eReid Spencer 1661c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner 1662c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner 1663c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner//===----------------------------------------------------------------------===// 1664c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner// Type Attribute Processing 1665c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner//===----------------------------------------------------------------------===// 1666232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner 1667232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the 1668c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner/// specified type. The attribute contains 1 argument, the id of the address 1669c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner/// space for the type. 16701eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void HandleAddressSpaceTypeAttribute(QualType &Type, 1671c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner const AttributeList &Attr, Sema &S){ 16720953e767ff7817f97b3ab20896b229891eeff45bJohn McCall 1673232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner // If this type is already address space qualified, reject it. 1674232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers 1675232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner // for two or more different address spaces." 1676232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner if (Type.getAddressSpace()) { 1677c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers); 1678c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner return; 1679232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner } 16801eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1681232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner // Check the attribute arguments. 1682545dd3401e7f31c256d69cb948a45d5ca781064cChris Lattner if (Attr.getNumArgs() != 1) { 1683f3a41af4d5c98a72a1d6720bbbfd658e57ef2541Chris Lattner S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1684c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner return; 1685232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner } 1686545dd3401e7f31c256d69cb948a45d5ca781064cChris Lattner Expr *ASArgExpr = static_cast<Expr *>(Attr.getArg(0)); 1687232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner llvm::APSInt addrSpace(32); 1688c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner if (!ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) { 1689dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner S.Diag(Attr.getLoc(), diag::err_attribute_address_space_not_int) 1690dcd5ef12488e4c7ea844327835896ca86b609a97Chris Lattner << ASArgExpr->getSourceRange(); 1691c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner return; 1692232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner } 1693232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner 1694efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall // Bounds checking. 1695efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall if (addrSpace.isSigned()) { 1696efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall if (addrSpace.isNegative()) { 1697efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative) 1698efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall << ASArgExpr->getSourceRange(); 1699efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall return; 1700efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall } 1701efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall addrSpace.setIsSigned(false); 1702efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall } 1703efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall llvm::APSInt max(addrSpace.getBitWidth()); 17040953e767ff7817f97b3ab20896b229891eeff45bJohn McCall max = Qualifiers::MaxAddressSpace; 1705efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall if (addrSpace > max) { 1706efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high) 17070953e767ff7817f97b3ab20896b229891eeff45bJohn McCall << Qualifiers::MaxAddressSpace << ASArgExpr->getSourceRange(); 1708efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall return; 1709efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall } 1710efadb7768e7c7418185f5a4010ecd8b21ca9731bJohn McCall 17111eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue()); 1712f11284ac87daa613bc7b30db9f54bd716d123222Fariborz Jahanian Type = S.Context.getAddrSpaceQualType(Type, ASIdx); 1713c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner} 1714c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner 1715d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian/// HandleObjCGCTypeAttribute - Process an objc's gc attribute on the 1716d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian/// specified type. The attribute contains 1 argument, weak or strong. 17171eb4433ac451dc16f4133a88af2d002ac26c58efMike Stumpstatic void HandleObjCGCTypeAttribute(QualType &Type, 17183b6b83b8311ecdfa43cbb37ccc38c107d3b8d88bChris Lattner const AttributeList &Attr, Sema &S) { 17190953e767ff7817f97b3ab20896b229891eeff45bJohn McCall if (Type.getObjCGCAttr() != Qualifiers::GCNone) { 17205934e75d98d99374f72722a69c5eefe026f35c74Fariborz Jahanian S.Diag(Attr.getLoc(), diag::err_attribute_multiple_objc_gc); 1721d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return; 1722d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian } 17231eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1724d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian // Check the attribute arguments. 17251eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (!Attr.getParameterName()) { 1726ba372b85524f712e5b97a176f6ce0197d365835dFariborz Jahanian S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string) 1727ba372b85524f712e5b97a176f6ce0197d365835dFariborz Jahanian << "objc_gc" << 1; 1728ba372b85524f712e5b97a176f6ce0197d365835dFariborz Jahanian return; 1729ba372b85524f712e5b97a176f6ce0197d365835dFariborz Jahanian } 17300953e767ff7817f97b3ab20896b229891eeff45bJohn McCall Qualifiers::GC GCAttr; 1731ba372b85524f712e5b97a176f6ce0197d365835dFariborz Jahanian if (Attr.getNumArgs() != 0) { 1732d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 1733d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return; 1734d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian } 17351eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump if (Attr.getParameterName()->isStr("weak")) 17360953e767ff7817f97b3ab20896b229891eeff45bJohn McCall GCAttr = Qualifiers::Weak; 1737d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian else if (Attr.getParameterName()->isStr("strong")) 17380953e767ff7817f97b3ab20896b229891eeff45bJohn McCall GCAttr = Qualifiers::Strong; 1739d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian else { 1740d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported) 1741d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian << "objc_gc" << Attr.getParameterName(); 1742d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian return; 1743d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian } 17441eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 17453b6b83b8311ecdfa43cbb37ccc38c107d3b8d88bChris Lattner Type = S.Context.getObjCGCQualType(Type, GCAttr); 1746d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian} 1747d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian 174804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall/// Process an individual function attribute. Returns true if the 174904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall/// attribute does not make sense to apply to this type. 175004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallbool ProcessFnAttr(Sema &S, QualType &Type, const AttributeList &Attr) { 175104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (Attr.getKind() == AttributeList::AT_noreturn) { 175204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Complain immediately if the arg count is wrong. 175304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (Attr.getNumArgs() != 0) { 175404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 175504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 175604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 17572455636163fdd18581d7fdae816433f886d88213Mike Stump 175804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Delay if this is not a function or pointer to block. 175904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!Type->isFunctionPointerType() 176004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall && !Type->isBlockPointerType() 176104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall && !Type->isFunctionType()) 176204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return true; 17632455636163fdd18581d7fdae816433f886d88213Mike Stump 176404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Otherwise we can process right away. 176504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall Type = S.Context.getNoReturnType(Type); 176604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 176704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 17682455636163fdd18581d7fdae816433f886d88213Mike Stump 1769425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola if (Attr.getKind() == AttributeList::AT_regparm) { 1770425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola // The warning is emitted elsewhere 1771425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola if (Attr.getNumArgs() != 1) { 1772425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola return false; 1773425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola } 1774425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola 1775425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola // Delay if this is not a function or pointer to block. 1776425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola if (!Type->isFunctionPointerType() 1777425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola && !Type->isBlockPointerType() 1778425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola && !Type->isFunctionType()) 1779425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola return true; 1780425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola 1781425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola // Otherwise we can process right away. 1782425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola Expr *NumParamsExpr = static_cast<Expr *>(Attr.getArg(0)); 1783425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola llvm::APSInt NumParams(32); 1784425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola 1785425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola // The warning is emitted elsewhere 1786425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola if (!NumParamsExpr->isIntegerConstantExpr(NumParams, S.Context)) 1787425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola return false; 1788425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola 1789425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola Type = S.Context.getRegParmType(Type, NumParams.getZExtValue()); 1790425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola return false; 1791425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola } 1792425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola 179304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Otherwise, a calling convention. 179404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (Attr.getNumArgs() != 0) { 179504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 0; 179604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 179704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 1798f82b4e85b1219295cad4b5851b035575bc293010John McCall 179904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall QualType T = Type; 180004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (const PointerType *PT = Type->getAs<PointerType>()) 180104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall T = PT->getPointeeType(); 180204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall const FunctionType *Fn = T->getAs<FunctionType>(); 180304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 180404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Delay if the type didn't work out to a function. 180504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (!Fn) return true; 180604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 180704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // TODO: diagnose uses of these conventions on the wrong target. 180804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CallingConv CC; 180904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall switch (Attr.getKind()) { 181004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_cdecl: CC = CC_C; break; 181104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_fastcall: CC = CC_X86FastCall; break; 181204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_stdcall: CC = CC_X86StdCall; break; 181304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall default: llvm_unreachable("unexpected attribute kind"); return false; 181404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 181504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 181604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall CallingConv CCOld = Fn->getCallConv(); 1817064f7db69def9299f5f4d9a32114afc10b6a6420Charles Davis if (S.Context.getCanonicalCallConv(CC) == 1818064f7db69def9299f5f4d9a32114afc10b6a6420Charles Davis S.Context.getCanonicalCallConv(CCOld)) return false; 181904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 182004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (CCOld != CC_Default) { 182104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Should we diagnose reapplications of the same convention? 182204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(Attr.getLoc(), diag::err_attributes_are_not_compatible) 182304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << FunctionType::getNameForCallConv(CC) 182404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << FunctionType::getNameForCallConv(CCOld); 182504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 182604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 182704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 182804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall // Diagnose the use of X86 fastcall on varargs or unprototyped functions. 182904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (CC == CC_X86FastCall) { 183004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (isa<FunctionNoProtoType>(Fn)) { 183104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(Attr.getLoc(), diag::err_cconv_knr) 183204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << FunctionType::getNameForCallConv(CC); 183304a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 183404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 183504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 183604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall const FunctionProtoType *FnP = cast<FunctionProtoType>(Fn); 183704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall if (FnP->isVariadic()) { 183804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall S.Diag(Attr.getLoc(), diag::err_cconv_varargs) 183904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall << FunctionType::getNameForCallConv(CC); 184004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 184104a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 184204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall } 1843f82b4e85b1219295cad4b5851b035575bc293010John McCall 184404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall Type = S.Context.getCallConvType(Type, CC); 184504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall return false; 1846f82b4e85b1219295cad4b5851b035575bc293010John McCall} 1847f82b4e85b1219295cad4b5851b035575bc293010John McCall 18486e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// HandleVectorSizeAttribute - this attribute is only applicable to integral 18496e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// and float scalars, although arrays, pointers, and function return values are 18506e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// allowed in conjunction with this construct. Aggregates with this attribute 18516e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// are invalid, even if they are of the same size as a corresponding scalar. 18526e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// The raw attribute should contain precisely 1 argument, the vector size for 18536e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// the variable, measured in bytes. If curType and rawAttr are well formed, 18546e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson/// this routine will return a new vector type. 18556e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompsonstatic void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr, Sema &S) { 18566e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // Check the attribute arugments. 18576e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson if (Attr.getNumArgs() != 1) { 18586e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1; 18596e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson return; 18606e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson } 18616e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson Expr *sizeExpr = static_cast<Expr *>(Attr.getArg(0)); 18626e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson llvm::APSInt vecSize(32); 18636e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson if (!sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) { 18646e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int) 18656e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson << "vector_size" << sizeExpr->getSourceRange(); 18666e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson return; 18676e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson } 18686e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // the base type must be integer or float, and can't already be a vector. 18696e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson if (CurType->isVectorType() || 18706e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson (!CurType->isIntegerType() && !CurType->isRealFloatingType())) { 18716e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType; 18726e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson return; 18736e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson } 18746e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType)); 18756e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // vecSize is specified in bytes - convert to bits. 18766e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8); 18776e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson 18786e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // the vector size needs to be an integral multiple of the type size. 18796e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson if (vectorSize % typeSize) { 18806e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size) 18816e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson << sizeExpr->getSourceRange(); 18826e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson return; 18836e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson } 18846e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson if (vectorSize == 0) { 18856e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson S.Diag(Attr.getLoc(), diag::err_attribute_zero_size) 18866e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson << sizeExpr->getSourceRange(); 18876e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson return; 18886e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson } 18896e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson 18906e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // Success! Instantiate the vector type, the number of elements is > 0, and 18916e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson // not required to be a power of 2, unlike GCC. 189282287d19ded35248c4ce6a425ce74116a13ce44eJohn Thompson CurType = S.Context.getVectorType(CurType, vectorSize/typeSize, false, false); 18936e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson} 18946e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson 189504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCallvoid ProcessTypeAttributeList(Sema &S, QualType &Result, 1896328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis bool IsDeclSpec, const AttributeList *AL, 189704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall DelayedAttributeSet &FnAttrs) { 1898c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // Scan through and apply attributes to this type where it makes sense. Some 1899c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // attributes (such as __address_space__, __vector_size__, etc) apply to the 1900c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // type, but others can be present in the type specifiers even though they 1901c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // apply to the decl. Here we apply type attributes and ignore the rest. 1902c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner for (; AL; AL = AL->getNext()) { 1903c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // If this is an attribute we can handle, do so now, otherwise, add it to 1904c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner // the LeftOverAttrs list for rechaining. 1905c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner switch (AL->getKind()) { 1906c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner default: break; 190704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 1908c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner case AttributeList::AT_address_space: 190904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall HandleAddressSpaceTypeAttribute(Result, *AL, S); 1910c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner break; 1911d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian case AttributeList::AT_objc_gc: 191204a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall HandleObjCGCTypeAttribute(Result, *AL, S); 1913d33d9c0cc0cfdcd0b10f35a6acdfb25da4a64f19Fariborz Jahanian break; 191404a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_vector_size: 191504a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall HandleVectorSizeAttr(Result, *AL, S); 1916f82b4e85b1219295cad4b5851b035575bc293010John McCall break; 191704a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall 191804a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_noreturn: 191904a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_cdecl: 192004a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall case AttributeList::AT_fastcall: 1921f82b4e85b1219295cad4b5851b035575bc293010John McCall case AttributeList::AT_stdcall: 1922425ef72306d4ff6b3698b744353e5f0e56b4b884Rafael Espindola case AttributeList::AT_regparm: 1923328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis // Don't process these on the DeclSpec. 1924328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis if (IsDeclSpec || 1925328ce34c7d0c4e8696d352853b48b385dec1fef4Charles Davis ProcessFnAttr(S, Result, *AL)) 192604a67a6aa3dfdc92d57f7f8d93ba397348c868a4John McCall FnAttrs.push_back(DelayedAttribute(AL, Result)); 19276e132aab867c189b1c3ee7463ef9d2b1f03a294dJohn Thompson break; 1928c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner } 1929c9b346d7b3b24f8bf940735cc812893dfcef1d4bChris Lattner } 1930232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner} 1931232e882226aa116807ee08a700dfc2350fbfabb1Chris Lattner 19321eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// @brief Ensure that the type T is a complete type. 19334ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// 19344ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// This routine checks whether the type @p T is complete in any 19354ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// context where a complete type is required. If @p T is a complete 193686447ec25fa34aa3c2f48ebc49ec09bc1f03f002Douglas Gregor/// type, returns false. If @p T is a class template specialization, 193786447ec25fa34aa3c2f48ebc49ec09bc1f03f002Douglas Gregor/// this routine then attempts to perform class template 193886447ec25fa34aa3c2f48ebc49ec09bc1f03f002Douglas Gregor/// instantiation. If instantiation fails, or if @p T is incomplete 193986447ec25fa34aa3c2f48ebc49ec09bc1f03f002Douglas Gregor/// and cannot be completed, issues the diagnostic @p diag (giving it 194086447ec25fa34aa3c2f48ebc49ec09bc1f03f002Douglas Gregor/// the type @p T) and returns true. 19414ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// 19424ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// @param Loc The location in the source that the incomplete type 19434ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// diagnostic should refer to. 19444ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// 19454ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// @param T The type that this routine is examining for completeness. 19464ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// 19471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump/// @param PD The partial diagnostic that will be printed out if T is not a 1948b790661a15d93941d2c33a0ea328254277b3d7e3Anders Carlsson/// complete type. 19494ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// 19504ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// @returns @c true if @p T is incomplete and a diagnostic was emitted, 19514ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor/// @c false otherwise. 195291a0cc913ecc5619b76d2e40742fd09725be8c56Anders Carlssonbool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 19538c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson const PartialDiagnostic &PD, 19548c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson std::pair<SourceLocation, 19558c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson PartialDiagnostic> Note) { 195691a0cc913ecc5619b76d2e40742fd09725be8c56Anders Carlsson unsigned diag = PD.getDiagID(); 19571eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 1958573d9c325279b6e156c7fde163ffe3629c62d596Douglas Gregor // FIXME: Add this assertion to make sure we always get instantiation points. 1959573d9c325279b6e156c7fde163ffe3629c62d596Douglas Gregor // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType"); 1960690dc7f4f2c0fe87409839b7560c19dee7832195Douglas Gregor // FIXME: Add this assertion to help us flush out problems with 1961690dc7f4f2c0fe87409839b7560c19dee7832195Douglas Gregor // checking for dependent types and type-dependent expressions. 1962690dc7f4f2c0fe87409839b7560c19dee7832195Douglas Gregor // 19631eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump // assert(!T->isDependentType() && 1964690dc7f4f2c0fe87409839b7560c19dee7832195Douglas Gregor // "Can't ask whether a dependent type is complete"); 1965690dc7f4f2c0fe87409839b7560c19dee7832195Douglas Gregor 19664ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor // If we have a complete type, we're done. 19674ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor if (!T->isIncompleteType()) 19684ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor return false; 19694ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor 1970d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor // If we have a class template specialization or a class member of a 1971923d56d436f750bc1f29db50e641078725558a1bSebastian Redl // class template specialization, or an array with known size of such, 1972923d56d436f750bc1f29db50e641078725558a1bSebastian Redl // try to instantiate it. 1973923d56d436f750bc1f29db50e641078725558a1bSebastian Redl QualType MaybeTemplate = T; 197489c49f09b0292dc7c03885f6c765d667a9837597Douglas Gregor if (const ConstantArrayType *Array = Context.getAsConstantArrayType(T)) 1975923d56d436f750bc1f29db50e641078725558a1bSebastian Redl MaybeTemplate = Array->getElementType(); 1976923d56d436f750bc1f29db50e641078725558a1bSebastian Redl if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) { 19772943aed177b33ae3f14273b11a7b398e5276ec62Douglas Gregor if (ClassTemplateSpecializationDecl *ClassTemplateSpec 1978d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) { 1979972e6ce33c7e307f4b0da12bd6079bbd6ef76948Douglas Gregor if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) 1980972e6ce33c7e307f4b0da12bd6079bbd6ef76948Douglas Gregor return InstantiateClassTemplateSpecialization(Loc, ClassTemplateSpec, 1981d0e3daf2b980b505e535d35b432c938c6d0208efDouglas Gregor TSK_ImplicitInstantiation, 19825842ba9fd482bb2fe5198b32c2ae549cd5474e6dDouglas Gregor /*Complain=*/diag != 0); 19831eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump } else if (CXXRecordDecl *Rec 1984d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor = dyn_cast<CXXRecordDecl>(Record->getDecl())) { 1985d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) { 1986b3ae4fcd4314a9c1c46d41b200883599c32025b4Douglas Gregor MemberSpecializationInfo *MSInfo = Rec->getMemberSpecializationInfo(); 1987b3ae4fcd4314a9c1c46d41b200883599c32025b4Douglas Gregor assert(MSInfo && "Missing member specialization information?"); 1988357bbd022c1d340c8e255aea7a684ddb34bc76e5Douglas Gregor // This record was instantiated from a class within a template. 1989b3ae4fcd4314a9c1c46d41b200883599c32025b4Douglas Gregor if (MSInfo->getTemplateSpecializationKind() 1990972e6ce33c7e307f4b0da12bd6079bbd6ef76948Douglas Gregor != TSK_ExplicitSpecialization) 1991f6b1185f0a8a209c06dfc1efdb6a59cc851e970cDouglas Gregor return InstantiateClass(Loc, Rec, Pattern, 1992f6b1185f0a8a209c06dfc1efdb6a59cc851e970cDouglas Gregor getTemplateInstantiationArgs(Rec), 1993f6b1185f0a8a209c06dfc1efdb6a59cc851e970cDouglas Gregor TSK_ImplicitInstantiation, 1994f6b1185f0a8a209c06dfc1efdb6a59cc851e970cDouglas Gregor /*Complain=*/diag != 0); 1995d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor } 1996d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor } 1997d475b8d9e6f5ff0e6ab8d15667ce8a64c7cb9a4dDouglas Gregor } 19982943aed177b33ae3f14273b11a7b398e5276ec62Douglas Gregor 19995842ba9fd482bb2fe5198b32c2ae549cd5474e6dDouglas Gregor if (diag == 0) 20005842ba9fd482bb2fe5198b32c2ae549cd5474e6dDouglas Gregor return true; 20011eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 200201620704304f819b82ecef769ec114e541a364d7Rafael Espindola const TagType *Tag = 0; 200301620704304f819b82ecef769ec114e541a364d7Rafael Espindola if (const RecordType *Record = T->getAs<RecordType>()) 200401620704304f819b82ecef769ec114e541a364d7Rafael Espindola Tag = Record; 200501620704304f819b82ecef769ec114e541a364d7Rafael Espindola else if (const EnumType *Enum = T->getAs<EnumType>()) 200601620704304f819b82ecef769ec114e541a364d7Rafael Espindola Tag = Enum; 200701620704304f819b82ecef769ec114e541a364d7Rafael Espindola 200801620704304f819b82ecef769ec114e541a364d7Rafael Espindola // Avoid diagnosing invalid decls as incomplete. 200901620704304f819b82ecef769ec114e541a364d7Rafael Espindola if (Tag && Tag->getDecl()->isInvalidDecl()) 201001620704304f819b82ecef769ec114e541a364d7Rafael Espindola return true; 201101620704304f819b82ecef769ec114e541a364d7Rafael Espindola 20124ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor // We have an incomplete type. Produce a diagnostic. 201391a0cc913ecc5619b76d2e40742fd09725be8c56Anders Carlsson Diag(Loc, PD) << T; 20143c0eb160ca1361a82b9f15b3b40a2425adc14d0fEli Friedman 20158c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson // If we have a note, produce it. 20168c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson if (!Note.first.isInvalid()) 20178c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson Diag(Note.first, Note.second); 20188c8d91917c307dc3ba4f60661377c745f2a6bef2Anders Carlsson 20194ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor // If the type was a forward declaration of a class/struct/union 202001620704304f819b82ecef769ec114e541a364d7Rafael Espindola // type, produce a note. 20214ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor if (Tag && !Tag->getDecl()->isInvalidDecl()) 20221eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump Diag(Tag->getDecl()->getLocation(), 20234ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor Tag->isBeingDefined() ? diag::note_type_being_defined 20244ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor : diag::note_forward_declaration) 20254ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor << QualType(Tag, 0); 20264ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor 20274ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor return true; 20284ec339f43c0cae2678334850c90926bea10999c7Douglas Gregor} 2029e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor 2030fe6b2d481d91140923f4541f273b253291884214Douglas Gregorbool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 2031fe6b2d481d91140923f4541f273b253291884214Douglas Gregor const PartialDiagnostic &PD) { 2032fe6b2d481d91140923f4541f273b253291884214Douglas Gregor return RequireCompleteType(Loc, T, PD, 2033fe6b2d481d91140923f4541f273b253291884214Douglas Gregor std::make_pair(SourceLocation(), PDiag(0))); 2034fe6b2d481d91140923f4541f273b253291884214Douglas Gregor} 2035fe6b2d481d91140923f4541f273b253291884214Douglas Gregor 2036fe6b2d481d91140923f4541f273b253291884214Douglas Gregorbool Sema::RequireCompleteType(SourceLocation Loc, QualType T, 2037fe6b2d481d91140923f4541f273b253291884214Douglas Gregor unsigned DiagID) { 2038fe6b2d481d91140923f4541f273b253291884214Douglas Gregor return RequireCompleteType(Loc, T, PDiag(DiagID), 2039fe6b2d481d91140923f4541f273b253291884214Douglas Gregor std::make_pair(SourceLocation(), PDiag(0))); 2040fe6b2d481d91140923f4541f273b253291884214Douglas Gregor} 2041fe6b2d481d91140923f4541f273b253291884214Douglas Gregor 2042e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor/// \brief Retrieve a version of the type 'T' that is qualified by the 2043e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor/// nested-name-specifier contained in SS. 2044e6258936178b4c52b43b3b9dbec13552961cd645Douglas GregorQualType Sema::getQualifiedNameType(const CXXScopeSpec &SS, QualType T) { 2045e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor if (!SS.isSet() || SS.isInvalid() || T.isNull()) 2046e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor return T; 20471eb4433ac451dc16f4133a88af2d002ac26c58efMike Stump 2048ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor NestedNameSpecifier *NNS 20493507369940bfb269551bfa1fec812481f60e3552Douglas Gregor = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 2050ab452ba8323d1985e08bade2bced588cddf2cc28Douglas Gregor return Context.getQualifiedNameType(NNS, T); 2051e6258936178b4c52b43b3b9dbec13552961cd645Douglas Gregor} 2052af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson 2053af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders CarlssonQualType Sema::BuildTypeofExprType(Expr *E) { 20544b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (E->getType() == Context.OverloadTy) { 20554b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // C++ [temp.arg.explicit]p3 allows us to resolve a template-id to a 20564b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // function template specialization wherever deduction cannot occur. 20574b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (FunctionDecl *Specialization 20584b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor = ResolveSingleFunctionTemplateSpecialization(E)) { 2059161755a09898c95d21bfff33707da9ca41cd53c5John McCall // The access doesn't really matter in this case. 2060161755a09898c95d21bfff33707da9ca41cd53c5John McCall DeclAccessPair Found = DeclAccessPair::make(Specialization, 2061161755a09898c95d21bfff33707da9ca41cd53c5John McCall Specialization->getAccess()); 2062161755a09898c95d21bfff33707da9ca41cd53c5John McCall E = FixOverloadedFunctionReference(E, Found, Specialization); 20634b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!E) 20644b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return QualType(); 20654b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } else { 20664b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Diag(E->getLocStart(), 20674b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor diag::err_cannot_determine_declared_type_of_overloaded_function) 20684b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor << false << E->getSourceRange(); 20694b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return QualType(); 20704b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 20714b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 20724b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 2073af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson return Context.getTypeOfExprType(E); 2074af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson} 2075af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson 2076af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders CarlssonQualType Sema::BuildDecltypeType(Expr *E) { 2077af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson if (E->getType() == Context.OverloadTy) { 20784b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // C++ [temp.arg.explicit]p3 allows us to resolve a template-id to a 20794b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor // function template specialization wherever deduction cannot occur. 20804b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (FunctionDecl *Specialization 20814b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor = ResolveSingleFunctionTemplateSpecialization(E)) { 2082161755a09898c95d21bfff33707da9ca41cd53c5John McCall // The access doesn't really matter in this case. 2083161755a09898c95d21bfff33707da9ca41cd53c5John McCall DeclAccessPair Found = DeclAccessPair::make(Specialization, 2084161755a09898c95d21bfff33707da9ca41cd53c5John McCall Specialization->getAccess()); 2085161755a09898c95d21bfff33707da9ca41cd53c5John McCall E = FixOverloadedFunctionReference(E, Found, Specialization); 20864b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor if (!E) 20874b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return QualType(); 20884b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } else { 20894b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor Diag(E->getLocStart(), 20904b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor diag::err_cannot_determine_declared_type_of_overloaded_function) 20914b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor << true << E->getSourceRange(); 20924b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor return QualType(); 20934b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor } 2094af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson } 20954b52e25f3b05ab0f9d2492276a52323a50a84fb7Douglas Gregor 2096af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson return Context.getDecltypeType(E); 2097af017e682918f7a1a95ff08d9ab7ae3426436ca3Anders Carlsson} 2098