blob: 5df0aecd8fae7713f6994f43daab7f5956262a29 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements type-related semantic analysis.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
Steve Naroff980e5082007-10-01 19:00:59 +000016#include "clang/AST/DeclObjC.h"
Douglas Gregor2943aed2009-03-03 04:44:36 +000017#include "clang/AST/DeclTemplate.h"
Daniel Dunbare91593e2008-08-11 04:54:23 +000018#include "clang/AST/Expr.h"
Daniel Dunbare4858a62008-08-11 03:45:03 +000019#include "clang/Parse/DeclSpec.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000020using namespace clang;
21
Douglas Gregor2dc0e642009-03-23 23:06:20 +000022/// \brief Perform adjustment on the parameter type of a function.
23///
24/// This routine adjusts the given parameter type @p T to the actual
25/// parameter type used by semantic analysis (C99 6.7.5.3p[7,8],
26/// C++ [dcl.fct]p3). The adjusted parameter type is returned.
27QualType Sema::adjustParameterType(QualType T) {
28 // C99 6.7.5.3p7:
29 if (T->isArrayType()) {
30 // C99 6.7.5.3p7:
31 // A declaration of a parameter as "array of type" shall be
32 // adjusted to "qualified pointer to type", where the type
33 // qualifiers (if any) are those specified within the [ and ] of
34 // the array type derivation.
35 return Context.getArrayDecayedType(T);
36 } else if (T->isFunctionType())
37 // C99 6.7.5.3p8:
38 // A declaration of a parameter as "function returning type"
39 // shall be adjusted to "pointer to function returning type", as
40 // in 6.3.2.1.
41 return Context.getPointerType(T);
42
43 return T;
44}
45
Douglas Gregor930d8b52009-01-30 22:09:00 +000046/// \brief Convert the specified declspec to the appropriate type
47/// object.
48/// \param DS the declaration specifiers
Chris Lattner3f84ad22009-04-22 05:27:59 +000049/// \param DeclLoc The location of the declarator identifier or invalid if none.
Chris Lattner5153ee62009-04-25 08:47:54 +000050/// \returns The type described by the declaration specifiers. This function
51/// never returns null.
Chris Lattner3f84ad22009-04-22 05:27:59 +000052QualType Sema::ConvertDeclSpecToType(const DeclSpec &DS,
Chris Lattnereaaebc72009-04-25 08:06:05 +000053 SourceLocation DeclLoc,
54 bool &isInvalid) {
Reid Spencer5f016e22007-07-11 17:01:13 +000055 // FIXME: Should move the logic from DeclSpec::Finish to here for validity
56 // checking.
Chris Lattner958858e2008-02-20 21:40:32 +000057 QualType Result;
Reid Spencer5f016e22007-07-11 17:01:13 +000058
59 switch (DS.getTypeSpecType()) {
Chris Lattner96b77fc2008-04-02 06:50:17 +000060 case DeclSpec::TST_void:
61 Result = Context.VoidTy;
62 break;
Reid Spencer5f016e22007-07-11 17:01:13 +000063 case DeclSpec::TST_char:
64 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
Chris Lattnerfab5b452008-02-20 23:53:49 +000065 Result = Context.CharTy;
Reid Spencer5f016e22007-07-11 17:01:13 +000066 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
Chris Lattnerfab5b452008-02-20 23:53:49 +000067 Result = Context.SignedCharTy;
Reid Spencer5f016e22007-07-11 17:01:13 +000068 else {
69 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
70 "Unknown TSS value");
Chris Lattnerfab5b452008-02-20 23:53:49 +000071 Result = Context.UnsignedCharTy;
Reid Spencer5f016e22007-07-11 17:01:13 +000072 }
Chris Lattner958858e2008-02-20 21:40:32 +000073 break;
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +000074 case DeclSpec::TST_wchar:
75 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
76 Result = Context.WCharTy;
77 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +000078 Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
79 << DS.getSpecifierName(DS.getTypeSpecType());
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +000080 Result = Context.getSignedWCharType();
81 } else {
82 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
83 "Unknown TSS value");
Chris Lattnerf3a41af2008-11-20 06:38:18 +000084 Diag(DS.getTypeSpecSignLoc(), diag::ext_invalid_sign_spec)
85 << DS.getSpecifierName(DS.getTypeSpecType());
Argyrios Kyrtzidis64c438a2008-08-09 16:51:54 +000086 Result = Context.getUnsignedWCharType();
87 }
88 break;
Chris Lattnerd658b562008-04-05 06:32:51 +000089 case DeclSpec::TST_unspecified:
Chris Lattner62f5f7f2008-07-26 00:46:50 +000090 // "<proto1,proto2>" is an objc qualified ID with a missing id.
Chris Lattner097e9162008-10-20 02:01:50 +000091 if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
Chris Lattnerae4da612008-07-26 01:53:50 +000092 Result = Context.getObjCQualifiedIdType((ObjCProtocolDecl**)PQ,
Chris Lattner62f5f7f2008-07-26 00:46:50 +000093 DS.getNumProtocolQualifiers());
94 break;
95 }
96
Chris Lattnerd658b562008-04-05 06:32:51 +000097 // Unspecified typespec defaults to int in C90. However, the C90 grammar
98 // [C90 6.5] only allows a decl-spec if there was *some* type-specifier,
99 // type-qualifier, or storage-class-specifier. If not, emit an extwarn.
100 // Note that the one exception to this is function definitions, which are
101 // allowed to be completely missing a declspec. This is handled in the
102 // parser already though by it pretending to have seen an 'int' in this
103 // case.
104 if (getLangOptions().ImplicitInt) {
Chris Lattner35d276f2009-02-27 18:53:28 +0000105 // In C89 mode, we only warn if there is a completely missing declspec
106 // when one is not allowed.
Chris Lattner3f84ad22009-04-22 05:27:59 +0000107 if (DS.isEmpty()) {
108 if (DeclLoc.isInvalid())
109 DeclLoc = DS.getSourceRange().getBegin();
110 Diag(DeclLoc, diag::warn_missing_declspec)
111 << DS.getSourceRange()
Chris Lattner173144a2009-02-27 22:31:56 +0000112 << CodeModificationHint::CreateInsertion(DS.getSourceRange().getBegin(),
113 "int");
Chris Lattner3f84ad22009-04-22 05:27:59 +0000114 }
Douglas Gregor4310f4e2009-02-16 22:38:20 +0000115 } else if (!DS.hasTypeSpecifier()) {
Chris Lattnerd658b562008-04-05 06:32:51 +0000116 // C99 and C++ require a type specifier. For example, C99 6.7.2p2 says:
117 // "At least one type specifier shall be given in the declaration
118 // specifiers in each declaration, and in the specifier-qualifier list in
119 // each struct declaration and type name."
Douglas Gregor4310f4e2009-02-16 22:38:20 +0000120 // FIXME: Does Microsoft really have the implicit int extension in C++?
Chris Lattner3f84ad22009-04-22 05:27:59 +0000121 if (DeclLoc.isInvalid())
122 DeclLoc = DS.getSourceRange().getBegin();
123
124 if (getLangOptions().CPlusPlus && !getLangOptions().Microsoft)
125 Diag(DeclLoc, diag::err_missing_type_specifier)
126 << DS.getSourceRange();
127 else
128 Diag(DeclLoc, diag::warn_missing_type_specifier)
129 << DS.getSourceRange();
Douglas Gregord17a9e52009-03-27 05:10:56 +0000130
131 // FIXME: If we could guarantee that the result would be
132 // well-formed, it would be useful to have a code insertion hint
133 // here. However, after emitting this warning/error, we often
134 // emit other errors.
Chris Lattnerd658b562008-04-05 06:32:51 +0000135 }
136
137 // FALL THROUGH.
Chris Lattner3cbc38b2007-08-21 17:02:28 +0000138 case DeclSpec::TST_int: {
Reid Spencer5f016e22007-07-11 17:01:13 +0000139 if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
140 switch (DS.getTypeSpecWidth()) {
Chris Lattnerfab5b452008-02-20 23:53:49 +0000141 case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
142 case DeclSpec::TSW_short: Result = Context.ShortTy; break;
143 case DeclSpec::TSW_long: Result = Context.LongTy; break;
144 case DeclSpec::TSW_longlong: Result = Context.LongLongTy; break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000145 }
146 } else {
147 switch (DS.getTypeSpecWidth()) {
Chris Lattnerfab5b452008-02-20 23:53:49 +0000148 case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
149 case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break;
150 case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break;
151 case DeclSpec::TSW_longlong: Result =Context.UnsignedLongLongTy; break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000152 }
153 }
Chris Lattner958858e2008-02-20 21:40:32 +0000154 break;
Chris Lattner3cbc38b2007-08-21 17:02:28 +0000155 }
Chris Lattnerfab5b452008-02-20 23:53:49 +0000156 case DeclSpec::TST_float: Result = Context.FloatTy; break;
Chris Lattner958858e2008-02-20 21:40:32 +0000157 case DeclSpec::TST_double:
158 if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
Chris Lattnerfab5b452008-02-20 23:53:49 +0000159 Result = Context.LongDoubleTy;
Chris Lattner958858e2008-02-20 21:40:32 +0000160 else
Chris Lattnerfab5b452008-02-20 23:53:49 +0000161 Result = Context.DoubleTy;
Chris Lattner958858e2008-02-20 21:40:32 +0000162 break;
Chris Lattnerfab5b452008-02-20 23:53:49 +0000163 case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
Reid Spencer5f016e22007-07-11 17:01:13 +0000164 case DeclSpec::TST_decimal32: // _Decimal32
165 case DeclSpec::TST_decimal64: // _Decimal64
166 case DeclSpec::TST_decimal128: // _Decimal128
167 assert(0 && "FIXME: GNU decimal extensions not supported yet!");
Chris Lattner99dc9142008-04-13 18:59:07 +0000168 case DeclSpec::TST_class:
Reid Spencer5f016e22007-07-11 17:01:13 +0000169 case DeclSpec::TST_enum:
170 case DeclSpec::TST_union:
171 case DeclSpec::TST_struct: {
172 Decl *D = static_cast<Decl *>(DS.getTypeRep());
Chris Lattner99dc9142008-04-13 18:59:07 +0000173 assert(D && "Didn't get a decl for a class/enum/union/struct?");
Reid Spencer5f016e22007-07-11 17:01:13 +0000174 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
175 DS.getTypeSpecSign() == 0 &&
176 "Can't handle qualifiers on typedef names yet!");
177 // TypeQuals handled by caller.
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000178 Result = Context.getTypeDeclType(cast<TypeDecl>(D));
Chris Lattner5153ee62009-04-25 08:47:54 +0000179
180 if (D->isInvalidDecl())
181 isInvalid = true;
Chris Lattner958858e2008-02-20 21:40:32 +0000182 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000183 }
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000184 case DeclSpec::TST_typename: {
Reid Spencer5f016e22007-07-11 17:01:13 +0000185 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
186 DS.getTypeSpecSign() == 0 &&
187 "Can't handle qualifiers on typedef names yet!");
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000188 Result = QualType::getFromOpaquePtr(DS.getTypeRep());
Douglas Gregor2ce52f32008-04-13 21:07:44 +0000189
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000190 if (DeclSpec::ProtocolQualifierListTy PQ = DS.getProtocolQualifiers()) {
191 // FIXME: Adding a TST_objcInterface clause doesn't seem ideal, so
192 // we have this "hack" for now...
193 if (const ObjCInterfaceType *Interface = Result->getAsObjCInterfaceType())
194 Result = Context.getObjCQualifiedInterfaceType(Interface->getDecl(),
195 (ObjCProtocolDecl**)PQ,
196 DS.getNumProtocolQualifiers());
197 else if (Result == Context.getObjCIdType())
Chris Lattnerae4da612008-07-26 01:53:50 +0000198 // id<protocol-list>
199 Result = Context.getObjCQualifiedIdType((ObjCProtocolDecl**)PQ,
200 DS.getNumProtocolQualifiers());
Chris Lattner3f84ad22009-04-22 05:27:59 +0000201 else if (Result == Context.getObjCClassType()) {
202 if (DeclLoc.isInvalid())
203 DeclLoc = DS.getSourceRange().getBegin();
Steve Naroff4262a072009-02-23 18:53:24 +0000204 // Class<protocol-list>
Chris Lattner3f84ad22009-04-22 05:27:59 +0000205 Diag(DeclLoc, diag::err_qualified_class_unsupported)
206 << DS.getSourceRange();
207 } else {
208 if (DeclLoc.isInvalid())
209 DeclLoc = DS.getSourceRange().getBegin();
210 Diag(DeclLoc, diag::err_invalid_protocol_qualifiers)
211 << DS.getSourceRange();
Chris Lattnereaaebc72009-04-25 08:06:05 +0000212 isInvalid = true;
Chris Lattner3f84ad22009-04-22 05:27:59 +0000213 }
Fariborz Jahanianc5692492007-12-17 21:03:50 +0000214 }
Chris Lattnereaaebc72009-04-25 08:06:05 +0000215
216 // If this is a reference to an invalid typedef, propagate the invalidity.
217 if (TypedefType *TDT = dyn_cast<TypedefType>(Result))
218 if (TDT->getDecl()->isInvalidDecl())
219 isInvalid = true;
220
Reid Spencer5f016e22007-07-11 17:01:13 +0000221 // TypeQuals handled by caller.
Chris Lattner958858e2008-02-20 21:40:32 +0000222 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000223 }
Chris Lattner958858e2008-02-20 21:40:32 +0000224 case DeclSpec::TST_typeofType:
225 Result = QualType::getFromOpaquePtr(DS.getTypeRep());
226 assert(!Result.isNull() && "Didn't get a type for typeof?");
Steve Naroffd1861fd2007-07-31 12:34:36 +0000227 // TypeQuals handled by caller.
Chris Lattnerfab5b452008-02-20 23:53:49 +0000228 Result = Context.getTypeOfType(Result);
Chris Lattner958858e2008-02-20 21:40:32 +0000229 break;
Steve Naroffd1861fd2007-07-31 12:34:36 +0000230 case DeclSpec::TST_typeofExpr: {
231 Expr *E = static_cast<Expr *>(DS.getTypeRep());
232 assert(E && "Didn't get an expression for typeof?");
233 // TypeQuals handled by caller.
Douglas Gregor72564e72009-02-26 23:50:07 +0000234 Result = Context.getTypeOfExprType(E);
Chris Lattner958858e2008-02-20 21:40:32 +0000235 break;
Steve Naroffd1861fd2007-07-31 12:34:36 +0000236 }
Douglas Gregor809070a2009-02-18 17:45:20 +0000237 case DeclSpec::TST_error:
Chris Lattner5153ee62009-04-25 08:47:54 +0000238 Result = Context.IntTy;
239 isInvalid = true;
240 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000241 }
Chris Lattner958858e2008-02-20 21:40:32 +0000242
243 // Handle complex types.
Douglas Gregorf244cd72009-02-14 21:06:05 +0000244 if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex) {
245 if (getLangOptions().Freestanding)
246 Diag(DS.getTypeSpecComplexLoc(), diag::ext_freestanding_complex);
Chris Lattnerfab5b452008-02-20 23:53:49 +0000247 Result = Context.getComplexType(Result);
Douglas Gregorf244cd72009-02-14 21:06:05 +0000248 }
Chris Lattner958858e2008-02-20 21:40:32 +0000249
250 assert(DS.getTypeSpecComplex() != DeclSpec::TSC_imaginary &&
251 "FIXME: imaginary types not supported yet!");
252
Chris Lattner38d8b982008-02-20 22:04:11 +0000253 // See if there are any attributes on the declspec that apply to the type (as
254 // opposed to the decl).
Chris Lattnerfca0ddd2008-06-26 06:27:57 +0000255 if (const AttributeList *AL = DS.getAttributes())
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000256 ProcessTypeAttributeList(Result, AL);
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000257
Chris Lattner96b77fc2008-04-02 06:50:17 +0000258 // Apply const/volatile/restrict qualifiers to T.
259 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
260
261 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
262 // or incomplete types shall not be restrict-qualified." C++ also allows
263 // restrict-qualified references.
264 if (TypeQuals & QualType::Restrict) {
Daniel Dunbarbb710012009-02-26 19:13:44 +0000265 if (Result->isPointerType() || Result->isReferenceType()) {
266 QualType EltTy = Result->isPointerType() ?
267 Result->getAsPointerType()->getPointeeType() :
268 Result->getAsReferenceType()->getPointeeType();
Chris Lattnerbdcd6372008-04-02 17:35:06 +0000269
Douglas Gregorbad0e652009-03-24 20:32:41 +0000270 // If we have a pointer or reference, the pointee must have an object
Chris Lattnerbdcd6372008-04-02 17:35:06 +0000271 // incomplete type.
272 if (!EltTy->isIncompleteOrObjectType()) {
273 Diag(DS.getRestrictSpecLoc(),
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000274 diag::err_typecheck_invalid_restrict_invalid_pointee)
Chris Lattnerd1625842008-11-24 06:25:27 +0000275 << EltTy << DS.getSourceRange();
Chris Lattnerbdcd6372008-04-02 17:35:06 +0000276 TypeQuals &= ~QualType::Restrict; // Remove the restrict qualifier.
277 }
278 } else {
Chris Lattner96b77fc2008-04-02 06:50:17 +0000279 Diag(DS.getRestrictSpecLoc(),
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000280 diag::err_typecheck_invalid_restrict_not_pointer)
Chris Lattnerd1625842008-11-24 06:25:27 +0000281 << Result << DS.getSourceRange();
Chris Lattnerbdcd6372008-04-02 17:35:06 +0000282 TypeQuals &= ~QualType::Restrict; // Remove the restrict qualifier.
Chris Lattner96b77fc2008-04-02 06:50:17 +0000283 }
Chris Lattner96b77fc2008-04-02 06:50:17 +0000284 }
285
286 // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification
287 // of a function type includes any type qualifiers, the behavior is
288 // undefined."
289 if (Result->isFunctionType() && TypeQuals) {
290 // Get some location to point at, either the C or V location.
291 SourceLocation Loc;
292 if (TypeQuals & QualType::Const)
293 Loc = DS.getConstSpecLoc();
294 else {
295 assert((TypeQuals & QualType::Volatile) &&
296 "Has CV quals but not C or V?");
297 Loc = DS.getVolatileSpecLoc();
298 }
Chris Lattnerd3a94e22008-11-20 06:06:08 +0000299 Diag(Loc, diag::warn_typecheck_function_qualifiers)
Chris Lattnerd1625842008-11-24 06:25:27 +0000300 << Result << DS.getSourceRange();
Chris Lattner96b77fc2008-04-02 06:50:17 +0000301 }
302
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +0000303 // C++ [dcl.ref]p1:
304 // Cv-qualified references are ill-formed except when the
305 // cv-qualifiers are introduced through the use of a typedef
306 // (7.1.3) or of a template type argument (14.3), in which
307 // case the cv-qualifiers are ignored.
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000308 // FIXME: Shouldn't we be checking SCS_typedef here?
309 if (DS.getTypeSpecType() == DeclSpec::TST_typename &&
Douglas Gregorf1f9b4e2008-11-03 15:51:28 +0000310 TypeQuals && Result->isReferenceType()) {
311 TypeQuals &= ~QualType::Const;
312 TypeQuals &= ~QualType::Volatile;
313 }
314
Chris Lattner96b77fc2008-04-02 06:50:17 +0000315 Result = Result.getQualifiedType(TypeQuals);
316 }
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000317 return Result;
318}
319
Douglas Gregorcd281c32009-02-28 00:25:32 +0000320static std::string getPrintableNameForEntity(DeclarationName Entity) {
321 if (Entity)
322 return Entity.getAsString();
323
324 return "type name";
325}
326
327/// \brief Build a pointer type.
328///
329/// \param T The type to which we'll be building a pointer.
330///
331/// \param Quals The cvr-qualifiers to be applied to the pointer type.
332///
333/// \param Loc The location of the entity whose type involves this
334/// pointer type or, if there is no such entity, the location of the
335/// type that will have pointer type.
336///
337/// \param Entity The name of the entity that involves the pointer
338/// type, if known.
339///
340/// \returns A suitable pointer type, if there are no
341/// errors. Otherwise, returns a NULL type.
342QualType Sema::BuildPointerType(QualType T, unsigned Quals,
343 SourceLocation Loc, DeclarationName Entity) {
344 if (T->isReferenceType()) {
345 // C++ 8.3.2p4: There shall be no ... pointers to references ...
346 Diag(Loc, diag::err_illegal_decl_pointer_to_reference)
347 << getPrintableNameForEntity(Entity);
348 return QualType();
349 }
350
351 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
352 // object or incomplete types shall not be restrict-qualified."
353 if ((Quals & QualType::Restrict) && !T->isIncompleteOrObjectType()) {
354 Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
355 << T;
356 Quals &= ~QualType::Restrict;
357 }
358
359 // Build the pointer type.
360 return Context.getPointerType(T).getQualifiedType(Quals);
361}
362
363/// \brief Build a reference type.
364///
365/// \param T The type to which we'll be building a reference.
366///
367/// \param Quals The cvr-qualifiers to be applied to the reference type.
368///
369/// \param Loc The location of the entity whose type involves this
370/// reference type or, if there is no such entity, the location of the
371/// type that will have reference type.
372///
373/// \param Entity The name of the entity that involves the reference
374/// type, if known.
375///
376/// \returns A suitable reference type, if there are no
377/// errors. Otherwise, returns a NULL type.
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000378QualType Sema::BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000379 SourceLocation Loc, DeclarationName Entity) {
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000380 if (LValueRef) {
381 if (const RValueReferenceType *R = T->getAsRValueReferenceType()) {
Sebastian Redldfe292d2009-03-22 21:28:55 +0000382 // C++0x [dcl.typedef]p9: If a typedef TD names a type that is a
383 // reference to a type T, and attempt to create the type "lvalue
384 // reference to cv TD" creates the type "lvalue reference to T".
385 // We use the qualifiers (restrict or none) of the original reference,
386 // not the new ones. This is consistent with GCC.
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000387 return Context.getLValueReferenceType(R->getPointeeType()).
Sebastian Redldfe292d2009-03-22 21:28:55 +0000388 getQualifiedType(T.getCVRQualifiers());
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000389 }
390 }
Douglas Gregorcd281c32009-02-28 00:25:32 +0000391 if (T->isReferenceType()) {
392 // C++ [dcl.ref]p4: There shall be no references to references.
393 //
394 // According to C++ DR 106, references to references are only
395 // diagnosed when they are written directly (e.g., "int & &"),
396 // but not when they happen via a typedef:
397 //
398 // typedef int& intref;
399 // typedef intref& intref2;
400 //
401 // Parser::ParserDeclaratorInternal diagnoses the case where
402 // references are written directly; here, we handle the
403 // collapsing of references-to-references as described in C++
404 // DR 106 and amended by C++ DR 540.
405 return T;
406 }
407
408 // C++ [dcl.ref]p1:
409 // A declarator that specifies the type “reference to cv void”
410 // is ill-formed.
411 if (T->isVoidType()) {
412 Diag(Loc, diag::err_reference_to_void);
413 return QualType();
414 }
415
416 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
417 // object or incomplete types shall not be restrict-qualified."
418 if ((Quals & QualType::Restrict) && !T->isIncompleteOrObjectType()) {
419 Diag(Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
420 << T;
421 Quals &= ~QualType::Restrict;
422 }
423
424 // C++ [dcl.ref]p1:
425 // [...] Cv-qualified references are ill-formed except when the
426 // cv-qualifiers are introduced through the use of a typedef
427 // (7.1.3) or of a template type argument (14.3), in which case
428 // the cv-qualifiers are ignored.
429 //
430 // We diagnose extraneous cv-qualifiers for the non-typedef,
431 // non-template type argument case within the parser. Here, we just
432 // ignore any extraneous cv-qualifiers.
433 Quals &= ~QualType::Const;
434 Quals &= ~QualType::Volatile;
435
436 // Handle restrict on references.
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000437 if (LValueRef)
438 return Context.getLValueReferenceType(T).getQualifiedType(Quals);
439 return Context.getRValueReferenceType(T).getQualifiedType(Quals);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000440}
441
442/// \brief Build an array type.
443///
444/// \param T The type of each element in the array.
445///
446/// \param ASM C99 array size modifier (e.g., '*', 'static').
447///
448/// \param ArraySize Expression describing the size of the array.
449///
450/// \param Quals The cvr-qualifiers to be applied to the array's
451/// element type.
452///
453/// \param Loc The location of the entity whose type involves this
454/// array type or, if there is no such entity, the location of the
455/// type that will have array type.
456///
457/// \param Entity The name of the entity that involves the array
458/// type, if known.
459///
460/// \returns A suitable array type, if there are no errors. Otherwise,
461/// returns a NULL type.
462QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
463 Expr *ArraySize, unsigned Quals,
464 SourceLocation Loc, DeclarationName Entity) {
465 // C99 6.7.5.2p1: If the element type is an incomplete or function type,
466 // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
Douglas Gregor86447ec2009-03-09 16:13:40 +0000467 if (RequireCompleteType(Loc, T,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000468 diag::err_illegal_decl_array_incomplete_type))
469 return QualType();
470
471 if (T->isFunctionType()) {
472 Diag(Loc, diag::err_illegal_decl_array_of_functions)
473 << getPrintableNameForEntity(Entity);
474 return QualType();
475 }
476
477 // C++ 8.3.2p4: There shall be no ... arrays of references ...
478 if (T->isReferenceType()) {
479 Diag(Loc, diag::err_illegal_decl_array_of_references)
480 << getPrintableNameForEntity(Entity);
481 return QualType();
482 }
483
484 if (const RecordType *EltTy = T->getAsRecordType()) {
485 // If the element type is a struct or union that contains a variadic
486 // array, accept it as a GNU extension: C99 6.7.2.1p2.
487 if (EltTy->getDecl()->hasFlexibleArrayMember())
488 Diag(Loc, diag::ext_flexible_array_in_array) << T;
489 } else if (T->isObjCInterfaceType()) {
490 Diag(Loc, diag::warn_objc_array_of_interfaces) << T;
491 }
492
493 // C99 6.7.5.2p1: The size expression shall have integer type.
494 if (ArraySize && !ArraySize->isTypeDependent() &&
495 !ArraySize->getType()->isIntegerType()) {
496 Diag(ArraySize->getLocStart(), diag::err_array_size_non_int)
497 << ArraySize->getType() << ArraySize->getSourceRange();
498 ArraySize->Destroy(Context);
499 return QualType();
500 }
501 llvm::APSInt ConstVal(32);
502 if (!ArraySize) {
Eli Friedmanf91f5c82009-04-26 21:57:51 +0000503 if (ASM == ArrayType::Star)
504 T = Context.getVariableArrayType(T, 0, ASM, Quals);
505 else
506 T = Context.getIncompleteArrayType(T, ASM, Quals);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000507 } else if (ArraySize->isValueDependent()) {
508 T = Context.getDependentSizedArrayType(T, ArraySize, ASM, Quals);
509 } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context) ||
510 (!T->isDependentType() && !T->isConstantSizeType())) {
511 // Per C99, a variable array is an array with either a non-constant
512 // size or an element type that has a non-constant-size
513 T = Context.getVariableArrayType(T, ArraySize, ASM, Quals);
514 } else {
515 // C99 6.7.5.2p1: If the expression is a constant expression, it shall
516 // have a value greater than zero.
517 if (ConstVal.isSigned()) {
518 if (ConstVal.isNegative()) {
519 Diag(ArraySize->getLocStart(),
520 diag::err_typecheck_negative_array_size)
521 << ArraySize->getSourceRange();
522 return QualType();
523 } else if (ConstVal == 0) {
524 // GCC accepts zero sized static arrays.
525 Diag(ArraySize->getLocStart(), diag::ext_typecheck_zero_array_size)
526 << ArraySize->getSourceRange();
527 }
528 }
529 T = Context.getConstantArrayType(T, ConstVal, ASM, Quals);
530 }
531 // If this is not C99, extwarn about VLA's and C99 array size modifiers.
532 if (!getLangOptions().C99) {
533 if (ArraySize && !ArraySize->isTypeDependent() &&
534 !ArraySize->isValueDependent() &&
535 !ArraySize->isIntegerConstantExpr(Context))
536 Diag(Loc, diag::ext_vla);
537 else if (ASM != ArrayType::Normal || Quals != 0)
538 Diag(Loc, diag::ext_c99_array_usage);
539 }
540
541 return T;
542}
543
Douglas Gregor724651c2009-02-28 01:04:19 +0000544/// \brief Build a function type.
545///
546/// This routine checks the function type according to C++ rules and
547/// under the assumption that the result type and parameter types have
548/// just been instantiated from a template. It therefore duplicates
Douglas Gregor2943aed2009-03-03 04:44:36 +0000549/// some of the behavior of GetTypeForDeclarator, but in a much
Douglas Gregor724651c2009-02-28 01:04:19 +0000550/// simpler form that is only suitable for this narrow use case.
551///
552/// \param T The return type of the function.
553///
554/// \param ParamTypes The parameter types of the function. This array
555/// will be modified to account for adjustments to the types of the
556/// function parameters.
557///
558/// \param NumParamTypes The number of parameter types in ParamTypes.
559///
560/// \param Variadic Whether this is a variadic function type.
561///
562/// \param Quals The cvr-qualifiers to be applied to the function type.
563///
564/// \param Loc The location of the entity whose type involves this
565/// function type or, if there is no such entity, the location of the
566/// type that will have function type.
567///
568/// \param Entity The name of the entity that involves the function
569/// type, if known.
570///
571/// \returns A suitable function type, if there are no
572/// errors. Otherwise, returns a NULL type.
573QualType Sema::BuildFunctionType(QualType T,
574 QualType *ParamTypes,
575 unsigned NumParamTypes,
576 bool Variadic, unsigned Quals,
577 SourceLocation Loc, DeclarationName Entity) {
578 if (T->isArrayType() || T->isFunctionType()) {
579 Diag(Loc, diag::err_func_returning_array_function) << T;
580 return QualType();
581 }
582
583 bool Invalid = false;
584 for (unsigned Idx = 0; Idx < NumParamTypes; ++Idx) {
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000585 QualType ParamType = adjustParameterType(ParamTypes[Idx]);
586 if (ParamType->isVoidType()) {
Douglas Gregor724651c2009-02-28 01:04:19 +0000587 Diag(Loc, diag::err_param_with_void_type);
588 Invalid = true;
589 }
Douglas Gregorcd281c32009-02-28 00:25:32 +0000590
Douglas Gregor724651c2009-02-28 01:04:19 +0000591 ParamTypes[Idx] = ParamType;
592 }
593
594 if (Invalid)
595 return QualType();
596
597 return Context.getFunctionType(T, ParamTypes, NumParamTypes, Variadic,
598 Quals);
599}
600
Mike Stump98eb8a72009-02-04 22:31:32 +0000601/// GetTypeForDeclarator - Convert the type for the specified
602/// declarator to Type instances. Skip the outermost Skip type
603/// objects.
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000604QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip) {
Mike Stump98eb8a72009-02-04 22:31:32 +0000605 bool OmittedReturnType = false;
606
607 if (D.getContext() == Declarator::BlockLiteralContext
608 && Skip == 0
609 && !D.getDeclSpec().hasTypeSpecifier()
610 && (D.getNumTypeObjects() == 0
611 || (D.getNumTypeObjects() == 1
612 && D.getTypeObject(0).Kind == DeclaratorChunk::Function)))
613 OmittedReturnType = true;
614
Chris Lattnerb23deda2007-08-28 16:40:32 +0000615 // long long is a C99 feature.
Chris Lattnerd1eb3322007-08-28 16:41:29 +0000616 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
Chris Lattnerb23deda2007-08-28 16:40:32 +0000617 D.getDeclSpec().getTypeSpecWidth() == DeclSpec::TSW_longlong)
618 Diag(D.getDeclSpec().getTypeSpecWidthLoc(), diag::ext_longlong);
Douglas Gregor930d8b52009-01-30 22:09:00 +0000619
620 // Determine the type of the declarator. Not all forms of declarator
621 // have a type.
622 QualType T;
623 switch (D.getKind()) {
624 case Declarator::DK_Abstract:
625 case Declarator::DK_Normal:
Mike Stump98eb8a72009-02-04 22:31:32 +0000626 case Declarator::DK_Operator: {
Chris Lattner3f84ad22009-04-22 05:27:59 +0000627 const DeclSpec &DS = D.getDeclSpec();
628 if (OmittedReturnType) {
Mike Stump98eb8a72009-02-04 22:31:32 +0000629 // We default to a dependent type initially. Can be modified by
630 // the first return statement.
631 T = Context.DependentTy;
Chris Lattner3f84ad22009-04-22 05:27:59 +0000632 } else {
Chris Lattnereaaebc72009-04-25 08:06:05 +0000633 bool isInvalid = false;
634 T = ConvertDeclSpecToType(DS, D.getIdentifierLoc(), isInvalid);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000635 if (isInvalid)
636 D.setInvalidType(true);
Douglas Gregor809070a2009-02-18 17:45:20 +0000637 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000638 break;
Mike Stump98eb8a72009-02-04 22:31:32 +0000639 }
Douglas Gregor930d8b52009-01-30 22:09:00 +0000640
641 case Declarator::DK_Constructor:
642 case Declarator::DK_Destructor:
643 case Declarator::DK_Conversion:
644 // Constructors and destructors don't have return types. Use
645 // "void" instead. Conversion operators will check their return
646 // types separately.
647 T = Context.VoidTy;
648 break;
649 }
Sebastian Redl4c5d3202008-11-21 19:14:01 +0000650
Douglas Gregorcd281c32009-02-28 00:25:32 +0000651 // The name we're declaring, if any.
652 DeclarationName Name;
653 if (D.getIdentifier())
654 Name = D.getIdentifier();
655
Mike Stump98eb8a72009-02-04 22:31:32 +0000656 // Walk the DeclTypeInfo, building the recursive type as we go.
657 // DeclTypeInfos are ordered from the identifier out, which is
658 // opposite of what we want :).
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000659 for (unsigned i = Skip, e = D.getNumTypeObjects(); i != e; ++i) {
660 DeclaratorChunk &DeclType = D.getTypeObject(e-i-1+Skip);
Reid Spencer5f016e22007-07-11 17:01:13 +0000661 switch (DeclType.Kind) {
662 default: assert(0 && "Unknown decltype!");
Steve Naroff5618bd42008-08-27 16:04:49 +0000663 case DeclaratorChunk::BlockPointer:
Chris Lattner9af55002009-03-27 04:18:06 +0000664 // If blocks are disabled, emit an error.
665 if (!LangOpts.Blocks)
666 Diag(DeclType.Loc, diag::err_blocks_disable);
667
Steve Naroff5618bd42008-08-27 16:04:49 +0000668 if (DeclType.Cls.TypeQuals)
669 Diag(D.getIdentifierLoc(), diag::err_qualified_block_pointer_type);
670 if (!T.getTypePtr()->isFunctionType())
671 Diag(D.getIdentifierLoc(), diag::err_nonfunction_block_type);
672 else
673 T = Context.getBlockPointerType(T);
674 break;
Reid Spencer5f016e22007-07-11 17:01:13 +0000675 case DeclaratorChunk::Pointer:
Douglas Gregorcd281c32009-02-28 00:25:32 +0000676 T = BuildPointerType(T, DeclType.Ptr.TypeQuals, DeclType.Loc, Name);
Reid Spencer5f016e22007-07-11 17:01:13 +0000677 break;
Douglas Gregorcd281c32009-02-28 00:25:32 +0000678 case DeclaratorChunk::Reference:
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000679 T = BuildReferenceType(T, DeclType.Ref.LValueRef,
680 DeclType.Ref.HasRestrict ? QualType::Restrict : 0,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000681 DeclType.Loc, Name);
Reid Spencer5f016e22007-07-11 17:01:13 +0000682 break;
683 case DeclaratorChunk::Array: {
Chris Lattnerfd89bc82008-04-02 01:05:10 +0000684 DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
Chris Lattner94f81fd2007-08-28 16:54:00 +0000685 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
Reid Spencer5f016e22007-07-11 17:01:13 +0000686 ArrayType::ArraySizeModifier ASM;
687 if (ATI.isStar)
688 ASM = ArrayType::Star;
689 else if (ATI.hasStatic)
690 ASM = ArrayType::Static;
691 else
692 ASM = ArrayType::Normal;
Eli Friedmanf91f5c82009-04-26 21:57:51 +0000693 if (ASM == ArrayType::Star &&
694 D.getContext() != Declarator::PrototypeContext) {
695 // FIXME: This check isn't quite right: it allows star in prototypes
696 // for function definitions, and disallows some edge cases detailed
697 // in http://gcc.gnu.org/ml/gcc-patches/2009-02/msg00133.html
698 Diag(DeclType.Loc, diag::err_array_star_outside_prototype);
699 ASM = ArrayType::Normal;
700 D.setInvalidType(true);
701 }
Douglas Gregorcd281c32009-02-28 00:25:32 +0000702 T = BuildArrayType(T, ASM, ArraySize, ATI.TypeQuals, DeclType.Loc, Name);
Reid Spencer5f016e22007-07-11 17:01:13 +0000703 break;
704 }
Sebastian Redlf30208a2009-01-24 21:16:55 +0000705 case DeclaratorChunk::Function: {
Reid Spencer5f016e22007-07-11 17:01:13 +0000706 // If the function declarator has a prototype (i.e. it is not () and
707 // does not have a K&R-style identifier list), then the arguments are part
708 // of the type, otherwise the argument list is ().
709 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
Chris Lattner68cfd492007-12-19 18:01:43 +0000710
Chris Lattnercd881292007-12-19 05:31:29 +0000711 // C99 6.7.5.3p1: The return type may not be a function or array type.
Chris Lattner68cfd492007-12-19 18:01:43 +0000712 if (T->isArrayType() || T->isFunctionType()) {
Chris Lattnerd1625842008-11-24 06:25:27 +0000713 Diag(DeclType.Loc, diag::err_func_returning_array_function) << T;
Chris Lattnercd881292007-12-19 05:31:29 +0000714 T = Context.IntTy;
715 D.setInvalidType(true);
716 }
717
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000718 if (FTI.NumArgs == 0) {
Argyrios Kyrtzidisc6f73452008-10-16 17:31:08 +0000719 if (getLangOptions().CPlusPlus) {
720 // C++ 8.3.5p2: If the parameter-declaration-clause is empty, the
721 // function takes no arguments.
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000722 T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic,FTI.TypeQuals);
Douglas Gregor965acbb2009-02-18 07:07:28 +0000723 } else if (FTI.isVariadic) {
724 // We allow a zero-parameter variadic function in C if the
725 // function is marked with the "overloadable"
726 // attribute. Scan for this attribute now.
727 bool Overloadable = false;
728 for (const AttributeList *Attrs = D.getAttributes();
729 Attrs; Attrs = Attrs->getNext()) {
730 if (Attrs->getKind() == AttributeList::AT_overloadable) {
731 Overloadable = true;
732 break;
733 }
734 }
735
736 if (!Overloadable)
737 Diag(FTI.getEllipsisLoc(), diag::err_ellipsis_first_arg);
738 T = Context.getFunctionType(T, NULL, 0, FTI.isVariadic, 0);
Argyrios Kyrtzidisc6f73452008-10-16 17:31:08 +0000739 } else {
740 // Simple void foo(), where the incoming T is the result type.
Douglas Gregor72564e72009-02-26 23:50:07 +0000741 T = Context.getFunctionNoProtoType(T);
Argyrios Kyrtzidisc6f73452008-10-16 17:31:08 +0000742 }
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000743 } else if (FTI.ArgInfo[0].Param == 0) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000744 // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000745 Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration);
Reid Spencer5f016e22007-07-11 17:01:13 +0000746 } else {
747 // Otherwise, we have a function with an argument list that is
748 // potentially variadic.
749 llvm::SmallVector<QualType, 16> ArgTys;
750
751 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
Chris Lattnerb28317a2009-03-28 19:18:32 +0000752 ParmVarDecl *Param =
753 cast<ParmVarDecl>(FTI.ArgInfo[i].Param.getAs<Decl>());
Chris Lattner8123a952008-04-10 02:22:51 +0000754 QualType ArgTy = Param->getType();
Chris Lattner78c75fb2007-07-21 05:30:18 +0000755 assert(!ArgTy.isNull() && "Couldn't parse type?");
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000756
757 // Adjust the parameter type.
Douglas Gregorbeb58cb2009-03-23 23:17:00 +0000758 assert((ArgTy == adjustParameterType(ArgTy)) && "Unadjusted type?");
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000759
Reid Spencer5f016e22007-07-11 17:01:13 +0000760 // Look for 'void'. void is allowed only as a single argument to a
761 // function with no other parameters (C99 6.7.5.3p10). We record
Douglas Gregor72564e72009-02-26 23:50:07 +0000762 // int(void) as a FunctionProtoType with an empty argument list.
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000763 if (ArgTy->isVoidType()) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000764 // If this is something like 'float(int, void)', reject it. 'void'
765 // is an incomplete type (C99 6.2.5p19) and function decls cannot
766 // have arguments of incomplete type.
767 if (FTI.NumArgs != 1 || FTI.isVariadic) {
768 Diag(DeclType.Loc, diag::err_void_only_param);
Chris Lattner2ff54262007-07-21 05:18:12 +0000769 ArgTy = Context.IntTy;
Chris Lattner8123a952008-04-10 02:22:51 +0000770 Param->setType(ArgTy);
Chris Lattner2ff54262007-07-21 05:18:12 +0000771 } else if (FTI.ArgInfo[i].Ident) {
772 // Reject, but continue to parse 'int(void abc)'.
Reid Spencer5f016e22007-07-11 17:01:13 +0000773 Diag(FTI.ArgInfo[i].IdentLoc,
Chris Lattner4565d4e2007-07-21 05:26:43 +0000774 diag::err_param_with_void_type);
Chris Lattner2ff54262007-07-21 05:18:12 +0000775 ArgTy = Context.IntTy;
Chris Lattner8123a952008-04-10 02:22:51 +0000776 Param->setType(ArgTy);
Chris Lattner2ff54262007-07-21 05:18:12 +0000777 } else {
778 // Reject, but continue to parse 'float(const void)'.
Chris Lattnerf46699c2008-02-20 20:55:12 +0000779 if (ArgTy.getCVRQualifiers())
Chris Lattner2ff54262007-07-21 05:18:12 +0000780 Diag(DeclType.Loc, diag::err_void_param_qualified);
781
782 // Do not add 'void' to the ArgTys list.
783 break;
784 }
Eli Friedmaneb4b7052008-08-25 21:31:01 +0000785 } else if (!FTI.hasPrototype) {
786 if (ArgTy->isPromotableIntegerType()) {
787 ArgTy = Context.IntTy;
788 } else if (const BuiltinType* BTy = ArgTy->getAsBuiltinType()) {
789 if (BTy->getKind() == BuiltinType::Float)
790 ArgTy = Context.DoubleTy;
791 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000792 }
793
794 ArgTys.push_back(ArgTy);
795 }
796 T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000797 FTI.isVariadic, FTI.TypeQuals);
Reid Spencer5f016e22007-07-11 17:01:13 +0000798 }
799 break;
800 }
Sebastian Redlf30208a2009-01-24 21:16:55 +0000801 case DeclaratorChunk::MemberPointer:
802 // The scope spec must refer to a class, or be dependent.
Douglas Gregore4e5b052009-03-19 00:18:19 +0000803 DeclContext *DC = computeDeclContext(DeclType.Mem.Scope());
Sebastian Redlf30208a2009-01-24 21:16:55 +0000804 QualType ClsType;
805 // FIXME: Extend for dependent types when it's actually supported.
806 // See ActOnCXXNestedNameSpecifier.
807 if (CXXRecordDecl *RD = dyn_cast_or_null<CXXRecordDecl>(DC)) {
808 ClsType = Context.getTagDeclType(RD);
809 } else {
810 if (DC) {
811 Diag(DeclType.Mem.Scope().getBeginLoc(),
812 diag::err_illegal_decl_mempointer_in_nonclass)
813 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name")
814 << DeclType.Mem.Scope().getRange();
815 }
816 D.setInvalidType(true);
817 ClsType = Context.IntTy;
818 }
819
820 // C++ 8.3.3p3: A pointer to member shall not pointer to ... a member
821 // with reference type, or "cv void."
822 if (T->isReferenceType()) {
823 Diag(DeclType.Loc, diag::err_illegal_decl_pointer_to_reference)
824 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
825 D.setInvalidType(true);
826 T = Context.IntTy;
827 }
828 if (T->isVoidType()) {
829 Diag(DeclType.Loc, diag::err_illegal_decl_mempointer_to_void)
830 << (D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
831 T = Context.IntTy;
832 }
833
834 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
835 // object or incomplete types shall not be restrict-qualified."
836 if ((DeclType.Mem.TypeQuals & QualType::Restrict) &&
837 !T->isIncompleteOrObjectType()) {
838 Diag(DeclType.Loc, diag::err_typecheck_invalid_restrict_invalid_pointee)
839 << T;
840 DeclType.Mem.TypeQuals &= ~QualType::Restrict;
841 }
842
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000843 T = Context.getMemberPointerType(T, ClsType.getTypePtr()).
844 getQualifiedType(DeclType.Mem.TypeQuals);
Sebastian Redlf30208a2009-01-24 21:16:55 +0000845
846 break;
847 }
848
Douglas Gregorcd281c32009-02-28 00:25:32 +0000849 if (T.isNull()) {
850 D.setInvalidType(true);
851 T = Context.IntTy;
852 }
853
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000854 // See if there are any attributes on this declarator chunk.
855 if (const AttributeList *AL = DeclType.getAttrs())
856 ProcessTypeAttributeList(T, AL);
Reid Spencer5f016e22007-07-11 17:01:13 +0000857 }
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000858
859 if (getLangOptions().CPlusPlus && T->isFunctionType()) {
Douglas Gregor72564e72009-02-26 23:50:07 +0000860 const FunctionProtoType *FnTy = T->getAsFunctionProtoType();
861 assert(FnTy && "Why oh why is there not a FunctionProtoType here ?");
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000862
863 // C++ 8.3.5p4: A cv-qualifier-seq shall only be part of the function type
864 // for a nonstatic member function, the function type to which a pointer
865 // to member refers, or the top-level function type of a function typedef
866 // declaration.
867 if (FnTy->getTypeQuals() != 0 &&
868 D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef &&
Douglas Gregor584049d2008-12-15 23:53:10 +0000869 ((D.getContext() != Declarator::MemberContext &&
870 (!D.getCXXScopeSpec().isSet() ||
Douglas Gregore4e5b052009-03-19 00:18:19 +0000871 !computeDeclContext(D.getCXXScopeSpec())->isRecord())) ||
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000872 D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static)) {
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000873 if (D.isFunctionDeclarator())
874 Diag(D.getIdentifierLoc(), diag::err_invalid_qualified_function_type);
875 else
876 Diag(D.getIdentifierLoc(),
877 diag::err_invalid_qualified_typedef_function_type_use);
878
879 // Strip the cv-quals from the type.
880 T = Context.getFunctionType(FnTy->getResultType(), FnTy->arg_type_begin(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +0000881 FnTy->getNumArgs(), FnTy->isVariadic(), 0);
Argyrios Kyrtzidis971c4fa2008-10-24 21:46:40 +0000882 }
883 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000884
Chris Lattner0bf29ad2008-06-29 00:19:33 +0000885 // If there were any type attributes applied to the decl itself (not the
886 // type, apply the type attribute to the type!)
887 if (const AttributeList *Attrs = D.getAttributes())
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000888 ProcessTypeAttributeList(T, Attrs);
Chris Lattner0bf29ad2008-06-29 00:19:33 +0000889
Reid Spencer5f016e22007-07-11 17:01:13 +0000890 return T;
891}
892
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000893/// ObjCGetTypeForMethodDefinition - Builds the type for a method definition
Fariborz Jahanian360300c2007-11-09 22:27:59 +0000894/// declarator
Chris Lattnerb28317a2009-03-28 19:18:32 +0000895QualType Sema::ObjCGetTypeForMethodDefinition(DeclPtrTy D) {
896 ObjCMethodDecl *MDecl = cast<ObjCMethodDecl>(D.getAs<Decl>());
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000897 QualType T = MDecl->getResultType();
898 llvm::SmallVector<QualType, 16> ArgTys;
899
Fariborz Jahanian35600022007-11-09 17:18:29 +0000900 // Add the first two invisible argument types for self and _cmd.
Douglas Gregorf8d49f62009-01-09 17:18:27 +0000901 if (MDecl->isInstanceMethod()) {
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000902 QualType selfTy = Context.getObjCInterfaceType(MDecl->getClassInterface());
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +0000903 selfTy = Context.getPointerType(selfTy);
904 ArgTys.push_back(selfTy);
Chris Lattner89951a82009-02-20 18:43:26 +0000905 } else
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000906 ArgTys.push_back(Context.getObjCIdType());
907 ArgTys.push_back(Context.getObjCSelType());
Fariborz Jahanian35600022007-11-09 17:18:29 +0000908
Chris Lattner89951a82009-02-20 18:43:26 +0000909 for (ObjCMethodDecl::param_iterator PI = MDecl->param_begin(),
910 E = MDecl->param_end(); PI != E; ++PI) {
911 QualType ArgTy = (*PI)->getType();
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000912 assert(!ArgTy.isNull() && "Couldn't parse type?");
Douglas Gregorbeb58cb2009-03-23 23:17:00 +0000913 ArgTy = adjustParameterType(ArgTy);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000914 ArgTys.push_back(ArgTy);
915 }
916 T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
Argyrios Kyrtzidis7fb5e482008-10-26 16:43:14 +0000917 MDecl->isVariadic(), 0);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000918 return T;
919}
920
Sebastian Redl9e5e4aa2009-01-26 19:54:48 +0000921/// UnwrapSimilarPointerTypes - If T1 and T2 are pointer types that
922/// may be similar (C++ 4.4), replaces T1 and T2 with the type that
923/// they point to and return true. If T1 and T2 aren't pointer types
924/// or pointer-to-member types, or if they are not similar at this
925/// level, returns false and leaves T1 and T2 unchanged. Top-level
926/// qualifiers on T1 and T2 are ignored. This function will typically
927/// be called in a loop that successively "unwraps" pointer and
928/// pointer-to-member types to compare them at each level.
Chris Lattnerecb81f22009-02-16 21:43:00 +0000929bool Sema::UnwrapSimilarPointerTypes(QualType& T1, QualType& T2) {
Douglas Gregor57373262008-10-22 14:17:15 +0000930 const PointerType *T1PtrType = T1->getAsPointerType(),
931 *T2PtrType = T2->getAsPointerType();
932 if (T1PtrType && T2PtrType) {
933 T1 = T1PtrType->getPointeeType();
934 T2 = T2PtrType->getPointeeType();
935 return true;
936 }
937
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000938 const MemberPointerType *T1MPType = T1->getAsMemberPointerType(),
939 *T2MPType = T2->getAsMemberPointerType();
Sebastian Redl21593ac2009-01-28 18:33:18 +0000940 if (T1MPType && T2MPType &&
941 Context.getCanonicalType(T1MPType->getClass()) ==
942 Context.getCanonicalType(T2MPType->getClass())) {
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000943 T1 = T1MPType->getPointeeType();
944 T2 = T2MPType->getPointeeType();
945 return true;
946 }
Douglas Gregor57373262008-10-22 14:17:15 +0000947 return false;
948}
949
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000950Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
Reid Spencer5f016e22007-07-11 17:01:13 +0000951 // C99 6.7.6: Type names have no identifier. This is already validated by
952 // the parser.
953 assert(D.getIdentifier() == 0 && "Type name should have no identifier!");
954
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000955 QualType T = GetTypeForDeclarator(D, S);
Chris Lattner5153ee62009-04-25 08:47:54 +0000956 if (D.isInvalidType())
Douglas Gregor809070a2009-02-18 17:45:20 +0000957 return true;
Steve Naroff5912a352007-08-28 20:14:24 +0000958
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000959 // Check that there are no default arguments (C++ only).
960 if (getLangOptions().CPlusPlus)
961 CheckExtraCXXDefaultArguments(D);
962
Reid Spencer5f016e22007-07-11 17:01:13 +0000963 return T.getAsOpaquePtr();
964}
965
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000966
967
968//===----------------------------------------------------------------------===//
969// Type Attribute Processing
970//===----------------------------------------------------------------------===//
971
972/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
973/// specified type. The attribute contains 1 argument, the id of the address
974/// space for the type.
975static void HandleAddressSpaceTypeAttribute(QualType &Type,
976 const AttributeList &Attr, Sema &S){
977 // If this type is already address space qualified, reject it.
978 // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers
979 // for two or more different address spaces."
980 if (Type.getAddressSpace()) {
981 S.Diag(Attr.getLoc(), diag::err_attribute_address_multiple_qualifiers);
982 return;
983 }
984
985 // Check the attribute arguments.
986 if (Attr.getNumArgs() != 1) {
Chris Lattnerf3a41af2008-11-20 06:38:18 +0000987 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000988 return;
989 }
990 Expr *ASArgExpr = static_cast<Expr *>(Attr.getArg(0));
991 llvm::APSInt addrSpace(32);
992 if (!ASArgExpr->isIntegerConstantExpr(addrSpace, S.Context)) {
Chris Lattnerdcd5ef12008-11-19 05:27:50 +0000993 S.Diag(Attr.getLoc(), diag::err_attribute_address_space_not_int)
994 << ASArgExpr->getSourceRange();
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000995 return;
996 }
997
998 unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
Fariborz Jahanianf11284a2009-02-17 18:27:45 +0000999 Type = S.Context.getAddrSpaceQualType(Type, ASIdx);
Chris Lattnerc9b346d2008-06-29 00:50:08 +00001000}
1001
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001002/// HandleObjCGCTypeAttribute - Process an objc's gc attribute on the
1003/// specified type. The attribute contains 1 argument, weak or strong.
1004static void HandleObjCGCTypeAttribute(QualType &Type,
Chris Lattner3b6b83b2009-02-18 22:58:38 +00001005 const AttributeList &Attr, Sema &S) {
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001006 if (Type.getObjCGCAttr() != QualType::GCNone) {
Fariborz Jahanian5934e752009-02-18 18:52:41 +00001007 S.Diag(Attr.getLoc(), diag::err_attribute_multiple_objc_gc);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001008 return;
1009 }
1010
1011 // Check the attribute arguments.
Fariborz Jahanianba372b82009-02-18 17:52:36 +00001012 if (!Attr.getParameterName()) {
1013 S.Diag(Attr.getLoc(), diag::err_attribute_argument_n_not_string)
1014 << "objc_gc" << 1;
1015 return;
1016 }
Chris Lattner3b6b83b2009-02-18 22:58:38 +00001017 QualType::GCAttrTypes GCAttr;
Fariborz Jahanianba372b82009-02-18 17:52:36 +00001018 if (Attr.getNumArgs() != 0) {
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001019 S.Diag(Attr.getLoc(), diag::err_attribute_wrong_number_arguments) << 1;
1020 return;
1021 }
1022 if (Attr.getParameterName()->isStr("weak"))
Chris Lattner3b6b83b2009-02-18 22:58:38 +00001023 GCAttr = QualType::Weak;
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001024 else if (Attr.getParameterName()->isStr("strong"))
Chris Lattner3b6b83b2009-02-18 22:58:38 +00001025 GCAttr = QualType::Strong;
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001026 else {
1027 S.Diag(Attr.getLoc(), diag::warn_attribute_type_not_supported)
1028 << "objc_gc" << Attr.getParameterName();
1029 return;
1030 }
1031
Chris Lattner3b6b83b2009-02-18 22:58:38 +00001032 Type = S.Context.getObjCGCQualType(Type, GCAttr);
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001033}
1034
Chris Lattnerc9b346d2008-06-29 00:50:08 +00001035void Sema::ProcessTypeAttributeList(QualType &Result, const AttributeList *AL) {
Chris Lattner232e8822008-02-21 01:08:11 +00001036 // Scan through and apply attributes to this type where it makes sense. Some
1037 // attributes (such as __address_space__, __vector_size__, etc) apply to the
1038 // type, but others can be present in the type specifiers even though they
Chris Lattnerfca0ddd2008-06-26 06:27:57 +00001039 // apply to the decl. Here we apply type attributes and ignore the rest.
1040 for (; AL; AL = AL->getNext()) {
Chris Lattner232e8822008-02-21 01:08:11 +00001041 // If this is an attribute we can handle, do so now, otherwise, add it to
1042 // the LeftOverAttrs list for rechaining.
Chris Lattnerfca0ddd2008-06-26 06:27:57 +00001043 switch (AL->getKind()) {
Chris Lattner232e8822008-02-21 01:08:11 +00001044 default: break;
1045 case AttributeList::AT_address_space:
Chris Lattnerc9b346d2008-06-29 00:50:08 +00001046 HandleAddressSpaceTypeAttribute(Result, *AL, *this);
1047 break;
Fariborz Jahaniand33d9c02009-02-18 05:09:49 +00001048 case AttributeList::AT_objc_gc:
1049 HandleObjCGCTypeAttribute(Result, *AL, *this);
1050 break;
Chris Lattner232e8822008-02-21 01:08:11 +00001051 }
Chris Lattner232e8822008-02-21 01:08:11 +00001052 }
Chris Lattner232e8822008-02-21 01:08:11 +00001053}
1054
Douglas Gregor86447ec2009-03-09 16:13:40 +00001055/// @brief Ensure that the type T is a complete type.
Douglas Gregor4ec339f2009-01-19 19:26:10 +00001056///
1057/// This routine checks whether the type @p T is complete in any
1058/// context where a complete type is required. If @p T is a complete
Douglas Gregor86447ec2009-03-09 16:13:40 +00001059/// type, returns false. If @p T is a class template specialization,
1060/// this routine then attempts to perform class template
1061/// instantiation. If instantiation fails, or if @p T is incomplete
1062/// and cannot be completed, issues the diagnostic @p diag (giving it
1063/// the type @p T) and returns true.
Douglas Gregor4ec339f2009-01-19 19:26:10 +00001064///
1065/// @param Loc The location in the source that the incomplete type
1066/// diagnostic should refer to.
1067///
1068/// @param T The type that this routine is examining for completeness.
1069///
1070/// @param diag The diagnostic value (e.g.,
1071/// @c diag::err_typecheck_decl_incomplete_type) that will be used
1072/// for the error message if @p T is incomplete.
1073///
1074/// @param Range1 An optional range in the source code that will be a
1075/// part of the "incomplete type" error message.
1076///
1077/// @param Range2 An optional range in the source code that will be a
1078/// part of the "incomplete type" error message.
1079///
1080/// @param PrintType If non-NULL, the type that should be printed
1081/// instead of @p T. This parameter should be used when the type that
1082/// we're checking for incompleteness isn't the type that should be
1083/// displayed to the user, e.g., when T is a type and PrintType is a
1084/// pointer to T.
1085///
1086/// @returns @c true if @p T is incomplete and a diagnostic was emitted,
1087/// @c false otherwise.
Douglas Gregor86447ec2009-03-09 16:13:40 +00001088bool Sema::RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Chris Lattner1efaa952009-04-24 00:30:45 +00001089 SourceRange Range1, SourceRange Range2,
1090 QualType PrintType) {
Douglas Gregor4ec339f2009-01-19 19:26:10 +00001091 // If we have a complete type, we're done.
1092 if (!T->isIncompleteType())
1093 return false;
Eli Friedman3c0eb162008-05-27 03:33:27 +00001094
Douglas Gregord475b8d2009-03-25 21:17:03 +00001095 // If we have a class template specialization or a class member of a
1096 // class template specialization, try to instantiate it.
1097 if (const RecordType *Record = T->getAsRecordType()) {
Douglas Gregor2943aed2009-03-03 04:44:36 +00001098 if (ClassTemplateSpecializationDecl *ClassTemplateSpec
Douglas Gregord475b8d2009-03-25 21:17:03 +00001099 = dyn_cast<ClassTemplateSpecializationDecl>(Record->getDecl())) {
Douglas Gregor2943aed2009-03-03 04:44:36 +00001100 if (ClassTemplateSpec->getSpecializationKind() == TSK_Undeclared) {
1101 // Update the class template specialization's location to
1102 // refer to the point of instantiation.
1103 if (Loc.isValid())
1104 ClassTemplateSpec->setLocation(Loc);
1105 return InstantiateClassTemplateSpecialization(ClassTemplateSpec,
1106 /*ExplicitInstantiation=*/false);
1107 }
Douglas Gregord475b8d2009-03-25 21:17:03 +00001108 } else if (CXXRecordDecl *Rec
1109 = dyn_cast<CXXRecordDecl>(Record->getDecl())) {
1110 if (CXXRecordDecl *Pattern = Rec->getInstantiatedFromMemberClass()) {
1111 // Find the class template specialization that surrounds this
1112 // member class.
1113 ClassTemplateSpecializationDecl *Spec = 0;
1114 for (DeclContext *Parent = Rec->getDeclContext();
1115 Parent && !Spec; Parent = Parent->getParent())
1116 Spec = dyn_cast<ClassTemplateSpecializationDecl>(Parent);
1117 assert(Spec && "Not a member of a class template specialization?");
1118 return InstantiateClass(Loc, Rec, Pattern,
1119 Spec->getTemplateArgs(),
1120 Spec->getNumTemplateArgs());
1121 }
1122 }
1123 }
Douglas Gregor2943aed2009-03-03 04:44:36 +00001124
Douglas Gregor4ec339f2009-01-19 19:26:10 +00001125 if (PrintType.isNull())
1126 PrintType = T;
1127
1128 // We have an incomplete type. Produce a diagnostic.
1129 Diag(Loc, diag) << PrintType << Range1 << Range2;
1130
1131 // If the type was a forward declaration of a class/struct/union
1132 // type, produce
1133 const TagType *Tag = 0;
1134 if (const RecordType *Record = T->getAsRecordType())
1135 Tag = Record;
1136 else if (const EnumType *Enum = T->getAsEnumType())
1137 Tag = Enum;
1138
1139 if (Tag && !Tag->getDecl()->isInvalidDecl())
1140 Diag(Tag->getDecl()->getLocation(),
1141 Tag->isBeingDefined() ? diag::note_type_being_defined
1142 : diag::note_forward_declaration)
1143 << QualType(Tag, 0);
1144
1145 return true;
1146}
Douglas Gregore6258932009-03-19 00:39:20 +00001147
1148/// \brief Retrieve a version of the type 'T' that is qualified by the
1149/// nested-name-specifier contained in SS.
1150QualType Sema::getQualifiedNameType(const CXXScopeSpec &SS, QualType T) {
1151 if (!SS.isSet() || SS.isInvalid() || T.isNull())
1152 return T;
1153
Douglas Gregorab452ba2009-03-26 23:50:42 +00001154 NestedNameSpecifier *NNS
Douglas Gregor35073692009-03-26 23:56:24 +00001155 = static_cast<NestedNameSpecifier *>(SS.getScopeRep());
Douglas Gregorab452ba2009-03-26 23:50:42 +00001156 return Context.getQualifiedNameType(NNS, T);
Douglas Gregore6258932009-03-19 00:39:20 +00001157}