blob: 76bb63b1add907da67d94568561361ac73e75144 [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- SemaType.cpp - Semantic Analysis for Types -----------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner959e5be2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattner4b009652007-07-25 00:24:17 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file implements type-related semantic analysis.
11//
12//===----------------------------------------------------------------------===//
13
14#include "Sema.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/Decl.h"
Steve Naroff3fafa102007-10-01 19:00:59 +000017#include "clang/AST/DeclObjC.h"
Chris Lattner4b009652007-07-25 00:24:17 +000018#include "clang/Parse/DeclSpec.h"
Chris Lattner11f20f92007-08-28 16:40:32 +000019#include "clang/Basic/LangOptions.h"
Chris Lattner4b009652007-07-25 00:24:17 +000020using namespace clang;
21
22/// ConvertDeclSpecToType - Convert the specified declspec to the appropriate
23/// type object. This returns null on error.
Chris Lattner726c5452008-02-20 23:53:49 +000024QualType Sema::ConvertDeclSpecToType(DeclSpec &DS) {
Chris Lattner4b009652007-07-25 00:24:17 +000025 // FIXME: Should move the logic from DeclSpec::Finish to here for validity
26 // checking.
Chris Lattner06fb8672008-02-20 21:40:32 +000027 QualType Result;
Chris Lattner4b009652007-07-25 00:24:17 +000028
29 switch (DS.getTypeSpecType()) {
30 default: return QualType(); // FIXME: Handle unimp cases!
Chris Lattner5fcb38b2008-04-02 06:50:17 +000031 case DeclSpec::TST_void:
32 Result = Context.VoidTy;
33 break;
Chris Lattner4b009652007-07-25 00:24:17 +000034 case DeclSpec::TST_char:
35 if (DS.getTypeSpecSign() == DeclSpec::TSS_unspecified)
Chris Lattner726c5452008-02-20 23:53:49 +000036 Result = Context.CharTy;
Chris Lattner4b009652007-07-25 00:24:17 +000037 else if (DS.getTypeSpecSign() == DeclSpec::TSS_signed)
Chris Lattner726c5452008-02-20 23:53:49 +000038 Result = Context.SignedCharTy;
Chris Lattner4b009652007-07-25 00:24:17 +000039 else {
40 assert(DS.getTypeSpecSign() == DeclSpec::TSS_unsigned &&
41 "Unknown TSS value");
Chris Lattner726c5452008-02-20 23:53:49 +000042 Result = Context.UnsignedCharTy;
Chris Lattner4b009652007-07-25 00:24:17 +000043 }
Chris Lattner06fb8672008-02-20 21:40:32 +000044 break;
Chris Lattner4b009652007-07-25 00:24:17 +000045 case DeclSpec::TST_unspecified: // Unspecific typespec defaults to int.
Chris Lattner5328f312007-08-21 17:02:28 +000046 case DeclSpec::TST_int: {
Chris Lattner4b009652007-07-25 00:24:17 +000047 if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
48 switch (DS.getTypeSpecWidth()) {
Chris Lattner726c5452008-02-20 23:53:49 +000049 case DeclSpec::TSW_unspecified: Result = Context.IntTy; break;
50 case DeclSpec::TSW_short: Result = Context.ShortTy; break;
51 case DeclSpec::TSW_long: Result = Context.LongTy; break;
52 case DeclSpec::TSW_longlong: Result = Context.LongLongTy; break;
Chris Lattner4b009652007-07-25 00:24:17 +000053 }
54 } else {
55 switch (DS.getTypeSpecWidth()) {
Chris Lattner726c5452008-02-20 23:53:49 +000056 case DeclSpec::TSW_unspecified: Result = Context.UnsignedIntTy; break;
57 case DeclSpec::TSW_short: Result = Context.UnsignedShortTy; break;
58 case DeclSpec::TSW_long: Result = Context.UnsignedLongTy; break;
59 case DeclSpec::TSW_longlong: Result =Context.UnsignedLongLongTy; break;
Chris Lattner4b009652007-07-25 00:24:17 +000060 }
61 }
Chris Lattner06fb8672008-02-20 21:40:32 +000062 break;
Chris Lattner5328f312007-08-21 17:02:28 +000063 }
Chris Lattner726c5452008-02-20 23:53:49 +000064 case DeclSpec::TST_float: Result = Context.FloatTy; break;
Chris Lattner06fb8672008-02-20 21:40:32 +000065 case DeclSpec::TST_double:
66 if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
Chris Lattner726c5452008-02-20 23:53:49 +000067 Result = Context.LongDoubleTy;
Chris Lattner06fb8672008-02-20 21:40:32 +000068 else
Chris Lattner726c5452008-02-20 23:53:49 +000069 Result = Context.DoubleTy;
Chris Lattner06fb8672008-02-20 21:40:32 +000070 break;
Chris Lattner726c5452008-02-20 23:53:49 +000071 case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
Chris Lattner4b009652007-07-25 00:24:17 +000072 case DeclSpec::TST_decimal32: // _Decimal32
73 case DeclSpec::TST_decimal64: // _Decimal64
74 case DeclSpec::TST_decimal128: // _Decimal128
75 assert(0 && "FIXME: GNU decimal extensions not supported yet!");
76 case DeclSpec::TST_enum:
77 case DeclSpec::TST_union:
78 case DeclSpec::TST_struct: {
79 Decl *D = static_cast<Decl *>(DS.getTypeRep());
80 assert(D && "Didn't get a decl for a enum/union/struct?");
81 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
82 DS.getTypeSpecSign() == 0 &&
83 "Can't handle qualifiers on typedef names yet!");
84 // TypeQuals handled by caller.
Chris Lattner726c5452008-02-20 23:53:49 +000085 Result = Context.getTagDeclType(cast<TagDecl>(D));
Chris Lattner06fb8672008-02-20 21:40:32 +000086 break;
Chris Lattner4b009652007-07-25 00:24:17 +000087 }
88 case DeclSpec::TST_typedef: {
89 Decl *D = static_cast<Decl *>(DS.getTypeRep());
90 assert(D && "Didn't get a decl for a typedef?");
91 assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
92 DS.getTypeSpecSign() == 0 &&
93 "Can't handle qualifiers on typedef names yet!");
Steve Naroff81f1bba2007-09-06 21:24:23 +000094 // FIXME: Adding a TST_objcInterface clause doesn't seem ideal, so
95 // we have this "hack" for now...
Ted Kremenek42730c52008-01-07 19:49:32 +000096 if (ObjCInterfaceDecl *ObjCIntDecl = dyn_cast<ObjCInterfaceDecl>(D)) {
Chris Lattner06fb8672008-02-20 21:40:32 +000097 if (DS.getProtocolQualifiers() == 0) {
Chris Lattner726c5452008-02-20 23:53:49 +000098 Result = Context.getObjCInterfaceType(ObjCIntDecl);
Chris Lattner06fb8672008-02-20 21:40:32 +000099 break;
100 }
Fariborz Jahanian91193f62007-10-11 00:55:41 +0000101
102 Action::DeclTy **PPDecl = &(*DS.getProtocolQualifiers())[0];
Chris Lattner726c5452008-02-20 23:53:49 +0000103 Result = Context.getObjCQualifiedInterfaceType(ObjCIntDecl,
Chris Lattner06fb8672008-02-20 21:40:32 +0000104 reinterpret_cast<ObjCProtocolDecl**>(PPDecl),
Chris Lattner69f01932008-02-21 01:32:26 +0000105 DS.getNumProtocolQualifiers());
Chris Lattner06fb8672008-02-20 21:40:32 +0000106 break;
Fariborz Jahanian91193f62007-10-11 00:55:41 +0000107 }
Fariborz Jahaniane76e8412007-12-17 21:03:50 +0000108 else if (TypedefDecl *typeDecl = dyn_cast<TypedefDecl>(D)) {
Chris Lattner726c5452008-02-20 23:53:49 +0000109 if (Context.getObjCIdType() == Context.getTypedefType(typeDecl)
Fariborz Jahaniane76e8412007-12-17 21:03:50 +0000110 && DS.getProtocolQualifiers()) {
111 // id<protocol-list>
112 Action::DeclTy **PPDecl = &(*DS.getProtocolQualifiers())[0];
Chris Lattner726c5452008-02-20 23:53:49 +0000113 Result = Context.getObjCQualifiedIdType(typeDecl->getUnderlyingType(),
Chris Lattner06fb8672008-02-20 21:40:32 +0000114 reinterpret_cast<ObjCProtocolDecl**>(PPDecl),
Chris Lattner69f01932008-02-21 01:32:26 +0000115 DS.getNumProtocolQualifiers());
Chris Lattner06fb8672008-02-20 21:40:32 +0000116 break;
Fariborz Jahaniane76e8412007-12-17 21:03:50 +0000117 }
118 }
Chris Lattner4b009652007-07-25 00:24:17 +0000119 // TypeQuals handled by caller.
Chris Lattner726c5452008-02-20 23:53:49 +0000120 Result = Context.getTypedefType(cast<TypedefDecl>(D));
Chris Lattner06fb8672008-02-20 21:40:32 +0000121 break;
Chris Lattner4b009652007-07-25 00:24:17 +0000122 }
Chris Lattner06fb8672008-02-20 21:40:32 +0000123 case DeclSpec::TST_typeofType:
124 Result = QualType::getFromOpaquePtr(DS.getTypeRep());
125 assert(!Result.isNull() && "Didn't get a type for typeof?");
Steve Naroff7cbb1462007-07-31 12:34:36 +0000126 // TypeQuals handled by caller.
Chris Lattner726c5452008-02-20 23:53:49 +0000127 Result = Context.getTypeOfType(Result);
Chris Lattner06fb8672008-02-20 21:40:32 +0000128 break;
Steve Naroff7cbb1462007-07-31 12:34:36 +0000129 case DeclSpec::TST_typeofExpr: {
130 Expr *E = static_cast<Expr *>(DS.getTypeRep());
131 assert(E && "Didn't get an expression for typeof?");
132 // TypeQuals handled by caller.
Chris Lattner726c5452008-02-20 23:53:49 +0000133 Result = Context.getTypeOfExpr(E);
Chris Lattner06fb8672008-02-20 21:40:32 +0000134 break;
Steve Naroff7cbb1462007-07-31 12:34:36 +0000135 }
Chris Lattner4b009652007-07-25 00:24:17 +0000136 }
Chris Lattner06fb8672008-02-20 21:40:32 +0000137
138 // Handle complex types.
139 if (DS.getTypeSpecComplex() == DeclSpec::TSC_complex)
Chris Lattner726c5452008-02-20 23:53:49 +0000140 Result = Context.getComplexType(Result);
Chris Lattner06fb8672008-02-20 21:40:32 +0000141
142 assert(DS.getTypeSpecComplex() != DeclSpec::TSC_imaginary &&
143 "FIXME: imaginary types not supported yet!");
144
Chris Lattnerd496fb92008-02-20 22:04:11 +0000145 // See if there are any attributes on the declspec that apply to the type (as
146 // opposed to the decl).
Chris Lattner9e982502008-02-21 01:07:18 +0000147 if (AttributeList *AL = DS.getAttributes())
148 DS.SetAttributes(ProcessTypeAttributes(Result, AL));
149
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000150 // Apply const/volatile/restrict qualifiers to T.
151 if (unsigned TypeQuals = DS.getTypeQualifiers()) {
152
153 // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
154 // or incomplete types shall not be restrict-qualified." C++ also allows
155 // restrict-qualified references.
156 if (TypeQuals & QualType::Restrict) {
157 QualType EltTy;
158 if (const PointerType *PT = Result->getAsPointerType())
159 EltTy = PT->getPointeeType();
160 else if (const ReferenceType *RT = Result->getAsReferenceType())
161 EltTy = RT->getReferenceeType();
162 else {
163 Diag(DS.getRestrictSpecLoc(),
164 diag::err_typecheck_invalid_restrict_not_pointer,
165 Result.getAsString(), DS.getSourceRange());
166 }
167
168 // If we have a pointer or reference, the pointee must have an object or
169 // incomplete type.
Chris Lattner9db553e2008-04-02 06:59:01 +0000170 if (!EltTy.isNull() && !EltTy->isIncompleteOrObjectType()) {
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000171 Diag(DS.getRestrictSpecLoc(),
172 diag::err_typecheck_invalid_restrict_invalid_pointee,
173 EltTy.getAsString(), DS.getSourceRange());
174 EltTy = QualType();
175 }
176
177 if (EltTy.isNull()) // Invalid restrict: remove the restrict qualifier.
178 TypeQuals &= ~QualType::Restrict;
179 }
180
181 // Warn about CV qualifiers on functions: C99 6.7.3p8: "If the specification
182 // of a function type includes any type qualifiers, the behavior is
183 // undefined."
184 if (Result->isFunctionType() && TypeQuals) {
185 // Get some location to point at, either the C or V location.
186 SourceLocation Loc;
187 if (TypeQuals & QualType::Const)
188 Loc = DS.getConstSpecLoc();
189 else {
190 assert((TypeQuals & QualType::Volatile) &&
191 "Has CV quals but not C or V?");
192 Loc = DS.getVolatileSpecLoc();
193 }
194 Diag(Loc, diag::warn_typecheck_function_qualifiers,
195 Result.getAsString(), DS.getSourceRange());
196 }
197
198 Result = Result.getQualifiedType(TypeQuals);
199 }
Chris Lattner9e982502008-02-21 01:07:18 +0000200 return Result;
201}
202
Chris Lattner4b009652007-07-25 00:24:17 +0000203/// GetTypeForDeclarator - Convert the type for the specified declarator to Type
204/// instances.
205QualType Sema::GetTypeForDeclarator(Declarator &D, Scope *S) {
Chris Lattner11f20f92007-08-28 16:40:32 +0000206 // long long is a C99 feature.
Chris Lattner1a7d9912007-08-28 16:41:29 +0000207 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x &&
Chris Lattner11f20f92007-08-28 16:40:32 +0000208 D.getDeclSpec().getTypeSpecWidth() == DeclSpec::TSW_longlong)
209 Diag(D.getDeclSpec().getTypeSpecWidthLoc(), diag::ext_longlong);
210
Chris Lattner726c5452008-02-20 23:53:49 +0000211 QualType T = ConvertDeclSpecToType(D.getDeclSpec());
Steve Naroff91b03f72007-08-28 03:03:08 +0000212
Chris Lattner4b009652007-07-25 00:24:17 +0000213 // Walk the DeclTypeInfo, building the recursive type as we go. DeclTypeInfos
214 // are ordered from the identifier out, which is opposite of what we want :).
215 for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {
Chris Lattner69f01932008-02-21 01:32:26 +0000216 DeclaratorChunk &DeclType = D.getTypeObject(e-i-1);
Chris Lattner4b009652007-07-25 00:24:17 +0000217 switch (DeclType.Kind) {
218 default: assert(0 && "Unknown decltype!");
219 case DeclaratorChunk::Pointer:
Chris Lattner36be3d82007-07-31 21:33:24 +0000220 if (T->isReferenceType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000221 // C++ 8.3.2p4: There shall be no ... pointers to references ...
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000222 Diag(DeclType.Loc, diag::err_illegal_decl_pointer_to_reference,
Steve Naroff73458bf2008-01-14 23:33:18 +0000223 D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
Steve Naroff91b03f72007-08-28 03:03:08 +0000224 D.setInvalidType(true);
Chris Lattner4b009652007-07-25 00:24:17 +0000225 T = Context.IntTy;
226 }
227
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000228 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
229 // object or incomplete types shall not be restrict-qualified."
230 if ((DeclType.Ptr.TypeQuals & QualType::Restrict) &&
Chris Lattner9db553e2008-04-02 06:59:01 +0000231 !T->isIncompleteOrObjectType()) {
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000232 Diag(DeclType.Loc,
233 diag::err_typecheck_invalid_restrict_invalid_pointee,
234 T.getAsString());
235 DeclType.Ptr.TypeQuals &= QualType::Restrict;
236 }
237
Chris Lattner4b009652007-07-25 00:24:17 +0000238 // Apply the pointer typequals to the pointer object.
239 T = Context.getPointerType(T).getQualifiedType(DeclType.Ptr.TypeQuals);
Chris Lattner69f01932008-02-21 01:32:26 +0000240
241 // See if there are any attributes on the pointer that apply to it.
242 if (AttributeList *AL = DeclType.Ptr.AttrList)
243 DeclType.Ptr.AttrList = ProcessTypeAttributes(T, AL);
244
Chris Lattner4b009652007-07-25 00:24:17 +0000245 break;
246 case DeclaratorChunk::Reference:
Chris Lattnerf0c4a0a2007-07-31 16:56:34 +0000247 if (const ReferenceType *RT = T->getAsReferenceType()) {
Chris Lattner2e7d57f2008-02-21 01:32:57 +0000248 // C++ 8.3.2p4: There shall be no references to references.
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000249 Diag(DeclType.Loc, diag::err_illegal_decl_reference_to_reference,
Steve Naroff73458bf2008-01-14 23:33:18 +0000250 D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
Steve Naroff91b03f72007-08-28 03:03:08 +0000251 D.setInvalidType(true);
Chris Lattner4b009652007-07-25 00:24:17 +0000252 T = RT->getReferenceeType();
253 }
254
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000255 // Enforce C99 6.7.3p2: "Types other than pointer types derived from
256 // object or incomplete types shall not be restrict-qualified."
257 if (DeclType.Ref.HasRestrict &&
Chris Lattner9db553e2008-04-02 06:59:01 +0000258 !T->isIncompleteOrObjectType()) {
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000259 Diag(DeclType.Loc,
260 diag::err_typecheck_invalid_restrict_invalid_pointee,
261 T.getAsString());
262 DeclType.Ref.HasRestrict = false;
263 }
264
Chris Lattner4b009652007-07-25 00:24:17 +0000265 T = Context.getReferenceType(T);
Chris Lattner5fcb38b2008-04-02 06:50:17 +0000266
267 // Handle restrict on references.
268 if (DeclType.Ref.HasRestrict)
269 T.addRestrict();
Chris Lattner2e7d57f2008-02-21 01:32:57 +0000270
Chris Lattner69f01932008-02-21 01:32:26 +0000271 // See if there are any attributes on the pointer that apply to it.
272 if (AttributeList *AL = DeclType.Ref.AttrList)
273 DeclType.Ref.AttrList = ProcessTypeAttributes(T, AL);
Chris Lattner4b009652007-07-25 00:24:17 +0000274 break;
275 case DeclaratorChunk::Array: {
Chris Lattner67d3c8d2008-04-02 01:05:10 +0000276 DeclaratorChunk::ArrayTypeInfo &ATI = DeclType.Arr;
Chris Lattner47958f62007-08-28 16:54:00 +0000277 Expr *ArraySize = static_cast<Expr*>(ATI.NumElts);
Chris Lattner4b009652007-07-25 00:24:17 +0000278 ArrayType::ArraySizeModifier ASM;
279 if (ATI.isStar)
280 ASM = ArrayType::Star;
281 else if (ATI.hasStatic)
282 ASM = ArrayType::Static;
283 else
284 ASM = ArrayType::Normal;
285
286 // C99 6.7.5.2p1: If the element type is an incomplete or function type,
287 // reject it (e.g. void ary[7], struct foo ary[7], void ary[7]())
288 if (T->isIncompleteType()) {
289 Diag(D.getIdentifierLoc(), diag::err_illegal_decl_array_incomplete_type,
290 T.getAsString());
Steve Naroff91b03f72007-08-28 03:03:08 +0000291 T = Context.IntTy;
292 D.setInvalidType(true);
Chris Lattner4b009652007-07-25 00:24:17 +0000293 } else if (T->isFunctionType()) {
294 Diag(D.getIdentifierLoc(), diag::err_illegal_decl_array_of_functions,
Steve Naroff73458bf2008-01-14 23:33:18 +0000295 D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
Steve Naroff91b03f72007-08-28 03:03:08 +0000296 T = Context.getPointerType(T);
297 D.setInvalidType(true);
Chris Lattnerf0c4a0a2007-07-31 16:56:34 +0000298 } else if (const ReferenceType *RT = T->getAsReferenceType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000299 // C++ 8.3.2p4: There shall be no ... arrays of references ...
300 Diag(D.getIdentifierLoc(), diag::err_illegal_decl_array_of_references,
Steve Naroff73458bf2008-01-14 23:33:18 +0000301 D.getIdentifier() ? D.getIdentifier()->getName() : "type name");
Steve Naroff91b03f72007-08-28 03:03:08 +0000302 T = RT->getReferenceeType();
303 D.setInvalidType(true);
Chris Lattner36be3d82007-07-31 21:33:24 +0000304 } else if (const RecordType *EltTy = T->getAsRecordType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000305 // If the element type is a struct or union that contains a variadic
306 // array, reject it: C99 6.7.2.1p2.
307 if (EltTy->getDecl()->hasFlexibleArrayMember()) {
308 Diag(DeclType.Loc, diag::err_flexible_array_in_array,
309 T.getAsString());
Steve Naroff91b03f72007-08-28 03:03:08 +0000310 T = Context.IntTy;
311 D.setInvalidType(true);
Chris Lattner4b009652007-07-25 00:24:17 +0000312 }
313 }
Steve Naroff63b6a642007-08-30 22:35:45 +0000314 // C99 6.7.5.2p1: The size expression shall have integer type.
315 if (ArraySize && !ArraySize->getType()->isIntegerType()) {
316 Diag(ArraySize->getLocStart(), diag::err_array_size_non_int,
317 ArraySize->getType().getAsString(), ArraySize->getSourceRange());
318 D.setInvalidType(true);
Chris Lattner67d3c8d2008-04-02 01:05:10 +0000319 delete ArraySize;
320 ATI.NumElts = ArraySize = 0;
Steve Naroff63b6a642007-08-30 22:35:45 +0000321 }
Steve Naroff24c9b982007-08-30 18:10:14 +0000322 llvm::APSInt ConstVal(32);
Chris Lattner67d3c8d2008-04-02 01:05:10 +0000323 // If no expression was provided, we consider it an incomplete array.
Eli Friedman8ff07782008-02-15 18:16:39 +0000324 if (!ArraySize) {
325 T = Context.getIncompleteArrayType(T, ASM, ATI.TypeQuals);
326 } else if (!ArraySize->isIntegerConstantExpr(ConstVal, Context)) {
Steve Naroff24c9b982007-08-30 18:10:14 +0000327 T = Context.getVariableArrayType(T, ArraySize, ASM, ATI.TypeQuals);
Eli Friedman8ff07782008-02-15 18:16:39 +0000328 } else {
Steve Naroff63b6a642007-08-30 22:35:45 +0000329 // C99 6.7.5.2p1: If the expression is a constant expression, it shall
330 // have a value greater than zero.
331 if (ConstVal.isSigned()) {
332 if (ConstVal.isNegative()) {
333 Diag(ArraySize->getLocStart(),
334 diag::err_typecheck_negative_array_size,
335 ArraySize->getSourceRange());
336 D.setInvalidType(true);
337 } else if (ConstVal == 0) {
338 // GCC accepts zero sized static arrays.
339 Diag(ArraySize->getLocStart(), diag::ext_typecheck_zero_array_size,
340 ArraySize->getSourceRange());
341 }
342 }
Steve Naroff24c9b982007-08-30 18:10:14 +0000343 T = Context.getConstantArrayType(T, ConstVal, ASM, ATI.TypeQuals);
Steve Naroff63b6a642007-08-30 22:35:45 +0000344 }
Chris Lattner47958f62007-08-28 16:54:00 +0000345 // If this is not C99, extwarn about VLA's and C99 array size modifiers.
346 if (!getLangOptions().C99 &&
347 (ASM != ArrayType::Normal ||
348 (ArraySize && !ArraySize->isIntegerConstantExpr(Context))))
349 Diag(D.getIdentifierLoc(), diag::ext_vla);
Chris Lattner4b009652007-07-25 00:24:17 +0000350 break;
351 }
352 case DeclaratorChunk::Function:
353 // If the function declarator has a prototype (i.e. it is not () and
354 // does not have a K&R-style identifier list), then the arguments are part
355 // of the type, otherwise the argument list is ().
356 const DeclaratorChunk::FunctionTypeInfo &FTI = DeclType.Fun;
Chris Lattnerbccfc152007-12-19 18:01:43 +0000357
Chris Lattner6ad7e882007-12-19 05:31:29 +0000358 // C99 6.7.5.3p1: The return type may not be a function or array type.
Chris Lattnerbccfc152007-12-19 18:01:43 +0000359 if (T->isArrayType() || T->isFunctionType()) {
Chris Lattner6ad7e882007-12-19 05:31:29 +0000360 Diag(DeclType.Loc, diag::err_func_returning_array_function,
361 T.getAsString());
362 T = Context.IntTy;
363 D.setInvalidType(true);
364 }
365
Chris Lattner4b009652007-07-25 00:24:17 +0000366 if (!FTI.hasPrototype) {
367 // Simple void foo(), where the incoming T is the result type.
368 T = Context.getFunctionTypeNoProto(T);
369
370 // C99 6.7.5.3p3: Reject int(x,y,z) when it's not a function definition.
371 if (FTI.NumArgs != 0)
372 Diag(FTI.ArgInfo[0].IdentLoc, diag::err_ident_list_in_fn_declaration);
373
374 } else {
375 // Otherwise, we have a function with an argument list that is
376 // potentially variadic.
377 llvm::SmallVector<QualType, 16> ArgTys;
378
379 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) {
380 QualType ArgTy = QualType::getFromOpaquePtr(FTI.ArgInfo[i].TypeInfo);
381 assert(!ArgTy.isNull() && "Couldn't parse type?");
Steve Naroff1830be72007-09-10 22:17:00 +0000382 //
383 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]).
384 // This matches the conversion that is done in
Nate Begeman2240f542007-11-13 21:49:48 +0000385 // Sema::ActOnParamDeclarator(). Without this conversion, the
Steve Naroff1830be72007-09-10 22:17:00 +0000386 // argument type in the function prototype *will not* match the
387 // type in ParmVarDecl (which makes the code generator unhappy).
388 //
389 // FIXME: We still apparently need the conversion in
Chris Lattner19eb97e2008-04-02 05:18:44 +0000390 // Sema::ActOnParamDeclarator(). This doesn't make any sense, since
Steve Naroff1830be72007-09-10 22:17:00 +0000391 // it should be driving off the type being created here.
392 //
393 // FIXME: If a source translation tool needs to see the original type,
394 // then we need to consider storing both types somewhere...
395 //
Chris Lattner19eb97e2008-04-02 05:18:44 +0000396 if (ArgTy->isArrayType()) {
397 ArgTy = Context.getArrayDecayedType(ArgTy);
Chris Lattnerc08564a2008-01-02 22:50:48 +0000398 } else if (ArgTy->isFunctionType())
Steve Naroff1830be72007-09-10 22:17:00 +0000399 ArgTy = Context.getPointerType(ArgTy);
Chris Lattner19eb97e2008-04-02 05:18:44 +0000400
Chris Lattner4b009652007-07-25 00:24:17 +0000401 // Look for 'void'. void is allowed only as a single argument to a
402 // function with no other parameters (C99 6.7.5.3p10). We record
403 // int(void) as a FunctionTypeProto with an empty argument list.
Steve Naroff1830be72007-09-10 22:17:00 +0000404 else if (ArgTy->isVoidType()) {
Chris Lattner4b009652007-07-25 00:24:17 +0000405 // If this is something like 'float(int, void)', reject it. 'void'
406 // is an incomplete type (C99 6.2.5p19) and function decls cannot
407 // have arguments of incomplete type.
408 if (FTI.NumArgs != 1 || FTI.isVariadic) {
409 Diag(DeclType.Loc, diag::err_void_only_param);
410 ArgTy = Context.IntTy;
411 FTI.ArgInfo[i].TypeInfo = ArgTy.getAsOpaquePtr();
412 } else if (FTI.ArgInfo[i].Ident) {
413 // Reject, but continue to parse 'int(void abc)'.
414 Diag(FTI.ArgInfo[i].IdentLoc,
415 diag::err_param_with_void_type);
416 ArgTy = Context.IntTy;
417 FTI.ArgInfo[i].TypeInfo = ArgTy.getAsOpaquePtr();
418 } else {
419 // Reject, but continue to parse 'float(const void)'.
Chris Lattner35fef522008-02-20 20:55:12 +0000420 if (ArgTy.getCVRQualifiers())
Chris Lattner4b009652007-07-25 00:24:17 +0000421 Diag(DeclType.Loc, diag::err_void_param_qualified);
422
423 // Do not add 'void' to the ArgTys list.
424 break;
425 }
426 }
427
428 ArgTys.push_back(ArgTy);
429 }
430 T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
431 FTI.isVariadic);
432 }
433 break;
434 }
435 }
436
437 return T;
438}
439
Ted Kremenek42730c52008-01-07 19:49:32 +0000440/// ObjCGetTypeForMethodDefinition - Builds the type for a method definition
Fariborz Jahanianff746bc2007-11-09 22:27:59 +0000441/// declarator
Ted Kremenek42730c52008-01-07 19:49:32 +0000442QualType Sema::ObjCGetTypeForMethodDefinition(DeclTy *D) {
443 ObjCMethodDecl *MDecl = dyn_cast<ObjCMethodDecl>(static_cast<Decl *>(D));
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000444 QualType T = MDecl->getResultType();
445 llvm::SmallVector<QualType, 16> ArgTys;
446
Fariborz Jahanianea86cb82007-11-09 17:18:29 +0000447 // Add the first two invisible argument types for self and _cmd.
Fariborz Jahanian8473b222007-11-09 19:52:12 +0000448 if (MDecl->isInstance()) {
Ted Kremenek42730c52008-01-07 19:49:32 +0000449 QualType selfTy = Context.getObjCInterfaceType(MDecl->getClassInterface());
Fariborz Jahanian8473b222007-11-09 19:52:12 +0000450 selfTy = Context.getPointerType(selfTy);
451 ArgTys.push_back(selfTy);
452 }
Fariborz Jahanianea86cb82007-11-09 17:18:29 +0000453 else
Ted Kremenek42730c52008-01-07 19:49:32 +0000454 ArgTys.push_back(Context.getObjCIdType());
455 ArgTys.push_back(Context.getObjCSelType());
Fariborz Jahanianea86cb82007-11-09 17:18:29 +0000456
Chris Lattner685d7922008-03-16 01:07:14 +0000457 for (int i = 0, e = MDecl->getNumParams(); i != e; ++i) {
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000458 ParmVarDecl *PDecl = MDecl->getParamDecl(i);
459 QualType ArgTy = PDecl->getType();
460 assert(!ArgTy.isNull() && "Couldn't parse type?");
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000461 // Perform the default function/array conversion (C99 6.7.5.3p[7,8]).
462 // This matches the conversion that is done in
Chris Lattner19eb97e2008-04-02 05:18:44 +0000463 // Sema::ActOnParamDeclarator().
464 if (ArgTy->isArrayType())
465 ArgTy = Context.getArrayDecayedType(ArgTy);
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000466 else if (ArgTy->isFunctionType())
467 ArgTy = Context.getPointerType(ArgTy);
468 ArgTys.push_back(ArgTy);
469 }
470 T = Context.getFunctionType(T, &ArgTys[0], ArgTys.size(),
Steve Naroffc1a88c12007-12-18 03:41:15 +0000471 MDecl->isVariadic());
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000472 return T;
473}
474
Steve Naroff0acc9c92007-09-15 18:49:24 +0000475Sema::TypeResult Sema::ActOnTypeName(Scope *S, Declarator &D) {
Chris Lattner4b009652007-07-25 00:24:17 +0000476 // C99 6.7.6: Type names have no identifier. This is already validated by
477 // the parser.
478 assert(D.getIdentifier() == 0 && "Type name should have no identifier!");
479
480 QualType T = GetTypeForDeclarator(D, S);
Steve Naroffd1ad6ae2007-08-28 20:14:24 +0000481
482 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
Chris Lattner4b009652007-07-25 00:24:17 +0000483
Steve Naroffd1ad6ae2007-08-28 20:14:24 +0000484 // In this context, we *do not* check D.getInvalidType(). If the declarator
485 // type was invalid, GetTypeForDeclarator() still returns a "valid" type,
486 // though it will not reflect the user specified type.
Chris Lattner4b009652007-07-25 00:24:17 +0000487 return T.getAsOpaquePtr();
488}
489
Steve Naroff91b03f72007-08-28 03:03:08 +0000490// Called from Parser::ParseParenDeclarator().
Steve Naroff0acc9c92007-09-15 18:49:24 +0000491Sema::TypeResult Sema::ActOnParamDeclaratorType(Scope *S, Declarator &D) {
Chris Lattner4b009652007-07-25 00:24:17 +0000492 // Note: parameters have identifiers, but we don't care about them here, we
493 // just want the type converted.
494 QualType T = GetTypeForDeclarator(D, S);
495
Steve Naroffd1ad6ae2007-08-28 20:14:24 +0000496 assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
497
498 // In this context, we *do not* check D.getInvalidType(). If the declarator
499 // type was invalid, GetTypeForDeclarator() still returns a "valid" type,
500 // though it will not reflect the user specified type.
Chris Lattner4b009652007-07-25 00:24:17 +0000501 return T.getAsOpaquePtr();
502}
Chris Lattner1aaeeb92008-02-21 01:08:11 +0000503
504AttributeList *Sema::ProcessTypeAttributes(QualType &Result, AttributeList *AL){
505 // Scan through and apply attributes to this type where it makes sense. Some
506 // attributes (such as __address_space__, __vector_size__, etc) apply to the
507 // type, but others can be present in the type specifiers even though they
508 // apply to the decl. Here we apply and delete attributes that apply to the
509 // type and leave the others alone.
510 llvm::SmallVector<AttributeList *, 8> LeftOverAttrs;
511 while (AL) {
512 // Unlink this attribute from the chain, so we can process it independently.
513 AttributeList *ThisAttr = AL;
514 AL = AL->getNext();
515 ThisAttr->setNext(0);
516
517 // If this is an attribute we can handle, do so now, otherwise, add it to
518 // the LeftOverAttrs list for rechaining.
519 switch (ThisAttr->getKind()) {
520 default: break;
521 case AttributeList::AT_address_space:
522 Result = HandleAddressSpaceTypeAttribute(Result, ThisAttr);
523 delete ThisAttr; // Consume the attribute.
524 continue;
525 }
526
527 LeftOverAttrs.push_back(ThisAttr);
528 }
529
530 // Rechain any attributes that haven't been deleted to the DeclSpec.
531 AttributeList *List = 0;
532 for (unsigned i = 0, e = LeftOverAttrs.size(); i != e; ++i) {
533 LeftOverAttrs[i]->setNext(List);
534 List = LeftOverAttrs[i];
535 }
536
537 return List;
538}
539
540/// HandleAddressSpaceTypeAttribute - Process an address_space attribute on the
541/// specified type.
542QualType Sema::HandleAddressSpaceTypeAttribute(QualType Type,
543 AttributeList *Attr) {
544 // If this type is already address space qualified, reject it.
545 // Clause 6.7.3 - Type qualifiers: "No type shall be qualified by qualifiers
546 // for two or more different address spaces."
547 if (Type.getAddressSpace()) {
548 Diag(Attr->getLoc(), diag::err_attribute_address_multiple_qualifiers);
549 return Type;
550 }
551
552 // Check the attribute arguments.
553 if (Attr->getNumArgs() != 1) {
554 Diag(Attr->getLoc(), diag::err_attribute_wrong_number_arguments,
555 std::string("1"));
556 return Type;
557 }
558 Expr *ASArgExpr = static_cast<Expr *>(Attr->getArg(0));
559 llvm::APSInt addrSpace(32);
560 if (!ASArgExpr->isIntegerConstantExpr(addrSpace, Context)) {
561 Diag(Attr->getLoc(), diag::err_attribute_address_space_not_int,
562 ASArgExpr->getSourceRange());
563 return Type;
564 }
565
566 unsigned ASIdx = static_cast<unsigned>(addrSpace.getZExtValue());
567 return Context.getASQualType(Type, ASIdx);
568}
569