1 //===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements type-related semantic analysis.
12 //===----------------------------------------------------------------------===//
14 #include "clang/Sema/SemaInternal.h"
15 #include "clang/Sema/Template.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/DeclObjC.h"
19 #include "clang/AST/DeclTemplate.h"
20 #include "clang/AST/TypeLoc.h"
21 #include "clang/AST/TypeLocVisitor.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/Basic/PartialDiagnostic.h"
24 #include "clang/Basic/TargetInfo.h"
25 #include "clang/Sema/DeclSpec.h"
26 #include "llvm/ADT/SmallPtrSet.h"
27 #include "llvm/Support/ErrorHandling.h"
28 using namespace clang;
30 /// \brief Perform adjustment on the parameter type of a function.
32 /// This routine adjusts the given parameter type @p T to the actual
33 /// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
34 /// C++ [dcl.fct]p3). The adjusted parameter type is returned.
35 QualType Sema::adjustParameterType(QualType T) {
37 // A declaration of a parameter as "array of type" shall be
38 // adjusted to "qualified pointer to type", where the type
39 // qualifiers (if any) are those specified within the [ and ] of
40 // the array type derivation.
42 return Context.getArrayDecayedType(T);
45 // A declaration of a parameter as "function returning type"
46 // shall be adjusted to "pointer to function returning type", as
48 if (T->isFunctionType())
49 return Context.getPointerType(T);
56 /// isOmittedBlockReturnType - Return true if this declarator is missing a
57 /// return type because this is a omitted return type on a block literal.
58 static bool isOmittedBlockReturnType(const Declarator &D) {
59 if (D.getContext() != Declarator::BlockLiteralContext ||
60 D.getDeclSpec().hasTypeSpecifier())
63 if (D.getNumTypeObjects() == 0)
64 return true; // ^{ ... }
66 if (D.getNumTypeObjects() == 1 &&
67 D.getTypeObject(0).Kind == DeclaratorChunk::Function)
68 return true; // ^(int X, float Y) { ... }
73 // objc_gc applies to Objective-C pointers or, otherwise, to the
74 // smallest available pointer type (i.e. 'void*' in 'void**').
75 #define OBJC_POINTER_TYPE_ATTRS_CASELIST \
76 case AttributeList::AT_objc_gc
78 // Function type attributes.
79 #define FUNCTION_TYPE_ATTRS_CASELIST \
80 case AttributeList::AT_noreturn: \
81 case AttributeList::AT_cdecl: \
82 case AttributeList::AT_fastcall: \
83 case AttributeList::AT_stdcall: \
84 case AttributeList::AT_thiscall: \
85 case AttributeList::AT_pascal: \
86 case AttributeList::AT_regparm
89 /// An object which stores processing state for the entire
90 /// GetTypeForDeclarator process.
91 class TypeProcessingState {
94 /// The declarator being processed.
95 Declarator &declarator;
97 /// The index of the declarator chunk we're currently processing.
98 /// May be the total number of valid chunks, indicating the
102 /// Whether there are non-trivial modifications to the decl spec.
105 /// The original set of attributes on the DeclSpec.
106 llvm::SmallVector<AttributeList*, 2> savedAttrs;
108 /// A list of attributes to diagnose the uselessness of when the
109 /// processing is complete.
110 llvm::SmallVector<AttributeList*, 2> ignoredTypeAttrs;
113 TypeProcessingState(Sema &sema, Declarator &declarator)
114 : sema(sema), declarator(declarator),
115 chunkIndex(declarator.getNumTypeObjects()),
118 Sema &getSema() const {
122 Declarator &getDeclarator() const {
126 unsigned getCurrentChunkIndex() const {
130 void setCurrentChunkIndex(unsigned idx) {
131 assert(idx <= declarator.getNumTypeObjects());
135 AttributeList *&getCurrentAttrListRef() const {
136 assert(chunkIndex <= declarator.getNumTypeObjects());
137 if (chunkIndex == declarator.getNumTypeObjects())
138 return getMutableDeclSpec().getAttributes().getListRef();
139 return declarator.getTypeObject(chunkIndex).getAttrListRef();
142 /// Save the current set of attributes on the DeclSpec.
143 void saveDeclSpecAttrs() {
144 // Don't try to save them multiple times.
145 if (!savedAttrs.empty()) return;
147 DeclSpec &spec = getMutableDeclSpec();
148 for (AttributeList *attr = spec.getAttributes().getList(); attr;
149 attr = attr->getNext())
150 savedAttrs.push_back(attr);
151 trivial &= savedAttrs.empty();
154 /// Record that we had nowhere to put the given type attribute.
155 /// We will diagnose such attributes later.
156 void addIgnoredTypeAttr(AttributeList &attr) {
157 ignoredTypeAttrs.push_back(&attr);
160 /// Diagnose all the ignored type attributes, given that the
161 /// declarator worked out to the given type.
162 void diagnoseIgnoredTypeAttrs(QualType type) const {
163 for (llvm::SmallVectorImpl<AttributeList*>::const_iterator
164 i = ignoredTypeAttrs.begin(), e = ignoredTypeAttrs.end();
166 AttributeList &attr = **i;
167 getSema().Diag(attr.getLoc(), diag::warn_function_attribute_wrong_type)
168 << attr.getName() << type;
172 ~TypeProcessingState() {
175 restoreDeclSpecAttrs();
179 DeclSpec &getMutableDeclSpec() const {
180 return const_cast<DeclSpec&>(declarator.getDeclSpec());
183 void restoreDeclSpecAttrs() {
184 assert(!savedAttrs.empty());
185 getMutableDeclSpec().getAttributes().set(savedAttrs[0]);
186 for (unsigned i = 0, e = savedAttrs.size() - 1; i != e; ++i)
187 savedAttrs[i]->setNext(savedAttrs[i+1]);
188 savedAttrs.back()->setNext(0);
192 /// Basically std::pair except that we really want to avoid an
193 /// implicit operator= for safety concerns. It's also a minor
194 /// link-time optimization for this to be a private type.
197 AttributeList &first;
199 /// The head of the list the attribute is currently in.
200 AttributeList *&second;
202 AttrAndList(AttributeList &attr, AttributeList *&head)
203 : first(attr), second(head) {}
208 template <> struct isPodLike<AttrAndList> {
209 static const bool value = true;
213 static void spliceAttrIntoList(AttributeList &attr, AttributeList *&head) {
218 static void spliceAttrOutOfList(AttributeList &attr, AttributeList *&head) {
220 head = attr.getNext();
224 AttributeList *cur = head;
226 assert(cur && cur->getNext() && "ran out of attrs?");
227 if (cur->getNext() == &attr) {
228 cur->setNext(attr.getNext());
231 cur = cur->getNext();
235 static void moveAttrFromListToList(AttributeList &attr,
236 AttributeList *&fromList,
237 AttributeList *&toList) {
238 spliceAttrOutOfList(attr, fromList);
239 spliceAttrIntoList(attr, toList);
242 static void processTypeAttrs(TypeProcessingState &state,
243 QualType &type, bool isDeclSpec,
244 AttributeList *attrs);
246 static bool handleFunctionTypeAttr(TypeProcessingState &state,
250 static bool handleObjCGCTypeAttr(TypeProcessingState &state,
251 AttributeList &attr, QualType &type);
253 static bool handleObjCPointerTypeAttr(TypeProcessingState &state,
254 AttributeList &attr, QualType &type) {
255 // Right now, we have exactly one of these attributes: objc_gc.
256 assert(attr.getKind() == AttributeList::AT_objc_gc);
257 return handleObjCGCTypeAttr(state, attr, type);
260 /// Given that an objc_gc attribute was written somewhere on a
261 /// declaration *other* than on the declarator itself (for which, use
262 /// distributeObjCPointerTypeAttrFromDeclarator), and given that it
263 /// didn't apply in whatever position it was written in, try to move
264 /// it to a more appropriate position.
265 static void distributeObjCPointerTypeAttr(TypeProcessingState &state,
268 Declarator &declarator = state.getDeclarator();
269 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
270 DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
271 switch (chunk.Kind) {
272 case DeclaratorChunk::Pointer:
273 case DeclaratorChunk::BlockPointer:
274 moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
275 chunk.getAttrListRef());
278 case DeclaratorChunk::Paren:
279 case DeclaratorChunk::Array:
282 // Don't walk through these.
283 case DeclaratorChunk::Reference:
284 case DeclaratorChunk::Function:
285 case DeclaratorChunk::MemberPointer:
291 state.getSema().Diag(attr.getLoc(), diag::warn_function_attribute_wrong_type)
292 << attr.getName() << type;
295 /// Distribute an objc_gc type attribute that was written on the
298 distributeObjCPointerTypeAttrFromDeclarator(TypeProcessingState &state,
300 QualType &declSpecType) {
301 Declarator &declarator = state.getDeclarator();
303 // objc_gc goes on the innermost pointer to something that's not a
305 unsigned innermost = -1U;
306 bool considerDeclSpec = true;
307 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
308 DeclaratorChunk &chunk = declarator.getTypeObject(i);
309 switch (chunk.Kind) {
310 case DeclaratorChunk::Pointer:
311 case DeclaratorChunk::BlockPointer:
315 case DeclaratorChunk::Reference:
316 case DeclaratorChunk::MemberPointer:
317 case DeclaratorChunk::Paren:
318 case DeclaratorChunk::Array:
321 case DeclaratorChunk::Function:
322 considerDeclSpec = false;
328 // That might actually be the decl spec if we weren't blocked by
329 // anything in the declarator.
330 if (considerDeclSpec) {
331 if (handleObjCPointerTypeAttr(state, attr, declSpecType))
335 // Otherwise, if we found an appropriate chunk, splice the attribute
337 if (innermost != -1U) {
338 moveAttrFromListToList(attr, declarator.getAttrListRef(),
339 declarator.getTypeObject(innermost).getAttrListRef());
343 // Otherwise, diagnose when we're done building the type.
344 spliceAttrOutOfList(attr, declarator.getAttrListRef());
345 state.addIgnoredTypeAttr(attr);
348 /// A function type attribute was written somewhere in a declaration
349 /// *other* than on the declarator itself or in the decl spec. Given
350 /// that it didn't apply in whatever position it was written in, try
351 /// to move it to a more appropriate position.
352 static void distributeFunctionTypeAttr(TypeProcessingState &state,
355 Declarator &declarator = state.getDeclarator();
357 // Try to push the attribute from the return type of a function to
358 // the function itself.
359 for (unsigned i = state.getCurrentChunkIndex(); i != 0; --i) {
360 DeclaratorChunk &chunk = declarator.getTypeObject(i-1);
361 switch (chunk.Kind) {
362 case DeclaratorChunk::Function:
363 moveAttrFromListToList(attr, state.getCurrentAttrListRef(),
364 chunk.getAttrListRef());
367 case DeclaratorChunk::Paren:
368 case DeclaratorChunk::Pointer:
369 case DeclaratorChunk::BlockPointer:
370 case DeclaratorChunk::Array:
371 case DeclaratorChunk::Reference:
372 case DeclaratorChunk::MemberPointer:
377 state.getSema().Diag(attr.getLoc(), diag::warn_function_attribute_wrong_type)
378 << attr.getName() << type;
381 /// Try to distribute a function type attribute to the innermost
382 /// function chunk or type. Returns true if the attribute was
383 /// distributed, false if no location was found.
385 distributeFunctionTypeAttrToInnermost(TypeProcessingState &state,
387 AttributeList *&attrList,
388 QualType &declSpecType) {
389 Declarator &declarator = state.getDeclarator();
391 // Put it on the innermost function chunk, if there is one.
392 for (unsigned i = 0, e = declarator.getNumTypeObjects(); i != e; ++i) {
393 DeclaratorChunk &chunk = declarator.getTypeObject(i);
394 if (chunk.Kind != DeclaratorChunk::Function) continue;
396 moveAttrFromListToList(attr, attrList, chunk.getAttrListRef());
400 return handleFunctionTypeAttr(state, attr, declSpecType);
403 /// A function type attribute was written in the decl spec. Try to
404 /// apply it somewhere.
406 distributeFunctionTypeAttrFromDeclSpec(TypeProcessingState &state,
408 QualType &declSpecType) {
409 state.saveDeclSpecAttrs();
411 // Try to distribute to the innermost.
412 if (distributeFunctionTypeAttrToInnermost(state, attr,
413 state.getCurrentAttrListRef(),
417 // If that failed, diagnose the bad attribute when the declarator is
419 state.addIgnoredTypeAttr(attr);
422 /// A function type attribute was written on the declarator. Try to
423 /// apply it somewhere.
425 distributeFunctionTypeAttrFromDeclarator(TypeProcessingState &state,
427 QualType &declSpecType) {
428 Declarator &declarator = state.getDeclarator();
430 // Try to distribute to the innermost.
431 if (distributeFunctionTypeAttrToInnermost(state, attr,
432 declarator.getAttrListRef(),
436 // If that failed, diagnose the bad attribute when the declarator is
438 spliceAttrOutOfList(attr, declarator.getAttrListRef());
439 state.addIgnoredTypeAttr(attr);
442 /// \brief Given that there are attributes written on the declarator
443 /// itself, try to distribute any type attributes to the appropriate
444 /// declarator chunk.
446 /// These are attributes like the following:
449 /// but not necessarily this:
451 static void distributeTypeAttrsFromDeclarator(TypeProcessingState &state,
452 QualType &declSpecType) {
453 // Collect all the type attributes from the declarator itself.
454 assert(state.getDeclarator().getAttributes() && "declarator has no attrs!");
455 AttributeList *attr = state.getDeclarator().getAttributes();
458 next = attr->getNext();
460 switch (attr->getKind()) {
461 OBJC_POINTER_TYPE_ATTRS_CASELIST:
462 distributeObjCPointerTypeAttrFromDeclarator(state, *attr, declSpecType);
465 FUNCTION_TYPE_ATTRS_CASELIST:
466 distributeFunctionTypeAttrFromDeclarator(state, *attr, declSpecType);
472 } while ((attr = next));
475 /// Add a synthetic '()' to a block-literal declarator if it is
476 /// required, given the return type.
477 static void maybeSynthesizeBlockSignature(TypeProcessingState &state,
478 QualType declSpecType) {
479 Declarator &declarator = state.getDeclarator();
481 // First, check whether the declarator would produce a function,
482 // i.e. whether the innermost semantic chunk is a function.
483 if (declarator.isFunctionDeclarator()) {
484 // If so, make that declarator a prototyped declarator.
485 declarator.getFunctionTypeInfo().hasPrototype = true;
489 // If there are any type objects, the type as written won't name a
490 // function, regardless of the decl spec type. This is because a
491 // block signature declarator is always an abstract-declarator, and
492 // abstract-declarators can't just be parentheses chunks. Therefore
493 // we need to build a function chunk unless there are no type
494 // objects and the decl spec type is a function.
495 if (!declarator.getNumTypeObjects() && declSpecType->isFunctionType())
498 // Note that there *are* cases with invalid declarators where
499 // declarators consist solely of parentheses. In general, these
500 // occur only in failed efforts to make function declarators, so
501 // faking up the function chunk is still the right thing to do.
503 // Otherwise, we need to fake up a function declarator.
504 SourceLocation loc = declarator.getSourceRange().getBegin();
506 // ...and *prepend* it to the declarator.
507 declarator.AddInnermostTypeInfo(DeclaratorChunk::getFunction(
510 /*variadic*/ false, SourceLocation(),
513 /*ref-qualifier*/true, SourceLocation(),
514 /*EH*/ false, SourceLocation(), false, 0, 0, 0,
518 // For consistency, make sure the state still has us as processing
520 assert(state.getCurrentChunkIndex() == declarator.getNumTypeObjects() - 1);
521 state.setCurrentChunkIndex(declarator.getNumTypeObjects());
524 /// \brief Convert the specified declspec to the appropriate type
526 /// \param D the declarator containing the declaration specifier.
527 /// \returns The type described by the declaration specifiers. This function
528 /// never returns null.
529 static QualType ConvertDeclSpecToType(Sema &S, TypeProcessingState &state) {
530 // FIXME: Should move the logic from DeclSpec::Finish to here for validity
533 Declarator &declarator = state.getDeclarator();
534 const DeclSpec &DS = declarator.getDeclSpec();
535 SourceLocation DeclLoc = declarator.getIdentifierLoc();
536 if (DeclLoc.isInvalid())
537 DeclLoc = DS.getSourceRange().getBegin();
539 ASTContext &Context = S.Context;
542 switch (DS.getTypeSpecType()) {
543 case DeclSpec::TST_void:
544 Result = Context.VoidTy;
546 case DeclSpec::TST_char:
547 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
548 Result = Context.CharTy;
549 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
550 Result = Context.SignedCharTy;
552 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
553 "Unknown TSS value");
554 Result = Context.UnsignedCharTy;
557 case DeclSpec::TST_wchar:
558 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
559 Result = Context.WCharTy;
560 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
561 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
562 << DS.getSpecifierName(DS.getTypeSpecType());
563 Result = Context.getSignedWCharType();
565 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
566 "Unknown TSS value");
567 S.Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
568 << DS.getSpecifierName(DS.getTypeSpecType());
569 Result = Context.getUnsignedWCharType();
572 case DeclSpec::TST_char16:
573 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
574 "Unknown TSS value");
575 Result = Context.Char16Ty;
577 case DeclSpec::TST_char32:
578 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unspecified &&
579 "Unknown TSS value");
580 Result = Context.Char32Ty;
582 case DeclSpec::TST_unspecified:
583 // "<proto1,proto2>" is an objc qualified ID with a missing id.
584 if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
585 Result = Context.getObjCObjectType(Context.ObjCBuiltinIdTy,
586 (ObjCProtocolDecl**)PQ,
587 DS.getNumProtocolQualifiers());
588 Result = Context.getObjCObjectPointerType(Result);
592 // If this is a missing declspec in a block literal return context, then it
593 // is inferred from the return statements inside the block.
594 if (isOmittedBlockReturnType(declarator)) {
595 Result = Context.DependentTy;
599 // Unspecified typespec defaults to int in C90. However, the C90 grammar
600 // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
601 // type-qualifier, or storage-class-specifier. If not, emit an extwarn.
602 // Note that the one exception to this is function definitions, which are
603 // allowed to be completely missing a declspec. This is handled in the
604 // parser already though by it pretending to have seen an 'int' in this
606 if (S.getLangOptions().ImplicitInt) {
607 // In C89 mode, we only warn if there is a completely missing declspec
608 // when one is not allowed.
610 S.Diag(DeclLoc, diag::ext_missing_declspec)
611 << DS.getSourceRange()
612 << FixItHint::CreateInsertion(DS.getSourceRange().getBegin(), "int");
614 } else if (!DS.hasTypeSpecifier()) {
615 // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says:
616 // "At least one type specifier shall be given in the declaration
617 // specifiers in each declaration, and in the specifier-qualifier list in
618 // each struct declaration and type name."
619 // FIXME: Does Microsoft really have the implicit int extension in C++?
620 if (S.getLangOptions().CPlusPlus &&
621 !S.getLangOptions().Microsoft) {
622 S.Diag(DeclLoc, diag::err_missing_type_specifier)
623 << DS.getSourceRange();
625 // When this occurs in C++ code, often something is very broken with the
626 // value being declared, poison it as invalid so we don't get chains of
628 declarator.setInvalidType(true);
630 S.Diag(DeclLoc, diag::ext_missing_type_specifier)
631 << DS.getSourceRange();
636 case DeclSpec::TST_int: {
637 if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
638 switch (DS.getTypeSpecWidth()) {
639 case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
640 case DeclSpec::TSW_short: Result = Context.ShortTy; break;
641 case DeclSpec::TSW_long: Result = Context.LongTy; break;
642 case DeclSpec::TSW_longlong:
643 Result = Context.LongLongTy;
645 // long long is a C99 feature.
646 if (!S.getLangOptions().C99 &&
647 !S.getLangOptions().CPlusPlus0x)
648 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong);
652 switch (DS.getTypeSpecWidth()) {
653 case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
654 case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break;
655 case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break;
656 case DeclSpec::TSW_longlong:
657 Result = Context.UnsignedLongLongTy;
659 // long long is a C99 feature.
660 if (!S.getLangOptions().C99 &&
661 !S.getLangOptions().CPlusPlus0x)
662 S.Diag(DS.getTypeSpecWidthLoc(), diag::ext_longlong);
668 case DeclSpec::TST_float: Result = Context.FloatTy; break;
669 case DeclSpec::TST_double:
670 if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
671 Result = Context.LongDoubleTy;
673 Result = Context.DoubleTy;
675 if (S.getLangOptions().OpenCL && !S.getOpenCLOptions().cl_khr_fp64) {
676 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_double_requires_fp64);
677 declarator.setInvalidType(true);
680 case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
681 case DeclSpec::TST_decimal32: // _Decimal32
682 case DeclSpec::TST_decimal64: // _Decimal64
683 case DeclSpec::TST_decimal128: // _Decimal128
684 S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
685 Result = Context.IntTy;
686 declarator.setInvalidType(true);
688 case DeclSpec::TST_class:
689 case DeclSpec::TST_enum:
690 case DeclSpec::TST_union:
691 case DeclSpec::TST_struct: {
692 TypeDecl *D = dyn_cast_or_null<TypeDecl>(DS.getRepAsDecl());
694 // This can happen in C++ with ambiguous lookups.
695 Result = Context.IntTy;
696 declarator.setInvalidType(true);
700 // If the type is deprecated or unavailable, diagnose it.
701 S.DiagnoseUseOfDecl(D, DS.getTypeSpecTypeLoc());
703 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
704 DS.getTypeSpecSign() == 0 && "No qualifiers on tag names!");
706 // TypeQuals handled by caller.
707 Result = Context.getTypeDeclType(D);
709 // In C++, make an ElaboratedType.
710 if (S.getLangOptions().CPlusPlus) {
711 ElaboratedTypeKeyword Keyword
712 = ElaboratedType::getKeywordForTypeSpec(DS.getTypeSpecType());
713 Result = S.getElaboratedType(Keyword, DS.getTypeSpecScope(), Result);
715 if (D->isInvalidDecl())
716 declarator.setInvalidType(true);
719 case DeclSpec::TST_typename: {
720 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
721 DS.getTypeSpecSign() == 0 &&
722 "Can't handle qualifiers on typedef names yet!");
723 Result = S.GetTypeFromParser(DS.getRepAsType());
725 declarator.setInvalidType(true);
726 else if (DeclSpec::ProtocolQualifierListTy PQ
727 = DS.getProtocolQualifiers()) {
728 if (const ObjCObjectType *ObjT = Result->getAs<ObjCObjectType>()) {
729 // Silently drop any existing protocol qualifiers.
730 // TODO: determine whether that's the right thing to do.
731 if (ObjT->getNumProtocols())
732 Result = ObjT->getBaseType();
734 if (DS.getNumProtocolQualifiers())
735 Result = Context.getObjCObjectType(Result,
736 (ObjCProtocolDecl**) PQ,
737 DS.getNumProtocolQualifiers());
738 } else if (Result->isObjCIdType()) {
740 Result = Context.getObjCObjectType(Context.ObjCBuiltinIdTy,
741 (ObjCProtocolDecl**) PQ,
742 DS.getNumProtocolQualifiers());
743 Result = Context.getObjCObjectPointerType(Result);
744 } else if (Result->isObjCClassType()) {
745 // Class<protocol-list>
746 Result = Context.getObjCObjectType(Context.ObjCBuiltinClassTy,
747 (ObjCProtocolDecl**) PQ,
748 DS.getNumProtocolQualifiers());
749 Result = Context.getObjCObjectPointerType(Result);
751 S.Diag(DeclLoc, diag::err_invalid_protocol_qualifiers)
752 << DS.getSourceRange();
753 declarator.setInvalidType(true);
757 // TypeQuals handled by caller.
760 case DeclSpec::TST_typeofType:
761 // FIXME: Preserve type source info.
762 Result = S.GetTypeFromParser(DS.getRepAsType());
763 assert(!Result.isNull() && "Didn't get a type for typeof?");
764 if (!Result->isDependentType())
765 if (const TagType *TT = Result->getAs<TagType>())
766 S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc());
767 // TypeQuals handled by caller.
768 Result = Context.getTypeOfType(Result);
770 case DeclSpec::TST_typeofExpr: {
771 Expr *E = DS.getRepAsExpr();
772 assert(E && "Didn't get an expression for typeof?");
773 // TypeQuals handled by caller.
774 Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc());
775 if (Result.isNull()) {
776 Result = Context.IntTy;
777 declarator.setInvalidType(true);
781 case DeclSpec::TST_decltype: {
782 Expr *E = DS.getRepAsExpr();
783 assert(E && "Didn't get an expression for decltype?");
784 // TypeQuals handled by caller.
785 Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
786 if (Result.isNull()) {
787 Result = Context.IntTy;
788 declarator.setInvalidType(true);
792 case DeclSpec::TST_auto: {
793 // TypeQuals handled by caller.
794 Result = Context.getAutoType(QualType());
798 case DeclSpec::TST_error:
799 Result = Context.IntTy;
800 declarator.setInvalidType(true);
804 // Handle complex types.
805 if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
806 if (S.getLangOptions().Freestanding)
807 S.Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
808 Result = Context.getComplexType(Result);
809 } else if (DS.isTypeAltiVecVector()) {
810 unsigned typeSize = static_cast<unsigned>(Context.getTypeSize(Result));
811 assert(typeSize > 0 && "type size for vector must be greater than 0 bits");
812 VectorType::VectorKind VecKind = VectorType::AltiVecVector;
813 if (DS.isTypeAltiVecPixel())
814 VecKind = VectorType::AltiVecPixel;
815 else if (DS.isTypeAltiVecBool())
816 VecKind = VectorType::AltiVecBool;
817 Result = Context.getVectorType(Result, 128/typeSize, VecKind);
821 if (DS.getTypeSpecComplex() == DeclSpec::TSC_imaginary)
822 S.Diag(DS.getTypeSpecComplexLoc(), diag::err_imaginary_not_supported);
824 // Before we process any type attributes, synthesize a block literal
825 // function declarator if necessary.
826 if (declarator.getContext() == Declarator::BlockLiteralContext)
827 maybeSynthesizeBlockSignature(state, Result);
829 // Apply any type attributes from the decl spec. This may cause the
830 // list of type attributes to be temporarily saved while the type
831 // attributes are pushed around.
832 if (AttributeList *attrs = DS.getAttributes().getList())
833 processTypeAttrs(state, Result, true, attrs);
835 // Apply const/volatile/restrict qualifiers to T.
836 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
838 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
839 // or incomplete types shall not be restrict-qualified." C++ also allows
840 // restrict-qualified references.
841 if (TypeQuals & DeclSpec::TQ_restrict) {
842 if (Result->isAnyPointerType() || Result->isReferenceType()) {
844 if (Result->isObjCObjectPointerType())
847 EltTy = Result->isPointerType() ?
848 Result->getAs<PointerType>()->getPointeeType() :
849 Result->getAs<ReferenceType>()->getPointeeType();
851 // If we have a pointer or reference, the pointee must have an object
853 if (!EltTy->isIncompleteOrObjectType()) {
854 S.Diag(DS.getRestrictSpecLoc(),
855 diag::err_typecheck_invalid_restrict_invalid_pointee)
856 << EltTy << DS.getSourceRange();
857 TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier.
860 S.Diag(DS.getRestrictSpecLoc(),
861 diag::err_typecheck_invalid_restrict_not_pointer)
862 << Result << DS.getSourceRange();
863 TypeQuals &= ~DeclSpec::TQ_restrict; // Remove the restrict qualifier.
867 // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification
868 // of a function type includes any type qualifiers, the behavior is
870 if (Result->isFunctionType() && TypeQuals) {
871 // Get some location to point at, either the C or V location.
873 if (TypeQuals & DeclSpec::TQ_const)
874 Loc = DS.getConstSpecLoc();
875 else if (TypeQuals & DeclSpec::TQ_volatile)
876 Loc = DS.getVolatileSpecLoc();
878 assert((TypeQuals & DeclSpec::TQ_restrict) &&
879 "Has CVR quals but not C, V, or R?");
880 Loc = DS.getRestrictSpecLoc();
882 S.Diag(Loc, diag::warn_typecheck_function_qualifiers)
883 << Result << DS.getSourceRange();
887 // Cv-qualified references are ill-formed except when the
888 // cv-qualifiers are introduced through the use of a typedef
889 // (7.1.3) or of a template type argument (14.3), in which
890 // case the cv-qualifiers are ignored.
891 // FIXME: Shouldn't we be checking SCS_typedef here?
892 if (DS.getTypeSpecType() == DeclSpec::TST_typename &&
893 TypeQuals && Result->isReferenceType()) {
894 TypeQuals &= ~DeclSpec::TQ_const;
895 TypeQuals &= ~DeclSpec::TQ_volatile;
898 Qualifiers Quals = Qualifiers::fromCVRMask(TypeQuals);
899 Result = Context.getQualifiedType(Result, Quals);
905 static std::string getPrintableNameForEntity(DeclarationName Entity) {
907 return Entity.getAsString();
912 QualType Sema::BuildQualifiedType(QualType T, SourceLocation Loc,
914 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
915 // object or incomplete types shall not be restrict-qualified."
916 if (Qs.hasRestrict()) {
920 const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
921 if (const ReferenceType *RTy = dyn_cast<ReferenceType>(Ty)) {
922 if (!RTy->getPointeeType()->isIncompleteOrObjectType()) {
923 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
924 ProblemTy = T->getAs<ReferenceType>()->getPointeeType();
926 } else if (const PointerType *PTy = dyn_cast<PointerType>(Ty)) {
927 if (!PTy->getPointeeType()->isIncompleteOrObjectType()) {
928 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
929 ProblemTy = T->getAs<PointerType>()->getPointeeType();
931 } else if (const MemberPointerType *PTy = dyn_cast<MemberPointerType>(Ty)) {
932 if (!PTy->getPointeeType()->isIncompleteOrObjectType()) {
933 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
934 ProblemTy = T->getAs<PointerType>()->getPointeeType();
936 } else if (!Ty->isDependentType()) {
937 // FIXME: this deserves a proper diagnostic
938 DiagID = diag::err_typecheck_invalid_restrict_invalid_pointee;
943 Diag(Loc, DiagID) << ProblemTy;
948 return Context.getQualifiedType(T, Qs);
951 /// \brief Build a paren type including \p T.
952 QualType Sema::BuildParenType(QualType T) {
953 return Context.getParenType(T);
956 /// \brief Build a pointer type.
958 /// \param T The type to which we'll be building a pointer.
960 /// \param Loc The location of the entity whose type involves this
961 /// pointer type or, if there is no such entity, the location of the
962 /// type that will have pointer type.
964 /// \param Entity The name of the entity that involves the pointer
967 /// \returns A suitable pointer type, if there are no
968 /// errors. Otherwise, returns a NULL type.
969 QualType Sema::BuildPointerType(QualType T,
970 SourceLocation Loc, DeclarationName Entity) {
971 if (T->isReferenceType()) {
972 // C++ 8.3.2p4: There shall be no ... pointers to references ...
973 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
974 << getPrintableNameForEntity(Entity) << T;
978 assert(!T->isObjCObjectType() && "Should build ObjCObjectPointerType");
980 // Build the pointer type.
981 return Context.getPointerType(T);
984 /// \brief Build a reference type.
986 /// \param T The type to which we'll be building a reference.
988 /// \param Loc The location of the entity whose type involves this
989 /// reference type or, if there is no such entity, the location of the
990 /// type that will have reference type.
992 /// \param Entity The name of the entity that involves the reference
995 /// \returns A suitable reference type, if there are no
996 /// errors. Otherwise, returns a NULL type.
997 QualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue,
999 DeclarationName Entity) {
1000 // C++0x [dcl.ref]p6:
1001 // If a typedef (7.1.3), a type template-parameter (14.3.1), or a
1002 // decltype-specifier (7.1.6.2) denotes a type TR that is a reference to a
1003 // type T, an attempt to create the type "lvalue reference to cv TR" creates
1004 // the type "lvalue reference to T", while an attempt to create the type
1005 // "rvalue reference to cv TR" creates the type TR.
1006 bool LValueRef = SpelledAsLValue || T->getAs<LValueReferenceType>();
1008 // C++ [dcl.ref]p4: There shall be no references to references.
1010 // According to C++ DR 106, references to references are only
1011 // diagnosed when they are written directly (e.g., "int & &"),
1012 // but not when they happen via a typedef:
1014 // typedef int& intref;
1015 // typedef intref& intref2;
1017 // Parser::ParseDeclaratorInternal diagnoses the case where
1018 // references are written directly; here, we handle the
1019 // collapsing of references-to-references as described in C++0x.
1020 // DR 106 and 540 introduce reference-collapsing into C++98/03.
1023 // A declarator that specifies the type "reference to cv void"
1025 if (T->isVoidType()) {
1026 Diag(Loc, diag::err_reference_to_void);
1030 // Handle restrict on references.
1032 return Context.getLValueReferenceType(T, SpelledAsLValue);
1033 return Context.getRValueReferenceType(T);
1036 /// \brief Build an array type.
1038 /// \param T The type of each element in the array.
1040 /// \param ASM C99 array size modifier (e.g., '*', 'static').
1042 /// \param ArraySize Expression describing the size of the array.
1044 /// \param Loc The location of the entity whose type involves this
1045 /// array type or, if there is no such entity, the location of the
1046 /// type that will have array type.
1048 /// \param Entity The name of the entity that involves the array
1051 /// \returns A suitable array type, if there are no errors. Otherwise,
1052 /// returns a NULL type.
1053 QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
1054 Expr *ArraySize, unsigned Quals,
1055 SourceRange Brackets, DeclarationName Entity) {
1057 SourceLocation Loc = Brackets.getBegin();
1058 if (getLangOptions().CPlusPlus) {
1059 // C++ [dcl.array]p1:
1060 // T is called the array element type; this type shall not be a reference
1061 // type, the (possibly cv-qualified) type void, a function type or an
1062 // abstract class type.
1064 // Note: function types are handled in the common path with C.
1065 if (T->isReferenceType()) {
1066 Diag(Loc, diag::err_illegal_decl_array_of_references)
1067 << getPrintableNameForEntity(Entity) << T;
1071 if (T->isVoidType()) {
1072 Diag(Loc, diag::err_illegal_decl_array_incomplete_type) << T;
1076 if (RequireNonAbstractType(Brackets.getBegin(), T,
1077 diag::err_array_of_abstract_type))
1081 // C99 6.7.5.2p1: If the element type is an incomplete or function type,
1082 // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
1083 if (RequireCompleteType(Loc, T,
1084 diag::err_illegal_decl_array_incomplete_type))
1088 if (T->isFunctionType()) {
1089 Diag(Loc, diag::err_illegal_decl_array_of_functions)
1090 << getPrintableNameForEntity(Entity) << T;
1094 if (T->getContainedAutoType()) {
1095 Diag(Loc, diag::err_illegal_decl_array_of_auto)
1096 << getPrintableNameForEntity(Entity) << T;
1100 if (const RecordType *EltTy = T->getAs<RecordType>()) {
1101 // If the element type is a struct or union that contains a variadic
1102 // array, accept it as a GNU extension: C99 6.7.2.1p2.
1103 if (EltTy->getDecl()->hasFlexibleArrayMember())
1104 Diag(Loc, diag::ext_flexible_array_in_array) << T;
1105 } else if (T->isObjCObjectType()) {
1106 Diag(Loc, diag::err_objc_array_of_interfaces) << T;
1110 // Do lvalue-to-rvalue conversions on the array size expression.
1111 if (ArraySize && !ArraySize->isRValue())
1112 DefaultLvalueConversion(ArraySize);
1114 // C99 6.7.5.2p1: The size expression shall have integer type.
1115 // TODO: in theory, if we were insane, we could allow contextual
1116 // conversions to integer type here.
1117 if (ArraySize && !ArraySize->isTypeDependent() &&
1118 !ArraySize->getType()->isIntegralOrUnscopedEnumerationType()) {
1119 Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
1120 << ArraySize->getType() << ArraySize->getSourceRange();
1123 llvm::APSInt ConstVal(Context.getTypeSize(Context.getSizeType()));
1125 if (ASM == ArrayType::Star)
1126 T = Context.getVariableArrayType(T, 0, ASM, Quals, Brackets);
1128 T = Context.getIncompleteArrayType(T, ASM, Quals);
1129 } else if (ArraySize->isTypeDependent() || ArraySize->isValueDependent()) {
1130 T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals, Brackets);
1131 } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context) ||
1132 (!T->isDependentType() && !T->isIncompleteType() &&
1133 !T->isConstantSizeType())) {
1134 // Per C99, a variable array is an array with either a non-constant
1135 // size or an element type that has a non-constant-size
1136 T = Context.getVariableArrayType(T, ArraySize, ASM, Quals, Brackets);
1138 // C99 6.7.5.2p1: If the expression is a constant expression, it shall
1139 // have a value greater than zero.
1140 if (ConstVal.isSigned() && ConstVal.isNegative()) {
1142 Diag(ArraySize->getLocStart(), diag::err_decl_negative_array_size)
1143 << getPrintableNameForEntity(Entity) << ArraySize->getSourceRange();
1145 Diag(ArraySize->getLocStart(), diag::err_typecheck_negative_array_size)
1146 << ArraySize->getSourceRange();
1149 if (ConstVal == 0) {
1150 // GCC accepts zero sized static arrays. We allow them when
1151 // we're not in a SFINAE context.
1152 Diag(ArraySize->getLocStart(),
1153 isSFINAEContext()? diag::err_typecheck_zero_array_size
1154 : diag::ext_typecheck_zero_array_size)
1155 << ArraySize->getSourceRange();
1156 } else if (!T->isDependentType() && !T->isVariablyModifiedType() &&
1157 !T->isIncompleteType()) {
1158 // Is the array too large?
1159 unsigned ActiveSizeBits
1160 = ConstantArrayType::getNumAddressingBits(Context, T, ConstVal);
1161 if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context))
1162 Diag(ArraySize->getLocStart(), diag::err_array_too_large)
1163 << ConstVal.toString(10)
1164 << ArraySize->getSourceRange();
1167 T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
1169 // If this is not C99, extwarn about VLA's and C99 array size modifiers.
1170 if (!getLangOptions().C99) {
1171 if (T->isVariableArrayType()) {
1172 // Prohibit the use of non-POD types in VLAs.
1173 if (!T->isDependentType() &&
1174 !Context.getBaseElementType(T)->isPODType()) {
1175 Diag(Loc, diag::err_vla_non_pod)
1176 << Context.getBaseElementType(T);
1179 // Prohibit the use of VLAs during template argument deduction.
1180 else if (isSFINAEContext()) {
1181 Diag(Loc, diag::err_vla_in_sfinae);
1184 // Just extwarn about VLAs.
1186 Diag(Loc, diag::ext_vla);
1187 } else if (ASM != ArrayType::Normal || Quals != 0)
1189 getLangOptions().CPlusPlus? diag::err_c99_array_usage_cxx
1190 : diag::ext_c99_array_usage);
1196 /// \brief Build an ext-vector type.
1198 /// Run the required checks for the extended vector type.
1199 QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize,
1200 SourceLocation AttrLoc) {
1201 // unlike gcc's vector_size attribute, we do not allow vectors to be defined
1202 // in conjunction with complex types (pointers, arrays, functions, etc.).
1203 if (!T->isDependentType() &&
1204 !T->isIntegerType() && !T->isRealFloatingType()) {
1205 Diag(AttrLoc, diag::err_attribute_invalid_vector_type) << T;
1209 if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) {
1210 llvm::APSInt vecSize(32);
1211 if (!ArraySize->isIntegerConstantExpr(vecSize, Context)) {
1212 Diag(AttrLoc, diag::err_attribute_argument_not_int)
1213 << "ext_vector_type" << ArraySize->getSourceRange();
1217 // unlike gcc's vector_size attribute, the size is specified as the
1218 // number of elements, not the number of bytes.
1219 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue());
1221 if (vectorSize == 0) {
1222 Diag(AttrLoc, diag::err_attribute_zero_size)
1223 << ArraySize->getSourceRange();
1227 if (!T->isDependentType())
1228 return Context.getExtVectorType(T, vectorSize);
1231 return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc);
1234 /// \brief Build a function type.
1236 /// This routine checks the function type according to C++ rules and
1237 /// under the assumption that the result type and parameter types have
1238 /// just been instantiated from a template. It therefore duplicates
1239 /// some of the behavior of GetTypeForDeclarator, but in a much
1240 /// simpler form that is only suitable for this narrow use case.
1242 /// \param T The return type of the function.
1244 /// \param ParamTypes The parameter types of the function. This array
1245 /// will be modified to account for adjustments to the types of the
1246 /// function parameters.
1248 /// \param NumParamTypes The number of parameter types in ParamTypes.
1250 /// \param Variadic Whether this is a variadic function type.
1252 /// \param Quals The cvr-qualifiers to be applied to the function type.
1254 /// \param Loc The location of the entity whose type involves this
1255 /// function type or, if there is no such entity, the location of the
1256 /// type that will have function type.
1258 /// \param Entity The name of the entity that involves the function
1261 /// \returns A suitable function type, if there are no
1262 /// errors. Otherwise, returns a NULL type.
1263 QualType Sema::BuildFunctionType(QualType T,
1264 QualType *ParamTypes,
1265 unsigned NumParamTypes,
1266 bool Variadic, unsigned Quals,
1267 RefQualifierKind RefQualifier,
1268 SourceLocation Loc, DeclarationName Entity,
1269 FunctionType::ExtInfo Info) {
1270 if (T->isArrayType() || T->isFunctionType()) {
1271 Diag(Loc, diag::err_func_returning_array_function)
1272 << T->isFunctionType() << T;
1276 bool Invalid = false;
1277 for (unsigned Idx = 0; Idx < NumParamTypes; ++Idx) {
1278 QualType ParamType = adjustParameterType(ParamTypes[Idx]);
1279 if (ParamType->isVoidType()) {
1280 Diag(Loc, diag::err_param_with_void_type);
1284 ParamTypes[Idx] = ParamType;
1290 FunctionProtoType::ExtProtoInfo EPI;
1291 EPI.Variadic = Variadic;
1292 EPI.TypeQuals = Quals;
1293 EPI.RefQualifier = RefQualifier;
1296 return Context.getFunctionType(T, ParamTypes, NumParamTypes, EPI);
1299 /// \brief Build a member pointer type \c T Class::*.
1301 /// \param T the type to which the member pointer refers.
1302 /// \param Class the class type into which the member pointer points.
1303 /// \param CVR Qualifiers applied to the member pointer type
1304 /// \param Loc the location where this type begins
1305 /// \param Entity the name of the entity that will have this member pointer type
1307 /// \returns a member pointer type, if successful, or a NULL type if there was
1309 QualType Sema::BuildMemberPointerType(QualType T, QualType Class,
1311 DeclarationName Entity) {
1312 // Verify that we're not building a pointer to pointer to function with
1313 // exception specification.
1314 if (CheckDistantExceptionSpec(T)) {
1315 Diag(Loc, diag::err_distant_exception_spec);
1317 // FIXME: If we're doing this as part of template instantiation,
1318 // we should return immediately.
1320 // Build the type anyway, but use the canonical type so that the
1321 // exception specifiers are stripped off.
1322 T = Context.getCanonicalType(T);
1325 // C++ 8.3.3p3: A pointer to member shall not point to ... a member
1326 // with reference type, or "cv void."
1327 if (T->isReferenceType()) {
1328 Diag(Loc, diag::err_illegal_decl_mempointer_to_reference)
1329 << (Entity? Entity.getAsString() : "type name") << T;
1333 if (T->isVoidType()) {
1334 Diag(Loc, diag::err_illegal_decl_mempointer_to_void)
1335 << (Entity? Entity.getAsString() : "type name");
1339 if (!Class->isDependentType() && !Class->isRecordType()) {
1340 Diag(Loc, diag::err_mempointer_in_nonclass_type) << Class;
1344 // In the Microsoft ABI, the class is allowed to be an incomplete
1345 // type. In such cases, the compiler makes a worst-case assumption.
1346 // We make no such assumption right now, so emit an error if the
1347 // class isn't a complete type.
1348 if (Context.Target.getCXXABI() == CXXABI_Microsoft &&
1349 RequireCompleteType(Loc, Class, diag::err_incomplete_type))
1352 return Context.getMemberPointerType(T, Class.getTypePtr());
1355 /// \brief Build a block pointer type.
1357 /// \param T The type to which we'll be building a block pointer.
1359 /// \param CVR The cvr-qualifiers to be applied to the block pointer type.
1361 /// \param Loc The location of the entity whose type involves this
1362 /// block pointer type or, if there is no such entity, the location of the
1363 /// type that will have block pointer type.
1365 /// \param Entity The name of the entity that involves the block pointer
1368 /// \returns A suitable block pointer type, if there are no
1369 /// errors. Otherwise, returns a NULL type.
1370 QualType Sema::BuildBlockPointerType(QualType T,
1372 DeclarationName Entity) {
1373 if (!T->isFunctionType()) {
1374 Diag(Loc, diag::err_nonfunction_block_type);
1378 return Context.getBlockPointerType(T);
1381 QualType Sema::GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo) {
1382 QualType QT = Ty.get();
1384 if (TInfo) *TInfo = 0;
1388 TypeSourceInfo *DI = 0;
1389 if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT)) {
1390 QT = LIT->getType();
1391 DI = LIT->getTypeSourceInfo();
1394 if (TInfo) *TInfo = DI;
1398 static void DiagnoseIgnoredQualifiers(unsigned Quals,
1399 SourceLocation ConstQualLoc,
1400 SourceLocation VolatileQualLoc,
1401 SourceLocation RestrictQualLoc,
1403 std::string QualStr;
1404 unsigned NumQuals = 0;
1407 FixItHint ConstFixIt;
1408 FixItHint VolatileFixIt;
1409 FixItHint RestrictFixIt;
1411 // FIXME: The locations here are set kind of arbitrarily. It'd be nicer to
1412 // find a range and grow it to encompass all the qualifiers, regardless of
1413 // the order in which they textually appear.
1414 if (Quals & Qualifiers::Const) {
1415 ConstFixIt = FixItHint::CreateRemoval(ConstQualLoc);
1420 if (Quals & Qualifiers::Volatile) {
1421 VolatileFixIt = FixItHint::CreateRemoval(VolatileQualLoc);
1422 if (NumQuals == 0) {
1423 Loc = VolatileQualLoc;
1424 QualStr = "volatile";
1426 QualStr += " volatile";
1430 if (Quals & Qualifiers::Restrict) {
1431 RestrictFixIt = FixItHint::CreateRemoval(RestrictQualLoc);
1432 if (NumQuals == 0) {
1433 Loc = RestrictQualLoc;
1434 QualStr = "restrict";
1436 QualStr += " restrict";
1441 assert(NumQuals > 0 && "No known qualifiers?");
1443 S.Diag(Loc, diag::warn_qual_return_type)
1444 << QualStr << NumQuals
1445 << ConstFixIt << VolatileFixIt << RestrictFixIt;
1448 /// GetTypeForDeclarator - Convert the type for the specified
1449 /// declarator to Type instances.
1451 /// If OwnedDecl is non-NULL, and this declarator's decl-specifier-seq
1452 /// owns the declaration of a type (e.g., the definition of a struct
1453 /// type), then *OwnedDecl will receive the owned declaration.
1455 /// The result of this call will never be null, but the associated
1456 /// type may be a null type if there's an unrecoverable error.
1457 TypeSourceInfo *Sema::GetTypeForDeclarator(Declarator &D, Scope *S,
1458 TagDecl **OwnedDecl,
1459 bool AutoAllowedInTypeName) {
1460 // Determine the type of the declarator. Not all forms of declarator
1463 TypeSourceInfo *ReturnTypeInfo = 0;
1465 TypeProcessingState state(*this, D);
1467 switch (D.getName().getKind()) {
1468 case UnqualifiedId::IK_Identifier:
1469 case UnqualifiedId::IK_OperatorFunctionId:
1470 case UnqualifiedId::IK_LiteralOperatorId:
1471 case UnqualifiedId::IK_TemplateId:
1472 T = ConvertDeclSpecToType(*this, state);
1474 if (!D.isInvalidType() && D.getDeclSpec().isTypeSpecOwned()) {
1475 TagDecl* Owned = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
1476 // Owned is embedded if it was defined here, or if it is the
1477 // very first (i.e., canonical) declaration of this tag type.
1478 Owned->setEmbeddedInDeclarator(Owned->isDefinition() ||
1479 Owned->isCanonicalDecl());
1480 if (OwnedDecl) *OwnedDecl = Owned;
1484 case UnqualifiedId::IK_ConstructorName:
1485 case UnqualifiedId::IK_ConstructorTemplateId:
1486 case UnqualifiedId::IK_DestructorName:
1487 // Constructors and destructors don't have return types. Use
1492 case UnqualifiedId::IK_ConversionFunctionId:
1493 // The result type of a conversion function is the type that it
1495 T = GetTypeFromParser(D.getName().ConversionFunctionId,
1500 if (D.getAttributes())
1501 distributeTypeAttrsFromDeclarator(state, T);
1503 // C++0x [dcl.spec.auto]p5: reject 'auto' if it is not in an allowed context.
1504 // In C++0x, a function declarator using 'auto' must have a trailing return
1505 // type (this is checked later) and we can skip this. In other languages
1506 // using auto, we need to check regardless.
1507 if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto &&
1508 (!getLangOptions().CPlusPlus0x || !D.isFunctionDeclarator())) {
1511 switch (D.getContext()) {
1512 case Declarator::KNRTypeListContext:
1513 assert(0 && "K&R type lists aren't allowed in C++");
1515 case Declarator::PrototypeContext:
1516 Error = 0; // Function prototype
1518 case Declarator::MemberContext:
1519 switch (cast<TagDecl>(CurContext)->getTagKind()) {
1520 case TTK_Enum: assert(0 && "unhandled tag kind"); break;
1521 case TTK_Struct: Error = 1; /* Struct member */ break;
1522 case TTK_Union: Error = 2; /* Union member */ break;
1523 case TTK_Class: Error = 3; /* Class member */ break;
1526 case Declarator::CXXCatchContext:
1527 Error = 4; // Exception declaration
1529 case Declarator::TemplateParamContext:
1530 Error = 5; // Template parameter
1532 case Declarator::BlockLiteralContext:
1533 Error = 6; // Block literal
1535 case Declarator::TemplateTypeArgContext:
1536 Error = 7; // Template type argument
1538 case Declarator::TypeNameContext:
1539 if (!AutoAllowedInTypeName)
1540 Error = 10; // Generic
1542 case Declarator::FileContext:
1543 case Declarator::BlockContext:
1544 case Declarator::ForContext:
1545 case Declarator::ConditionContext:
1549 if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1552 // In Objective-C it is an error to use 'auto' on a function declarator.
1553 if (D.isFunctionDeclarator())
1556 // C++0x [dcl.spec.auto]p2: 'auto' is always fine if the declarator
1557 // contains a trailing return type. That is only legal at the outermost
1558 // level. Check all declarator chunks (outermost first) anyway, to give
1559 // better diagnostics.
1560 if (getLangOptions().CPlusPlus0x && Error != -1) {
1561 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
1562 unsigned chunkIndex = e - i - 1;
1563 state.setCurrentChunkIndex(chunkIndex);
1564 DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex);
1565 if (DeclType.Kind == DeclaratorChunk::Function) {
1566 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
1567 if (FTI.TrailingReturnType) {
1576 Diag(D.getDeclSpec().getTypeSpecTypeLoc(), diag::err_auto_not_allowed)
1579 D.setInvalidType(true);
1584 return Context.getNullTypeSourceInfo();
1586 // The name we're declaring, if any.
1587 DeclarationName Name;
1588 if (D.getIdentifier())
1589 Name = D.getIdentifier();
1591 // Walk the DeclTypeInfo, building the recursive type as we go.
1592 // DeclTypeInfos are ordered from the identifier out, which is
1593 // opposite of what we want :).
1594 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
1595 unsigned chunkIndex = e - i - 1;
1596 state.setCurrentChunkIndex(chunkIndex);
1597 DeclaratorChunk &DeclType = D.getTypeObject(chunkIndex);
1598 switch (DeclType.Kind) {
1599 default: assert(0 && "Unknown decltype!");
1600 case DeclaratorChunk::Paren:
1601 T = BuildParenType(T);
1603 case DeclaratorChunk::BlockPointer:
1604 // If blocks are disabled, emit an error.
1605 if (!LangOpts.Blocks)
1606 Diag(DeclType.Loc, diag::err_blocks_disable);
1608 T = BuildBlockPointerType(T, D.getIdentifierLoc(), Name);
1609 if (DeclType.Cls.TypeQuals)
1610 T = BuildQualifiedType(T, DeclType.Loc, DeclType.Cls.TypeQuals);
1612 case DeclaratorChunk::Pointer:
1613 // Verify that we're not building a pointer to pointer to function with
1614 // exception specification.
1615 if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
1616 Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
1617 D.setInvalidType(true);
1618 // Build the type anyway.
1620 if (getLangOptions().ObjC1 && T->getAs<ObjCObjectType>()) {
1621 T = Context.getObjCObjectPointerType(T);
1622 if (DeclType.Ptr.TypeQuals)
1623 T = BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
1626 T = BuildPointerType(T, DeclType.Loc, Name);
1627 if (DeclType.Ptr.TypeQuals)
1628 T = BuildQualifiedType(T, DeclType.Loc, DeclType.Ptr.TypeQuals);
1631 case DeclaratorChunk::Reference: {
1632 // Verify that we're not building a reference to pointer to function with
1633 // exception specification.
1634 if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
1635 Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
1636 D.setInvalidType(true);
1637 // Build the type anyway.
1639 T = BuildReferenceType(T, DeclType.Ref.LValueRef, DeclType.Loc, Name);
1642 if (DeclType.Ref.HasRestrict)
1643 T = BuildQualifiedType(T, DeclType.Loc, Qualifiers::Restrict);
1646 case DeclaratorChunk::Array: {
1647 // Verify that we're not building an array of pointers to function with
1648 // exception specification.
1649 if (getLangOptions().CPlusPlus && CheckDistantExceptionSpec(T)) {
1650 Diag(D.getIdentifierLoc(), diag::err_distant_exception_spec);
1651 D.setInvalidType(true);
1652 // Build the type anyway.
1654 DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
1655 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
1656 ArrayType::ArraySizeModifier ASM;
1658 ASM = ArrayType::Star;
1659 else if (ATI.hasStatic)
1660 ASM = ArrayType::Static;
1662 ASM = ArrayType::Normal;
1663 if (ASM == ArrayType::Star &&
1664 D.getContext() != Declarator::PrototypeContext) {
1665 // FIXME: This check isn't quite right: it allows star in prototypes
1666 // for function definitions, and disallows some edge cases detailed
1667 // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
1668 Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
1669 ASM = ArrayType::Normal;
1670 D.setInvalidType(true);
1672 T = BuildArrayType(T, ASM, ArraySize,
1673 Qualifiers::fromCVRMask(ATI.TypeQuals),
1674 SourceRange(DeclType.Loc, DeclType.EndLoc), Name);
1677 case DeclaratorChunk::Function: {
1678 // If the function declarator has a prototype (i.e. it is not () and
1679 // does not have a K&R-style identifier list), then the arguments are part
1680 // of the type, otherwise the argument list is ().
1681 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
1683 // Check for auto functions and trailing return type and adjust the
1684 // return type accordingly.
1685 if (!D.isInvalidType()) {
1686 // trailing-return-type is only required if we're declaring a function,
1687 // and not, for instance, a pointer to a function.
1688 if (D.getDeclSpec().getTypeSpecType() == DeclSpec::TST_auto &&
1689 !FTI.TrailingReturnType && chunkIndex == 0) {
1690 Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
1691 diag::err_auto_missing_trailing_return);
1693 D.setInvalidType(true);
1694 } else if (FTI.TrailingReturnType) {
1695 // T must be exactly 'auto' at this point. See CWG issue 681.
1696 if (isa<ParenType>(T)) {
1697 Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
1698 diag::err_trailing_return_in_parens)
1699 << T << D.getDeclSpec().getSourceRange();
1700 D.setInvalidType(true);
1701 } else if (T.hasQualifiers() || !isa<AutoType>(T)) {
1702 Diag(D.getDeclSpec().getTypeSpecTypeLoc(),
1703 diag::err_trailing_return_without_auto)
1704 << T << D.getDeclSpec().getSourceRange();
1705 D.setInvalidType(true);
1708 T = GetTypeFromParser(
1709 ParsedType::getFromOpaquePtr(FTI.TrailingReturnType),
1714 // C99 6.7.5.3p1: The return type may not be a function or array type.
1715 // For conversion functions, we'll diagnose this particular error later.
1716 if ((T->isArrayType() || T->isFunctionType()) &&
1717 (D.getName().getKind() != UnqualifiedId::IK_ConversionFunctionId)) {
1718 unsigned diagID = diag::err_func_returning_array_function;
1719 // Last processing chunk in block context means this function chunk
1720 // represents the block.
1721 if (chunkIndex == 0 &&
1722 D.getContext() == Declarator::BlockLiteralContext)
1723 diagID = diag::err_block_returning_array_function;
1724 Diag(DeclType.Loc, diagID) << T->isFunctionType() << T;
1726 D.setInvalidType(true);
1729 // cv-qualifiers on return types are pointless except when the type is a
1730 // class type in C++.
1731 if (T->isPointerType() && T.getCVRQualifiers() &&
1732 (!getLangOptions().CPlusPlus || !T->isDependentType())) {
1733 assert(chunkIndex + 1 < e && "No DeclaratorChunk for the return type?");
1734 DeclaratorChunk ReturnTypeChunk = D.getTypeObject(chunkIndex + 1);
1735 assert(ReturnTypeChunk.Kind == DeclaratorChunk::Pointer);
1737 DeclaratorChunk::PointerTypeInfo &PTI = ReturnTypeChunk.Ptr;
1739 DiagnoseIgnoredQualifiers(PTI.TypeQuals,
1740 SourceLocation::getFromRawEncoding(PTI.ConstQualLoc),
1741 SourceLocation::getFromRawEncoding(PTI.VolatileQualLoc),
1742 SourceLocation::getFromRawEncoding(PTI.RestrictQualLoc),
1745 } else if (T.getCVRQualifiers() && D.getDeclSpec().getTypeQualifiers() &&
1746 (!getLangOptions().CPlusPlus ||
1747 (!T->isDependentType() && !T->isRecordType()))) {
1749 DiagnoseIgnoredQualifiers(D.getDeclSpec().getTypeQualifiers(),
1750 D.getDeclSpec().getConstSpecLoc(),
1751 D.getDeclSpec().getVolatileSpecLoc(),
1752 D.getDeclSpec().getRestrictSpecLoc(),
1756 if (getLangOptions().CPlusPlus && D.getDeclSpec().isTypeSpecOwned()) {
1758 // Types shall not be defined in return or parameter types.
1759 TagDecl *Tag = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
1760 if (Tag->isDefinition())
1761 Diag(Tag->getLocation(), diag::err_type_defined_in_result_type)
1762 << Context.getTypeDeclType(Tag);
1765 // Exception specs are not allowed in typedefs. Complain, but add it
1767 if (FTI.hasExceptionSpec &&
1768 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
1769 Diag(FTI.getThrowLoc(), diag::err_exception_spec_in_typedef);
1771 if (!FTI.NumArgs && !FTI.isVariadic && !getLangOptions().CPlusPlus) {
1772 // Simple void foo(), where the incoming T is the result type.
1773 T = Context.getFunctionNoProtoType(T);
1775 // We allow a zero-parameter variadic function in C if the
1776 // function is marked with the "overloadable" attribute. Scan
1777 // for this attribute now.
1778 if (!FTI.NumArgs && FTI.isVariadic && !getLangOptions().CPlusPlus) {
1779 bool Overloadable = false;
1780 for (const AttributeList *Attrs = D.getAttributes();
1781 Attrs; Attrs = Attrs->getNext()) {
1782 if (Attrs->getKind() == AttributeList::AT_overloadable) {
1783 Overloadable = true;
1789 Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_arg);
1792 if (FTI.NumArgs && FTI.ArgInfo[0].Param == 0) {
1793 // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function
1795 Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration);
1796 D.setInvalidType(true);
1800 FunctionProtoType::ExtProtoInfo EPI;
1801 EPI.Variadic = FTI.isVariadic;
1802 EPI.TypeQuals = FTI.TypeQuals;
1803 EPI.RefQualifier = !FTI.hasRefQualifier()? RQ_None
1804 : FTI.RefQualifierIsLValueRef? RQ_LValue
1807 // Otherwise, we have a function with an argument list that is
1808 // potentially variadic.
1809 llvm::SmallVector<QualType, 16> ArgTys;
1810 ArgTys.reserve(FTI.NumArgs);
1812 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
1813 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param);
1814 QualType ArgTy = Param->getType();
1815 assert(!ArgTy.isNull() && "Couldn't parse type?");
1817 // Adjust the parameter type.
1818 assert((ArgTy == adjustParameterType(ArgTy)) && "Unadjusted type?");
1820 // Look for 'void'. void is allowed only as a single argument to a
1821 // function with no other parameters (C99 6.7.5.3p10). We record
1822 // int(void) as a FunctionProtoType with an empty argument list.
1823 if (ArgTy->isVoidType()) {
1824 // If this is something like 'float(int, void)', reject it. 'void'
1825 // is an incomplete type (C99 6.2.5p19) and function decls cannot
1826 // have arguments of incomplete type.
1827 if (FTI.NumArgs != 1 || FTI.isVariadic) {
1828 Diag(DeclType.Loc, diag::err_void_only_param);
1829 ArgTy = Context.IntTy;
1830 Param->setType(ArgTy);
1831 } else if (FTI.ArgInfo[i].Ident) {
1832 // Reject, but continue to parse 'int(void abc)'.
1833 Diag(FTI.ArgInfo[i].IdentLoc,
1834 diag::err_param_with_void_type);
1835 ArgTy = Context.IntTy;
1836 Param->setType(ArgTy);
1838 // Reject, but continue to parse 'float(const void)'.
1839 if (ArgTy.hasQualifiers())
1840 Diag(DeclType.Loc, diag::err_void_param_qualified);
1842 // Do not add 'void' to the ArgTys list.
1845 } else if (!FTI.hasPrototype) {
1846 if (ArgTy->isPromotableIntegerType()) {
1847 ArgTy = Context.getPromotedIntegerType(ArgTy);
1848 } else if (const BuiltinType* BTy = ArgTy->getAs<BuiltinType>()) {
1849 if (BTy->getKind() == BuiltinType::Float)
1850 ArgTy = Context.DoubleTy;
1854 ArgTys.push_back(ArgTy);
1857 llvm::SmallVector<QualType, 4> Exceptions;
1858 if (FTI.hasExceptionSpec) {
1859 EPI.HasExceptionSpec = FTI.hasExceptionSpec;
1860 EPI.HasAnyExceptionSpec = FTI.hasAnyExceptionSpec;
1861 Exceptions.reserve(FTI.NumExceptions);
1862 for (unsigned ei = 0, ee = FTI.NumExceptions; ei != ee; ++ei) {
1863 // FIXME: Preserve type source info.
1864 QualType ET = GetTypeFromParser(FTI.Exceptions[ei].Ty);
1865 // Check that the type is valid for an exception spec, and
1867 if (!CheckSpecifiedExceptionType(ET, FTI.Exceptions[ei].Range))
1868 Exceptions.push_back(ET);
1870 EPI.NumExceptions = Exceptions.size();
1871 EPI.Exceptions = Exceptions.data();
1874 T = Context.getFunctionType(T, ArgTys.data(), ArgTys.size(), EPI);
1879 case DeclaratorChunk::MemberPointer:
1880 // The scope spec must refer to a class, or be dependent.
1881 CXXScopeSpec &SS = DeclType.Mem.Scope();
1883 if (SS.isInvalid()) {
1884 // Avoid emitting extra errors if we already errored on the scope.
1885 D.setInvalidType(true);
1886 } else if (isDependentScopeSpecifier(SS) ||
1887 dyn_cast_or_null<CXXRecordDecl>(computeDeclContext(SS))) {
1888 NestedNameSpecifier *NNS
1889 = static_cast<NestedNameSpecifier*>(SS.getScopeRep());
1890 NestedNameSpecifier *NNSPrefix = NNS->getPrefix();
1891 switch (NNS->getKind()) {
1892 case NestedNameSpecifier::Identifier:
1893 ClsType = Context.getDependentNameType(ETK_None, NNSPrefix,
1894 NNS->getAsIdentifier());
1897 case NestedNameSpecifier::Namespace:
1898 case NestedNameSpecifier::NamespaceAlias:
1899 case NestedNameSpecifier::Global:
1900 llvm_unreachable("Nested-name-specifier must name a type");
1903 case NestedNameSpecifier::TypeSpec:
1904 case NestedNameSpecifier::TypeSpecWithTemplate:
1905 ClsType = QualType(NNS->getAsType(), 0);
1906 // Note: if NNS is dependent, then its prefix (if any) is already
1907 // included in ClsType; this does not hold if the NNS is
1908 // nondependent: in this case (if there is indeed a prefix)
1909 // ClsType needs to be wrapped into an elaborated type.
1910 if (NNSPrefix && !NNS->isDependent())
1911 ClsType = Context.getElaboratedType(ETK_None, NNSPrefix, ClsType);
1915 Diag(DeclType.Mem.Scope().getBeginLoc(),
1916 diag::err_illegal_decl_mempointer_in_nonclass)
1917 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
1918 << DeclType.Mem.Scope().getRange();
1919 D.setInvalidType(true);
1922 if (!ClsType.isNull())
1923 T = BuildMemberPointerType(T, ClsType, DeclType.Loc, D.getIdentifier());
1926 D.setInvalidType(true);
1927 } else if (DeclType.Mem.TypeQuals) {
1928 T = BuildQualifiedType(T, DeclType.Loc, DeclType.Mem.TypeQuals);
1934 D.setInvalidType(true);
1938 // See if there are any attributes on this declarator chunk.
1939 if (AttributeList *attrs = const_cast<AttributeList*>(DeclType.getAttrs()))
1940 processTypeAttrs(state, T, false, attrs);
1943 if (getLangOptions().CPlusPlus && T->isFunctionType()) {
1944 const FunctionProtoType *FnTy = T->getAs<FunctionProtoType>();
1945 assert(FnTy && "Why oh why is there not a FunctionProtoType here?");
1948 // A cv-qualifier-seq shall only be part of the function type
1949 // for a nonstatic member function, the function type to which a pointer
1950 // to member refers, or the top-level function type of a function typedef
1953 // Core issue 547 also allows cv-qualifiers on function types that are
1954 // top-level template type arguments.
1956 if (!D.getCXXScopeSpec().isSet()) {
1957 FreeFunction = (D.getContext() != Declarator::MemberContext ||
1958 D.getDeclSpec().isFriendSpecified());
1960 DeclContext *DC = computeDeclContext(D.getCXXScopeSpec());
1961 FreeFunction = (DC && !DC->isRecord());
1964 // C++0x [dcl.fct]p6:
1965 // A ref-qualifier shall only be part of the function type for a
1966 // non-static member function, the function type to which a pointer to
1967 // member refers, or the top-level function type of a function typedef
1969 if ((FnTy->getTypeQuals() != 0 || FnTy->getRefQualifier()) &&
1970 !(D.getContext() == Declarator::TemplateTypeArgContext &&
1971 !D.isFunctionDeclarator()) &&
1972 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
1974 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)) {
1975 if (D.getContext() == Declarator::TemplateTypeArgContext) {
1976 // Accept qualified function types as template type arguments as a GNU
1977 // extension. This is also the subject of C++ core issue 547.
1979 if (FnTy->getTypeQuals() != 0)
1980 Quals = Qualifiers::fromCVRMask(FnTy->getTypeQuals()).getAsString();
1982 switch (FnTy->getRefQualifier()) {
1999 Diag(D.getIdentifierLoc(),
2000 diag::ext_qualified_function_type_template_arg)
2003 if (FnTy->getTypeQuals() != 0) {
2004 if (D.isFunctionDeclarator())
2005 Diag(D.getIdentifierLoc(),
2006 diag::err_invalid_qualified_function_type);
2008 Diag(D.getIdentifierLoc(),
2009 diag::err_invalid_qualified_typedef_function_type_use)
2013 if (FnTy->getRefQualifier()) {
2014 if (D.isFunctionDeclarator()) {
2015 SourceLocation Loc = D.getIdentifierLoc();
2016 for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {
2017 const DeclaratorChunk &Chunk = D.getTypeObject(N-I-1);
2018 if (Chunk.Kind == DeclaratorChunk::Function &&
2019 Chunk.Fun.hasRefQualifier()) {
2020 Loc = Chunk.Fun.getRefQualifierLoc();
2025 Diag(Loc, diag::err_invalid_ref_qualifier_function_type)
2026 << (FnTy->getRefQualifier() == RQ_LValue)
2027 << FixItHint::CreateRemoval(Loc);
2029 Diag(D.getIdentifierLoc(),
2030 diag::err_invalid_ref_qualifier_typedef_function_type_use)
2032 << (FnTy->getRefQualifier() == RQ_LValue);
2036 // Strip the cv-qualifiers and ref-qualifiers from the type.
2037 FunctionProtoType::ExtProtoInfo EPI = FnTy->getExtProtoInfo();
2039 EPI.RefQualifier = RQ_None;
2041 T = Context.getFunctionType(FnTy->getResultType(),
2042 FnTy->arg_type_begin(),
2043 FnTy->getNumArgs(), EPI);
2048 // Apply any undistributed attributes from the declarator.
2050 if (AttributeList *attrs = D.getAttributes())
2051 processTypeAttrs(state, T, false, attrs);
2053 // Diagnose any ignored type attributes.
2054 if (!T.isNull()) state.diagnoseIgnoredTypeAttrs(T);
2056 // If there's a constexpr specifier, treat it as a top-level const.
2057 if (D.getDeclSpec().isConstexprSpecified()) {
2061 // If there was an ellipsis in the declarator, the declaration declares a
2062 // parameter pack whose type may be a pack expansion type.
2063 if (D.hasEllipsis() && !T.isNull()) {
2064 // C++0x [dcl.fct]p13:
2065 // A declarator-id or abstract-declarator containing an ellipsis shall
2066 // only be used in a parameter-declaration. Such a parameter-declaration
2067 // is a parameter pack (14.5.3). [...]
2068 switch (D.getContext()) {
2069 case Declarator::PrototypeContext:
2070 // C++0x [dcl.fct]p13:
2071 // [...] When it is part of a parameter-declaration-clause, the
2072 // parameter pack is a function parameter pack (14.5.3). The type T
2073 // of the declarator-id of the function parameter pack shall contain
2074 // a template parameter pack; each template parameter pack in T is
2075 // expanded by the function parameter pack.
2077 // We represent function parameter packs as function parameters whose
2078 // type is a pack expansion.
2079 if (!T->containsUnexpandedParameterPack()) {
2080 Diag(D.getEllipsisLoc(),
2081 diag::err_function_parameter_pack_without_parameter_packs)
2082 << T << D.getSourceRange();
2083 D.setEllipsisLoc(SourceLocation());
2085 T = Context.getPackExpansionType(T, llvm::Optional<unsigned>());
2089 case Declarator::TemplateParamContext:
2090 // C++0x [temp.param]p15:
2091 // If a template-parameter is a [...] is a parameter-declaration that
2092 // declares a parameter pack (8.3.5), then the template-parameter is a
2093 // template parameter pack (14.5.3).
2095 // Note: core issue 778 clarifies that, if there are any unexpanded
2096 // parameter packs in the type of the non-type template parameter, then
2097 // it expands those parameter packs.
2098 if (T->containsUnexpandedParameterPack())
2099 T = Context.getPackExpansionType(T, llvm::Optional<unsigned>());
2100 else if (!getLangOptions().CPlusPlus0x)
2101 Diag(D.getEllipsisLoc(), diag::ext_variadic_templates);
2104 case Declarator::FileContext:
2105 case Declarator::KNRTypeListContext:
2106 case Declarator::TypeNameContext:
2107 case Declarator::MemberContext:
2108 case Declarator::BlockContext:
2109 case Declarator::ForContext:
2110 case Declarator::ConditionContext:
2111 case Declarator::CXXCatchContext:
2112 case Declarator::BlockLiteralContext:
2113 case Declarator::TemplateTypeArgContext:
2114 // FIXME: We may want to allow parameter packs in block-literal contexts
2116 Diag(D.getEllipsisLoc(), diag::err_ellipsis_in_declarator_not_parameter);
2117 D.setEllipsisLoc(SourceLocation());
2123 return Context.getNullTypeSourceInfo();
2124 else if (D.isInvalidType())
2125 return Context.getTrivialTypeSourceInfo(T);
2126 return GetTypeSourceInfoForDeclarator(D, T, ReturnTypeInfo);
2130 class TypeSpecLocFiller : public TypeLocVisitor<TypeSpecLocFiller> {
2131 ASTContext &Context;
2135 TypeSpecLocFiller(ASTContext &Context, const DeclSpec &DS)
2136 : Context(Context), DS(DS) {}
2138 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
2139 Visit(TL.getUnqualifiedLoc());
2141 void VisitTypedefTypeLoc(TypedefTypeLoc TL) {
2142 TL.setNameLoc(DS.getTypeSpecTypeLoc());
2144 void VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
2145 TL.setNameLoc(DS.getTypeSpecTypeLoc());
2147 void VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
2148 // Handle the base type, which might not have been written explicitly.
2149 if (DS.getTypeSpecType() == DeclSpec::TST_unspecified) {
2150 TL.setHasBaseTypeAsWritten(false);
2151 TL.getBaseLoc().initialize(Context, SourceLocation());
2153 TL.setHasBaseTypeAsWritten(true);
2154 Visit(TL.getBaseLoc());
2157 // Protocol qualifiers.
2158 if (DS.getProtocolQualifiers()) {
2159 assert(TL.getNumProtocols() > 0);
2160 assert(TL.getNumProtocols() == DS.getNumProtocolQualifiers());
2161 TL.setLAngleLoc(DS.getProtocolLAngleLoc());
2162 TL.setRAngleLoc(DS.getSourceRange().getEnd());
2163 for (unsigned i = 0, e = DS.getNumProtocolQualifiers(); i != e; ++i)
2164 TL.setProtocolLoc(i, DS.getProtocolLocs()[i]);
2166 assert(TL.getNumProtocols() == 0);
2167 TL.setLAngleLoc(SourceLocation());
2168 TL.setRAngleLoc(SourceLocation());
2171 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
2172 TL.setStarLoc(SourceLocation());
2173 Visit(TL.getPointeeLoc());
2175 void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
2176 TypeSourceInfo *TInfo = 0;
2177 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
2179 // If we got no declarator info from previous Sema routines,
2180 // just fill with the typespec loc.
2182 TL.initialize(Context, DS.getTypeSpecTypeLoc());
2186 TypeLoc OldTL = TInfo->getTypeLoc();
2187 if (TInfo->getType()->getAs<ElaboratedType>()) {
2188 ElaboratedTypeLoc ElabTL = cast<ElaboratedTypeLoc>(OldTL);
2189 TemplateSpecializationTypeLoc NamedTL =
2190 cast<TemplateSpecializationTypeLoc>(ElabTL.getNamedTypeLoc());
2194 TL.copy(cast<TemplateSpecializationTypeLoc>(OldTL));
2196 void VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
2197 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofExpr);
2198 TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
2199 TL.setParensRange(DS.getTypeofParensRange());
2201 void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
2202 assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType);
2203 TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
2204 TL.setParensRange(DS.getTypeofParensRange());
2205 assert(DS.getRepAsType());
2206 TypeSourceInfo *TInfo = 0;
2207 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
2208 TL.setUnderlyingTInfo(TInfo);
2210 void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
2211 // By default, use the source location of the type specifier.
2212 TL.setBuiltinLoc(DS.getTypeSpecTypeLoc());
2213 if (TL.needsExtraLocalData()) {
2214 // Set info for the written builtin specifiers.
2215 TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs();
2216 // Try to have a meaningful source location.
2217 if (TL.getWrittenSignSpec() != TSS_unspecified)
2218 // Sign spec loc overrides the others (e.g., 'unsigned long').
2219 TL.setBuiltinLoc(DS.getTypeSpecSignLoc());
2220 else if (TL.getWrittenWidthSpec() != TSW_unspecified)
2221 // Width spec loc overrides type spec loc (e.g., 'short int').
2222 TL.setBuiltinLoc(DS.getTypeSpecWidthLoc());
2225 void VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
2226 ElaboratedTypeKeyword Keyword
2227 = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType());
2228 if (DS.getTypeSpecType() == TST_typename) {
2229 TypeSourceInfo *TInfo = 0;
2230 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
2232 TL.copy(cast<ElaboratedTypeLoc>(TInfo->getTypeLoc()));
2236 TL.setKeywordLoc(Keyword != ETK_None
2237 ? DS.getTypeSpecTypeLoc()
2238 : SourceLocation());
2239 const CXXScopeSpec& SS = DS.getTypeSpecScope();
2240 TL.setQualifierRange(SS.isEmpty() ? SourceRange(): SS.getRange());
2241 Visit(TL.getNextTypeLoc().getUnqualifiedLoc());
2243 void VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
2244 ElaboratedTypeKeyword Keyword
2245 = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType());
2246 if (DS.getTypeSpecType() == TST_typename) {
2247 TypeSourceInfo *TInfo = 0;
2248 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
2250 TL.copy(cast<DependentNameTypeLoc>(TInfo->getTypeLoc()));
2254 TL.setKeywordLoc(Keyword != ETK_None
2255 ? DS.getTypeSpecTypeLoc()
2256 : SourceLocation());
2257 const CXXScopeSpec& SS = DS.getTypeSpecScope();
2258 TL.setQualifierRange(SS.isEmpty() ? SourceRange() : SS.getRange());
2259 // FIXME: load appropriate source location.
2260 TL.setNameLoc(DS.getTypeSpecTypeLoc());
2262 void VisitDependentTemplateSpecializationTypeLoc(
2263 DependentTemplateSpecializationTypeLoc TL) {
2264 ElaboratedTypeKeyword Keyword
2265 = TypeWithKeyword::getKeywordForTypeSpec(DS.getTypeSpecType());
2266 if (Keyword == ETK_Typename) {
2267 TypeSourceInfo *TInfo = 0;
2268 Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
2270 TL.copy(cast<DependentTemplateSpecializationTypeLoc>(
2271 TInfo->getTypeLoc()));
2275 TL.initializeLocal(Context, SourceLocation());
2276 TL.setKeywordLoc(Keyword != ETK_None
2277 ? DS.getTypeSpecTypeLoc()
2278 : SourceLocation());
2279 const CXXScopeSpec& SS = DS.getTypeSpecScope();
2280 TL.setQualifierRange(SS.isEmpty() ? SourceRange() : SS.getRange());
2281 // FIXME: load appropriate source location.
2282 TL.setNameLoc(DS.getTypeSpecTypeLoc());
2285 void VisitTypeLoc(TypeLoc TL) {
2286 // FIXME: add other typespec types and change this to an assert.
2287 TL.initialize(Context, DS.getTypeSpecTypeLoc());
2291 class DeclaratorLocFiller : public TypeLocVisitor<DeclaratorLocFiller> {
2292 const DeclaratorChunk &Chunk;
2295 DeclaratorLocFiller(const DeclaratorChunk &Chunk) : Chunk(Chunk) {}
2297 void VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
2298 llvm_unreachable("qualified type locs not expected here!");
2301 void VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
2302 assert(Chunk.Kind == DeclaratorChunk::BlockPointer);
2303 TL.setCaretLoc(Chunk.Loc);
2305 void VisitPointerTypeLoc(PointerTypeLoc TL) {
2306 assert(Chunk.Kind == DeclaratorChunk::Pointer);
2307 TL.setStarLoc(Chunk.Loc);
2309 void VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
2310 assert(Chunk.Kind == DeclaratorChunk::Pointer);
2311 TL.setStarLoc(Chunk.Loc);
2313 void VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
2314 assert(Chunk.Kind == DeclaratorChunk::MemberPointer);
2315 TL.setStarLoc(Chunk.Loc);
2316 // FIXME: nested name specifier
2318 void VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
2319 assert(Chunk.Kind == DeclaratorChunk::Reference);
2320 // 'Amp' is misleading: this might have been originally
2321 /// spelled with AmpAmp.
2322 TL.setAmpLoc(Chunk.Loc);
2324 void VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
2325 assert(Chunk.Kind == DeclaratorChunk::Reference);
2326 assert(!Chunk.Ref.LValueRef);
2327 TL.setAmpAmpLoc(Chunk.Loc);
2329 void VisitArrayTypeLoc(ArrayTypeLoc TL) {
2330 assert(Chunk.Kind == DeclaratorChunk::Array);
2331 TL.setLBracketLoc(Chunk.Loc);
2332 TL.setRBracketLoc(Chunk.EndLoc);
2333 TL.setSizeExpr(static_cast<Expr*>(Chunk.Arr.NumElts));
2335 void VisitFunctionTypeLoc(FunctionTypeLoc TL) {
2336 assert(Chunk.Kind == DeclaratorChunk::Function);
2337 TL.setLParenLoc(Chunk.Loc);
2338 TL.setRParenLoc(Chunk.EndLoc);
2339 TL.setTrailingReturn(!!Chunk.Fun.TrailingReturnType);
2341 const DeclaratorChunk::FunctionTypeInfo &FTI = Chunk.Fun;
2342 for (unsigned i = 0, e = TL.getNumArgs(), tpi = 0; i != e; ++i) {
2343 ParmVarDecl *Param = cast<ParmVarDecl>(FTI.ArgInfo[i].Param);
2344 TL.setArg(tpi++, Param);
2346 // FIXME: exception specs
2348 void VisitParenTypeLoc(ParenTypeLoc TL) {
2349 assert(Chunk.Kind == DeclaratorChunk::Paren);
2350 TL.setLParenLoc(Chunk.Loc);
2351 TL.setRParenLoc(Chunk.EndLoc);
2354 void VisitTypeLoc(TypeLoc TL) {
2355 llvm_unreachable("unsupported TypeLoc kind in declarator!");
2360 /// \brief Create and instantiate a TypeSourceInfo with type source information.
2362 /// \param T QualType referring to the type as written in source code.
2364 /// \param ReturnTypeInfo For declarators whose return type does not show
2365 /// up in the normal place in the declaration specifiers (such as a C++
2366 /// conversion function), this pointer will refer to a type source information
2367 /// for that return type.
2369 Sema::GetTypeSourceInfoForDeclarator(Declarator &D, QualType T,
2370 TypeSourceInfo *ReturnTypeInfo) {
2371 TypeSourceInfo *TInfo = Context.CreateTypeSourceInfo(T);
2372 UnqualTypeLoc CurrTL = TInfo->getTypeLoc().getUnqualifiedLoc();
2374 // Handle parameter packs whose type is a pack expansion.
2375 if (isa<PackExpansionType>(T)) {
2376 cast<PackExpansionTypeLoc>(CurrTL).setEllipsisLoc(D.getEllipsisLoc());
2377 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
2380 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
2381 DeclaratorLocFiller(D.getTypeObject(i)).Visit(CurrTL);
2382 CurrTL = CurrTL.getNextTypeLoc().getUnqualifiedLoc();
2385 // If we have different source information for the return type, use
2386 // that. This really only applies to C++ conversion functions.
2387 if (ReturnTypeInfo) {
2388 TypeLoc TL = ReturnTypeInfo->getTypeLoc();
2389 assert(TL.getFullDataSize() == CurrTL.getFullDataSize());
2390 memcpy(CurrTL.getOpaqueData(), TL.getOpaqueData(), TL.getFullDataSize());
2392 TypeSpecLocFiller(Context, D.getDeclSpec()).Visit(CurrTL);
2398 /// \brief Create a LocInfoType to hold the given QualType and TypeSourceInfo.
2399 ParsedType Sema::CreateParsedType(QualType T, TypeSourceInfo *TInfo) {
2400 // FIXME: LocInfoTypes are "transient", only needed for passing to/from Parser
2401 // and Sema during declaration parsing. Try deallocating/caching them when
2402 // it's appropriate, instead of allocating them and keeping them around.
2403 LocInfoType *LocT = (LocInfoType*)BumpAlloc.Allocate(sizeof(LocInfoType),
2405 new (LocT) LocInfoType(T, TInfo);
2406 assert(LocT->getTypeClass() != T->getTypeClass() &&
2407 "LocInfoType's TypeClass conflicts with an existing Type class");
2408 return ParsedType::make(QualType(LocT, 0));
2411 void LocInfoType::getAsStringInternal(std::string &Str,
2412 const PrintingPolicy &Policy) const {
2413 assert(false && "LocInfoType leaked into the type system; an opaque TypeTy*"
2414 " was used directly instead of getting the QualType through"
2415 " GetTypeFromParser");
2418 TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
2419 // C99 6.7.6: Type names have no identifier. This is already validated by
2421 assert(D.getIdentifier() == 0 && "Type name should have no identifier!");
2423 TagDecl *OwnedTag = 0;
2424 TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S, &OwnedTag);
2425 QualType T = TInfo->getType();
2426 if (D.isInvalidType())
2429 if (getLangOptions().CPlusPlus) {
2430 // Check that there are no default arguments (C++ only).
2431 CheckExtraCXXDefaultArguments(D);
2433 // C++0x [dcl.type]p3:
2434 // A type-specifier-seq shall not define a class or enumeration
2435 // unless it appears in the type-id of an alias-declaration
2437 if (OwnedTag && OwnedTag->isDefinition())
2438 Diag(OwnedTag->getLocation(), diag::err_type_defined_in_type_specifier)
2439 << Context.getTypeDeclType(OwnedTag);
2442 return CreateParsedType(T, TInfo);
2447 //===----------------------------------------------------------------------===//
2448 // Type Attribute Processing
2449 //===----------------------------------------------------------------------===//
2451 /// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
2452 /// specified type. The attribute contains 1 argument, the id of the address
2453 /// space for the type.
2454 static void HandleAddressSpaceTypeAttribute(QualType &Type,
2455 const AttributeList &Attr, Sema &S){
2457 // If this type is already address space qualified, reject it.
2458 // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers
2459 // for two or more different address spaces."
2460 if (Type.getAddressSpace()) {
2461 S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers);
2466 // Check the attribute arguments.
2467 if (Attr.getNumArgs() != 1) {
2468 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2472 Expr *ASArgExpr = static_cast<Expr *>(Attr.getArg(0));
2473 llvm::APSInt addrSpace(32);
2474 if (ASArgExpr->isTypeDependent() || ASArgExpr->isValueDependent() ||
2475 !ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
2476 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_not_int)
2477 << ASArgExpr->getSourceRange();
2483 if (addrSpace.isSigned()) {
2484 if (addrSpace.isNegative()) {
2485 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_negative)
2486 << ASArgExpr->getSourceRange();
2490 addrSpace.setIsSigned(false);
2492 llvm::APSInt max(addrSpace.getBitWidth());
2493 max = Qualifiers::MaxAddressSpace;
2494 if (addrSpace > max) {
2495 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_too_high)
2496 << Qualifiers::MaxAddressSpace << ASArgExpr->getSourceRange();
2501 unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
2502 Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
2505 /// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type
2506 /// attribute on the specified type. Returns true to indicate that
2507 /// the attribute was handled, false to indicate that the type does
2508 /// not permit the attribute.
2509 static bool handleObjCGCTypeAttr(TypeProcessingState &state,
2510 AttributeList &attr,
2512 Sema &S = state.getSema();
2514 // Delay if this isn't some kind of pointer.
2515 if (!type->isPointerType() &&
2516 !type->isObjCObjectPointerType() &&
2517 !type->isBlockPointerType())
2520 if (type.getObjCGCAttr() != Qualifiers::GCNone) {
2521 S.Diag(attr.getLoc(), diag::err_attribute_multiple_objc_gc);
2526 // Check the attribute arguments.
2527 if (!attr.getParameterName()) {
2528 S.Diag(attr.getLoc(), diag::err_attribute_argument_n_not_string)
2533 Qualifiers::GC GCAttr;
2534 if (attr.getNumArgs() != 0) {
2535 S.Diag(attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2539 if (attr.getParameterName()->isStr("weak"))
2540 GCAttr = Qualifiers::Weak;
2541 else if (attr.getParameterName()->isStr("strong"))
2542 GCAttr = Qualifiers::Strong;
2544 S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported)
2545 << "objc_gc" << attr.getParameterName();
2550 type = S.Context.getObjCGCQualType(type, GCAttr);
2555 /// A helper class to unwrap a type down to a function for the
2556 /// purposes of applying attributes there.
2559 /// FunctionTypeUnwrapper unwrapped(SemaRef, T);
2560 /// if (unwrapped.isFunctionType()) {
2561 /// const FunctionType *fn = unwrapped.get();
2562 /// // change fn somehow
2563 /// T = unwrapped.wrap(fn);
2565 struct FunctionTypeUnwrapper {
2576 const FunctionType *Fn;
2577 llvm::SmallVector<unsigned char /*WrapKind*/, 8> Stack;
2579 FunctionTypeUnwrapper(Sema &S, QualType T) : Original(T) {
2581 const Type *Ty = T.getTypePtr();
2582 if (isa<FunctionType>(Ty)) {
2583 Fn = cast<FunctionType>(Ty);
2585 } else if (isa<ParenType>(Ty)) {
2586 T = cast<ParenType>(Ty)->getInnerType();
2587 Stack.push_back(Parens);
2588 } else if (isa<PointerType>(Ty)) {
2589 T = cast<PointerType>(Ty)->getPointeeType();
2590 Stack.push_back(Pointer);
2591 } else if (isa<BlockPointerType>(Ty)) {
2592 T = cast<BlockPointerType>(Ty)->getPointeeType();
2593 Stack.push_back(BlockPointer);
2594 } else if (isa<MemberPointerType>(Ty)) {
2595 T = cast<MemberPointerType>(Ty)->getPointeeType();
2596 Stack.push_back(MemberPointer);
2597 } else if (isa<ReferenceType>(Ty)) {
2598 T = cast<ReferenceType>(Ty)->getPointeeType();
2599 Stack.push_back(Reference);
2601 const Type *DTy = Ty->getUnqualifiedDesugaredType();
2607 T = QualType(DTy, 0);
2608 Stack.push_back(Desugar);
2613 bool isFunctionType() const { return (Fn != 0); }
2614 const FunctionType *get() const { return Fn; }
2616 QualType wrap(Sema &S, const FunctionType *New) {
2617 // If T wasn't modified from the unwrapped type, do nothing.
2618 if (New == get()) return Original;
2621 return wrap(S.Context, Original, 0);
2625 QualType wrap(ASTContext &C, QualType Old, unsigned I) {
2626 if (I == Stack.size())
2627 return C.getQualifiedType(Fn, Old.getQualifiers());
2629 // Build up the inner type, applying the qualifiers from the old
2630 // type to the new type.
2631 SplitQualType SplitOld = Old.split();
2633 // As a special case, tail-recurse if there are no qualifiers.
2634 if (SplitOld.second.empty())
2635 return wrap(C, SplitOld.first, I);
2636 return C.getQualifiedType(wrap(C, SplitOld.first, I), SplitOld.second);
2639 QualType wrap(ASTContext &C, const Type *Old, unsigned I) {
2640 if (I == Stack.size()) return QualType(Fn, 0);
2642 switch (static_cast<WrapKind>(Stack[I++])) {
2644 // This is the point at which we potentially lose source
2646 return wrap(C, Old->getUnqualifiedDesugaredType(), I);
2649 QualType New = wrap(C, cast<ParenType>(Old)->getInnerType(), I);
2650 return C.getParenType(New);
2654 QualType New = wrap(C, cast<PointerType>(Old)->getPointeeType(), I);
2655 return C.getPointerType(New);
2658 case BlockPointer: {
2659 QualType New = wrap(C, cast<BlockPointerType>(Old)->getPointeeType(),I);
2660 return C.getBlockPointerType(New);
2663 case MemberPointer: {
2664 const MemberPointerType *OldMPT = cast<MemberPointerType>(Old);
2665 QualType New = wrap(C, OldMPT->getPointeeType(), I);
2666 return C.getMemberPointerType(New, OldMPT->getClass());
2670 const ReferenceType *OldRef = cast<ReferenceType>(Old);
2671 QualType New = wrap(C, OldRef->getPointeeType(), I);
2672 if (isa<LValueReferenceType>(OldRef))
2673 return C.getLValueReferenceType(New, OldRef->isSpelledAsLValue());
2675 return C.getRValueReferenceType(New);
2679 llvm_unreachable("unknown wrapping kind");
2685 /// Process an individual function attribute. Returns true to
2686 /// indicate that the attribute was handled, false if it wasn't.
2687 static bool handleFunctionTypeAttr(TypeProcessingState &state,
2688 AttributeList &attr,
2690 Sema &S = state.getSema();
2692 FunctionTypeUnwrapper unwrapped(S, type);
2694 if (attr.getKind() == AttributeList::AT_noreturn) {
2695 if (S.CheckNoReturnAttr(attr))
2698 // Delay if this is not a function type.
2699 if (!unwrapped.isFunctionType())
2702 // Otherwise we can process right away.
2703 FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withNoReturn(true);
2704 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
2708 if (attr.getKind() == AttributeList::AT_regparm) {
2710 if (S.CheckRegparmAttr(attr, value))
2713 // Delay if this is not a function type.
2714 if (!unwrapped.isFunctionType())
2717 // Diagnose regparm with fastcall.
2718 const FunctionType *fn = unwrapped.get();
2719 CallingConv CC = fn->getCallConv();
2720 if (CC == CC_X86FastCall) {
2721 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
2722 << FunctionType::getNameForCallConv(CC)
2728 FunctionType::ExtInfo EI =
2729 unwrapped.get()->getExtInfo().withRegParm(value);
2730 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
2734 // Otherwise, a calling convention.
2736 if (S.CheckCallingConvAttr(attr, CC))
2739 // Delay if the type didn't work out to a function.
2740 if (!unwrapped.isFunctionType()) return false;
2742 const FunctionType *fn = unwrapped.get();
2743 CallingConv CCOld = fn->getCallConv();
2744 if (S.Context.getCanonicalCallConv(CC) ==
2745 S.Context.getCanonicalCallConv(CCOld)) {
2746 FunctionType::ExtInfo EI= unwrapped.get()->getExtInfo().withCallingConv(CC);
2747 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
2751 if (CCOld != CC_Default) {
2752 // Should we diagnose reapplications of the same convention?
2753 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
2754 << FunctionType::getNameForCallConv(CC)
2755 << FunctionType::getNameForCallConv(CCOld);
2760 // Diagnose the use of X86 fastcall on varargs or unprototyped functions.
2761 if (CC == CC_X86FastCall) {
2762 if (isa<FunctionNoProtoType>(fn)) {
2763 S.Diag(attr.getLoc(), diag::err_cconv_knr)
2764 << FunctionType::getNameForCallConv(CC);
2769 const FunctionProtoType *FnP = cast<FunctionProtoType>(fn);
2770 if (FnP->isVariadic()) {
2771 S.Diag(attr.getLoc(), diag::err_cconv_varargs)
2772 << FunctionType::getNameForCallConv(CC);
2777 // Also diagnose fastcall with regparm.
2778 if (fn->getRegParmType()) {
2779 S.Diag(attr.getLoc(), diag::err_attributes_are_not_compatible)
2781 << FunctionType::getNameForCallConv(CC);
2787 FunctionType::ExtInfo EI = unwrapped.get()->getExtInfo().withCallingConv(CC);
2788 type = unwrapped.wrap(S, S.Context.adjustFunctionType(unwrapped.get(), EI));
2792 /// HandleVectorSizeAttribute - this attribute is only applicable to integral
2793 /// and float scalars, although arrays, pointers, and function return values are
2794 /// allowed in conjunction with this construct. Aggregates with this attribute
2795 /// are invalid, even if they are of the same size as a corresponding scalar.
2796 /// The raw attribute should contain precisely 1 argument, the vector size for
2797 /// the variable, measured in bytes. If curType and rawAttr are well formed,
2798 /// this routine will return a new vector type.
2799 static void HandleVectorSizeAttr(QualType& CurType, const AttributeList &Attr,
2801 // Check the attribute arguments.
2802 if (Attr.getNumArgs() != 1) {
2803 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2807 Expr *sizeExpr = static_cast<Expr *>(Attr.getArg(0));
2808 llvm::APSInt vecSize(32);
2809 if (sizeExpr->isTypeDependent() || sizeExpr->isValueDependent() ||
2810 !sizeExpr->isIntegerConstantExpr(vecSize, S.Context)) {
2811 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2812 << "vector_size" << sizeExpr->getSourceRange();
2816 // the base type must be integer or float, and can't already be a vector.
2817 if (!CurType->isIntegerType() && !CurType->isRealFloatingType()) {
2818 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) << CurType;
2822 unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
2823 // vecSize is specified in bytes - convert to bits.
2824 unsigned vectorSize = static_cast<unsigned>(vecSize.getZExtValue() * 8);
2826 // the vector size needs to be an integral multiple of the type size.
2827 if (vectorSize % typeSize) {
2828 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_size)
2829 << sizeExpr->getSourceRange();
2833 if (vectorSize == 0) {
2834 S.Diag(Attr.getLoc(), diag::err_attribute_zero_size)
2835 << sizeExpr->getSourceRange();
2840 // Success! Instantiate the vector type, the number of elements is > 0, and
2841 // not required to be a power of 2, unlike GCC.
2842 CurType = S.Context.getVectorType(CurType, vectorSize/typeSize,
2843 VectorType::GenericVector);
2846 /// HandleNeonVectorTypeAttr - The "neon_vector_type" and
2847 /// "neon_polyvector_type" attributes are used to create vector types that
2848 /// are mangled according to ARM's ABI. Otherwise, these types are identical
2849 /// to those created with the "vector_size" attribute. Unlike "vector_size"
2850 /// the argument to these Neon attributes is the number of vector elements,
2851 /// not the vector size in bytes. The vector width and element type must
2852 /// match one of the standard Neon vector types.
2853 static void HandleNeonVectorTypeAttr(QualType& CurType,
2854 const AttributeList &Attr, Sema &S,
2855 VectorType::VectorKind VecKind,
2856 const char *AttrName) {
2857 // Check the attribute arguments.
2858 if (Attr.getNumArgs() != 1) {
2859 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
2863 // The number of elements must be an ICE.
2864 Expr *numEltsExpr = static_cast<Expr *>(Attr.getArg(0));
2865 llvm::APSInt numEltsInt(32);
2866 if (numEltsExpr->isTypeDependent() || numEltsExpr->isValueDependent() ||
2867 !numEltsExpr->isIntegerConstantExpr(numEltsInt, S.Context)) {
2868 S.Diag(Attr.getLoc(), diag::err_attribute_argument_not_int)
2869 << AttrName << numEltsExpr->getSourceRange();
2873 // Only certain element types are supported for Neon vectors.
2874 const BuiltinType* BTy = CurType->getAs<BuiltinType>();
2876 (VecKind == VectorType::NeonPolyVector &&
2877 BTy->getKind() != BuiltinType::SChar &&
2878 BTy->getKind() != BuiltinType::Short) ||
2879 (BTy->getKind() != BuiltinType::SChar &&
2880 BTy->getKind() != BuiltinType::UChar &&
2881 BTy->getKind() != BuiltinType::Short &&
2882 BTy->getKind() != BuiltinType::UShort &&
2883 BTy->getKind() != BuiltinType::Int &&
2884 BTy->getKind() != BuiltinType::UInt &&
2885 BTy->getKind() != BuiltinType::LongLong &&
2886 BTy->getKind() != BuiltinType::ULongLong &&
2887 BTy->getKind() != BuiltinType::Float)) {
2888 S.Diag(Attr.getLoc(), diag::err_attribute_invalid_vector_type) <<CurType;
2892 // The total size of the vector must be 64 or 128 bits.
2893 unsigned typeSize = static_cast<unsigned>(S.Context.getTypeSize(CurType));
2894 unsigned numElts = static_cast<unsigned>(numEltsInt.getZExtValue());
2895 unsigned vecSize = typeSize * numElts;
2896 if (vecSize != 64 && vecSize != 128) {
2897 S.Diag(Attr.getLoc(), diag::err_attribute_bad_neon_vector_size) << CurType;
2902 CurType = S.Context.getVectorType(CurType, numElts, VecKind);
2905 static void processTypeAttrs(TypeProcessingState &state, QualType &type,
2906 bool isDeclSpec, AttributeList *attrs) {
2907 // Scan through and apply attributes to this type where it makes sense. Some
2908 // attributes (such as __address_space__, __vector_size__, etc) apply to the
2909 // type, but others can be present in the type specifiers even though they
2910 // apply to the decl. Here we apply type attributes and ignore the rest.
2912 AttributeList *next;
2914 AttributeList &attr = *attrs;
2915 next = attr.getNext();
2917 // Skip attributes that were marked to be invalid.
2918 if (attr.isInvalid())
2921 // If this is an attribute we can handle, do so now,
2922 // otherwise, add it to the FnAttrs list for rechaining.
2923 switch (attr.getKind()) {
2926 case AttributeList::AT_address_space:
2927 HandleAddressSpaceTypeAttribute(type, attr, state.getSema());
2929 OBJC_POINTER_TYPE_ATTRS_CASELIST:
2930 if (!handleObjCPointerTypeAttr(state, attr, type))
2931 distributeObjCPointerTypeAttr(state, attr, type);
2933 case AttributeList::AT_vector_size:
2934 HandleVectorSizeAttr(type, attr, state.getSema());
2936 case AttributeList::AT_neon_vector_type:
2937 HandleNeonVectorTypeAttr(type, attr, state.getSema(),
2938 VectorType::NeonVector, "neon_vector_type");
2940 case AttributeList::AT_neon_polyvector_type:
2941 HandleNeonVectorTypeAttr(type, attr, state.getSema(),
2942 VectorType::NeonPolyVector,
2943 "neon_polyvector_type");
2946 FUNCTION_TYPE_ATTRS_CASELIST:
2947 // Never process function type attributes as part of the
2948 // declaration-specifiers.
2950 distributeFunctionTypeAttrFromDeclSpec(state, attr, type);
2952 // Otherwise, handle the possible delays.
2953 else if (!handleFunctionTypeAttr(state, attr, type))
2954 distributeFunctionTypeAttr(state, attr, type);
2957 } while ((attrs = next));
2960 /// @brief Ensure that the type T is a complete type.
2962 /// This routine checks whether the type @p T is complete in any
2963 /// context where a complete type is required. If @p T is a complete
2964 /// type, returns false. If @p T is a class template specialization,
2965 /// this routine then attempts to perform class template
2966 /// instantiation. If instantiation fails, or if @p T is incomplete
2967 /// and cannot be completed, issues the diagnostic @p diag (giving it
2968 /// the type @p T) and returns true.
2970 /// @param Loc The location in the source that the incomplete type
2971 /// diagnostic should refer to.
2973 /// @param T The type that this routine is examining for completeness.
2975 /// @param PD The partial diagnostic that will be printed out if T is not a
2978 /// @returns @c true if @p T is incomplete and a diagnostic was emitted,
2979 /// @c false otherwise.
2980 bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
2981 const PartialDiagnostic &PD,
2982 std::pair<SourceLocation,
2983 PartialDiagnostic> Note) {
2984 unsigned diag = PD.getDiagID();
2986 // FIXME: Add this assertion to make sure we always get instantiation points.
2987 // assert(!Loc.isInvalid() && "Invalid location in RequireCompleteType");
2988 // FIXME: Add this assertion to help us flush out problems with
2989 // checking for dependent types and type-dependent expressions.
2991 // assert(!T->isDependentType() &&
2992 // "Can't ask whether a dependent type is complete");
2994 // If we have a complete type, we're done.
2995 if (!T->isIncompleteType())
2998 // If we have a class template specialization or a class member of a
2999 // class template specialization, or an array with known size of such,
3000 // try to instantiate it.
3001 QualType MaybeTemplate = T;
3002 if (const ConstantArrayType *Array = Context.getAsConstantArrayType(T))
3003 MaybeTemplate = Array->getElementType();
3004 if (const RecordType *Record = MaybeTemplate->getAs<RecordType>()) {
3005 if (ClassTemplateSpecializationDecl *ClassTemplateSpec
3006 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
3007 if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared)
3008 return InstantiateClassTemplateSpecialization(Loc, ClassTemplateSpec,
3009 TSK_ImplicitInstantiation,
3010 /*Complain=*/diag != 0);
3011 } else if (CXXRecordDecl *Rec
3012 = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
3013 if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) {
3014 MemberSpecializationInfo *MSInfo = Rec->getMemberSpecializationInfo();
3015 assert(MSInfo && "Missing member specialization information?");
3016 // This record was instantiated from a class within a template.
3017 if (MSInfo->getTemplateSpecializationKind()
3018 != TSK_ExplicitSpecialization)
3019 return InstantiateClass(Loc, Rec, Pattern,
3020 getTemplateInstantiationArgs(Rec),
3021 TSK_ImplicitInstantiation,
3022 /*Complain=*/diag != 0);
3030 const TagType *Tag = T->getAs<TagType>();
3032 // Avoid diagnosing invalid decls as incomplete.
3033 if (Tag && Tag->getDecl()->isInvalidDecl())
3036 // Give the external AST source a chance to complete the type.
3037 if (Tag && Tag->getDecl()->hasExternalLexicalStorage()) {
3038 Context.getExternalSource()->CompleteType(Tag->getDecl());
3039 if (!Tag->isIncompleteType())
3043 // We have an incomplete type. Produce a diagnostic.
3046 // If we have a note, produce it.
3047 if (!Note.first.isInvalid())
3048 Diag(Note.first, Note.second);
3050 // If the type was a forward declaration of a class/struct/union
3051 // type, produce a note.
3052 if (Tag && !Tag->getDecl()->isInvalidDecl())
3053 Diag(Tag->getDecl()->getLocation(),
3054 Tag->isBeingDefined() ? diag::note_type_being_defined
3055 : diag::note_forward_declaration)
3056 << QualType(Tag, 0);
3061 bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
3062 const PartialDiagnostic &PD) {
3063 return RequireCompleteType(Loc, T, PD,
3064 std::make_pair(SourceLocation(), PDiag(0)));
3067 bool Sema::RequireCompleteType(SourceLocation Loc, QualType T,
3069 return RequireCompleteType(Loc, T, PDiag(DiagID),
3070 std::make_pair(SourceLocation(), PDiag(0)));
3073 /// \brief Retrieve a version of the type 'T' that is elaborated by Keyword
3074 /// and qualified by the nested-name-specifier contained in SS.
3075 QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword,
3076 const CXXScopeSpec &SS, QualType T) {
3079 NestedNameSpecifier *NNS;
3081 NNS = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
3083 if (Keyword == ETK_None)
3087 return Context.getElaboratedType(Keyword, NNS, T);
3090 QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) {
3091 ExprResult ER = CheckPlaceholderExpr(E, Loc);
3092 if (ER.isInvalid()) return QualType();
3095 if (!E->isTypeDependent()) {
3096 QualType T = E->getType();
3097 if (const TagType *TT = T->getAs<TagType>())
3098 DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc());
3100 return Context.getTypeOfExprType(E);
3103 QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc) {
3104 ExprResult ER = CheckPlaceholderExpr(E, Loc);
3105 if (ER.isInvalid()) return QualType();
3108 return Context.getDecltypeType(E);