blob: 7b305737c2a91beb8f49623279a3cd8cec5a4758 [file] [log] [blame]
Chris Lattner4b009652007-07-25 00:24:17 +00001//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
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 defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_SEMA_H
16#define LLVM_CLANG_AST_SEMA_H
17
Chris Lattner2a1e2ed2008-04-11 07:00:53 +000018#include "IdentifierResolver.h"
Chris Lattner4b009652007-07-25 00:24:17 +000019#include "clang/Parse/Action.h"
Steve Naroff434fa8d2007-11-12 03:44:46 +000020#include "clang/Parse/DeclSpec.h"
Chris Lattner4b009652007-07-25 00:24:17 +000021#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian67907bd2007-10-05 18:00:57 +000022#include "llvm/ADT/DenseSet.h"
Chris Lattnera7a191c2007-10-07 01:13:46 +000023#include "llvm/ADT/SmallPtrSet.h"
Chris Lattner4b009652007-07-25 00:24:17 +000024#include <vector>
25#include <string>
26
Chris Lattner3429a812007-08-23 05:46:52 +000027namespace llvm {
28 class APSInt;
29}
30
Chris Lattner4b009652007-07-25 00:24:17 +000031namespace clang {
32 class ASTContext;
Chris Lattnera8c2d592008-02-06 00:46:58 +000033 class ASTConsumer;
Chris Lattner4b009652007-07-25 00:24:17 +000034 class Preprocessor;
35 class Decl;
Chris Lattnerf3874bc2008-04-06 04:47:34 +000036 class DeclContext;
Steve Naroffe57c21a2008-04-01 23:04:06 +000037 class NamedDecl;
Steve Naroffd21bc0d2007-09-13 18:10:37 +000038 class ScopedDecl;
Chris Lattner4b009652007-07-25 00:24:17 +000039 class Expr;
Steve Naroff9091f3f2007-09-02 15:34:30 +000040 class InitListExpr;
Chris Lattner83bd5eb2007-12-28 05:29:59 +000041 class CallExpr;
Chris Lattner4b009652007-07-25 00:24:17 +000042 class VarDecl;
43 class ParmVarDecl;
44 class TypedefDecl;
45 class FunctionDecl;
46 class QualType;
Chris Lattner3496d522007-09-04 02:45:27 +000047 struct LangOptions;
Chris Lattner4b009652007-07-25 00:24:17 +000048 class Token;
49 class IntegerLiteral;
Steve Naroff0d4e6ad2008-01-22 00:55:40 +000050 class StringLiteral;
Chris Lattner4b009652007-07-25 00:24:17 +000051 class ArrayType;
52 class LabelStmt;
53 class SwitchStmt;
Steve Naroff1b8a46c2007-07-27 22:15:19 +000054 class OCUVectorType;
Steve Naroff82113e32007-07-29 16:33:31 +000055 class TypedefDecl;
Ted Kremenek42730c52008-01-07 19:49:32 +000056 class ObjCInterfaceDecl;
Steve Naroffe57c21a2008-04-01 23:04:06 +000057 class ObjCCompatibleAliasDecl;
Ted Kremenek42730c52008-01-07 19:49:32 +000058 class ObjCProtocolDecl;
59 class ObjCImplementationDecl;
60 class ObjCCategoryImplDecl;
61 class ObjCCategoryDecl;
62 class ObjCIvarDecl;
63 class ObjCMethodDecl;
Steve Naroff82113e32007-07-29 16:33:31 +000064
Chris Lattner4b009652007-07-25 00:24:17 +000065/// Sema - This implements semantic analysis and AST building for C.
66class Sema : public Action {
67 Preprocessor &PP;
Chris Lattner4b009652007-07-25 00:24:17 +000068 ASTContext &Context;
Chris Lattnera8c2d592008-02-06 00:46:58 +000069 ASTConsumer &Consumer;
Chris Lattner4b009652007-07-25 00:24:17 +000070
71 /// CurFunctionDecl - If inside of a function body, this contains a pointer to
72 /// the function decl for the function being parsed.
73 FunctionDecl *CurFunctionDecl;
Steve Naroffdd2e26c2007-11-12 13:56:41 +000074
75 /// CurMethodDecl - If inside of a method body, this contains a pointer to
76 /// the method decl for the method being parsed.
Ted Kremenek42730c52008-01-07 19:49:32 +000077 ObjCMethodDecl *CurMethodDecl;
Chris Lattnereee57c02008-04-04 06:12:32 +000078
Chris Lattnerf3874bc2008-04-06 04:47:34 +000079 DeclContext *CurContext;
Chris Lattnereee57c02008-04-04 06:12:32 +000080
Chris Lattner4b009652007-07-25 00:24:17 +000081 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
82 /// it (which acts like the label decl in some ways). Forward referenced
83 /// labels have a LabelStmt created for them with a null location & SubStmt.
84 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
85
86 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
Steve Naroff82113e32007-07-29 16:33:31 +000087
88 /// OCUVectorDecls - This is a list all the OCU vector types. This allows
89 /// us to associate a raw vector type with one of the OCU type names.
90 /// This is only necessary for issuing pretty diagnostics.
91 llvm::SmallVector<TypedefDecl*, 24> OCUVectorDecls;
Chris Lattner2e64c072007-08-10 20:18:51 +000092
Ted Kremenek42730c52008-01-07 19:49:32 +000093 /// ObjCImplementations - Keep track of all of the classes with
Chris Lattnera7a191c2007-10-07 01:13:46 +000094 /// @implementation's, so that we can emit errors on duplicates.
Ted Kremenek42730c52008-01-07 19:49:32 +000095 llvm::DenseMap<IdentifierInfo*, ObjCImplementationDecl*> ObjCImplementations;
Chris Lattnera7a191c2007-10-07 01:13:46 +000096
Ted Kremenek42730c52008-01-07 19:49:32 +000097 /// ObjCProtocols - Keep track of all protocol declarations declared
Fariborz Jahanianac142de2007-10-09 18:03:53 +000098 /// with @protocol keyword, so that we can emit errors on duplicates and
Chris Lattner042e6e82007-10-09 18:18:24 +000099 /// find the declarations when needed.
Ted Kremenek42730c52008-01-07 19:49:32 +0000100 llvm::DenseMap<IdentifierInfo*, ObjCProtocolDecl*> ObjCProtocols;
Steve Naroff15208162008-04-02 18:30:49 +0000101
102 /// ObjCInterfaceDecls - Keep track of all class declarations declared
103 /// with @interface, so that we can emit errors on duplicates and
104 /// find the declarations when needed.
105 typedef llvm::DenseMap<const IdentifierInfo*,
106 ObjCInterfaceDecl*> ObjCInterfaceDeclsTy;
107 ObjCInterfaceDeclsTy ObjCInterfaceDecls;
108
Steve Naroffe57c21a2008-04-01 23:04:06 +0000109 /// ObjCAliasDecls - Keep track of all class declarations declared
110 /// with @compatibility_alias, so that we can emit errors on duplicates and
111 /// find the declarations when needed. This construct is ancient and will
112 /// likely never be seen. Nevertheless, it is here for compatibility.
Steve Naroff64334ea2008-04-02 00:39:51 +0000113 typedef llvm::DenseMap<const IdentifierInfo*,
114 ObjCCompatibleAliasDecl*> ObjCAliasTy;
Steve Naroffe57c21a2008-04-01 23:04:06 +0000115 ObjCAliasTy ObjCAliasDecls;
Steve Naroff15208162008-04-02 18:30:49 +0000116
Chris Lattner2a1e2ed2008-04-11 07:00:53 +0000117 IdentifierResolver IdResolver;
118
Chris Lattner2e64c072007-08-10 20:18:51 +0000119 // Enum values used by KnownFunctionIDs (see below).
120 enum {
121 id_printf,
122 id_fprintf,
123 id_sprintf,
124 id_snprintf,
Chris Lattner2e64c072007-08-10 20:18:51 +0000125 id_asprintf,
Ted Kremenek2d7e9532007-08-10 21:13:51 +0000126 id_vsnprintf,
Chris Lattner2e64c072007-08-10 20:18:51 +0000127 id_vasprintf,
128 id_vfprintf,
129 id_vsprintf,
130 id_vprintf,
131 id_num_known_functions
132 };
133
134 /// KnownFunctionIDs - This is a list of IdentifierInfo objects to a set
135 /// of known functions used by the semantic analysis to do various
136 /// kinds of checking (e.g. checking format string errors in printf calls).
137 /// This list is populated upon the creation of a Sema object.
138 IdentifierInfo* KnownFunctionIDs[ id_num_known_functions ];
139
Steve Naroff415c1832007-10-10 17:32:04 +0000140 /// Translation Unit Scope - useful to Objective-C actions that need
141 /// to lookup file scope declarations in the "ordinary" C decl namespace.
142 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroff9637a9b2007-10-09 22:01:59 +0000143 Scope *TUScope;
Steve Naroffee1de132007-10-10 21:53:07 +0000144
Steve Naroff8255b042007-10-14 00:58:41 +0000145 /// ObjCMethodList - a linked list of methods with different signatures.
Ted Kremenek42730c52008-01-07 19:49:32 +0000146 struct ObjCMethodList {
147 ObjCMethodDecl *Method;
148 ObjCMethodList *Next;
Steve Naroff8255b042007-10-14 00:58:41 +0000149
Ted Kremenek42730c52008-01-07 19:49:32 +0000150 ObjCMethodList() {
Steve Naroff8255b042007-10-14 00:58:41 +0000151 Method = 0;
152 Next = 0;
153 }
Ted Kremenek42730c52008-01-07 19:49:32 +0000154 ObjCMethodList(ObjCMethodDecl *M, ObjCMethodList *C) {
Steve Naroff8255b042007-10-14 00:58:41 +0000155 Method = M;
156 Next = C;
157 }
158 };
159 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
160 /// messages to "id". We need to maintain a list, since selectors can have
161 /// differing signatures across classes. In Cocoa, this happens to be
162 /// extremely uncommon (only 1% of selectors are "overloaded").
Ted Kremenek42730c52008-01-07 19:49:32 +0000163 llvm::DenseMap<Selector, ObjCMethodList> InstanceMethodPool;
164 llvm::DenseMap<Selector, ObjCMethodList> FactoryMethodPool;
Chris Lattner4b009652007-07-25 00:24:17 +0000165public:
Chris Lattnera8c2d592008-02-06 00:46:58 +0000166 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer);
Chris Lattner4b009652007-07-25 00:24:17 +0000167
168 const LangOptions &getLangOptions() const;
169
170 /// The primitive diagnostic helpers - always returns true, which simplifies
171 /// error handling (i.e. less code).
172 bool Diag(SourceLocation Loc, unsigned DiagID);
173 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg);
174 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg1,
175 const std::string &Msg2);
176
177 /// More expressive diagnostic helpers for expressions (say that 6 times:-)
178 bool Diag(SourceLocation Loc, unsigned DiagID, SourceRange R1);
179 bool Diag(SourceLocation Loc, unsigned DiagID,
180 SourceRange R1, SourceRange R2);
181 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg,
182 SourceRange R1);
183 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg,
184 SourceRange R1, SourceRange R2);
185 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg1,
186 const std::string &Msg2, SourceRange R1);
Chris Lattner01e854d2008-01-03 23:38:43 +0000187 bool Diag(SourceLocation Loc, unsigned DiagID, const std::string &Msg1,
188 const std::string &Msg2, const std::string &Msg3, SourceRange R1);
Chris Lattner4b009652007-07-25 00:24:17 +0000189 bool Diag(SourceLocation Loc, unsigned DiagID,
190 const std::string &Msg1, const std::string &Msg2,
191 SourceRange R1, SourceRange R2);
Fariborz Jahanian0c5affb2007-09-29 00:54:24 +0000192
Chris Lattnerb26b7ad2007-08-31 04:53:24 +0000193 virtual void DeleteExpr(ExprTy *E);
194 virtual void DeleteStmt(StmtTy *S);
195
Chris Lattner4b009652007-07-25 00:24:17 +0000196 //===--------------------------------------------------------------------===//
197 // Type Analysis / Processing: SemaType.cpp.
198 //
Chris Lattner726c5452008-02-20 23:53:49 +0000199 QualType ConvertDeclSpecToType(DeclSpec &DS);
Chris Lattner9e982502008-02-21 01:07:18 +0000200 AttributeList *ProcessTypeAttributes(QualType &Result, AttributeList *AL);
Chris Lattner4b009652007-07-25 00:24:17 +0000201 QualType GetTypeForDeclarator(Declarator &D, Scope *S);
Chris Lattner9e982502008-02-21 01:07:18 +0000202
Chris Lattner4b009652007-07-25 00:24:17 +0000203
Ted Kremenek42730c52008-01-07 19:49:32 +0000204 QualType ObjCGetTypeForMethodDefinition(DeclTy *D);
Fariborz Jahaniandfb1c372007-11-08 23:49:49 +0000205
206
Steve Naroff0acc9c92007-09-15 18:49:24 +0000207 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Chris Lattner4b009652007-07-25 00:24:17 +0000208private:
209 //===--------------------------------------------------------------------===//
210 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
211 //
Steve Naroff6384a012008-04-02 14:35:35 +0000212 virtual DeclTy *isTypeName(const IdentifierInfo &II, Scope *S);
Steve Naroff0acc9c92007-09-15 18:49:24 +0000213 virtual DeclTy *ActOnDeclarator(Scope *S, Declarator &D, DeclTy *LastInGroup);
Chris Lattner3e254fb2008-04-08 04:40:51 +0000214 virtual DeclTy *ActOnParamDeclarator(Scope *S, Declarator &D);
215 virtual void ActOnParamDefaultArgument(DeclTy *param,
216 SourceLocation EqualLoc,
217 ExprTy *defarg);
Steve Naroff6a0e2092007-09-12 14:07:44 +0000218 void AddInitializerToDecl(DeclTy *dcl, ExprTy *init);
Chris Lattner4b009652007-07-25 00:24:17 +0000219 virtual DeclTy *FinalizeDeclaratorGroup(Scope *S, DeclTy *Group);
220
Chris Lattnerea148702007-10-09 17:14:05 +0000221 virtual DeclTy *ActOnStartOfFunctionDef(Scope *S, Declarator &D);
Ted Kremenek42730c52008-01-07 19:49:32 +0000222 virtual void ObjCActOnStartOfMethodDef(Scope *S, DeclTy *D);
Steve Naroff99ee4302007-11-11 23:20:51 +0000223
224 virtual DeclTy *ActOnFinishFunctionBody(DeclTy *Decl, StmtTy *Body);
Chris Lattner806a5f52008-01-12 07:05:38 +0000225 virtual DeclTy *ActOnLinkageSpec(SourceLocation Loc, SourceLocation LBrace,
Nate Begeman43f307d2008-02-20 22:57:40 +0000226 SourceLocation RBrace, const char *Lang,
227 unsigned StrSize, DeclTy *D);
Anders Carlsson4f7f4412008-02-08 00:33:21 +0000228 virtual DeclTy *ActOnFileScopeAsmDecl(SourceLocation Loc, ExprTy *expr);
229
Steve Naroff9637a9b2007-10-09 22:01:59 +0000230 /// Scope actions.
231 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
232 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Chris Lattner4b009652007-07-25 00:24:17 +0000233
234 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
235 /// no declarator (e.g. "struct foo;") is parsed.
236 virtual DeclTy *ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
237
Steve Naroff0acc9c92007-09-15 18:49:24 +0000238 virtual DeclTy *ActOnTag(Scope *S, unsigned TagType, TagKind TK,
Chris Lattner4b009652007-07-25 00:24:17 +0000239 SourceLocation KWLoc, IdentifierInfo *Name,
240 SourceLocation NameLoc, AttributeList *Attr);
Fariborz Jahanian751c6172008-04-10 23:32:45 +0000241 virtual DeclTy *ActOnField(Scope *S, SourceLocation DeclStart,
Chris Lattner4b009652007-07-25 00:24:17 +0000242 Declarator &D, ExprTy *BitfieldWidth);
Fariborz Jahanian751c6172008-04-10 23:32:45 +0000243
244 virtual DeclTy *ActOnIvar(Scope *S, SourceLocation DeclStart,
245 Declarator &D, ExprTy *BitfieldWidth,
Fariborz Jahanian4e0bb982008-04-11 16:55:42 +0000246 tok::ObjCKeywordKind visibility);
Fariborz Jahanian751c6172008-04-10 23:32:45 +0000247
Steve Naroffffeaa552007-09-14 23:09:53 +0000248 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian0c5affb2007-09-29 00:54:24 +0000249 virtual void ActOnFields(Scope* S,
Steve Naroff1a7fa7b2007-10-29 21:38:07 +0000250 SourceLocation RecLoc, DeclTy *TagDecl,
251 DeclTy **Fields, unsigned NumFields,
Fariborz Jahanian751c6172008-04-10 23:32:45 +0000252 SourceLocation LBrac, SourceLocation RBrac);
Steve Naroff0acc9c92007-09-15 18:49:24 +0000253 virtual DeclTy *ActOnEnumConstant(Scope *S, DeclTy *EnumDecl,
Chris Lattner4b009652007-07-25 00:24:17 +0000254 DeclTy *LastEnumConstant,
255 SourceLocation IdLoc, IdentifierInfo *Id,
256 SourceLocation EqualLoc, ExprTy *Val);
Steve Naroff0acc9c92007-09-15 18:49:24 +0000257 virtual void ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDecl,
Chris Lattner4b009652007-07-25 00:24:17 +0000258 DeclTy **Elements, unsigned NumElements);
259private:
Chris Lattnereee57c02008-04-04 06:12:32 +0000260 /// Set the current declaration context until it gets popped.
Chris Lattnerf3874bc2008-04-06 04:47:34 +0000261 void PushDeclContext(DeclContext *CD);
262 void PopDeclContext();
Chris Lattnereee57c02008-04-04 06:12:32 +0000263
Argiris Kirtzidis951f25b2008-04-12 00:47:19 +0000264 /// Add this decl to the scope shadowed decl chains.
265 void PushOnScopeChains(NamedDecl *D, Scope *S);
266
Chris Lattner9e982502008-02-21 01:07:18 +0000267 /// Subroutines of ActOnDeclarator().
Chris Lattner82bb4792007-11-14 06:34:38 +0000268 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
269 ScopedDecl *LastDecl);
Steve Naroffe57c21a2008-04-01 23:04:06 +0000270 TypedefDecl *MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
271 FunctionDecl *MergeFunctionDecl(FunctionDecl *New, Decl *Old);
272 VarDecl *MergeVarDecl(VarDecl *New, Decl *Old);
Chris Lattner3e254fb2008-04-08 04:40:51 +0000273 FunctionDecl *MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
274
275 /// Helpers for dealing with function parameters
276 bool CheckParmsForFunctionDef(FunctionDecl *FD);
277 ParmVarDecl *CreateImplicitParameter(Scope *S, IdentifierInfo *Id,
278 SourceLocation IdLoc, QualType Type);
279 void CheckCXXDefaultArguments(FunctionDecl *FD);
Chris Lattner4b009652007-07-25 00:24:17 +0000280
281 /// More parsing and symbol table subroutines...
Steve Naroff6384a012008-04-02 14:35:35 +0000282 Decl *LookupDecl(const IdentifierInfo *II, unsigned NSI, Scope *S,
283 bool enableLazyBuiltinCreation = true);
Ted Kremenek42730c52008-01-07 19:49:32 +0000284 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Steve Naroff6384a012008-04-02 14:35:35 +0000285 ScopedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
286 Scope *S);
Steve Narofff0c31dd2007-09-16 16:16:00 +0000287 ScopedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
Chris Lattner4b009652007-07-25 00:24:17 +0000288 Scope *S);
289 // Decl attributes - this routine is the top level dispatcher.
290 void HandleDeclAttributes(Decl *New, AttributeList *declspec_prefix,
291 AttributeList *declarator_postfix);
292 void HandleDeclAttribute(Decl *New, AttributeList *rawAttr);
Christopher Lamb2a72bb32008-02-04 02:31:56 +0000293
294 /// HandleAddressSpaceTypeAttribute - this attribute is only applicable to
295 /// objects without automatic storage duration.
296 /// The raw attribute contains 1 argument, the id of the address space
297 /// for the type.
298 QualType HandleAddressSpaceTypeAttribute(QualType curType,
299 AttributeList *rawAttr);
300
Chris Lattner4b009652007-07-25 00:24:17 +0000301 // HandleVectorTypeAttribute - this attribute is only applicable to
302 // integral and float scalars, although arrays, pointers, and function
303 // return values are allowed in conjunction with this construct. Aggregates
304 // with this attribute are invalid, even if they are of the same size as a
305 // corresponding scalar.
306 // The raw attribute should contain precisely 1 argument, the vector size
307 // for the variable, measured in bytes. If curType and rawAttr are well
308 // formed, this routine will return a new vector type.
309 QualType HandleVectorTypeAttribute(QualType curType, AttributeList *rawAttr);
Steve Naroff82113e32007-07-29 16:33:31 +0000310 void HandleOCUVectorTypeAttribute(TypedefDecl *d, AttributeList *rawAttr);
Chris Lattner4b009652007-07-25 00:24:17 +0000311
Anders Carlssonc8b44122007-12-19 07:19:40 +0000312 void HandleAlignedAttribute(Decl *d, AttributeList *rawAttr);
Anders Carlsson136cdc32008-02-16 00:29:18 +0000313 void HandlePackedAttribute(Decl *d, AttributeList *rawAttr);
Nate Begeman754d3fc2008-02-21 19:30:49 +0000314 void HandleAnnotateAttribute(Decl *d, AttributeList *rawAttr);
Ted Kremenek13bfae62008-02-27 20:43:06 +0000315 void HandleNoReturnAttribute(Decl *d, AttributeList *rawAttr);
Chris Lattner402b3372008-03-03 03:28:21 +0000316 void HandleDeprecatedAttribute(Decl *d, AttributeList *rawAttr);
317 void HandleWeakAttribute(Decl *d, AttributeList *rawAttr);
318 void HandleDLLImportAttribute(Decl *d, AttributeList *rawAttr);
319 void HandleDLLExportAttribute(Decl *d, AttributeList *rawAttr);
320 void HandleVisibilityAttribute(Decl *d, AttributeList *rawAttr);
321 void HandleNothrowAttribute(Decl *d, AttributeList *rawAttr);
322 void HandleFormatAttribute(Decl *d, AttributeList *rawAttr);
Nate Begemand75d28b2008-03-07 20:04:22 +0000323 void HandleStdCallAttribute(Decl *d, AttributeList *rawAttr);
324 void HandleFastCallAttribute(Decl *d, AttributeList *rawAttr);
Anders Carlsson136cdc32008-02-16 00:29:18 +0000325
Steve Naroffb4f48512008-02-10 21:38:56 +0000326 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
327 bool &IncompleteImpl);
328
Fariborz Jahanianf7cf3a62007-09-29 17:14:55 +0000329 /// CheckProtocolMethodDefs - This routine checks unimpletented methods
330 /// Declared in protocol, and those referenced by it.
Steve Naroffb268d2a2008-02-08 22:06:17 +0000331 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
332 ObjCProtocolDecl *PDecl,
Fariborz Jahaniand3952f32007-10-02 20:06:01 +0000333 bool& IncompleteImpl,
Steve Naroff7711ee32007-10-08 21:05:34 +0000334 const llvm::DenseSet<Selector> &InsMap,
Chris Lattner48ed6f82007-10-05 20:15:24 +0000335 const llvm::DenseSet<Selector> &ClsMap);
Fariborz Jahanianf7cf3a62007-09-29 17:14:55 +0000336
Steve Naroff89529b12007-10-02 21:43:37 +0000337 /// CheckImplementationIvars - This routine checks if the instance variables
338 /// listed in the implelementation match those listed in the interface.
Ted Kremenek42730c52008-01-07 19:49:32 +0000339 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
340 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroffb4f48512008-02-10 21:38:56 +0000341 SourceLocation Loc);
Steve Naroff89529b12007-10-02 21:43:37 +0000342
Fariborz Jahanianf7cf3a62007-09-29 17:14:55 +0000343 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
344 /// remains unimplemented in the @implementation class.
Ted Kremenek42730c52008-01-07 19:49:32 +0000345 void ImplMethodsVsClassMethods(ObjCImplementationDecl* IMPDecl,
346 ObjCInterfaceDecl* IDecl);
Fariborz Jahanianf7cf3a62007-09-29 17:14:55 +0000347
Fariborz Jahaniana91aa322007-10-02 16:38:50 +0000348 /// ImplCategoryMethodsVsIntfMethods - Checks that methods declared in the
349 /// category interface is implemented in the category @implementation.
Ted Kremenek42730c52008-01-07 19:49:32 +0000350 void ImplCategoryMethodsVsIntfMethods(ObjCCategoryImplDecl *CatImplDecl,
351 ObjCCategoryDecl *CatClassDecl);
Fariborz Jahanian67907bd2007-10-05 18:00:57 +0000352 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
353 /// true, or false, accordingly.
Ted Kremenek42730c52008-01-07 19:49:32 +0000354 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
355 const ObjCMethodDecl *PrevMethod);
Steve Naroffee1de132007-10-10 21:53:07 +0000356
Ted Kremenek42730c52008-01-07 19:49:32 +0000357 /// isBuiltinObjCType - Returns true of the type is "id", "SEL", "Class"
Fariborz Jahanianb4452ed2007-12-07 00:18:54 +0000358 /// or "Protocol".
Ted Kremenek42730c52008-01-07 19:49:32 +0000359 bool isBuiltinObjCType(TypedefDecl *TD);
Fariborz Jahanianfe0982d2008-01-04 00:27:46 +0000360
Ted Kremenek42730c52008-01-07 19:49:32 +0000361 /// isObjCObjectPointerType - Returns true if type is an objective-c pointer
Fariborz Jahanianfe0982d2008-01-04 00:27:46 +0000362 /// to an object type; such as "id", "Class", Intf*, id<P>, etc.
Ted Kremenek42730c52008-01-07 19:49:32 +0000363 bool isObjCObjectPointerType(QualType type) const;
Anders Carlsson7f23e3d2007-10-31 02:53:19 +0000364
Steve Naroff8255b042007-10-14 00:58:41 +0000365 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
366 /// unit are added to a global pool. This allows us to efficiently associate
367 /// a selector with a method declaraation for purposes of typechecking
368 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremenek42730c52008-01-07 19:49:32 +0000369 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff8255b042007-10-14 00:58:41 +0000370
371 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremenek42730c52008-01-07 19:49:32 +0000372 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Chris Lattner4b009652007-07-25 00:24:17 +0000373 //===--------------------------------------------------------------------===//
374 // Statement Parsing Callbacks: SemaStmt.cpp.
375public:
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000376 virtual StmtResult ActOnExprStmt(ExprTy *Expr);
Chris Lattner4b009652007-07-25 00:24:17 +0000377
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000378 virtual StmtResult ActOnNullStmt(SourceLocation SemiLoc);
379 virtual StmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
Chris Lattnerf2b07572007-08-31 21:49:55 +0000380 StmtTy **Elts, unsigned NumElts,
381 bool isStmtExpr);
Chris Lattnera4ff4272008-03-13 06:29:04 +0000382 virtual StmtResult ActOnDeclStmt(DeclTy *Decl, SourceLocation StartLoc,
383 SourceLocation EndLoc);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000384 virtual StmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprTy *LHSVal,
Chris Lattner4b009652007-07-25 00:24:17 +0000385 SourceLocation DotDotDotLoc, ExprTy *RHSVal,
386 SourceLocation ColonLoc, StmtTy *SubStmt);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000387 virtual StmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000388 SourceLocation ColonLoc, StmtTy *SubStmt,
389 Scope *CurScope);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000390 virtual StmtResult ActOnLabelStmt(SourceLocation IdentLoc, IdentifierInfo *II,
Chris Lattner4b009652007-07-25 00:24:17 +0000391 SourceLocation ColonLoc, StmtTy *SubStmt);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000392 virtual StmtResult ActOnIfStmt(SourceLocation IfLoc, ExprTy *CondVal,
Chris Lattner4b009652007-07-25 00:24:17 +0000393 StmtTy *ThenVal, SourceLocation ElseLoc,
394 StmtTy *ElseVal);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000395 virtual StmtResult ActOnStartOfSwitchStmt(ExprTy *Cond);
Chris Lattner48ed6f82007-10-05 20:15:24 +0000396 virtual StmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
397 StmtTy *Switch, ExprTy *Body);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000398 virtual StmtResult ActOnWhileStmt(SourceLocation WhileLoc, ExprTy *Cond,
Chris Lattner4b009652007-07-25 00:24:17 +0000399 StmtTy *Body);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000400 virtual StmtResult ActOnDoStmt(SourceLocation DoLoc, StmtTy *Body,
Chris Lattner4b009652007-07-25 00:24:17 +0000401 SourceLocation WhileLoc, ExprTy *Cond);
402
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000403 virtual StmtResult ActOnForStmt(SourceLocation ForLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000404 SourceLocation LParenLoc,
405 StmtTy *First, ExprTy *Second, ExprTy *Third,
406 SourceLocation RParenLoc, StmtTy *Body);
Ted Kremenek42730c52008-01-07 19:49:32 +0000407 virtual StmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
Fariborz Jahanian1300bc72008-01-03 17:55:25 +0000408 SourceLocation LParenLoc,
409 StmtTy *First, ExprTy *Second,
410 SourceLocation RParenLoc, StmtTy *Body);
411
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000412 virtual StmtResult ActOnGotoStmt(SourceLocation GotoLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000413 SourceLocation LabelLoc,
414 IdentifierInfo *LabelII);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000415 virtual StmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000416 SourceLocation StarLoc,
417 ExprTy *DestExp);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000418 virtual StmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000419 Scope *CurScope);
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000420 virtual StmtResult ActOnBreakStmt(SourceLocation GotoLoc, Scope *CurScope);
Chris Lattner4b009652007-07-25 00:24:17 +0000421
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000422 virtual StmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000423 ExprTy *RetValExp);
424
Anders Carlsson076c1112007-11-20 19:21:03 +0000425 virtual StmtResult ActOnAsmStmt(SourceLocation AsmLoc,
Anders Carlssonde6a9c42008-02-05 23:03:50 +0000426 bool IsSimple,
Anders Carlsson759f45d2007-11-23 23:12:25 +0000427 bool IsVolatile,
Anders Carlsson965d5202007-11-22 01:36:19 +0000428 unsigned NumOutputs,
429 unsigned NumInputs,
430 std::string *Names,
431 ExprTy **Constraints,
432 ExprTy **Exprs,
Anders Carlsson076c1112007-11-20 19:21:03 +0000433 ExprTy *AsmString,
Anders Carlsson965d5202007-11-22 01:36:19 +0000434 unsigned NumClobbers,
435 ExprTy **Clobbers,
Chris Lattner8a40a832007-10-29 04:04:16 +0000436 SourceLocation RParenLoc);
437
Ted Kremenek42730c52008-01-07 19:49:32 +0000438 virtual StmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
Fariborz Jahanian06798362007-11-01 23:59:59 +0000439 SourceLocation RParen, StmtTy *Parm,
440 StmtTy *Body, StmtTy *CatchList);
441
Ted Kremenek42730c52008-01-07 19:49:32 +0000442 virtual StmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
Fariborz Jahaniande3abf82007-11-02 00:18:53 +0000443 StmtTy *Body);
444
Ted Kremenek42730c52008-01-07 19:49:32 +0000445 virtual StmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
Fariborz Jahanianb8bf6072007-11-02 15:39:31 +0000446 StmtTy *Try,
447 StmtTy *Catch, StmtTy *Finally);
448
Ted Kremenek42730c52008-01-07 19:49:32 +0000449 virtual StmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Fariborz Jahanian08df2c62007-11-07 02:00:49 +0000450 StmtTy *Throw);
Fariborz Jahanianc9fd4d12008-01-29 19:14:59 +0000451 virtual StmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
452 ExprTy *SynchExpr,
453 StmtTy *SynchBody);
Fariborz Jahanian08df2c62007-11-07 02:00:49 +0000454
Chris Lattner4b009652007-07-25 00:24:17 +0000455 //===--------------------------------------------------------------------===//
456 // Expression Parsing Callbacks: SemaExpr.cpp.
457
458 // Primary Expressions.
Steve Naroff0acc9c92007-09-15 18:49:24 +0000459 virtual ExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
Chris Lattner4b009652007-07-25 00:24:17 +0000460 IdentifierInfo &II,
461 bool HasTrailingLParen);
Steve Naroff87d58b42007-09-16 03:34:24 +0000462 virtual ExprResult ActOnPreDefinedExpr(SourceLocation Loc,
Chris Lattner4b009652007-07-25 00:24:17 +0000463 tok::TokenKind Kind);
Steve Naroff87d58b42007-09-16 03:34:24 +0000464 virtual ExprResult ActOnNumericConstant(const Token &);
465 virtual ExprResult ActOnCharacterConstant(const Token &);
466 virtual ExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
Chris Lattner4b009652007-07-25 00:24:17 +0000467 ExprTy *Val);
468
Steve Naroff87d58b42007-09-16 03:34:24 +0000469 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Chris Lattner4b009652007-07-25 00:24:17 +0000470 /// fragments (e.g. "foo" "bar" L"baz").
Steve Naroff87d58b42007-09-16 03:34:24 +0000471 virtual ExprResult ActOnStringLiteral(const Token *Toks, unsigned NumToks);
Chris Lattner4b009652007-07-25 00:24:17 +0000472
473 // Binary/Unary Operators. 'Tok' is the token for the operator.
Steve Naroff87d58b42007-09-16 03:34:24 +0000474 virtual ExprResult ActOnUnaryOp(SourceLocation OpLoc, tok::TokenKind Op,
Chris Lattner4b009652007-07-25 00:24:17 +0000475 ExprTy *Input);
476 virtual ExprResult
Steve Naroff87d58b42007-09-16 03:34:24 +0000477 ActOnSizeOfAlignOfTypeExpr(SourceLocation OpLoc, bool isSizeof,
Chris Lattner4b009652007-07-25 00:24:17 +0000478 SourceLocation LParenLoc, TypeTy *Ty,
479 SourceLocation RParenLoc);
480
Steve Naroff87d58b42007-09-16 03:34:24 +0000481 virtual ExprResult ActOnPostfixUnaryOp(SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000482 tok::TokenKind Kind, ExprTy *Input);
483
Steve Naroff87d58b42007-09-16 03:34:24 +0000484 virtual ExprResult ActOnArraySubscriptExpr(ExprTy *Base, SourceLocation LLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000485 ExprTy *Idx, SourceLocation RLoc);
Steve Naroff87d58b42007-09-16 03:34:24 +0000486 virtual ExprResult ActOnMemberReferenceExpr(ExprTy *Base,SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000487 tok::TokenKind OpKind,
488 SourceLocation MemberLoc,
489 IdentifierInfo &Member);
490
Steve Naroff87d58b42007-09-16 03:34:24 +0000491 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Chris Lattner4b009652007-07-25 00:24:17 +0000492 /// This provides the location of the left/right parens and a list of comma
493 /// locations.
Steve Naroff87d58b42007-09-16 03:34:24 +0000494 virtual ExprResult ActOnCallExpr(ExprTy *Fn, SourceLocation LParenLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000495 ExprTy **Args, unsigned NumArgs,
496 SourceLocation *CommaLocs,
497 SourceLocation RParenLoc);
498
Steve Naroff87d58b42007-09-16 03:34:24 +0000499 virtual ExprResult ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
Chris Lattner4b009652007-07-25 00:24:17 +0000500 SourceLocation RParenLoc, ExprTy *Op);
501
Steve Naroff87d58b42007-09-16 03:34:24 +0000502 virtual ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty,
Chris Lattner4b009652007-07-25 00:24:17 +0000503 SourceLocation RParenLoc, ExprTy *Op);
504
Steve Naroff87d58b42007-09-16 03:34:24 +0000505 virtual ExprResult ActOnInitList(SourceLocation LParenLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000506 ExprTy **InitList, unsigned NumInit,
507 SourceLocation RParenLoc);
508
Steve Naroff87d58b42007-09-16 03:34:24 +0000509 virtual ExprResult ActOnBinOp(SourceLocation TokLoc, tok::TokenKind Kind,
Chris Lattner4b009652007-07-25 00:24:17 +0000510 ExprTy *LHS,ExprTy *RHS);
511
Steve Naroff87d58b42007-09-16 03:34:24 +0000512 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Chris Lattner4b009652007-07-25 00:24:17 +0000513 /// in the case of a the GNU conditional expr extension.
Steve Naroff87d58b42007-09-16 03:34:24 +0000514 virtual ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000515 SourceLocation ColonLoc,
516 ExprTy *Cond, ExprTy *LHS, ExprTy *RHS);
517
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000518 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
519 virtual ExprResult ActOnAddrLabel(SourceLocation OpLoc, SourceLocation LabLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000520 IdentifierInfo *LabelII);
521
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000522 virtual ExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtTy *SubStmt,
Chris Lattner4b009652007-07-25 00:24:17 +0000523 SourceLocation RPLoc); // "({..})"
Chris Lattner0d9bcea2007-08-30 17:45:32 +0000524
525 /// __builtin_offsetof(type, a.b[123][456].c)
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000526 virtual ExprResult ActOnBuiltinOffsetOf(SourceLocation BuiltinLoc,
Chris Lattner0d9bcea2007-08-30 17:45:32 +0000527 SourceLocation TypeLoc, TypeTy *Arg1,
528 OffsetOfComponent *CompPtr,
529 unsigned NumComponents,
530 SourceLocation RParenLoc);
531
Steve Naroff63bad2d2007-08-01 22:05:33 +0000532 // __builtin_types_compatible_p(type1, type2)
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000533 virtual ExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
Steve Naroff63bad2d2007-08-01 22:05:33 +0000534 TypeTy *arg1, TypeTy *arg2,
535 SourceLocation RPLoc);
Steve Naroff93c53012007-08-03 21:21:27 +0000536
537 // __builtin_choose_expr(constExpr, expr1, expr2)
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000538 virtual ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
Steve Naroff93c53012007-08-03 21:21:27 +0000539 ExprTy *cond, ExprTy *expr1, ExprTy *expr2,
540 SourceLocation RPLoc);
Chris Lattner4b009652007-07-25 00:24:17 +0000541
Nate Begeman9f3bfb72008-01-17 17:46:27 +0000542 // __builtin_overload(...)
543 virtual ExprResult ActOnOverloadExpr(ExprTy **Args, unsigned NumArgs,
544 SourceLocation *CommaLocs,
545 SourceLocation BuiltinLoc,
546 SourceLocation RParenLoc);
Nate Begemand75d28b2008-03-07 20:04:22 +0000547
Anders Carlsson36760332007-10-15 20:28:48 +0000548 // __builtin_va_arg(expr, type)
549 virtual ExprResult ActOnVAArg(SourceLocation BuiltinLoc,
550 ExprTy *expr, TypeTy *type,
551 SourceLocation RPLoc);
552
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000553 /// ActOnCXXCasts - Parse {dynamic,static,reinterpret,const}_cast's.
554 virtual ExprResult ActOnCXXCasts(SourceLocation OpLoc, tok::TokenKind Kind,
Chris Lattner4b009652007-07-25 00:24:17 +0000555 SourceLocation LAngleBracketLoc, TypeTy *Ty,
556 SourceLocation RAngleBracketLoc,
557 SourceLocation LParenLoc, ExprTy *E,
558 SourceLocation RParenLoc);
559
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000560 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
561 virtual ExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
Chris Lattner4b009652007-07-25 00:24:17 +0000562 tok::TokenKind Kind);
Anders Carlssona66cad42007-08-21 17:43:55 +0000563
Chris Lattnera7447ba2008-02-26 00:51:44 +0000564 //// ActOnCXXThrow - Parse throw expressions.
565 virtual ExprResult ActOnCXXThrow(SourceLocation OpLoc,
566 ExprTy *expr);
567
Anders Carlssona66cad42007-08-21 17:43:55 +0000568 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerddd3e632007-12-12 01:04:12 +0000569 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
570 ExprTy **Strings,
571 unsigned NumStrings);
Anders Carlsson8be1d402007-08-22 15:14:15 +0000572 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattnercfd61c82007-10-16 22:51:17 +0000573 SourceLocation EncodeLoc,
Anders Carlsson8be1d402007-08-22 15:14:15 +0000574 SourceLocation LParenLoc,
575 TypeTy *Ty,
576 SourceLocation RParenLoc);
577
Fariborz Jahanianf807c202007-10-16 20:40:23 +0000578 // ParseObjCSelectorExpression - Build selector expression for @selector
579 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
580 SourceLocation AtLoc,
Fariborz Jahanian957448a2007-10-16 23:21:02 +0000581 SourceLocation SelLoc,
Fariborz Jahanianf807c202007-10-16 20:40:23 +0000582 SourceLocation LParenLoc,
583 SourceLocation RParenLoc);
584
Fariborz Jahanianb391e6e2007-10-17 16:58:11 +0000585 // ParseObjCProtocolExpression - Build protocol expression for @protocol
586 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
587 SourceLocation AtLoc,
588 SourceLocation ProtoLoc,
589 SourceLocation LParenLoc,
590 SourceLocation RParenLoc);
Douglas Gregorec93f442008-04-13 21:30:24 +0000591
592 //===--------------------------------------------------------------------===//
593 // C++ Classes
594 //
595 /// ActOnBaseSpecifier - Parsed a base specifier
596 virtual void ActOnBaseSpecifier(DeclTy *classdecl, SourceRange SpecifierRange,
597 bool Virtual, AccessSpecifier Access,
598 DeclTy *basetype, SourceLocation BaseLoc);
Fariborz Jahanianb391e6e2007-10-17 16:58:11 +0000599
Douglas Gregorec93f442008-04-13 21:30:24 +0000600
Steve Naroff81f1bba2007-09-06 21:24:23 +0000601 // Objective-C declarations.
Steve Naroff415c1832007-10-10 17:32:04 +0000602 virtual DeclTy *ActOnStartClassInterface(
Nate Begeman43f307d2008-02-20 22:57:40 +0000603 SourceLocation AtInterafceLoc,
Steve Naroff81f1bba2007-09-06 21:24:23 +0000604 IdentifierInfo *ClassName, SourceLocation ClassLoc,
605 IdentifierInfo *SuperName, SourceLocation SuperLoc,
606 IdentifierInfo **ProtocolNames, unsigned NumProtocols,
Steve Naroffef20ed32007-10-30 02:23:23 +0000607 SourceLocation EndProtoLoc, AttributeList *AttrList);
Fariborz Jahanian05d212a2007-10-11 23:42:27 +0000608
609 virtual DeclTy *ActOnCompatiblityAlias(
610 SourceLocation AtCompatibilityAliasLoc,
611 IdentifierInfo *AliasName, SourceLocation AliasLocation,
612 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff81f1bba2007-09-06 21:24:23 +0000613
Steve Naroff415c1832007-10-10 17:32:04 +0000614 virtual DeclTy *ActOnStartProtocolInterface(
Nate Begeman43f307d2008-02-20 22:57:40 +0000615 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian63ca8ae2007-09-17 21:07:36 +0000616 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Steve Naroffef20ed32007-10-30 02:23:23 +0000617 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs,
618 SourceLocation EndProtoLoc);
Fariborz Jahanian63ca8ae2007-09-17 21:07:36 +0000619
Steve Naroff415c1832007-10-10 17:32:04 +0000620 virtual DeclTy *ActOnStartCategoryInterface(
Nate Begeman43f307d2008-02-20 22:57:40 +0000621 SourceLocation AtInterfaceLoc,
Fariborz Jahanianf25220e2007-09-18 20:26:58 +0000622 IdentifierInfo *ClassName, SourceLocation ClassLoc,
623 IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
Steve Naroff667f1682007-10-30 13:30:57 +0000624 IdentifierInfo **ProtoRefNames, unsigned NumProtoRefs,
625 SourceLocation EndProtoLoc);
Fariborz Jahanianf25220e2007-09-18 20:26:58 +0000626
Steve Naroff415c1832007-10-10 17:32:04 +0000627 virtual DeclTy *ActOnStartClassImplementation(
Nate Begeman43f307d2008-02-20 22:57:40 +0000628 SourceLocation AtClassImplLoc,
Fariborz Jahanianc091b5d2007-09-25 18:38:09 +0000629 IdentifierInfo *ClassName, SourceLocation ClassLoc,
630 IdentifierInfo *SuperClassname,
631 SourceLocation SuperClassLoc);
632
Steve Naroff415c1832007-10-10 17:32:04 +0000633 virtual DeclTy *ActOnStartCategoryImplementation(
Fariborz Jahaniana91aa322007-10-02 16:38:50 +0000634 SourceLocation AtCatImplLoc,
635 IdentifierInfo *ClassName,
636 SourceLocation ClassLoc,
637 IdentifierInfo *CatName,
638 SourceLocation CatLoc);
639
Steve Naroff415c1832007-10-10 17:32:04 +0000640 virtual DeclTy *ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroffb4dfe362007-10-02 22:39:18 +0000641 IdentifierInfo **IdentList,
642 unsigned NumElts);
Fariborz Jahanianc716c942007-09-21 15:40:54 +0000643
Steve Naroff415c1832007-10-10 17:32:04 +0000644 virtual DeclTy *ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Steve Naroffb4dfe362007-10-02 22:39:18 +0000645 IdentifierInfo **IdentList,
646 unsigned NumElts);
Fariborz Jahaniana096e1d2007-10-05 21:01:53 +0000647
Fariborz Jahanian91193f62007-10-11 00:55:41 +0000648 virtual void FindProtocolDeclaration(SourceLocation TypeLoc,
649 IdentifierInfo **ProtocolId,
650 unsigned NumProtocols,
651 llvm::SmallVector<DeclTy *, 8> &
652 Protocols);
Steve Naroff81f1bba2007-09-06 21:24:23 +0000653
Steve Naroffb82c50f2007-11-11 17:19:15 +0000654 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl,
655 DeclTy **allMethods = 0, unsigned allNum = 0,
656 DeclTy **allProperties = 0, unsigned pNum = 0);
Fariborz Jahaniand34caf92007-09-26 18:27:25 +0000657
Fariborz Jahaniane7071722008-04-11 23:40:25 +0000658 virtual DeclTy *ActOnAddObjCProperties(Scope *S, SourceLocation AtLoc,
659 FieldDeclarator *allProperties,
Fariborz Jahaniand8df6d82007-11-06 22:01:00 +0000660 unsigned NumProperties,
Fariborz Jahaniane7071722008-04-11 23:40:25 +0000661 ObjCDeclSpec &ODS);
Steve Naroff3774dd92007-10-26 20:53:56 +0000662 virtual DeclTy *ActOnMethodDeclaration(
663 SourceLocation BeginLoc, // location of the + or -.
664 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian8473b222007-11-09 19:52:12 +0000665 tok::TokenKind MethodType,
Ted Kremenek42730c52008-01-07 19:49:32 +0000666 DeclTy *ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanian2fd0daa2007-10-31 23:53:01 +0000667 Selector Sel,
Steve Naroff4ed9d662007-09-27 14:38:14 +0000668 // optional arguments. The number of types/arguments is obtained
669 // from the Sel.getNumArgs().
Ted Kremenek42730c52008-01-07 19:49:32 +0000670 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames,
Steve Naroff29fe7462007-11-15 12:35:21 +0000671 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
672 bool isVariadic = false);
Steve Naroff52664182007-10-16 23:12:48 +0000673
Steve Naroff4ed9d662007-09-27 14:38:14 +0000674 // ActOnClassMessage - used for both unary and keyword messages.
675 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff9f176d12007-11-15 13:05:42 +0000676 // is obtained from NumArgs.
Steve Naroff4ed9d662007-09-27 14:38:14 +0000677 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian2ce5dc52007-11-12 20:13:27 +0000678 Scope *S,
Steve Naroff6cb1d362007-09-28 22:22:11 +0000679 IdentifierInfo *receivingClassName, Selector Sel,
Steve Naroff9f176d12007-11-15 13:05:42 +0000680 SourceLocation lbrac, SourceLocation rbrac,
681 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff4ed9d662007-09-27 14:38:14 +0000682
683 // ActOnInstanceMessage - used for both unary and keyword messages.
684 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff9f176d12007-11-15 13:05:42 +0000685 // is obtained from NumArgs.
Steve Naroff4ed9d662007-09-27 14:38:14 +0000686 virtual ExprResult ActOnInstanceMessage(
Steve Naroff6cb1d362007-09-28 22:22:11 +0000687 ExprTy *receiver, Selector Sel,
Steve Naroff9f176d12007-11-15 13:05:42 +0000688 SourceLocation lbrac, SourceLocation rbrac,
689 ExprTy **ArgExprs, unsigned NumArgs);
Chris Lattner4b009652007-07-25 00:24:17 +0000690private:
Chris Lattnere992d6c2008-01-16 19:17:22 +0000691 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
692 /// cast. If there is already an implicit cast, merge into the existing one.
693 void ImpCastExprToType(Expr *&Expr, QualType Type);
694
Chris Lattner4b009652007-07-25 00:24:17 +0000695 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner83bd5eb2007-12-28 05:29:59 +0000696 // functions and arrays to their respective pointers (C99 6.3.2.1).
697 Expr *UsualUnaryConversions(Expr *&expr);
Chris Lattner4b009652007-07-25 00:24:17 +0000698
699 // DefaultFunctionArrayConversion - converts functions and arrays
700 // to their respective pointers (C99 6.3.2.1).
701 void DefaultFunctionArrayConversion(Expr *&expr);
702
Steve Naroffdb65e052007-08-28 23:30:39 +0000703 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
704 // do not have a prototype. Integer promotions are performed on each
705 // argument, and arguments that have type float are promoted to double.
Chris Lattner83bd5eb2007-12-28 05:29:59 +0000706 void DefaultArgumentPromotion(Expr *&Expr);
Steve Naroffdb65e052007-08-28 23:30:39 +0000707
Chris Lattner4b009652007-07-25 00:24:17 +0000708 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
709 // operands and then handles various conversions that are common to binary
710 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
711 // routine returns the first non-arithmetic type found. The client is
712 // responsible for emitting appropriate error diagnostics.
Steve Naroff8f708362007-08-24 19:07:16 +0000713 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
714 bool isCompAssign = false);
Chris Lattnerd951b7b2008-01-04 18:22:42 +0000715
716 /// AssignConvertType - All of the 'assignment' semantic checks return this
717 /// enum to indicate whether the assignment was allowed. These checks are
718 /// done for simple assignments, as well as initialization, return from
719 /// function, argument passing, etc. The query is phrased in terms of a
720 /// source and destination type.
Chris Lattner005ed752008-01-04 18:04:52 +0000721 enum AssignConvertType {
Chris Lattnerd951b7b2008-01-04 18:22:42 +0000722 /// Compatible - the types are compatible according to the standard.
Chris Lattner4b009652007-07-25 00:24:17 +0000723 Compatible,
Chris Lattnerd951b7b2008-01-04 18:22:42 +0000724
725 /// PointerToInt - The assignment converts a pointer to an int, which we
726 /// accept as an extension.
727 PointerToInt,
728
729 /// IntToPointer - The assignment converts an int to a pointer, which we
730 /// accept as an extension.
731 IntToPointer,
732
733 /// FunctionVoidPointer - The assignment is between a function pointer and
734 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattner4ca3d772008-01-03 22:56:36 +0000735 FunctionVoidPointer,
Chris Lattnerd951b7b2008-01-04 18:22:42 +0000736
737 /// IncompatiblePointer - The assignment is between two pointers types that
738 /// are not compatible, but we accept them as an extension.
Chris Lattner4b009652007-07-25 00:24:17 +0000739 IncompatiblePointer,
Chris Lattnerd951b7b2008-01-04 18:22:42 +0000740
741 /// CompatiblePointerDiscardsQualifiers - The assignment discards
742 /// c/v/r qualifiers, which we accept as an extension.
743 CompatiblePointerDiscardsQualifiers,
744
745 /// Incompatible - We reject this conversion outright, it is invalid to
746 /// represent it in the AST.
747 Incompatible
Chris Lattner4b009652007-07-25 00:24:17 +0000748 };
Chris Lattner005ed752008-01-04 18:04:52 +0000749
750 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
751 /// assignment conversion type specified by ConvTy. This returns true if the
752 /// conversion was invalid or false if the conversion was accepted.
753 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
754 SourceLocation Loc,
755 QualType DstType, QualType SrcType,
756 Expr *SrcExpr, const char *Flavor);
757
758 /// CheckAssignmentConstraints - Perform type checking for assignment,
759 /// argument passing, variable initialization, and function return values.
760 /// This routine is only used by the following two methods. C99 6.5.16.
761 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Chris Lattner4b009652007-07-25 00:24:17 +0000762
Steve Naroff87d58b42007-09-16 03:34:24 +0000763 // CheckSingleAssignmentConstraints - Currently used by ActOnCallExpr,
Steve Naroff5cbb02f2007-09-16 14:56:35 +0000764 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Chris Lattner4b009652007-07-25 00:24:17 +0000765 // this routine performs the default function/array converions.
Chris Lattner005ed752008-01-04 18:04:52 +0000766 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
767 Expr *&rExpr);
Chris Lattner4b009652007-07-25 00:24:17 +0000768 // CheckCompoundAssignmentConstraints - Type check without performing any
769 // conversions. For compound assignments, the "Check...Operands" methods
770 // perform the necessary conversions.
Chris Lattner005ed752008-01-04 18:04:52 +0000771 AssignConvertType CheckCompoundAssignmentConstraints(QualType lhs,
772 QualType rhs);
Chris Lattner4b009652007-07-25 00:24:17 +0000773
774 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner005ed752008-01-04 18:04:52 +0000775 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
776 QualType rhsType);
Chris Lattner4b009652007-07-25 00:24:17 +0000777
778 /// the following "Check" methods will return a valid/converted QualType
779 /// or a null QualType (indicating an error diagnostic was issued).
780
Steve Naroff87d58b42007-09-16 03:34:24 +0000781 /// type checking binary operators (subroutines of ActOnBinOp).
Chris Lattner2c8bff72007-12-12 05:47:28 +0000782 inline QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Chris Lattner4b009652007-07-25 00:24:17 +0000783 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
784 inline QualType CheckMultiplyDivideOperands( // C99 6.5.5
Steve Naroff8f708362007-08-24 19:07:16 +0000785 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner4b009652007-07-25 00:24:17 +0000786 inline QualType CheckRemainderOperands( // C99 6.5.5
Steve Naroff8f708362007-08-24 19:07:16 +0000787 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner4b009652007-07-25 00:24:17 +0000788 inline QualType CheckAdditionOperands( // C99 6.5.6
Steve Naroff8f708362007-08-24 19:07:16 +0000789 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner4b009652007-07-25 00:24:17 +0000790 inline QualType CheckSubtractionOperands( // C99 6.5.6
Steve Naroff8f708362007-08-24 19:07:16 +0000791 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner4b009652007-07-25 00:24:17 +0000792 inline QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff8f708362007-08-24 19:07:16 +0000793 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner254f3bc2007-08-26 01:18:55 +0000794 inline QualType CheckCompareOperands( // C99 6.5.8/9
795 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isRelational);
Chris Lattner4b009652007-07-25 00:24:17 +0000796 inline QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Steve Naroff8f708362007-08-24 19:07:16 +0000797 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Chris Lattner4b009652007-07-25 00:24:17 +0000798 inline QualType CheckLogicalOperands( // C99 6.5.[13,14]
799 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
800 // CheckAssignmentOperands is used for both simple and compound assignment.
801 // For simple assignment, pass both expressions and a null converted type.
802 // For compound assignment, pass both expressions and the converted type.
803 inline QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Naroff0f32f432007-08-24 22:33:52 +0000804 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Chris Lattner4b009652007-07-25 00:24:17 +0000805 inline QualType CheckCommaOperands( // C99 6.5.17
806 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
807 inline QualType CheckConditionalOperands( // C99 6.5.15
808 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
809
Steve Naroff87d58b42007-09-16 03:34:24 +0000810 /// type checking unary operators (subroutines of ActOnUnaryOp).
Chris Lattner4b009652007-07-25 00:24:17 +0000811 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
812 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc);
813 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
814 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
815 QualType CheckSizeOfAlignOfOperand(QualType type, SourceLocation loc,
816 bool isSizeof);
Chris Lattner5110ad52007-08-24 21:41:10 +0000817 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc);
Steve Naroff1b8a46c2007-07-27 22:15:19 +0000818
819 /// type checking primary expressions.
820 QualType CheckOCUVectorComponent(QualType baseType, SourceLocation OpLoc,
821 IdentifierInfo &Comp, SourceLocation CmpLoc);
822
Steve Naroffe14e5542007-09-02 02:04:30 +0000823 /// type checking declaration initializers (C99 6.7.8)
Steve Narofff0b23542008-01-10 22:15:12 +0000824 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType);
825 bool CheckSingleInitializer(Expr *&simpleInit, QualType declType);
Steve Naroffe6a8c9b2007-09-04 14:36:54 +0000826 bool CheckInitExpr(Expr *expr, InitListExpr *IList, unsigned slot,
Steve Narofff0b23542008-01-10 22:15:12 +0000827 QualType ElementType);
Steve Narofff3cb5142008-01-25 00:51:06 +0000828 bool CheckInitializerListTypes(InitListExpr*& IList, QualType &DeclType,
Nate Begeman43f307d2008-02-20 22:57:40 +0000829 bool topLevel, unsigned& startIndex);
Steve Narofff0b23542008-01-10 22:15:12 +0000830 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroffcb69fb72007-12-10 22:44:33 +0000831
Steve Naroff0d4e6ad2008-01-22 00:55:40 +0000832 StringLiteral *IsStringLiteralInit(Expr *Init, QualType DeclType);
833 bool CheckStringLiteralInit(StringLiteral *strLiteral, QualType &DeclT);
834
Anders Carlsson74375622007-11-27 07:16:40 +0000835 // CheckVectorCast - check type constraints for vectors.
836 // Since vectors are an extension, there are no C standard reference for this.
837 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssonf257b4c2007-11-27 05:51:55 +0000838 // returns true if the cast is invalid
839 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
840
Steve Naroff52664182007-10-16 23:12:48 +0000841 // returns true if there were any incompatible arguments.
842 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs,
Ted Kremenek42730c52008-01-07 19:49:32 +0000843 ObjCMethodDecl *Method);
Steve Naroff52664182007-10-16 23:12:48 +0000844
Chris Lattner3429a812007-08-23 05:46:52 +0000845 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
846 /// the specified width and sign. If an overflow occurs, detect it and emit
847 /// the specified diagnostic.
848 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
849 unsigned NewWidth, bool NewSign,
850 SourceLocation Loc, unsigned DiagID);
851
Chris Lattnerfe1f4032008-04-07 05:30:13 +0000852 bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
853 bool ForCompare);
854
855
Anders Carlsson36760332007-10-15 20:28:48 +0000856 void InitBuiltinVaListType();
857
Chris Lattner2e64c072007-08-10 20:18:51 +0000858 //===--------------------------------------------------------------------===//
859 // Extra semantic analysis beyond the C type system
Chris Lattner83bd5eb2007-12-28 05:29:59 +0000860private:
861 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall);
862 bool CheckBuiltinCFStringArgument(Expr* Arg);
863 bool SemaBuiltinVAStart(CallExpr *TheCall);
864 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
865 void CheckPrintfArguments(CallExpr *TheCall,
866 bool HasVAListArg, unsigned format_idx);
Ted Kremenek45925ab2007-08-17 16:46:58 +0000867 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
868 SourceLocation ReturnLoc);
Ted Kremenek30c66752007-11-25 00:58:00 +0000869 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Chris Lattner4b009652007-07-25 00:24:17 +0000870};
871
872
873} // end namespace clang
874
875#endif