blob: 90ef1367855fd70629ad5dcd16615b1ed3abbd6d [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
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 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 Lattner7f925cc2008-04-11 07:00:53 +000018#include "IdentifierResolver.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000019#include "CXXFieldCollector.h"
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000020#include "SemaOverload.h"
Douglas Gregoreb11cd02009-01-14 22:20:51 +000021#include "clang/AST/DeclBase.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000022#include "clang/Parse/Action.h"
Chris Lattner500d3292009-01-29 05:15:15 +000023#include "clang/Sema/SemaDiagnostic.h"
Anders Carlssonc1fcb772007-07-22 07:07:56 +000024#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian85ff2642007-10-05 18:00:57 +000025#include "llvm/ADT/DenseSet.h"
Chris Lattnerf3876682007-10-07 01:13:46 +000026#include "llvm/ADT/SmallPtrSet.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000027#include "llvm/ADT/OwningPtr.h"
Steve Naroff61d68522009-03-05 15:22:01 +000028#include "clang/AST/DeclObjC.h"
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +000029#include <string>
Douglas Gregor94b1dd22008-10-24 04:54:22 +000030#include <vector>
Reid Spencer5f016e22007-07-11 17:01:13 +000031
Chris Lattnerf4021e72007-08-23 05:46:52 +000032namespace llvm {
33 class APSInt;
34}
35
Reid Spencer5f016e22007-07-11 17:01:13 +000036namespace clang {
37 class ASTContext;
Chris Lattner2ae34ed2008-02-06 00:46:58 +000038 class ASTConsumer;
Reid Spencer5f016e22007-07-11 17:01:13 +000039 class Preprocessor;
40 class Decl;
Chris Lattnerb048c982008-04-06 04:47:34 +000041 class DeclContext;
Daniel Dunbar12bc6922008-08-11 03:27:53 +000042 class DeclSpec;
Steve Naroffe8043c32008-04-01 23:04:06 +000043 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000044 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000045 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000046 class InitListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000047 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000048 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000049 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000050 class VarDecl;
51 class ParmVarDecl;
52 class TypedefDecl;
53 class FunctionDecl;
54 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000055 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000056 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000057 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000058 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class ArrayType;
60 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000061 class SwitchStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000062 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000063 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000064 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000065 class TemplateArgument;
Douglas Gregorddc29e12009-02-06 22:42:48 +000066 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000067 class TemplateTemplateParmDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000068 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000069 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000070 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000071 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000072 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000073 class ObjCImplementationDecl;
74 class ObjCCategoryImplDecl;
75 class ObjCCategoryDecl;
76 class ObjCIvarDecl;
77 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000078 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000079 class ObjCContainerDecl;
Steve Naroff4eb206b2008-09-03 18:15:37 +000080 struct BlockSemaInfo;
Douglas Gregor94b1dd22008-10-24 04:54:22 +000081 class BasePaths;
Sebastian Redl43af76e2009-03-07 12:16:37 +000082 struct MemberLookupCriteria;
Steve Naroffbea0b342007-07-29 16:33:31 +000083
Reid Spencer5f016e22007-07-11 17:01:13 +000084/// Sema - This implements semantic analysis and AST building for C.
85class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +000086 Sema(const Sema&); // DO NOT IMPLEMENT
87 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +000088public:
Chris Lattner53ebff32009-01-22 19:21:44 +000089 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +000090 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +000091 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +000092 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +000093 Diagnostic &Diags;
94 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +000095
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +000096 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +000097 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +000098
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +000099 /// PreDeclaratorDC - Keeps the declaration context before switching to the
100 /// context of a declarator's nested-name-specifier.
101 DeclContext *PreDeclaratorDC;
102
Steve Naroff4eb206b2008-09-03 18:15:37 +0000103 /// CurBlock - If inside of a block definition, this contains a pointer to
104 /// the active block object that represents it.
105 BlockSemaInfo *CurBlock;
106
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000107 /// PackContext - Manages the stack for #pragma pack. An alignment
108 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000109 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000110
Steve Naroffcaaacec2009-03-13 15:38:40 +0000111 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
112 /// it (which acts like the label decl in some ways). Forward referenced
113 /// labels have a LabelStmt created for them with a null location & SubStmt.
114 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
115
Anders Carlssonc1fcb772007-07-22 07:07:56 +0000116 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
Steve Naroffbea0b342007-07-29 16:33:31 +0000117
Nate Begeman213541a2008-04-18 23:10:10 +0000118 /// ExtVectorDecls - This is a list all the extended vector types. This allows
119 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000120 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000121 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Chris Lattner59907c42007-08-10 20:18:51 +0000122
Steve Naroffe84a8642008-09-28 14:55:53 +0000123 /// ObjCImplementations - Keep track of all class @implementations
124 /// so we can emit errors on duplicates.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000125 llvm::DenseMap<IdentifierInfo*, ObjCImplementationDecl*> ObjCImplementations;
Chris Lattnerf3876682007-10-07 01:13:46 +0000126
Steve Naroffe84a8642008-09-28 14:55:53 +0000127 /// ObjCCategoryImpls - Maintain a list of category implementations so
128 /// we can check for duplicates and find local method declarations.
129 llvm::SmallVector<ObjCCategoryImplDecl*, 8> ObjCCategoryImpls;
130
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000131 /// ObjCProtocols - Keep track of all protocol declarations declared
Fariborz Jahanian05672a02007-10-09 18:03:53 +0000132 /// with @protocol keyword, so that we can emit errors on duplicates and
Chris Lattner4de884d2007-10-09 18:18:24 +0000133 /// find the declarations when needed.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000134 llvm::DenseMap<IdentifierInfo*, ObjCProtocolDecl*> ObjCProtocols;
Steve Naroff31102512008-04-02 18:30:49 +0000135
136 /// ObjCInterfaceDecls - Keep track of all class declarations declared
137 /// with @interface, so that we can emit errors on duplicates and
138 /// find the declarations when needed.
139 typedef llvm::DenseMap<const IdentifierInfo*,
140 ObjCInterfaceDecl*> ObjCInterfaceDeclsTy;
141 ObjCInterfaceDeclsTy ObjCInterfaceDecls;
142
Steve Naroffe8043c32008-04-01 23:04:06 +0000143 /// ObjCAliasDecls - Keep track of all class declarations declared
144 /// with @compatibility_alias, so that we can emit errors on duplicates and
145 /// find the declarations when needed. This construct is ancient and will
146 /// likely never be seen. Nevertheless, it is here for compatibility.
Steve Naroffc822ff42008-04-02 00:39:51 +0000147 typedef llvm::DenseMap<const IdentifierInfo*,
148 ObjCCompatibleAliasDecl*> ObjCAliasTy;
Steve Naroffe8043c32008-04-01 23:04:06 +0000149 ObjCAliasTy ObjCAliasDecls;
Steve Naroff31102512008-04-02 18:30:49 +0000150
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000151 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
152 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
153
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000154 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
155
156 /// PureVirtualClassDiagSet - a set of class declarations which we have
157 /// emitted a list of pure virtual functions. Used to prevent emitting the
158 /// same list more than once.
159 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
160
Douglas Gregor63935192009-03-02 00:19:53 +0000161 /// \brief A mapping from external names to the most recent
162 /// locally-scoped external declaration with that name.
163 ///
164 /// This map contains external declarations introduced in local
165 /// scoped, e.g.,
166 ///
167 /// \code
168 /// void f() {
169 /// void foo(int, int);
170 /// }
171 /// \endcode
172 ///
173 /// Here, the name "foo" will be associated with the declaration on
174 /// "foo" within f. This name is not visible outside of
175 /// "f". However, we still find it in two cases:
176 ///
177 /// - If we are declaring another external with the name "foo", we
178 /// can find "foo" as a previous declaration, so that the types
179 /// of this external declaration can be checked for
180 /// compatibility.
181 ///
182 /// - If we would implicitly declare "foo" (e.g., due to a call to
183 /// "foo" in C when no prototype or definition is visible), then
184 /// we find this declaration of "foo" and complain that it is
185 /// not visible.
186 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
187
Chris Lattner7f925cc2008-04-11 07:00:53 +0000188 IdentifierResolver IdResolver;
189
Chris Lattner59907c42007-08-10 20:18:51 +0000190 // Enum values used by KnownFunctionIDs (see below).
191 enum {
Ted Kremenek7ff22b22008-06-16 18:00:42 +0000192 id_NSLog,
Douglas Gregor3c385e52009-02-14 18:57:46 +0000193 id_NSLogv,
Daniel Dunbarde454282008-10-02 18:44:07 +0000194 id_asprintf,
Chris Lattner59907c42007-08-10 20:18:51 +0000195 id_vasprintf,
Chris Lattner59907c42007-08-10 20:18:51 +0000196 id_num_known_functions
197 };
198
199 /// KnownFunctionIDs - This is a list of IdentifierInfo objects to a set
200 /// of known functions used by the semantic analysis to do various
201 /// kinds of checking (e.g. checking format string errors in printf calls).
202 /// This list is populated upon the creation of a Sema object.
Chris Lattner06f54852008-08-23 02:00:52 +0000203 IdentifierInfo* KnownFunctionIDs[id_num_known_functions];
Daniel Dunbar662e8b52008-08-14 22:04:54 +0000204
Steve Naroffe440eb82007-10-10 17:32:04 +0000205 /// Translation Unit Scope - useful to Objective-C actions that need
206 /// to lookup file scope declarations in the "ordinary" C decl namespace.
207 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000208 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000209
210 /// The C++ "std" namespace, where the standard library resides. Cached here
211 /// by GetStdNamespace
212 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000213
214 /// A flag to remember whether the implicit forms of operator new and delete
215 /// have been declared.
216 bool GlobalNewDeleteDeclared;
Steve Naroff3b950172007-10-10 21:53:07 +0000217
Steve Naroff58ff9e82007-10-14 00:58:41 +0000218 /// ObjCMethodList - a linked list of methods with different signatures.
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000219 struct ObjCMethodList {
220 ObjCMethodDecl *Method;
221 ObjCMethodList *Next;
Steve Naroff58ff9e82007-10-14 00:58:41 +0000222
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000223 ObjCMethodList() {
Steve Naroff58ff9e82007-10-14 00:58:41 +0000224 Method = 0;
225 Next = 0;
226 }
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000227 ObjCMethodList(ObjCMethodDecl *M, ObjCMethodList *C) {
Steve Naroff58ff9e82007-10-14 00:58:41 +0000228 Method = M;
229 Next = C;
230 }
231 };
232 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
233 /// messages to "id". We need to maintain a list, since selectors can have
234 /// differing signatures across classes. In Cocoa, this happens to be
235 /// extremely uncommon (only 1% of selectors are "overloaded").
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000236 llvm::DenseMap<Selector, ObjCMethodList> InstanceMethodPool;
237 llvm::DenseMap<Selector, ObjCMethodList> FactoryMethodPool;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000238
239 /// Private Helper predicate to check for 'self'.
240 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000241public:
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000242 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer);
Chris Lattner574aa402009-02-17 01:09:29 +0000243 ~Sema() {
244 if (PackContext) FreePackedContext();
245 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000246
Chris Lattner53ebff32009-01-22 19:21:44 +0000247 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000248 Diagnostic &getDiagnostics() const { return Diags; }
249 SourceManager &getSourceManager() const { return SourceMgr; }
250
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000251 /// \brief Helper class that creates diagnostics with optional
252 /// template instantiation stacks.
253 ///
254 /// This class provides a wrapper around the basic DiagnosticBuilder
255 /// class that emits diagnostics. SemaDiagnosticBuilder is
256 /// responsible for emitting the diagnostic (as DiagnosticBuilder
257 /// does) and, if the diagnostic comes from inside a template
258 /// instantiation, printing the template instantiation stack as
259 /// well.
260 class SemaDiagnosticBuilder : public DiagnosticBuilder {
261 Sema &SemaRef;
262 unsigned DiagID;
263
264 public:
265 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
266 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
267
268 ~SemaDiagnosticBuilder();
269 };
270
271 /// \brief Emit a diagnostic.
272 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregoree1828a2009-03-10 18:03:33 +0000273 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000274 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000275 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000276
Chris Lattner394a3fd2007-08-31 04:53:24 +0000277 virtual void DeleteExpr(ExprTy *E);
278 virtual void DeleteStmt(StmtTy *S);
279
Sebastian Redl798d1192008-12-13 16:23:55 +0000280 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000281 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000282 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000283 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000284 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000285 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000286 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
287
Chris Lattner9299f3f2008-08-23 03:19:52 +0000288 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000289
Reid Spencer5f016e22007-07-11 17:01:13 +0000290 //===--------------------------------------------------------------------===//
291 // Type Analysis / Processing: SemaType.cpp.
292 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000293 QualType adjustParameterType(QualType T);
Chris Lattnerfca0ddd2008-06-26 06:27:57 +0000294 QualType ConvertDeclSpecToType(const DeclSpec &DS);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000295 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000296 QualType BuildPointerType(QualType T, unsigned Quals,
297 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000298 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000299 SourceLocation Loc, DeclarationName Entity);
300 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
301 Expr *ArraySize, unsigned Quals,
302 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor724651c2009-02-28 01:04:19 +0000303 QualType BuildFunctionType(QualType T,
304 QualType *ParamTypes, unsigned NumParamTypes,
305 bool Variadic, unsigned Quals,
306 SourceLocation Loc, DeclarationName Entity);
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000307 QualType GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip = 0);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000308 DeclarationName GetNameForDeclarator(Declarator &D);
309
Ted Kremeneka526c5c2008-01-07 19:49:32 +0000310 QualType ObjCGetTypeForMethodDefinition(DeclTy *D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000311
Douglas Gregor57373262008-10-22 14:17:15 +0000312 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
313
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000314 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000315
Douglas Gregor86447ec2009-03-09 16:13:40 +0000316 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Douglas Gregor4ec339f2009-01-19 19:26:10 +0000317 SourceRange Range1 = SourceRange(),
318 SourceRange Range2 = SourceRange(),
319 QualType PrintType = QualType());
320
Douglas Gregore6258932009-03-19 00:39:20 +0000321 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
322
Reid Spencer5f016e22007-07-11 17:01:13 +0000323 //===--------------------------------------------------------------------===//
324 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
325 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000326
327 /// getDeclName - Return a pretty name for the specified decl if possible, or
328 /// an empty string if not. This is used for pretty crash reporting.
329 virtual std::string getDeclName(DeclTy *D);
330
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000331 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregorb696ea32009-02-04 17:00:24 +0000332 Scope *S, const CXXScopeSpec *SS);
Chris Lattner76a642f2009-02-15 22:43:40 +0000333 virtual DeclTy *ActOnDeclarator(Scope *S, Declarator &D, DeclTy *LastInGroup){
Douglas Gregor584049d2008-12-15 23:53:10 +0000334 return ActOnDeclarator(S, D, LastInGroup, false);
335 }
336 DeclTy *ActOnDeclarator(Scope *S, Declarator &D, DeclTy *LastInGroup,
337 bool IsFunctionDefinition);
Douglas Gregor63935192009-03-02 00:19:53 +0000338 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
339 Scope *S);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000340 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
341 QualType R, Decl* LastDeclarator,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000342 Decl* PrevDecl, bool& InvalidDecl,
343 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000344 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000345 QualType R, Decl* LastDeclarator,
Douglas Gregor8f301052009-02-24 19:23:27 +0000346 NamedDecl* PrevDecl, bool& InvalidDecl,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000347 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000348 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
349 QualType R, Decl *LastDeclarator,
Douglas Gregor04495c82009-02-24 01:23:02 +0000350 NamedDecl* PrevDecl,
351 bool IsFunctionDefinition,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000352 bool& InvalidDecl, bool &Redeclaration);
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000353 bool CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
354 bool &Redeclaration,
355 bool &OverloadableAttrRequired);
Chris Lattner04421082008-04-08 04:40:51 +0000356 virtual DeclTy *ActOnParamDeclarator(Scope *S, Declarator &D);
Sebastian Redlf53597f2009-03-15 17:47:39 +0000357 virtual void ActOnParamDefaultArgument(DeclTy *param,
Chris Lattner04421082008-04-08 04:40:51 +0000358 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000359 ExprArg defarg);
Douglas Gregor61366e92008-12-24 00:01:03 +0000360 virtual void ActOnParamUnparsedDefaultArgument(DeclTy *param,
361 SourceLocation EqualLoc);
Douglas Gregor72b505b2008-12-16 21:30:33 +0000362 virtual void ActOnParamDefaultArgumentError(DeclTy *param);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000363 virtual void AddInitializerToDecl(DeclTy *dcl, ExprArg init);
364 void AddInitializerToDecl(DeclTy *dcl, ExprArg init, bool DirectInit);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000365 void ActOnUninitializedDecl(DeclTy *dcl);
Reid Spencer5f016e22007-07-11 17:01:13 +0000366 virtual DeclTy *FinalizeDeclaratorGroup(Scope *S, DeclTy *Group);
367
Douglas Gregorbe109b32009-01-23 16:23:13 +0000368 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D);
Chris Lattnerb652cea2007-10-09 17:14:05 +0000369 virtual DeclTy *ActOnStartOfFunctionDef(Scope *S, Declarator &D);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000370 virtual DeclTy *ActOnStartOfFunctionDef(Scope *S, DeclTy *D);
Steve Naroffebf64432009-02-28 16:59:13 +0000371 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclTy *D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000372
Sebastian Redl798d1192008-12-13 16:23:55 +0000373 virtual DeclTy *ActOnFinishFunctionBody(DeclTy *Decl, StmtArg Body);
Sebastian Redl798d1192008-12-13 16:23:55 +0000374 virtual DeclTy *ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000375
Steve Naroffb216c882007-10-09 22:01:59 +0000376 /// Scope actions.
377 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
378 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000379
380 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
381 /// no declarator (e.g. "struct foo;") is parsed.
Sebastian Redla4ed0d82008-12-28 15:28:59 +0000382 virtual DeclTy *ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000383
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000384 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
385 RecordDecl *AnonRecord);
386 virtual DeclTy *BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
387 RecordDecl *Record);
388
Douglas Gregor0b7a1582009-01-17 00:42:38 +0000389 virtual DeclTy *ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +0000390 SourceLocation KWLoc, const CXXScopeSpec &SS,
391 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregorddc29e12009-02-06 22:42:48 +0000392 AttributeList *Attr);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000393
Douglas Gregor44b43212008-12-11 16:49:14 +0000394 virtual void ActOnDefs(Scope *S, DeclTy *TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000395 IdentifierInfo *ClassName,
396 llvm::SmallVectorImpl<DeclTy*> &Decls);
Douglas Gregor44b43212008-12-11 16:49:14 +0000397 virtual DeclTy *ActOnField(Scope *S, DeclTy *TagD, SourceLocation DeclStart,
Reid Spencer5f016e22007-07-11 17:01:13 +0000398 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000399
400 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000401 Declarator &D, Expr *BitfieldWidth,
402 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000403
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000404 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
405 RecordDecl *Record, SourceLocation Loc,
406 bool Mutable, Expr *BitfieldWidth,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000407 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000408 Declarator *D = 0);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000409
410 virtual DeclTy *ActOnIvar(Scope *S, SourceLocation DeclStart,
411 Declarator &D, ExprTy *BitfieldWidth,
Fariborz Jahanian45bc03f2008-04-11 16:55:42 +0000412 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000413
Steve Narofff13271f2007-09-14 23:09:53 +0000414 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000415 virtual void ActOnFields(Scope* S,
Steve Naroff60fccee2007-10-29 21:38:07 +0000416 SourceLocation RecLoc, DeclTy *TagDecl,
417 DeclTy **Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000418 SourceLocation LBrac, SourceLocation RBrac,
419 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000420
421 /// ActOnTagStartDefinition - Invoked when we have entered the
422 /// scope of a tag's definition (e.g., for an enumeration, class,
423 /// struct, or union).
424 virtual void ActOnTagStartDefinition(Scope *S, DeclTy *TagDecl);
425
426 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
427 /// the definition of a tag (enumeration, class, struct, or union).
428 virtual void ActOnTagFinishDefinition(Scope *S, DeclTy *TagDecl);
429
Douglas Gregor879fd492009-03-17 19:05:46 +0000430 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
431 EnumConstantDecl *LastEnumConst,
432 SourceLocation IdLoc,
433 IdentifierInfo *Id,
434 ExprArg val);
435
Steve Naroff08d92e42007-09-15 18:49:24 +0000436 virtual DeclTy *ActOnEnumConstant(Scope *S, DeclTy *EnumDecl,
Reid Spencer5f016e22007-07-11 17:01:13 +0000437 DeclTy *LastEnumConstant,
438 SourceLocation IdLoc, IdentifierInfo *Id,
439 SourceLocation EqualLoc, ExprTy *Val);
Steve Naroff08d92e42007-09-15 18:49:24 +0000440 virtual void ActOnEnumBody(SourceLocation EnumLoc, DeclTy *EnumDecl,
Reid Spencer5f016e22007-07-11 17:01:13 +0000441 DeclTy **Elements, unsigned NumElements);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000442
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000443 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000444
Chris Lattner0ed844b2008-04-04 06:12:32 +0000445 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000446 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000447 void PopDeclContext();
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000448
Chris Lattner371f2582008-12-04 23:50:19 +0000449 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
450 /// to the function decl for the function being parsed. If we're currently
451 /// in a 'block', this returns the containing context.
452 FunctionDecl *getCurFunctionDecl();
453
454 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
455 /// the method decl for the method being parsed. If we're currently
456 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000457 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000458
Chris Lattner371f2582008-12-04 23:50:19 +0000459 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
460 /// or C function we're in, otherwise return null. If we're currently
461 /// in a 'block', this returns the containing context.
462 NamedDecl *getCurFunctionOrMethodDecl();
463
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000464 /// Add this decl to the scope shadowed decl chains.
465 void PushOnScopeChains(NamedDecl *D, Scope *S);
466
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000467 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
468 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
469 /// true if 'D' belongs to the given declaration context.
470 bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000471 return IdResolver.isDeclInScope(D, Ctx, Context, S);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000472 }
473
Eli Friedman8f17b662009-02-28 05:41:13 +0000474
475 void RecursiveCalcJumpScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
476 llvm::DenseMap<void*, Stmt*>& PopScopeMap,
477 llvm::DenseMap<Stmt*, void*>& GotoScopeMap,
478 std::vector<void*>& ScopeStack,
479 Stmt* CurStmt);
480
481 void RecursiveCalcLabelScopes(llvm::DenseMap<Stmt*, void*>& LabelScopeMap,
482 llvm::DenseMap<void*, Stmt*>& PopScopeMap,
483 std::vector<void*>& ScopeStack,
484 Stmt* CurStmt,
485 Stmt* ParentCompoundStmt);
486
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000487 /// Subroutines of ActOnDeclarator().
Chris Lattner41af0932007-11-14 06:34:38 +0000488 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000489 Decl *LastDecl);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000490 bool MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
491 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000492 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000493 bool MergeVarDecl(VarDecl *New, Decl *Old);
494 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000495
496 /// C++ Overloading.
497 bool IsOverload(FunctionDecl *New, Decl* OldD,
498 OverloadedFunctionDecl::function_iterator &MatchedDecl);
Douglas Gregor225c41e2008-11-03 19:09:14 +0000499 ImplicitConversionSequence
500 TryImplicitConversion(Expr* From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000501 bool SuppressUserConversions = false,
502 bool AllowExplicit = false);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000503 bool IsStandardConversion(Expr *From, QualType ToType,
504 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000505 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
506 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000507 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000508 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +0000509 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000510 bool isObjCPointerConversion(QualType FromType, QualType ToType,
511 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregor94b1dd22008-10-24 04:54:22 +0000512 bool CheckPointerConversion(Expr *From, QualType ToType);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000513 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
514 QualType &ConvertedType);
515 bool CheckMemberPointerConversion(Expr *From, QualType ToType);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000516 bool IsQualificationConversion(QualType FromType, QualType ToType);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000517 bool IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000518 UserDefinedConversionSequence& User,
Douglas Gregor734d9862009-01-30 23:27:23 +0000519 bool AllowConversionFunctions,
520 bool AllowExplicit);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000521
522 ImplicitConversionSequence::CompareKind
523 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
524 const ImplicitConversionSequence& ICS2);
525
526 ImplicitConversionSequence::CompareKind
527 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
528 const StandardConversionSequence& SCS2);
529
Douglas Gregor57373262008-10-22 14:17:15 +0000530 ImplicitConversionSequence::CompareKind
531 CompareQualificationConversions(const StandardConversionSequence& SCS1,
532 const StandardConversionSequence& SCS2);
533
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000534 ImplicitConversionSequence::CompareKind
535 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
536 const StandardConversionSequence& SCS2);
537
Douglas Gregor225c41e2008-11-03 19:09:14 +0000538 ImplicitConversionSequence
539 TryCopyInitialization(Expr* From, QualType ToType,
540 bool SuppressUserConversions = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000541 bool PerformCopyInitialization(Expr *&From, QualType ToType,
542 const char *Flavor);
543
Douglas Gregor96176b32008-11-18 23:14:02 +0000544 ImplicitConversionSequence
545 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
546 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
547
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000548 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
549 bool PerformContextuallyConvertToBool(Expr *&From);
550
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000551 /// OverloadingResult - Capture the result of performing overload
552 /// resolution.
553 enum OverloadingResult {
554 OR_Success, ///< Overload resolution succeeded.
555 OR_No_Viable_Function, ///< No viable function found.
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000556 OR_Ambiguous, ///< Ambiguous candidates found.
557 OR_Deleted ///< Overload resoltuion refers to a deleted function.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000558 };
559
Douglas Gregor063daf62009-03-13 18:40:31 +0000560 typedef llvm::SmallPtrSet<FunctionDecl *, 16> FunctionSet;
561 typedef llvm::SmallPtrSet<NamespaceDecl *, 16> AssociatedNamespaceSet;
562 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
563
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000564 void AddOverloadCandidate(FunctionDecl *Function,
565 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000566 OverloadCandidateSet& CandidateSet,
567 bool SuppressUserConversions = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000568 void AddFunctionCandidates(const FunctionSet &Functions,
569 Expr **Args, unsigned NumArgs,
570 OverloadCandidateSet& CandidateSet,
571 bool SuppressUserConversions = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000572 void AddMethodCandidate(CXXMethodDecl *Method,
573 Expr *Object, Expr **Args, unsigned NumArgs,
574 OverloadCandidateSet& CandidateSet,
Douglas Gregor88a35142008-12-22 05:46:06 +0000575 bool SuppressUserConversions = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000576 void AddConversionCandidate(CXXConversionDecl *Conversion,
577 Expr *From, QualType ToType,
578 OverloadCandidateSet& CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000579 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000580 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000581 Expr *Object, Expr **Args, unsigned NumArgs,
582 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000583 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000584 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000585 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000586 OverloadCandidateSet& CandidateSet,
587 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000588 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
589 SourceLocation OpLoc,
590 Expr **Args, unsigned NumArgs,
591 OverloadCandidateSet& CandidateSet,
592 SourceRange OpRange = SourceRange());
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000593 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
594 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000595 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000596 bool IsAssignmentOperator = false,
597 unsigned NumContextualBoolArguments = 0);
Douglas Gregor74253732008-11-19 15:42:04 +0000598 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
599 Expr **Args, unsigned NumArgs,
600 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000601 void AddArgumentDependentLookupCandidates(DeclarationName Name,
602 Expr **Args, unsigned NumArgs,
603 OverloadCandidateSet& CandidateSet);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000604 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
605 const OverloadCandidate& Cand2);
606 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
607 OverloadCandidateSet::iterator& Best);
608 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
609 bool OnlyViable);
610
Douglas Gregor904eed32008-11-10 20:40:00 +0000611 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
612 bool Complain);
613 void FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
614
Douglas Gregor17330012009-02-04 15:01:18 +0000615 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn, NamedDecl *Callee,
616 DeclarationName UnqualifiedName,
Douglas Gregor0a396682008-11-26 06:01:48 +0000617 SourceLocation LParenLoc,
618 Expr **Args, unsigned NumArgs,
619 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +0000620 SourceLocation RParenLoc,
Douglas Gregor17330012009-02-04 15:01:18 +0000621 bool &ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +0000622
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000623 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
624 unsigned Opc,
625 FunctionSet &Functions,
626 ExprArg input);
627
Douglas Gregor063daf62009-03-13 18:40:31 +0000628 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
629 unsigned Opc,
630 FunctionSet &Functions,
631 Expr *LHS, Expr *RHS);
632
Douglas Gregor88a35142008-12-22 05:46:06 +0000633 ExprResult
634 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
635 SourceLocation LParenLoc, Expr **Args,
636 unsigned NumArgs, SourceLocation *CommaLocs,
637 SourceLocation RParenLoc);
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000638 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +0000639 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000640 Expr **Args, unsigned NumArgs,
641 SourceLocation *CommaLocs,
642 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000643
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000644 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
Douglas Gregor8ba10742008-11-20 16:27:02 +0000645 SourceLocation MemberLoc,
646 IdentifierInfo &Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000647
Chris Lattner823c44e2009-01-06 07:27:21 +0000648 /// Helpers for dealing with function parameters.
Chris Lattner04421082008-04-08 04:40:51 +0000649 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +0000650 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000651 void CheckExtraCXXDefaultArguments(Declarator &D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000652
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000653 Scope *getNonFieldDeclScope(Scope *S);
654
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000655 /// \name Name lookup
656 ///
657 /// These routines provide name lookup that is used during semantic
658 /// analysis to resolve the various kinds of names (identifiers,
659 /// overloaded operator names, constructor names, etc.) into zero or
660 /// more declarations within a particular scope. The major entry
661 /// points are LookupName, which performs unqualified name lookup,
662 /// and LookupQualifiedName, which performs qualified name lookup.
663 ///
664 /// All name lookup is performed based on some specific criteria,
665 /// which specify what names will be visible to name lookup and how
666 /// far name lookup should work. These criteria are important both
667 /// for capturing language semantics (certain lookups will ignore
668 /// certain names, for example) and for performance, since name
669 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000670 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000671 ///
672 /// The results of name lookup can vary based on the kind of name
673 /// lookup performed, the current language, and the translation
674 /// unit. In C, for example, name lookup will either return nothing
675 /// (no entity found) or a single declaration. In C++, name lookup
676 /// can additionally refer to a set of overloaded functions or
677 /// result in an ambiguity. All of the possible results of name
678 /// lookup are captured by the LookupResult class, which provides
679 /// the ability to distinguish among them.
680 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +0000681
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000682 /// @brief Describes the kind of name lookup to perform.
683 enum LookupNameKind {
684 /// Ordinary name lookup, which finds ordinary names (functions,
685 /// variables, typedefs, etc.) in C and most kinds of names
686 /// (functions, variables, members, types, etc.) in C++.
687 LookupOrdinaryName = 0,
688 /// Tag name lookup, which finds the names of enums, classes,
689 /// structs, and unions.
690 LookupTagName,
691 /// Member name lookup, which finds the names of
692 /// class/struct/union members.
693 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000694 // Look up of an operator name (e.g., operator+) for use with
695 // operator overloading. This lookup is similar to ordinary name
696 // lookup, but will ignore any declarations that are class
697 // members.
698 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000699 /// Look up of a name that precedes the '::' scope resolution
700 /// operator in C++. This lookup completely ignores operator,
701 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
702 LookupNestedNameSpecifierName,
703 /// Look up a namespace name within a C++ using directive or
704 /// namespace alias definition, ignoring non-namespace names (C++
705 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000706 LookupNamespaceName,
707 // Look up an ordinary name that is going to be redeclared as a
708 // name with linkage. This lookup ignores any declarations that
709 // are outside of the current scope unless they have linkage. See
710 // C99 6.2.2p4-5 and C++ [basic.link]p6.
711 LookupRedeclarationWithLinkage
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000712 };
713
714 /// @brief Represents the results of name lookup.
715 ///
716 /// An instance of the LookupResult class captures the results of a
717 /// single name lookup, which can return no result (nothing found),
718 /// a single declaration, a set of overloaded functions, or an
719 /// ambiguity. Use the getKind() method to determine which of these
720 /// results occurred for a given lookup.
721 ///
722 /// Any non-ambiguous lookup can be converted into a single
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000723 /// (possibly NULL) @c NamedDecl* via a conversion function or the
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000724 /// getAsDecl() method. This conversion permits the common-case
725 /// usage in C and Objective-C where name lookup will always return
726 /// a single declaration.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000727 struct LookupResult {
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000728 /// The kind of entity that is actually stored within the
729 /// LookupResult object.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000730 enum {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000731 /// First is a single declaration (a NamedDecl*), which may be NULL.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000732 SingleDecl,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000733
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000734 /// First is a single declaration (an OverloadedFunctionDecl*).
735 OverloadedDeclSingleDecl,
736
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000737 /// [First, Last) is an iterator range represented as opaque
738 /// pointers used to reconstruct IdentifierResolver::iterators.
739 OverloadedDeclFromIdResolver,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000740
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000741 /// [First, Last) is an iterator range represented as opaque
742 /// pointers used to reconstruct DeclContext::lookup_iterators.
743 OverloadedDeclFromDeclContext,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000744
745 /// First is a pointer to a BasePaths structure, which is owned
746 /// by the LookupResult. Last is non-zero to indicate that the
747 /// ambiguity is caused by two names found in base class
748 /// subobjects of different types.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000749 AmbiguousLookupStoresBasePaths,
750
751 /// [First, Last) is an iterator range represented as opaque
752 /// pointers used to reconstruct new'ed Decl*[] array containing
753 /// found ambiguous decls. LookupResult is owner of this array.
754 AmbiguousLookupStoresDecls
755
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000756 } StoredKind;
757
758 /// The first lookup result, whose contents depend on the kind of
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000759 /// lookup result. This may be a NamedDecl* (if StoredKind ==
760 /// SingleDecl), OverloadedFunctionDecl* (if StoredKind ==
761 /// OverloadedDeclSingleDecl), the opaque pointer from an
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000762 /// IdentifierResolver::iterator (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000763 /// OverloadedDeclFromIdResolver), a DeclContext::lookup_iterator
764 /// (if StoredKind == OverloadedDeclFromDeclContext), or a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000765 /// BasePaths pointer (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000766 mutable uintptr_t First;
767
768 /// The last lookup result, whose contents depend on the kind of
769 /// lookup result. This may be unused (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000770 /// SingleDecl), it may have the same type as First (for
771 /// overloaded function declarations), or is may be used as a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000772 /// Boolean value (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000773 mutable uintptr_t Last;
774
775 /// Context - The context in which we will build any
776 /// OverloadedFunctionDecl nodes needed by the conversion to
777 /// Decl*.
778 ASTContext *Context;
779
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000780 /// @brief The kind of entity found by name lookup.
781 enum LookupKind {
782 /// @brief No entity found met the criteria.
783 NotFound = 0,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000784
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000785 /// @brief Name lookup found a single declaration that met the
Douglas Gregor7176fff2009-01-15 00:26:24 +0000786 /// criteria. getAsDecl will return this declaration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000787 Found,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000788
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000789 /// @brief Name lookup found a set of overloaded functions that
Douglas Gregor7176fff2009-01-15 00:26:24 +0000790 /// met the criteria. getAsDecl will turn this set of overloaded
791 /// functions into an OverloadedFunctionDecl.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000792 FoundOverloaded,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000793
794 /// Name lookup results in an ambiguity because multiple
795 /// entities that meet the lookup criteria were found in
796 /// subobjects of different types. For example:
797 /// @code
798 /// struct A { void f(int); }
799 /// struct B { void f(double); }
800 /// struct C : A, B { };
801 /// void test(C c) {
802 /// c.f(0); // error: A::f and B::f come from subobjects of different
803 /// // types. overload resolution is not performed.
804 /// }
805 /// @endcode
806 AmbiguousBaseSubobjectTypes,
807
808 /// Name lookup results in an ambiguity because multiple
809 /// nonstatic entities that meet the lookup criteria were found
810 /// in different subobjects of the same type. For example:
811 /// @code
812 /// struct A { int x; };
813 /// struct B : A { };
814 /// struct C : A { };
815 /// struct D : B, C { };
816 /// int test(D d) {
817 /// return d.x; // error: 'x' is found in two A subobjects (of B and C)
818 /// }
819 /// @endcode
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000820 AmbiguousBaseSubobjects,
821
822 /// Name lookup results in an ambiguity because multiple definitions
823 /// of entity that meet the lookup criteria were found in different
824 /// declaration contexts.
825 /// @code
826 /// namespace A {
827 /// int i;
828 /// namespace B { int i; }
829 /// int test() {
830 /// using namespace B;
831 /// return i; // error 'i' is found in namespace A and A::B
832 /// }
833 /// }
834 /// @endcode
835 AmbiguousReference
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000836 };
837
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000838 static LookupResult CreateLookupResult(ASTContext &Context, NamedDecl *D);
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000839
Douglas Gregor69d993a2009-01-17 01:13:24 +0000840 static LookupResult CreateLookupResult(ASTContext &Context,
841 IdentifierResolver::iterator F,
842 IdentifierResolver::iterator L);
Douglas Gregor7176fff2009-01-15 00:26:24 +0000843
Douglas Gregor69d993a2009-01-17 01:13:24 +0000844 static LookupResult CreateLookupResult(ASTContext &Context,
845 DeclContext::lookup_iterator F,
846 DeclContext::lookup_iterator L);
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000847
Douglas Gregor69d993a2009-01-17 01:13:24 +0000848 static LookupResult CreateLookupResult(ASTContext &Context, BasePaths *Paths,
849 bool DifferentSubobjectTypes) {
850 LookupResult Result;
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000851 Result.StoredKind = AmbiguousLookupStoresBasePaths;
Douglas Gregor69d993a2009-01-17 01:13:24 +0000852 Result.First = reinterpret_cast<uintptr_t>(Paths);
853 Result.Last = DifferentSubobjectTypes? 1 : 0;
854 Result.Context = &Context;
855 return Result;
856 }
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000857
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000858 template <typename Iterator>
859 static LookupResult CreateLookupResult(ASTContext &Context,
860 Iterator B, std::size_t Len) {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000861 NamedDecl ** Array = new NamedDecl*[Len];
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000862 for (std::size_t Idx = 0; Idx < Len; ++Idx, ++B)
863 Array[Idx] = *B;
864 LookupResult Result;
865 Result.StoredKind = AmbiguousLookupStoresDecls;
866 Result.First = reinterpret_cast<uintptr_t>(Array);
867 Result.Last = reinterpret_cast<uintptr_t>(Array + Len);
868 Result.Context = &Context;
869 return Result;
870 }
871
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000872 LookupKind getKind() const;
873
874 /// @brief Determine whether name look found something.
875 operator bool() const { return getKind() != NotFound; }
876
Douglas Gregor7176fff2009-01-15 00:26:24 +0000877 /// @brief Determines whether the lookup resulted in an ambiguity.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000878 bool isAmbiguous() const {
879 return StoredKind == AmbiguousLookupStoresBasePaths ||
880 StoredKind == AmbiguousLookupStoresDecls;
881 }
Douglas Gregor7176fff2009-01-15 00:26:24 +0000882
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000883 /// @brief Allows conversion of a lookup result into a
884 /// declaration, with the same behavior as getAsDecl.
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000885 operator NamedDecl*() const { return getAsDecl(); }
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000886
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000887 NamedDecl* getAsDecl() const;
Douglas Gregor7176fff2009-01-15 00:26:24 +0000888
889 BasePaths *getBasePaths() const;
Douglas Gregord8635172009-02-02 21:35:47 +0000890
891 /// \brief Iterate over the results of name lookup.
892 ///
893 /// The @c iterator class provides iteration over the results of a
894 /// non-ambiguous name lookup.
895 class iterator {
896 /// The LookupResult structure we're iterating through.
897 LookupResult *Result;
898
899 /// The current position of this iterator within the sequence of
900 /// results. This value will have the same representation as the
901 /// @c First field in the LookupResult structure.
902 mutable uintptr_t Current;
903
904 public:
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000905 typedef NamedDecl * value_type;
906 typedef NamedDecl * reference;
907 typedef NamedDecl * pointer;
Douglas Gregord8635172009-02-02 21:35:47 +0000908 typedef std::ptrdiff_t difference_type;
909 typedef std::forward_iterator_tag iterator_category;
910
911 iterator() : Result(0), Current(0) { }
912
913 iterator(LookupResult *Res, uintptr_t Cur) : Result(Res), Current(Cur) { }
914
915 reference operator*() const;
916
917 pointer operator->() const { return **this; }
918
919 iterator &operator++();
920
921 iterator operator++(int) {
922 iterator tmp(*this);
923 ++(*this);
924 return tmp;
925 }
926
927 friend inline bool operator==(iterator const& x, iterator const& y) {
928 return x.Current == y.Current;
929 }
930
931 friend inline bool operator!=(iterator const& x, iterator const& y) {
932 return x.Current != y.Current;
933 }
934 };
935 friend class iterator;
936
937 iterator begin();
938 iterator end();
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000939 };
940
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000941private:
942 typedef llvm::SmallVector<LookupResult, 3> LookupResultsVecTy;
943
944 std::pair<bool, LookupResult> CppLookupName(Scope *S, DeclarationName Name,
945 LookupNameKind NameKind,
946 bool RedeclarationOnly);
947
948public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000949 /// Determines whether D is a suitable lookup result according to the
950 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000951 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +0000952 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000953 switch (NameKind) {
954 case Sema::LookupOrdinaryName:
955 case Sema::LookupTagName:
956 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000957 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000958 return D->isInIdentifierNamespace(IDNS);
959
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000960 case Sema::LookupOperatorName:
961 return D->isInIdentifierNamespace(IDNS) &&
962 !D->getDeclContext()->isRecord();
963
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000964 case Sema::LookupNestedNameSpecifierName:
965 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
966
967 case Sema::LookupNamespaceName:
968 return isa<NamespaceDecl>(D);
969 }
970
971 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +0000972 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000973 return false;
974 }
Douglas Gregor7176fff2009-01-15 00:26:24 +0000975
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000976 LookupResult LookupName(Scope *S, DeclarationName Name,
977 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +0000978 bool RedeclarationOnly = false,
979 bool AllowBuiltinCreation = true,
980 SourceLocation Loc = SourceLocation());
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000981 LookupResult LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
982 LookupNameKind NameKind,
983 bool RedeclarationOnly = false);
984 LookupResult LookupParsedName(Scope *S, const CXXScopeSpec *SS,
985 DeclarationName Name,
986 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +0000987 bool RedeclarationOnly = false,
988 bool AllowBuiltinCreation = true,
989 SourceLocation Loc = SourceLocation());
Douglas Gregor3fd95ce2009-03-13 00:33:25 +0000990
Douglas Gregor3fd95ce2009-03-13 00:33:25 +0000991 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
992 QualType T1, QualType T2,
993 FunctionSet &Functions);
994
995 void ArgumentDependentLookup(DeclarationName Name,
996 Expr **Args, unsigned NumArgs,
997 FunctionSet &Functions);
998
Douglas Gregorfa047642009-02-04 00:32:51 +0000999 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1000 AssociatedNamespaceSet &AssociatedNamespaces,
1001 AssociatedClassSet &AssociatedClasses);
1002
Douglas Gregor7176fff2009-01-15 00:26:24 +00001003 bool DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
1004 SourceLocation NameLoc,
1005 SourceRange LookupRange = SourceRange());
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001006 //@}
1007
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001008 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001009 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001010 Scope *S, bool ForRedeclaration,
1011 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001012 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1013 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001014 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001015
1016 // More parsing and symbol table subroutines.
1017
Reid Spencer5f016e22007-07-11 17:01:13 +00001018 // Decl attributes - this routine is the top level dispatcher.
Chris Lattnere5c5ee12008-06-29 00:16:31 +00001019 void ProcessDeclAttributes(Decl *D, const Declarator &PD);
Chris Lattnerf2e4bd52008-06-28 23:58:55 +00001020 void ProcessDeclAttributeList(Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001021
Steve Naroff3c2eb662008-02-10 21:38:56 +00001022 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1023 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001024 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1025 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001026
1027 NamespaceDecl *GetStdNamespace();
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001028
1029 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001030 ObjCInterfaceDecl *IDecl);
Steve Naroff3c2eb662008-02-10 21:38:56 +00001031
Chris Lattner823c44e2009-01-06 07:27:21 +00001032 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001033 /// methods declared in protocol, and those referenced by it.
1034 /// \param IDecl - Used for checking for methods which may have been
1035 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001036 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1037 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001038 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001039 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001040 const llvm::DenseSet<Selector> &ClsMap,
1041 ObjCInterfaceDecl *IDecl);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001042
Steve Naroffa5997c42007-10-02 21:43:37 +00001043 /// CheckImplementationIvars - This routine checks if the instance variables
1044 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001045 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1046 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001047 SourceLocation Loc);
Steve Naroffa5997c42007-10-02 21:43:37 +00001048
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001049 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001050 /// remains unimplemented in the class or category @implementation.
1051 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1052 ObjCContainerDecl* IDecl,
1053 bool IncompleteImpl = false);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001054
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001055 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1056 /// true, or false, accordingly.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001057 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001058 const ObjCMethodDecl *PrevMethod,
1059 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001060
Steve Naroff58ff9e82007-10-14 00:58:41 +00001061 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1062 /// unit are added to a global pool. This allows us to efficiently associate
1063 /// a selector with a method declaraation for purposes of typechecking
1064 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001065 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff58ff9e82007-10-14 00:58:41 +00001066
Steve Naroff037cda52008-09-30 14:38:43 +00001067 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1068 /// there are multiple signatures.
1069 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R);
1070
Steve Naroff58ff9e82007-10-14 00:58:41 +00001071 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001072 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001073 //===--------------------------------------------------------------------===//
1074 // Statement Parsing Callbacks: SemaStmt.cpp.
1075public:
Sebastian Redla60528c2008-12-21 12:04:03 +00001076 virtual OwningStmtResult ActOnExprStmt(ExprArg Expr);
1077
1078 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1079 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1080 MultiStmtArg Elts,
1081 bool isStmtExpr);
1082 virtual OwningStmtResult ActOnDeclStmt(DeclTy *Decl, SourceLocation StartLoc,
1083 SourceLocation EndLoc);
Sebastian Redl117054a2008-12-28 16:13:43 +00001084 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1085 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001086 SourceLocation ColonLoc);
1087 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
1088
Sebastian Redl117054a2008-12-28 16:13:43 +00001089 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1090 SourceLocation ColonLoc,
1091 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001092 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1093 IdentifierInfo *II,
1094 SourceLocation ColonLoc,
1095 StmtArg SubStmt);
1096 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc, ExprArg CondVal,
1097 StmtArg ThenVal, SourceLocation ElseLoc,
1098 StmtArg ElseVal);
1099 virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond);
1100 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1101 StmtArg Switch, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001102 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc, ExprArg Cond,
1103 StmtArg Body);
1104 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
1105 SourceLocation WhileLoc, ExprArg Cond);
1106
1107 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1108 SourceLocation LParenLoc,
1109 StmtArg First, ExprArg Second,
1110 ExprArg Third, SourceLocation RParenLoc,
1111 StmtArg Body);
1112 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1113 SourceLocation LParenLoc,
1114 StmtArg First, ExprArg Second,
1115 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001116
1117 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1118 SourceLocation LabelLoc,
1119 IdentifierInfo *LabelII);
1120 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1121 SourceLocation StarLoc,
1122 ExprArg DestExp);
1123 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1124 Scope *CurScope);
1125 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1126 Scope *CurScope);
1127
1128 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
1129 ExprArg RetValExp);
1130 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1131 Expr *RetValExp);
1132
Sebastian Redl3037ed02009-01-18 16:53:17 +00001133 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1134 bool IsSimple,
1135 bool IsVolatile,
1136 unsigned NumOutputs,
1137 unsigned NumInputs,
1138 std::string *Names,
1139 MultiExprArg Constraints,
1140 MultiExprArg Exprs,
1141 ExprArg AsmString,
1142 MultiExprArg Clobbers,
1143 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001144
1145 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1146 SourceLocation RParen,
Steve Naroff7ba138a2009-03-03 19:52:17 +00001147 DeclTy *Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001148 StmtArg CatchList);
1149
1150 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1151 StmtArg Body);
1152
1153 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1154 StmtArg Try,
1155 StmtArg Catch, StmtArg Finally);
1156
1157 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001158 ExprArg Throw,
1159 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001160 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1161 ExprArg SynchExpr,
1162 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001163
Sebastian Redl4b07b292008-12-22 19:15:10 +00001164 virtual DeclTy *ActOnExceptionDeclarator(Scope *S, Declarator &D);
1165 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
1166 DeclTy *ExDecl,
1167 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001168 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1169 StmtArg TryBlock,
1170 MultiStmtArg Handlers);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001171
Reid Spencer5f016e22007-07-11 17:01:13 +00001172 //===--------------------------------------------------------------------===//
1173 // Expression Parsing Callbacks: SemaExpr.cpp.
1174
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001175 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Chris Lattner76a642f2009-02-15 22:43:40 +00001176
Reid Spencer5f016e22007-07-11 17:01:13 +00001177 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001178 virtual SourceRange getExprRange(ExprTy *E) const;
1179
Sebastian Redlcd965b92009-01-18 18:53:16 +00001180 virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
1181 IdentifierInfo &II,
1182 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001183 const CXXScopeSpec *SS = 0,
1184 bool isAddressOfOperand = false);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001185 virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001186 SourceLocation OperatorLoc,
1187 OverloadedOperatorKind Op,
1188 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001189 const CXXScopeSpec &SS,
1190 bool isAddressOfOperand);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001191 virtual OwningExprResult ActOnCXXConversionFunctionExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001192 SourceLocation OperatorLoc,
1193 TypeTy *Ty,
1194 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001195 const CXXScopeSpec &SS,
1196 bool isAddressOfOperand);
Douglas Gregor1a49af92009-01-06 05:10:23 +00001197 DeclRefExpr *BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
1198 bool TypeDependent, bool ValueDependent,
1199 const CXXScopeSpec *SS = 0);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001200 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001201 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1202 FieldDecl *Field,
1203 Expr *BaseObjectExpr = 0,
1204 SourceLocation OpLoc = SourceLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001205 OwningExprResult ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
1206 DeclarationName Name,
1207 bool HasTrailingLParen,
1208 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001209 bool isAddressOfOperand = false);
Douglas Gregor10c42622008-11-18 15:03:34 +00001210
Sebastian Redlcd965b92009-01-18 18:53:16 +00001211 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1212 tok::TokenKind Kind);
1213 virtual OwningExprResult ActOnNumericConstant(const Token &);
1214 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1215 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1216 ExprArg Val);
Reid Spencer5f016e22007-07-11 17:01:13 +00001217
Steve Narofff69936d2007-09-16 03:34:24 +00001218 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001219 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001220 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1221 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001222
Reid Spencer5f016e22007-07-11 17:01:13 +00001223 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001224 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
1225 unsigned OpcIn,
1226 ExprArg InputArg);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001227 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1228 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001229
Douglas Gregorba498172009-03-13 21:01:28 +00001230 OwningExprResult CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1231 bool isSizeOf, SourceRange R);
1232 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1233 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001234 virtual OwningExprResult
1235 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1236 void *TyOrEx, const SourceRange &ArgRange);
Douglas Gregorba498172009-03-13 21:01:28 +00001237
Chris Lattner31e21e02009-01-24 20:17:12 +00001238 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001239 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1240 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001241
1242 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1243 tok::TokenKind Kind,
1244 ExprArg Input);
1245
1246 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1247 SourceLocation LLoc,
1248 ExprArg Idx,
1249 SourceLocation RLoc);
1250 virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
1251 SourceLocation OpLoc,
1252 tok::TokenKind OpKind,
1253 SourceLocation MemberLoc,
Fariborz Jahaniana6e3ac52009-03-04 22:30:12 +00001254 IdentifierInfo &Member,
1255 DeclTy *ImplDecl=0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001256 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001257 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001258 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001259 Expr **Args, unsigned NumArgs,
1260 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001261
Steve Narofff69936d2007-09-16 03:34:24 +00001262 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001263 /// This provides the location of the left/right parens and a list of comma
1264 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001265 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1266 SourceLocation LParenLoc,
1267 MultiExprArg Args,
1268 SourceLocation *CommaLocs,
1269 SourceLocation RParenLoc);
1270
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001271 virtual OwningExprResult ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
1272 SourceLocation RParenLoc, ExprArg Op);
1273
1274 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1275 TypeTy *Ty,
1276 SourceLocation RParenLoc,
1277 ExprArg Op);
1278
1279 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1280 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001281 SourceLocation RParenLoc);
1282
Douglas Gregor05c13a32009-01-22 00:58:24 +00001283 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1284 SourceLocation Loc,
1285 bool UsedColonSyntax,
1286 OwningExprResult Init);
1287
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001288 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1289 tok::TokenKind Kind,
1290 ExprArg LHS, ExprArg RHS);
1291 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1292 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001293
Steve Narofff69936d2007-09-16 03:34:24 +00001294 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001295 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001296 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1297 SourceLocation ColonLoc,
1298 ExprArg Cond, ExprArg LHS,
1299 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001300
Steve Naroff1b273c42007-09-16 14:56:35 +00001301 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001302 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1303 SourceLocation LabLoc,
1304 IdentifierInfo *LabelII);
1305
1306 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1307 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001308
1309 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001310 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1311 SourceLocation BuiltinLoc,
1312 SourceLocation TypeLoc,
1313 TypeTy *Arg1,
1314 OffsetOfComponent *CompPtr,
1315 unsigned NumComponents,
1316 SourceLocation RParenLoc);
1317
Steve Naroffd34e9152007-08-01 22:05:33 +00001318 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001319 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1320 TypeTy *arg1, TypeTy *arg2,
1321 SourceLocation RPLoc);
1322
Steve Naroffd04fdd52007-08-03 21:21:27 +00001323 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001324 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1325 ExprArg cond, ExprArg expr1,
1326 ExprArg expr2, SourceLocation RPLoc);
1327
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001328 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001329 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1330 ExprArg expr, TypeTy *type,
1331 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001332
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001333 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001334 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001335
Steve Naroff4eb206b2008-09-03 18:15:37 +00001336 //===------------------------- "Block" Extension ------------------------===//
1337
1338 /// ActOnBlockStart - This callback is invoked when a block literal is
1339 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001340 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001341
Steve Naroff090276f2008-10-10 01:28:17 +00001342 /// ActOnBlockArguments - This callback allows processing of block arguments.
1343 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001344 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001345
Steve Naroff4eb206b2008-09-03 18:15:37 +00001346 /// ActOnBlockError - If there is an error parsing a block, this callback
1347 /// is invoked to pop the information about the block from the action impl.
1348 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001349
Steve Naroff4eb206b2008-09-03 18:15:37 +00001350 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1351 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001352 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1353 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001354
Chris Lattner76a642f2009-02-15 22:43:40 +00001355 //===---------------------------- C++ Features --------------------------===//
1356
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001357 // Act on C++ namespaces
1358 virtual DeclTy *ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001359 IdentifierInfo *Ident,
1360 SourceLocation LBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001361 virtual void ActOnFinishNamespaceDef(DeclTy *Dcl, SourceLocation RBrace);
1362
Douglas Gregorf780abc2008-12-30 03:27:21 +00001363 virtual DeclTy *ActOnUsingDirective(Scope *CurScope,
1364 SourceLocation UsingLoc,
1365 SourceLocation NamespcLoc,
1366 const CXXScopeSpec &SS,
1367 SourceLocation IdentLoc,
1368 IdentifierInfo *NamespcName,
1369 AttributeList *AttrList);
1370
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001371 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1372
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001373 /// AddCXXDirectInitializerToDecl - This action is called immediately after
1374 /// ActOnDeclarator, when a C++ direct initializer is present.
1375 /// e.g: "int x(1);"
1376 virtual void AddCXXDirectInitializerToDecl(DeclTy *Dcl,
1377 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001378 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001379 SourceLocation *CommaLocs,
1380 SourceLocation RParenLoc);
1381
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001382 /// InitializationKind - Represents which kind of C++ initialization
1383 /// [dcl.init] a routine is to perform.
1384 enum InitializationKind {
1385 IK_Direct, ///< Direct initialization
1386 IK_Copy, ///< Copy initialization
1387 IK_Default ///< Default initialization
1388 };
1389
Douglas Gregor18fe5682008-11-03 20:45:27 +00001390 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001391 PerformInitializationByConstructor(QualType ClassType,
1392 Expr **Args, unsigned NumArgs,
1393 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001394 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001395 InitializationKind Kind);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001396
Douglas Gregor49badde2008-10-27 19:41:14 +00001397 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001398 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1399 tok::TokenKind Kind,
1400 SourceLocation LAngleBracketLoc,
1401 TypeTy *Ty,
1402 SourceLocation RAngleBracketLoc,
1403 SourceLocation LParenLoc,
1404 ExprArg E,
1405 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001406
Sebastian Redlf53597f2009-03-15 17:47:39 +00001407 /// ActOnCXXTypeid - Parse typeid( something ).
1408 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1409 SourceLocation LParenLoc, bool isType,
1410 void *TyOrExpr,
1411 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001412
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001413 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001414 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001415
Steve Naroff1b273c42007-09-16 14:56:35 +00001416 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001417 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1418 tok::TokenKind Kind);
1419
Chris Lattner50dd2892008-02-26 00:51:44 +00001420 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001421 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1422 ExprArg expr);
Chris Lattner50dd2892008-02-26 00:51:44 +00001423
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001424 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1425 /// Can be interpreted either as function-style casting ("int(x)")
1426 /// or class type construction ("ClassType(x,y,z)")
1427 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001428 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1429 TypeTy *TypeRep,
1430 SourceLocation LParenLoc,
1431 MultiExprArg Exprs,
1432 SourceLocation *CommaLocs,
1433 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001434
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001435 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001436 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1437 SourceLocation PlacementLParen,
1438 MultiExprArg PlacementArgs,
1439 SourceLocation PlacementRParen,
1440 bool ParenTypeId, Declarator &D,
1441 SourceLocation ConstructorLParen,
1442 MultiExprArg ConstructorArgs,
1443 SourceLocation ConstructorRParen);
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001444 bool CheckAllocatedType(QualType AllocType, const Declarator &D);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001445 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1446 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001447 Expr **PlaceArgs, unsigned NumPlaceArgs,
1448 FunctionDecl *&OperatorNew,
1449 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001450 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1451 DeclarationName Name, Expr** Args,
1452 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001453 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001454 void DeclareGlobalNewDelete();
1455 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1456 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001457
1458 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001459 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1460 bool UseGlobal, bool ArrayForm,
1461 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001462
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001463 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
1464 /// C++ if/switch/while/for statement.
1465 /// e.g: "if (int x = f()) {...}"
Sebastian Redlf53597f2009-03-15 17:47:39 +00001466 virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001467 SourceLocation StartLoc,
1468 Declarator &D,
1469 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001470 ExprArg AssignExprVal);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001471
Sebastian Redl64b45f72009-01-05 20:52:13 +00001472 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1473 /// pseudo-functions.
1474 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1475 SourceLocation KWLoc,
1476 SourceLocation LParen,
1477 TypeTy *Ty,
1478 SourceLocation RParen);
1479
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001480 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001481
1482 DeclContext *computeDeclContext(const CXXScopeSpec &SS);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001483 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001484
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001485 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1486 /// global scope ('::').
1487 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1488 SourceLocation CCLoc);
1489
1490 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1491 /// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
1492 /// we want to resolve "bar::". 'SS' is empty or the previously parsed
1493 /// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
1494 /// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
1495 /// Returns a CXXScopeTy* object representing the C++ scope.
1496 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1497 const CXXScopeSpec &SS,
1498 SourceLocation IdLoc,
1499 SourceLocation CCLoc,
Douglas Gregor2def4832008-11-17 20:34:05 +00001500 IdentifierInfo &II);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001501
Douglas Gregor39a8de12009-02-25 19:37:18 +00001502 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1503 /// nested-name-specifier that involves a template-id, e.g.,
1504 /// "foo::bar<int, float>::", and now we need to build a scope
1505 /// specifier. \p SS is empty or the previously parsed nested-name
1506 /// part ("foo::"), \p Type is the already-parsed class template
1507 /// specialization (or other template-id that names a type), \p
1508 /// TypeRange is the source range where the type is located, and \p
1509 /// CCLoc is the location of the trailing '::'.
1510 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1511 const CXXScopeSpec &SS,
1512 TypeTy *Type,
1513 SourceRange TypeRange,
1514 SourceLocation CCLoc);
1515
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001516 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1517 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1518 /// After this method is called, according to [C++ 3.4.3p3], names should be
1519 /// looked up in the declarator-id's scope, until the declarator is parsed and
1520 /// ActOnCXXExitDeclaratorScope is called.
1521 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1522 virtual void ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
1523
1524 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1525 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1526 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1527 /// Used to indicate that names should revert to being looked up in the
1528 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00001529 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001530
Anders Carlsson55085182007-08-21 17:43:55 +00001531 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00001532 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
1533 ExprTy **Strings,
1534 unsigned NumStrings);
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001535 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00001536 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001537 SourceLocation LParenLoc,
1538 TypeTy *Ty,
1539 SourceLocation RParenLoc);
1540
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001541 // ParseObjCSelectorExpression - Build selector expression for @selector
1542 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
1543 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00001544 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001545 SourceLocation LParenLoc,
1546 SourceLocation RParenLoc);
1547
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001548 // ParseObjCProtocolExpression - Build protocol expression for @protocol
1549 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
1550 SourceLocation AtLoc,
1551 SourceLocation ProtoLoc,
1552 SourceLocation LParenLoc,
1553 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001554
1555 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00001556 // C++ Declarations
1557 //
1558 virtual DeclTy *ActOnStartLinkageSpecification(Scope *S,
1559 SourceLocation ExternLoc,
1560 SourceLocation LangLoc,
1561 const char *Lang,
1562 unsigned StrSize,
1563 SourceLocation LBraceLoc);
1564 virtual DeclTy *ActOnFinishLinkageSpecification(Scope *S,
1565 DeclTy *LinkageSpec,
1566 SourceLocation RBraceLoc);
1567
1568
1569 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001570 // C++ Classes
1571 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001572 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
1573 const CXXScopeSpec *SS);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001574
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001575 virtual DeclTy *ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
1576 Declarator &D, ExprTy *BitfieldWidth,
1577 ExprTy *Init, DeclTy *LastInGroup);
1578
Douglas Gregor7ad83902008-11-05 04:29:56 +00001579 virtual MemInitResult ActOnMemInitializer(DeclTy *ConstructorD,
1580 Scope *S,
1581 IdentifierInfo *MemberOrBase,
1582 SourceLocation IdLoc,
1583 SourceLocation LParenLoc,
1584 ExprTy **Args, unsigned NumArgs,
1585 SourceLocation *CommaLocs,
1586 SourceLocation RParenLoc);
1587
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001588 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
1589
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001590 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
1591 DeclTy *TagDecl,
1592 SourceLocation LBrac,
1593 SourceLocation RBrac);
1594
Douglas Gregor72b505b2008-12-16 21:30:33 +00001595 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S, DeclTy *Method);
1596 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclTy *Param);
1597 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S, DeclTy *Method);
1598
Anders Carlssonfb311762009-03-14 00:25:26 +00001599 virtual DeclTy *ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
1600 ExprArg AssertExpr,
Anders Carlsson94b15fb2009-03-15 18:44:04 +00001601 ExprArg AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00001602
Douglas Gregor42a552f2008-11-05 20:51:48 +00001603 bool CheckConstructorDeclarator(Declarator &D, QualType &R,
1604 FunctionDecl::StorageClass& SC);
Douglas Gregor72b505b2008-12-16 21:30:33 +00001605 bool CheckConstructor(CXXConstructorDecl *Constructor);
Douglas Gregor42a552f2008-11-05 20:51:48 +00001606 bool CheckDestructorDeclarator(Declarator &D, QualType &R,
1607 FunctionDecl::StorageClass& SC);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001608 bool CheckConversionDeclarator(Declarator &D, QualType &R,
1609 FunctionDecl::StorageClass& SC);
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001610 DeclTy *ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001611
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001612 //===--------------------------------------------------------------------===//
1613 // C++ Derived Classes
1614 //
1615
1616 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00001617 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
1618 SourceRange SpecifierRange,
1619 bool Virtual, AccessSpecifier Access,
1620 QualType BaseType,
1621 SourceLocation BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001622 virtual BaseResult ActOnBaseSpecifier(DeclTy *classdecl,
1623 SourceRange SpecifierRange,
1624 bool Virtual, AccessSpecifier Access,
Douglas Gregor2943aed2009-03-03 04:44:36 +00001625 TypeTy *basetype, SourceLocation
1626 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001627
Douglas Gregor2943aed2009-03-03 04:44:36 +00001628 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
1629 unsigned NumBases);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001630 virtual void ActOnBaseSpecifiers(DeclTy *ClassDecl, BaseTy **Bases,
1631 unsigned NumBases);
1632
1633 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001634 bool IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths);
Douglas Gregor7176fff2009-01-15 00:26:24 +00001635 bool LookupInBases(CXXRecordDecl *Class, const MemberLookupCriteria& Criteria,
1636 BasePaths &Paths);
Douglas Gregor0575d4a2008-10-24 16:17:19 +00001637 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1638 SourceLocation Loc, SourceRange Range);
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +00001639 std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001640
Anders Carlsson8211eff2009-03-24 01:19:16 +00001641 enum AbstractDiagSelID {
1642 AbstractNone = -1,
1643 AbstractReturnType,
1644 AbstractParamType,
1645 AbstractVariableType,
1646 AbstractFieldType
1647 };
1648
1649 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001650 AbstractDiagSelID SelID = AbstractNone,
1651 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001652
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001653 //===--------------------------------------------------------------------===//
1654 // C++ Overloaded Operators [C++ 13.5]
1655 //
1656
1657 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
1658
Douglas Gregor72c3f312008-12-05 18:15:24 +00001659 //===--------------------------------------------------------------------===//
1660 // C++ Templates [C++ 14]
1661 //
Douglas Gregor55f6b142009-02-09 18:46:07 +00001662 virtual TemplateNameKind isTemplateName(IdentifierInfo &II, Scope *S,
1663 DeclTy *&TemplateDecl,
1664 const CXXScopeSpec *SS = 0);
Douglas Gregor72c3f312008-12-05 18:15:24 +00001665 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001666 TemplateDecl *AdjustDeclIfTemplate(DeclTy *&Decl);
1667
1668 virtual DeclTy *ActOnTypeParameter(Scope *S, bool Typename,
1669 SourceLocation KeyLoc,
1670 IdentifierInfo *ParamName,
1671 SourceLocation ParamNameLoc,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001672 unsigned Depth, unsigned Position);
Douglas Gregord684b002009-02-10 19:49:53 +00001673 virtual void ActOnTypeParameterDefault(DeclTy *TypeParam,
1674 SourceLocation EqualLoc,
1675 SourceLocation DefaultLoc,
1676 TypeTy *Default);
1677
Douglas Gregor2943aed2009-03-03 04:44:36 +00001678 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001679 virtual DeclTy *ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001680 unsigned Depth,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001681 unsigned Position);
Douglas Gregord684b002009-02-10 19:49:53 +00001682 virtual void ActOnNonTypeTemplateParameterDefault(DeclTy *TemplateParam,
1683 SourceLocation EqualLoc,
1684 ExprArg Default);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001685 virtual DeclTy *ActOnTemplateTemplateParameter(Scope *S,
1686 SourceLocation TmpLoc,
1687 TemplateParamsTy *Params,
1688 IdentifierInfo *ParamName,
1689 SourceLocation ParamNameLoc,
1690 unsigned Depth,
1691 unsigned Position);
Douglas Gregord684b002009-02-10 19:49:53 +00001692 virtual void ActOnTemplateTemplateParameterDefault(DeclTy *TemplateParam,
1693 SourceLocation EqualLoc,
1694 ExprArg Default);
1695
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001696 virtual TemplateParamsTy *
1697 ActOnTemplateParameterList(unsigned Depth,
1698 SourceLocation ExportLoc,
1699 SourceLocation TemplateLoc,
1700 SourceLocation LAngleLoc,
1701 DeclTy **Params, unsigned NumParams,
1702 SourceLocation RAngleLoc);
Douglas Gregord684b002009-02-10 19:49:53 +00001703 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
1704 TemplateParameterList *OldParams);
1705
Douglas Gregorddc29e12009-02-06 22:42:48 +00001706 virtual DeclTy *
1707 ActOnClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
1708 SourceLocation KWLoc, const CXXScopeSpec &SS,
1709 IdentifierInfo *Name, SourceLocation NameLoc,
1710 AttributeList *Attr,
1711 MultiTemplateParamsArg TemplateParameterLists);
1712
Douglas Gregor40808ce2009-03-09 23:48:35 +00001713 QualType CheckClassTemplateId(ClassTemplateDecl *ClassTemplate,
1714 SourceLocation TemplateLoc,
1715 SourceLocation LAngleLoc,
1716 const TemplateArgument *TemplateArgs,
1717 unsigned NumTemplateArgs,
1718 SourceLocation RAngleLoc);
1719
Douglas Gregorcc636682009-02-17 23:15:12 +00001720 virtual TypeResult
1721 ActOnClassTemplateId(DeclTy *Template, SourceLocation TemplateLoc,
1722 SourceLocation LAngleLoc,
1723 ASTTemplateArgsPtr TemplateArgs,
1724 SourceLocation *TemplateArgLocs,
1725 SourceLocation RAngleLoc,
1726 const CXXScopeSpec *SS);
1727
Douglas Gregor88b70942009-02-25 22:02:03 +00001728 bool CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
1729 ClassTemplateSpecializationDecl *PrevDecl,
1730 SourceLocation TemplateNameLoc,
1731 SourceRange ScopeSpecifierRange);
1732
Douglas Gregorcc636682009-02-17 23:15:12 +00001733 virtual DeclTy *
1734 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
1735 SourceLocation KWLoc,
1736 const CXXScopeSpec &SS,
1737 DeclTy *Template,
1738 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001739 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00001740 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregorc15cb382009-02-09 23:23:08 +00001741 SourceLocation *TemplateArgLocs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001742 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00001743 AttributeList *Attr,
1744 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001745
Douglas Gregorc15cb382009-02-09 23:23:08 +00001746 bool CheckTemplateArgumentList(TemplateDecl *Template,
1747 SourceLocation TemplateLoc,
1748 SourceLocation LAngleLoc,
Douglas Gregor40808ce2009-03-09 23:48:35 +00001749 const TemplateArgument *TemplateArgs,
1750 unsigned NumTemplateArgs,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001751 SourceLocation RAngleLoc,
1752 llvm::SmallVectorImpl<TemplateArgument> &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001753
1754 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg,
1755 SourceLocation ArgLoc);
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001756 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
1757 NamedDecl *&Entity);
1758 bool CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001759 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
1760 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001761 llvm::SmallVectorImpl<TemplateArgument> *Converted = 0);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001762 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param, DeclRefExpr *Arg);
Douglas Gregorddc29e12009-02-06 22:42:48 +00001763 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
1764 TemplateParameterList *Old,
1765 bool Complain,
Douglas Gregordd0574e2009-02-10 00:24:35 +00001766 bool IsTemplateTemplateParm = false,
1767 SourceLocation TemplateArgLoc
1768 = SourceLocation());
Douglas Gregorddc29e12009-02-06 22:42:48 +00001769
1770 bool CheckTemplateDeclScope(Scope *S,
1771 MultiTemplateParamsArg &TemplateParameterLists);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001772
Douglas Gregor99ebf652009-02-27 19:31:52 +00001773 //===--------------------------------------------------------------------===//
1774 // C++ Template Instantiation
1775 //
Douglas Gregor26dce442009-03-10 00:06:19 +00001776
1777 /// \brief A template instantiation that is currently in progress.
1778 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00001779 /// \brief The kind of template instantiation we are performing
1780 enum {
1781 /// We are instantiating a template declaration. The entity is
1782 /// the declaration we're instantiation (e.g., a
1783 /// ClassTemplateSpecializationDecl).
1784 TemplateInstantiation,
1785
1786 /// We are instantiating a default argument for a template
1787 /// parameter. The Entity is the template, and
1788 /// TemplateArgs/NumTemplateArguments provides the template
1789 /// arguments as specified.
1790 DefaultTemplateArgumentInstantiation
1791 } Kind;
1792
Douglas Gregor26dce442009-03-10 00:06:19 +00001793 /// \brief The point of instantiation within the source code.
1794 SourceLocation PointOfInstantiation;
1795
1796 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00001797 uintptr_t Entity;
1798
1799 // \brief If this the instantiation of a default template
1800 // argument, the list of tempalte arguments.
1801 const TemplateArgument *TemplateArgs;
1802
1803 /// \brief The number of template arguments in TemplateArgs.
1804 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00001805
1806 /// \brief The source range that covers the construct that cause
1807 /// the instantiation, e.g., the template-id that causes a class
1808 /// template instantiation.
1809 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00001810
1811 friend bool operator==(const ActiveTemplateInstantiation &X,
1812 const ActiveTemplateInstantiation &Y) {
1813 if (X.Kind != Y.Kind)
1814 return false;
1815
1816 if (X.Entity != Y.Entity)
1817 return false;
1818
1819 switch (X.Kind) {
1820 case TemplateInstantiation:
1821 return true;
1822
1823 case DefaultTemplateArgumentInstantiation:
1824 return X.TemplateArgs == Y.TemplateArgs;
1825 }
1826
1827 return true;
1828 }
1829
1830 friend bool operator!=(const ActiveTemplateInstantiation &X,
1831 const ActiveTemplateInstantiation &Y) {
1832 return !(X == Y);
1833 }
Douglas Gregor26dce442009-03-10 00:06:19 +00001834 };
1835
1836 /// \brief List of active template instantiations.
1837 ///
1838 /// This vector is treated as a stack. As one template instantiation
1839 /// requires another template instantiation, additional
1840 /// instantiations are pushed onto the stack up to a
1841 /// user-configurable limit LangOptions::InstantiationDepth.
1842 llvm::SmallVector<ActiveTemplateInstantiation, 16>
1843 ActiveTemplateInstantiations;
1844
Douglas Gregor27b152f2009-03-10 18:52:44 +00001845 /// \brief The last template from which a template instantiation
1846 /// error or warning was produced.
1847 ///
1848 /// This value is used to suppress printing of redundant template
1849 /// instantiation backtraces when there are multiple errors in the
1850 /// same instantiation. FIXME: Does this belong in Sema? It's tough
1851 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00001852 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00001853
Douglas Gregor26dce442009-03-10 00:06:19 +00001854 /// \brief A stack object to be created when performing template
1855 /// instantiation.
1856 ///
1857 /// Construction of an object of type \c InstantiatingTemplate
1858 /// pushes the current instantiation onto the stack of active
1859 /// instantiations. If the size of this stack exceeds the maximum
1860 /// number of recursive template instantiations, construction
1861 /// produces an error and evaluates true.
1862 ///
1863 /// Destruction of this object will pop the named instantiation off
1864 /// the stack.
1865 struct InstantiatingTemplate {
Douglas Gregordf667e72009-03-10 20:44:00 +00001866 /// \brief Note that we are instantiating a class template.
Douglas Gregor26dce442009-03-10 00:06:19 +00001867 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
1868 ClassTemplateSpecializationDecl *Entity,
1869 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00001870
1871 /// \brief Note that we are instantiating a default argument in a
1872 /// template-id.
1873 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
1874 TemplateDecl *Template,
1875 const TemplateArgument *TemplateArgs,
1876 unsigned NumTemplateArgs,
1877 SourceRange InstantiationRange = SourceRange());
1878
Douglas Gregor26dce442009-03-10 00:06:19 +00001879 ~InstantiatingTemplate();
1880
1881 /// \brief Determines whether we have exceeded the maximum
1882 /// recursive template instantiations.
1883 operator bool() const { return Invalid; }
1884
1885 private:
1886 Sema &SemaRef;
1887 bool Invalid;
1888
Douglas Gregordf667e72009-03-10 20:44:00 +00001889 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
1890 SourceRange InstantiationRange);
1891
Douglas Gregor26dce442009-03-10 00:06:19 +00001892 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
1893
1894 InstantiatingTemplate&
1895 operator=(const InstantiatingTemplate&); // not implemented
1896 };
1897
Douglas Gregoree1828a2009-03-10 18:03:33 +00001898 void PrintInstantiationStack();
1899
Douglas Gregor99ebf652009-02-27 19:31:52 +00001900 QualType InstantiateType(QualType T, const TemplateArgument *TemplateArgs,
1901 unsigned NumTemplateArgs,
1902 SourceLocation Loc, DeclarationName Entity);
Douglas Gregora0e500d2009-03-12 16:53:44 +00001903
1904 OwningExprResult InstantiateExpr(Expr *E,
1905 const TemplateArgument *TemplateArgs,
1906 unsigned NumTemplateArgs);
1907
Douglas Gregor8dbc2692009-03-17 21:15:40 +00001908 Decl *InstantiateDecl(Decl *D, DeclContext *Owner,
1909 const TemplateArgument *TemplateArgs,
1910 unsigned NumTemplateArgs);
1911
Douglas Gregor2943aed2009-03-03 04:44:36 +00001912 bool
1913 InstantiateBaseSpecifiers(ClassTemplateSpecializationDecl *ClassTemplateSpec,
1914 ClassTemplateDecl *ClassTemplate);
1915 bool
1916 InstantiateClassTemplateSpecialization(
1917 ClassTemplateSpecializationDecl *ClassTemplateSpec,
1918 bool ExplicitInstantiation);
Douglas Gregor99ebf652009-02-27 19:31:52 +00001919
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001920 CXXScopeSpec InstantiateScopeSpecifier(const NestedNameSpecifier *Components,
1921 unsigned NumComponents,
1922 SourceRange Range,
1923 const TemplateArgument *TemplateArgs,
1924 unsigned NumTemplateArgs);
1925
Anders Carlssona135fb42009-03-15 18:34:13 +00001926 // Simple function for cloning expressions.
1927 template<typename T>
1928 OwningExprResult Clone(T *E) {
1929 assert(!E->isValueDependent() && !E->isTypeDependent() &&
1930 "expression is value or type dependent!");
1931 return Owned(E->Clone(Context));
1932 }
1933
Steve Naroff3536b442007-09-06 21:24:23 +00001934 // Objective-C declarations.
Chris Lattner06036d32008-07-26 04:13:19 +00001935 virtual DeclTy *ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
1936 IdentifierInfo *ClassName,
1937 SourceLocation ClassLoc,
1938 IdentifierInfo *SuperName,
1939 SourceLocation SuperLoc,
1940 DeclTy * const *ProtoRefs,
1941 unsigned NumProtoRefs,
1942 SourceLocation EndProtoLoc,
1943 AttributeList *AttrList);
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00001944
1945 virtual DeclTy *ActOnCompatiblityAlias(
1946 SourceLocation AtCompatibilityAliasLoc,
1947 IdentifierInfo *AliasName, SourceLocation AliasLocation,
1948 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00001949
1950 void CheckForwardProtocolDeclarationForCircularDependency(
1951 IdentifierInfo *PName,
1952 SourceLocation &PLoc, SourceLocation PrevLoc,
1953 const ObjCList<ObjCProtocolDecl> &PList);
Steve Naroff3536b442007-09-06 21:24:23 +00001954
Steve Naroffe440eb82007-10-10 17:32:04 +00001955 virtual DeclTy *ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00001956 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00001957 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnere13b9592008-07-26 04:03:38 +00001958 DeclTy * const *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00001959 SourceLocation EndProtoLoc,
1960 AttributeList *AttrList);
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00001961
Chris Lattner6bd6d0b2008-07-26 04:07:02 +00001962 virtual DeclTy *ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
1963 IdentifierInfo *ClassName,
1964 SourceLocation ClassLoc,
1965 IdentifierInfo *CategoryName,
1966 SourceLocation CategoryLoc,
1967 DeclTy * const *ProtoRefs,
1968 unsigned NumProtoRefs,
1969 SourceLocation EndProtoLoc);
Fariborz Jahanianfd225cc2007-09-18 20:26:58 +00001970
Steve Naroffe440eb82007-10-10 17:32:04 +00001971 virtual DeclTy *ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00001972 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00001973 IdentifierInfo *ClassName, SourceLocation ClassLoc,
1974 IdentifierInfo *SuperClassname,
1975 SourceLocation SuperClassLoc);
1976
Steve Naroffe440eb82007-10-10 17:32:04 +00001977 virtual DeclTy *ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00001978 SourceLocation AtCatImplLoc,
1979 IdentifierInfo *ClassName,
1980 SourceLocation ClassLoc,
1981 IdentifierInfo *CatName,
1982 SourceLocation CatLoc);
1983
Steve Naroffe440eb82007-10-10 17:32:04 +00001984 virtual DeclTy *ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroff37e58d12007-10-02 22:39:18 +00001985 IdentifierInfo **IdentList,
1986 unsigned NumElts);
Fariborz Jahanian894c57f2007-09-21 15:40:54 +00001987
Steve Naroffe440eb82007-10-10 17:32:04 +00001988 virtual DeclTy *ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00001989 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00001990 unsigned NumElts,
1991 AttributeList *attrList);
Fariborz Jahanian245f92a2007-10-05 21:01:53 +00001992
Chris Lattnere13b9592008-07-26 04:03:38 +00001993 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00001994 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00001995 unsigned NumProtocols,
Chris Lattner7caeabd2008-07-21 22:17:28 +00001996 llvm::SmallVectorImpl<DeclTy *> &Protocols);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00001997
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00001998 /// Ensure attributes are consistent with type.
1999 /// \param [in, out] Attributes The attributes to check; they will
2000 /// be modified to be consistent with \arg PropertyTy.
2001 void CheckObjCPropertyAttributes(QualType PropertyTy,
2002 SourceLocation Loc,
2003 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00002004 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002005 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
2006 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00002007 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002008 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Fariborz Jahanianb5e02242008-04-24 19:58:34 +00002009
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002010 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002011 DeclTy *MergeProtocols);
2012
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00002013 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
2014 ObjCInterfaceDecl *ID);
2015
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002016 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002017 ObjCProtocolDecl *PDecl);
2018
Steve Naroff0416fb92007-11-11 17:19:15 +00002019 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclTy *classDecl,
2020 DeclTy **allMethods = 0, unsigned allNum = 0,
Fariborz Jahanian38e24c72009-03-18 22:33:24 +00002021 DeclTy **allProperties = 0, unsigned pNum = 0,
2022 DeclTy **allTUVars = 0, unsigned tuvNum = 0);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002023
Fariborz Jahanian1de1e742008-04-14 23:36:35 +00002024 virtual DeclTy *ActOnProperty(Scope *S, SourceLocation AtLoc,
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00002025 FieldDeclarator &FD, ObjCDeclSpec &ODS,
Fariborz Jahanian5251e132008-05-06 18:09:04 +00002026 Selector GetterSel, Selector SetterSel,
Fariborz Jahanian8cf0bb32008-11-26 20:01:34 +00002027 DeclTy *ClassCategory, bool *OverridingProperty,
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00002028 tok::ObjCKeywordKind MethodImplKind);
2029
Fariborz Jahanianf624f812008-04-18 00:19:30 +00002030 virtual DeclTy *ActOnPropertyImplDecl(SourceLocation AtLoc,
2031 SourceLocation PropertyLoc,
2032 bool ImplKind, DeclTy *ClassImplDecl,
2033 IdentifierInfo *PropertyId,
2034 IdentifierInfo *PropertyIvar);
2035
Steve Naroffbef11852007-10-26 20:53:56 +00002036 virtual DeclTy *ActOnMethodDeclaration(
2037 SourceLocation BeginLoc, // location of the + or -.
2038 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +00002039 tok::TokenKind MethodType,
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002040 DeclTy *ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00002041 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00002042 // optional arguments. The number of types/arguments is obtained
2043 // from the Sel.getNumArgs().
Ted Kremeneka526c5c2008-01-07 19:49:32 +00002044 ObjCDeclSpec *ArgQT, TypeTy **ArgTypes, IdentifierInfo **ArgNames,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00002045 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00002046 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
2047 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00002048
Steve Narofff1afaf62009-02-26 15:55:06 +00002049 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
2050 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00002051 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00002052 // Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +00002053 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
2054 ObjCInterfaceDecl *CDecl);
2055 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
2056 ObjCInterfaceDecl *ClassDecl);
Steve Narofff1afaf62009-02-26 15:55:06 +00002057
Steve Naroff61f72cb2009-03-09 21:12:44 +00002058 virtual OwningExprResult ActOnClassPropertyRefExpr(
2059 IdentifierInfo &receiverName,
2060 IdentifierInfo &propertyName,
2061 SourceLocation &receiverNameLoc,
2062 SourceLocation &propertyNameLoc);
2063
Steve Naroff68d331a2007-09-27 14:38:14 +00002064 // ActOnClassMessage - used for both unary and keyword messages.
2065 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002066 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002067 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00002068 Scope *S,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002069 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
2070 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002071 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00002072
2073 // ActOnInstanceMessage - used for both unary and keyword messages.
2074 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002075 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002076 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00002077 ExprTy *receiver, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002078 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002079 ExprTy **ArgExprs, unsigned NumArgs);
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002080
2081 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
2082 virtual void ActOnPragmaPack(PragmaPackKind Kind,
2083 IdentifierInfo *Name,
2084 ExprTy *Alignment,
2085 SourceLocation PragmaLoc,
2086 SourceLocation LParenLoc,
2087 SourceLocation RParenLoc);
Chris Lattner574aa402009-02-17 01:09:29 +00002088
Ted Kremenek4726d032009-03-23 22:28:25 +00002089 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
2090 virtual void ActOnPragmaUnused(ExprTy **Exprs, unsigned NumExprs,
2091 SourceLocation PragmaLoc,
2092 SourceLocation LParenLoc,
2093 SourceLocation RParenLoc);
2094
Chris Lattner574aa402009-02-17 01:09:29 +00002095 /// getPragmaPackAlignment() - Return the current alignment as specified by
2096 /// the current #pragma pack directive, or 0 if none is currently active.
2097 unsigned getPragmaPackAlignment() const;
2098
2099 /// FreePackedContext - Deallocate and null out PackContext.
2100 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002101
Chris Lattner1e0a3902008-01-16 19:17:22 +00002102 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
2103 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002104 /// If isLvalue, the result of the cast is an lvalue.
2105 void ImpCastExprToType(Expr *&Expr, QualType Type, bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00002106
Reid Spencer5f016e22007-07-11 17:01:13 +00002107 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00002108 // functions and arrays to their respective pointers (C99 6.3.2.1).
2109 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00002110
Steve Naroffc80b4ee2007-07-16 21:54:35 +00002111 // DefaultFunctionArrayConversion - converts functions and arrays
2112 // to their respective pointers (C99 6.3.2.1).
2113 void DefaultFunctionArrayConversion(Expr *&expr);
Steve Naroff90045e82007-07-13 23:32:42 +00002114
Steve Naroffb291ab62007-08-28 23:30:39 +00002115 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
2116 // do not have a prototype. Integer promotions are performed on each
2117 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00002118 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00002119
2120 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
2121 enum VariadicCallType {
2122 VariadicFunction,
2123 VariadicBlock,
2124 VariadicMethod
2125 };
2126
2127 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
2128 // will warn if the resulting type is not a POD type.
2129 void DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Steve Naroffb291ab62007-08-28 23:30:39 +00002130
Reid Spencer5f016e22007-07-11 17:01:13 +00002131 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
2132 // operands and then handles various conversions that are common to binary
2133 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
2134 // routine returns the first non-arithmetic type found. The client is
2135 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002136 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
2137 bool isCompAssign = false);
Chris Lattnerb7b61152008-01-04 18:22:42 +00002138
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002139 /// UsualArithmeticConversionsType - handles the various conversions
2140 /// that are common to binary operators (C99 6.3.1.8, C++ [expr]p9)
2141 /// and returns the result type of that conversion.
2142 QualType UsualArithmeticConversionsType(QualType lhs, QualType rhs);
2143
2144
Chris Lattnerb7b61152008-01-04 18:22:42 +00002145 /// AssignConvertType - All of the 'assignment' semantic checks return this
2146 /// enum to indicate whether the assignment was allowed. These checks are
2147 /// done for simple assignments, as well as initialization, return from
2148 /// function, argument passing, etc. The query is phrased in terms of a
2149 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002150 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00002151 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00002152 Compatible,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002153
2154 /// PointerToInt - The assignment converts a pointer to an int, which we
2155 /// accept as an extension.
2156 PointerToInt,
2157
2158 /// IntToPointer - The assignment converts an int to a pointer, which we
2159 /// accept as an extension.
2160 IntToPointer,
2161
2162 /// FunctionVoidPointer - The assignment is between a function pointer and
2163 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00002164 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002165
2166 /// IncompatiblePointer - The assignment is between two pointers types that
2167 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00002168 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00002169
2170 /// IncompatiblePointer - The assignment is between two pointers types which
2171 /// point to integers which have a different sign, but are otherwise identical.
2172 /// This is a subset of the above, but broken out because it's by far the most
2173 /// common case of incompatible pointers.
2174 IncompatiblePointerSign,
2175
Chris Lattnerb7b61152008-01-04 18:22:42 +00002176 /// CompatiblePointerDiscardsQualifiers - The assignment discards
2177 /// c/v/r qualifiers, which we accept as an extension.
2178 CompatiblePointerDiscardsQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00002179
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00002180 /// IncompatibleVectors - The assignment is between two vector types that
2181 /// have the same size, which we accept as an extension.
2182 IncompatibleVectors,
2183
Steve Naroffbfdcae62008-09-04 15:31:07 +00002184 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002185 /// pointer. We disallow this.
2186 IntToBlockPointer,
2187
Steve Naroffbfdcae62008-09-04 15:31:07 +00002188 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002189 /// pointers types that are not compatible.
2190 IncompatibleBlockPointer,
2191
Steve Naroff39579072008-10-14 22:18:38 +00002192 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
2193 /// id type and something else (that is incompatible with it). For example,
2194 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
2195 IncompatibleObjCQualifiedId,
2196
Chris Lattnerb7b61152008-01-04 18:22:42 +00002197 /// Incompatible - We reject this conversion outright, it is invalid to
2198 /// represent it in the AST.
2199 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00002200 };
Chris Lattner5cf216b2008-01-04 18:04:52 +00002201
2202 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
2203 /// assignment conversion type specified by ConvTy. This returns true if the
2204 /// conversion was invalid or false if the conversion was accepted.
2205 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
2206 SourceLocation Loc,
2207 QualType DstType, QualType SrcType,
2208 Expr *SrcExpr, const char *Flavor);
2209
2210 /// CheckAssignmentConstraints - Perform type checking for assignment,
2211 /// argument passing, variable initialization, and function return values.
2212 /// This routine is only used by the following two methods. C99 6.5.16.
2213 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00002214
Steve Narofff69936d2007-09-16 03:34:24 +00002215 // CheckSingleAssignmentConstraints - Currently used by ActOnCallExpr,
Steve Naroff1b273c42007-09-16 14:56:35 +00002216 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00002217 // this routine performs the default function/array converions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002218 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
2219 Expr *&rExpr);
Steve Naroff90045e82007-07-13 23:32:42 +00002220 // CheckCompoundAssignmentConstraints - Type check without performing any
2221 // conversions. For compound assignments, the "Check...Operands" methods
2222 // perform the necessary conversions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002223 AssignConvertType CheckCompoundAssignmentConstraints(QualType lhs,
2224 QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00002225
Reid Spencer5f016e22007-07-11 17:01:13 +00002226 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner5cf216b2008-01-04 18:04:52 +00002227 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
2228 QualType rhsType);
Steve Naroff1c7d0672008-09-04 15:10:53 +00002229
2230 // Helper function for CheckAssignmentConstraints involving two
2231 // blcok pointer types.
2232 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
2233 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00002234
2235 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002236
Douglas Gregor45920e82008-12-19 17:40:08 +00002237 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002238 const char *Flavor, bool AllowExplicit = false);
2239 bool PerformImplicitConversion(Expr *&From, QualType ToType,
2240 const ImplicitConversionSequence& ICS,
Douglas Gregor45920e82008-12-19 17:40:08 +00002241 const char *Flavor);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002242 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00002243 const StandardConversionSequence& SCS,
2244 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00002245
Reid Spencer5f016e22007-07-11 17:01:13 +00002246 /// the following "Check" methods will return a valid/converted QualType
2247 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00002248
2249 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00002250 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00002251 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002252 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00002253 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002254 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002255 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002256 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002257 QualType CheckAdditionOperands( // C99 6.5.6
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002258 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002259 QualType CheckSubtractionOperands( // C99 6.5.6
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002260 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002261 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002262 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002263 QualType CheckCompareOperands( // C99 6.5.8/9
Chris Lattnera5937dd2007-08-26 01:18:55 +00002264 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00002265 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00002266 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002267 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00002268 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002269 // CheckAssignmentOperands is used for both simple and compound assignment.
2270 // For simple assignment, pass both expressions and a null converted type.
2271 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00002272 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00002273 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00002274 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00002275 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00002276 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00002277 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Nate Begemanbe2341d2008-07-14 18:02:46 +00002278
2279 /// type checking for vector binary operators.
2280 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
2281 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
2282 SourceLocation l, bool isRel);
Reid Spencer5f016e22007-07-11 17:01:13 +00002283
Steve Narofff69936d2007-09-16 03:34:24 +00002284 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00002285 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00002286 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
2287 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002288 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
2289 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00002290 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002291
2292 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00002293 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002294 IdentifierInfo &Comp, SourceLocation CmpLoc);
2295
Steve Narofff0090632007-09-02 02:04:30 +00002296 /// type checking declaration initializers (C99 6.7.8)
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002297 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002298 SourceLocation InitLoc,DeclarationName InitEntity,
2299 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002300 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00002301 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroff2fdc3742007-12-10 22:44:33 +00002302
Douglas Gregor87fd7032009-02-02 17:43:21 +00002303 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002304
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002305 // type checking C++ declaration initializers (C++ [dcl.init]).
2306
2307 /// ReferenceCompareResult - Expresses the result of comparing two
2308 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
2309 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
2310 enum ReferenceCompareResult {
2311 /// Ref_Incompatible - The two types are incompatible, so direct
2312 /// reference binding is not possible.
2313 Ref_Incompatible = 0,
2314 /// Ref_Related - The two types are reference-related, which means
2315 /// that their unqualified forms (T1 and T2) are either the same
2316 /// or T1 is a base class of T2.
2317 Ref_Related,
2318 /// Ref_Compatible_With_Added_Qualification - The two types are
2319 /// reference-compatible with added qualification, meaning that
2320 /// they are reference-compatible and the qualifiers on T1 (cv1)
2321 /// are greater than the qualifiers on T2 (cv2).
2322 Ref_Compatible_With_Added_Qualification,
2323 /// Ref_Compatible - The two types are reference-compatible and
2324 /// have equivalent qualifiers (cv1 == cv2).
2325 Ref_Compatible
2326 };
2327
Douglas Gregor15da57e2008-10-29 02:00:59 +00002328 ReferenceCompareResult CompareReferenceRelationship(QualType T1, QualType T2,
2329 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002330
2331 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00002332 ImplicitConversionSequence *ICS = 0,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002333 bool SuppressUserConversions = false,
2334 bool AllowExplicit = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002335
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002336 /// CheckCastTypes - Check type constraints for casting between types.
Daniel Dunbar58d5ebb2008-08-20 03:55:42 +00002337 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr);
Steve Naroffa49e1fa2008-01-22 00:55:40 +00002338
Anders Carlsson584b2472007-11-27 07:16:40 +00002339 // CheckVectorCast - check type constraints for vectors.
2340 // Since vectors are an extension, there are no C standard reference for this.
2341 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00002342 // returns true if the cast is invalid
2343 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
2344
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002345 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
2346 /// \param Method - May be null.
2347 /// \param [out] ReturnType - The return type of the send.
2348 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00002349 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00002350 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002351 SourceLocation lbrac, SourceLocation rbrac,
2352 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002353
2354 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
2355 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Steve Naroff81bfde92007-10-16 23:12:48 +00002356
Chris Lattnerf4021e72007-08-23 05:46:52 +00002357 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
2358 /// the specified width and sign. If an overflow occurs, detect it and emit
2359 /// the specified diagnostic.
2360 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
2361 unsigned NewWidth, bool NewSign,
2362 SourceLocation Loc, unsigned DiagID);
2363
Chris Lattnereca7be62008-04-07 05:30:13 +00002364 bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
2365 bool ForCompare);
2366
Anders Carlsson15281452008-11-04 16:57:32 +00002367 /// Checks that the Objective-C declaration is declared in the global scope.
2368 /// Emits an error and marks the declaration as invalid if it's not declared
2369 /// in the global scope.
2370 bool CheckObjCDeclScope(Decl *D);
2371
Anders Carlsson7c50aca2007-10-15 20:28:48 +00002372 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00002373
Anders Carlssone21555e2008-11-30 19:50:32 +00002374 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
2375 /// and reports the appropriate diagnostics. Returns false on success.
2376 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002377 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00002378
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002379 /// VerifyBitField - verifies that a bit field expression is an ICE and has
2380 /// the correct width, and that the field type is valid.
2381 /// Returns false on success.
2382 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
2383 QualType FieldTy, const Expr *BitWidth);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002384
Chris Lattner59907c42007-08-10 20:18:51 +00002385 //===--------------------------------------------------------------------===//
2386 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00002387private:
Sebastian Redl0eb23302009-01-19 00:08:26 +00002388 Action::OwningExprResult CheckFunctionCall(FunctionDecl *FDecl,
2389 CallExpr *TheCall);
Chris Lattner60800082009-02-18 17:49:48 +00002390 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
2391 unsigned ByteNo) const;
Chris Lattner69039812009-02-18 06:01:06 +00002392 bool CheckObjCString(Expr *Arg);
Chris Lattner925e60d2007-12-28 05:29:59 +00002393 bool SemaBuiltinVAStart(CallExpr *TheCall);
2394 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00002395 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002396 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Daniel Dunbar4493f792008-07-21 22:59:13 +00002397 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Daniel Dunbard5f8a4f2008-09-03 21:13:56 +00002398 bool SemaBuiltinObjectSize(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00002399 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
2400 bool HasVAListArg, unsigned format_idx,
2401 unsigned firstDataArg);
2402 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
2403 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002404 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek082d9362009-03-20 21:35:28 +00002405 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002406 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00002407 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
2408 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00002409 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00002410};
2411
Steve Naroff4eb206b2008-09-03 18:15:37 +00002412/// BlockSemaInfo - When a block is being parsed, this contains information
2413/// about the block. It is pointed to from Sema::CurBlock.
2414struct BlockSemaInfo {
2415 llvm::SmallVector<ParmVarDecl*, 8> Params;
Steve Naroff4eb206b2008-09-03 18:15:37 +00002416 bool hasPrototype;
2417 bool isVariadic;
Mike Stumpb83d2872009-02-19 22:01:56 +00002418 bool hasBlockDeclRefExprs;
2419
Steve Naroff1c90bfc2008-10-08 18:44:00 +00002420 BlockDecl *TheDecl;
2421
Chris Lattnerda425eb2009-02-18 07:09:44 +00002422 /// TheScope - This is the scope for the block itself, which contains
Steve Naroff4eb206b2008-09-03 18:15:37 +00002423 /// arguments etc.
2424 Scope *TheScope;
2425
2426 /// ReturnType - This will get set to block result type, by looking at
2427 /// return types, if any, in the block body.
2428 Type *ReturnType;
2429
Steve Naroffd8eb4562009-03-13 16:03:38 +00002430 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
2431 /// it (which acts like the label decl in some ways). Forward referenced
2432 /// labels have a LabelStmt created for them with a null location & SubStmt.
2433 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
2434
Steve Naroff4eb206b2008-09-03 18:15:37 +00002435 /// PrevBlockInfo - If this is nested inside another block, this points
2436 /// to the outer block.
2437 BlockSemaInfo *PrevBlockInfo;
2438};
Ted Kremenek8189cde2009-02-07 01:47:29 +00002439
2440//===--------------------------------------------------------------------===//
2441// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
2442template <typename T>
2443class ExprOwningPtr : public Action::ExprArg {
2444public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00002445 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Ted Kremenek8189cde2009-02-07 01:47:29 +00002446
2447 void reset(T* p) { Action::ExprArg::operator=(p); }
2448 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
2449 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
2450 T* release() { return take(); }
2451
2452 T& operator*() const { return *get(); }
2453 T* operator->() const { return get(); }
2454};
2455
Reid Spencer5f016e22007-07-11 17:01:13 +00002456} // end namespace clang
2457
2458#endif