blob: d4c03a12a8edae90772bfe1f0398fd01315c0e0f [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"
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000022#include "clang/AST/DeclObjC.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000023#include "clang/Parse/Action.h"
Chris Lattner500d3292009-01-29 05:15:15 +000024#include "clang/Sema/SemaDiagnostic.h"
Anders Carlssonc1fcb772007-07-22 07:07:56 +000025#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian85ff2642007-10-05 18:00:57 +000026#include "llvm/ADT/DenseSet.h"
Chris Lattnerf3876682007-10-07 01:13:46 +000027#include "llvm/ADT/SmallPtrSet.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000028#include "llvm/ADT/OwningPtr.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;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000043 class ExternalSemaSource;
Steve Naroffe8043c32008-04-01 23:04:06 +000044 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000045 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000046 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000047 class InitListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000048 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000049 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000050 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000051 class VarDecl;
52 class ParmVarDecl;
53 class TypedefDecl;
54 class FunctionDecl;
55 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000056 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000057 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000058 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000059 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000060 class ArrayType;
61 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000062 class SwitchStmt;
Sebastian Redl13e88542009-04-27 21:33:24 +000063 class CXXTryStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000064 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000065 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000066 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000067 class TemplateArgument;
Douglas Gregor7e063902009-05-11 23:53:27 +000068 class TemplateArgumentList;
Douglas Gregorddc29e12009-02-06 22:42:48 +000069 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000070 class TemplateTemplateParmDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000071 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000072 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000073 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000074 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000075 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000076 class ObjCImplementationDecl;
77 class ObjCCategoryImplDecl;
78 class ObjCCategoryDecl;
79 class ObjCIvarDecl;
80 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000081 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000082 class ObjCContainerDecl;
Douglas Gregor94b1dd22008-10-24 04:54:22 +000083 class BasePaths;
Sebastian Redl43af76e2009-03-07 12:16:37 +000084 struct MemberLookupCriteria;
Steve Naroffbea0b342007-07-29 16:33:31 +000085
Chris Lattnerea29a3a2009-04-18 20:01:55 +000086/// BlockSemaInfo - When a block is being parsed, this contains information
87/// about the block. It is pointed to from Sema::CurBlock.
88struct BlockSemaInfo {
89 llvm::SmallVector<ParmVarDecl*, 8> Params;
90 bool hasPrototype;
91 bool isVariadic;
92 bool hasBlockDeclRefExprs;
93
94 BlockDecl *TheDecl;
95
96 /// TheScope - This is the scope for the block itself, which contains
97 /// arguments etc.
98 Scope *TheScope;
99
100 /// ReturnType - This will get set to block result type, by looking at
101 /// return types, if any, in the block body.
102 Type *ReturnType;
103
104 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
105 /// it (which acts like the label decl in some ways). Forward referenced
106 /// labels have a LabelStmt created for them with a null location & SubStmt.
107 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
108
Chris Lattnerbcfce662009-04-18 20:10:59 +0000109 /// SwitchStack - This is the current set of active switch statements in the
110 /// block.
111 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
112
Chris Lattner17a78302009-04-19 05:28:12 +0000113 /// SavedFunctionNeedsScopeChecking - This is the value of
114 /// CurFunctionNeedsScopeChecking at the point when the block started.
115 bool SavedFunctionNeedsScopeChecking;
116
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000117 /// PrevBlockInfo - If this is nested inside another block, this points
118 /// to the outer block.
119 BlockSemaInfo *PrevBlockInfo;
120};
121
Reid Spencer5f016e22007-07-11 17:01:13 +0000122/// Sema - This implements semantic analysis and AST building for C.
123class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +0000124 Sema(const Sema&); // DO NOT IMPLEMENT
125 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +0000126public:
Chris Lattner53ebff32009-01-22 19:21:44 +0000127 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +0000128 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +0000129 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000130 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +0000131 Diagnostic &Diags;
132 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +0000133
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000134 /// \brief Source of additional semantic information.
135 ExternalSemaSource *ExternalSource;
136
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000137 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +0000138 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +0000139
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000140 /// PreDeclaratorDC - Keeps the declaration context before switching to the
141 /// context of a declarator's nested-name-specifier.
142 DeclContext *PreDeclaratorDC;
143
Steve Naroff4eb206b2008-09-03 18:15:37 +0000144 /// CurBlock - If inside of a block definition, this contains a pointer to
145 /// the active block object that represents it.
146 BlockSemaInfo *CurBlock;
147
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000148 /// PackContext - Manages the stack for #pragma pack. An alignment
149 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000150 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000151
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000152 /// FunctionLabelMap - This is a mapping from label identifiers to the
153 /// LabelStmt for it (which acts like the label decl in some ways). Forward
154 /// referenced labels have a LabelStmt created for them with a null location &
155 /// SubStmt.
156 ///
157 /// Note that this should always be accessed through getLabelMap() in order
158 /// to handle blocks properly.
159 llvm::DenseMap<IdentifierInfo*, LabelStmt*> FunctionLabelMap;
Steve Naroffcaaacec2009-03-13 15:38:40 +0000160
Chris Lattnerbcfce662009-04-18 20:10:59 +0000161 /// FunctionSwitchStack - This is the current set of active switch statements
162 /// in the top level function. Clients should always use getSwitchStack() to
163 /// handle the case when they are in a block.
164 llvm::SmallVector<SwitchStmt*, 8> FunctionSwitchStack;
Steve Naroffbea0b342007-07-29 16:33:31 +0000165
Chris Lattner38c5ebd2009-04-19 05:21:20 +0000166 /// CurFunctionNeedsScopeChecking - This is set to true when a function or
167 /// ObjC method body contains a VLA or an ObjC try block, which introduce
168 /// scopes that need to be checked for goto conditions. If a function does
169 /// not contain this, then it need not have the jump checker run on it.
170 bool CurFunctionNeedsScopeChecking;
171
Nate Begeman213541a2008-04-18 23:10:10 +0000172 /// ExtVectorDecls - This is a list all the extended vector types. This allows
173 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000174 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000175 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Chris Lattner59907c42007-08-10 20:18:51 +0000176
Steve Naroffe84a8642008-09-28 14:55:53 +0000177 /// ObjCCategoryImpls - Maintain a list of category implementations so
178 /// we can check for duplicates and find local method declarations.
179 llvm::SmallVector<ObjCCategoryImplDecl*, 8> ObjCCategoryImpls;
180
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000181 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
182 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
183
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000184 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
185
186 /// PureVirtualClassDiagSet - a set of class declarations which we have
187 /// emitted a list of pure virtual functions. Used to prevent emitting the
188 /// same list more than once.
189 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
190
Douglas Gregor63935192009-03-02 00:19:53 +0000191 /// \brief A mapping from external names to the most recent
192 /// locally-scoped external declaration with that name.
193 ///
194 /// This map contains external declarations introduced in local
195 /// scoped, e.g.,
196 ///
197 /// \code
198 /// void f() {
199 /// void foo(int, int);
200 /// }
201 /// \endcode
202 ///
203 /// Here, the name "foo" will be associated with the declaration on
204 /// "foo" within f. This name is not visible outside of
205 /// "f". However, we still find it in two cases:
206 ///
207 /// - If we are declaring another external with the name "foo", we
208 /// can find "foo" as a previous declaration, so that the types
209 /// of this external declaration can be checked for
210 /// compatibility.
211 ///
212 /// - If we would implicitly declare "foo" (e.g., due to a call to
213 /// "foo" in C when no prototype or definition is visible), then
214 /// we find this declaration of "foo" and complain that it is
215 /// not visible.
216 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
217
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000218 /// \brief The set of tentative declarations seen so far in this
219 /// translation unit for which no definition has been seen.
220 ///
221 /// The tentative declarations are indexed by the name of the
222 /// declaration, and only the most recent tentative declaration for
223 /// a given variable will be recorded here.
224 llvm::DenseMap<DeclarationName, VarDecl *> TentativeDefinitions;
225
Chris Lattner7f925cc2008-04-11 07:00:53 +0000226 IdentifierResolver IdResolver;
227
Steve Naroffe440eb82007-10-10 17:32:04 +0000228 /// Translation Unit Scope - useful to Objective-C actions that need
229 /// to lookup file scope declarations in the "ordinary" C decl namespace.
230 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000231 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000232
233 /// The C++ "std" namespace, where the standard library resides. Cached here
234 /// by GetStdNamespace
235 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000236
237 /// A flag to remember whether the implicit forms of operator new and delete
238 /// have been declared.
239 bool GlobalNewDeleteDeclared;
Douglas Gregorf807fe02009-04-14 16:27:31 +0000240
241 /// \brief Whether the code handled by Sema should be considered a
242 /// complete translation unit or not.
243 ///
244 /// When true (which is generally the case), Sema will perform
245 /// end-of-translation-unit semantic tasks (such as creating
246 /// initializers for tentative definitions in C) once parsing has
247 /// completed. This flag will be false when building PCH files,
248 /// since a PCH file is by definition not a complete translation
249 /// unit.
250 bool CompleteTranslationUnit;
251
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000252 typedef llvm::DenseMap<Selector, ObjCMethodList> MethodPool;
253
Steve Naroff58ff9e82007-10-14 00:58:41 +0000254 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
255 /// messages to "id". We need to maintain a list, since selectors can have
256 /// differing signatures across classes. In Cocoa, this happens to be
257 /// extremely uncommon (only 1% of selectors are "overloaded").
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000258 MethodPool InstanceMethodPool;
259 MethodPool FactoryMethodPool;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000260
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000261 MethodPool::iterator ReadMethodPool(Selector Sel, bool isInstance);
262
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000263 /// Private Helper predicate to check for 'self'.
264 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000265public:
Douglas Gregorf807fe02009-04-14 16:27:31 +0000266 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
267 bool CompleteTranslationUnit = true);
Chris Lattner574aa402009-02-17 01:09:29 +0000268 ~Sema() {
269 if (PackContext) FreePackedContext();
270 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000271
Chris Lattner53ebff32009-01-22 19:21:44 +0000272 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000273 Diagnostic &getDiagnostics() const { return Diags; }
274 SourceManager &getSourceManager() const { return SourceMgr; }
275
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000276 /// \brief Helper class that creates diagnostics with optional
277 /// template instantiation stacks.
278 ///
279 /// This class provides a wrapper around the basic DiagnosticBuilder
280 /// class that emits diagnostics. SemaDiagnosticBuilder is
281 /// responsible for emitting the diagnostic (as DiagnosticBuilder
282 /// does) and, if the diagnostic comes from inside a template
283 /// instantiation, printing the template instantiation stack as
284 /// well.
285 class SemaDiagnosticBuilder : public DiagnosticBuilder {
286 Sema &SemaRef;
287 unsigned DiagID;
288
289 public:
290 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
291 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
292
293 ~SemaDiagnosticBuilder();
294 };
295
296 /// \brief Emit a diagnostic.
297 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregoree1828a2009-03-10 18:03:33 +0000298 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000299 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000300 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000301
Chris Lattner394a3fd2007-08-31 04:53:24 +0000302 virtual void DeleteExpr(ExprTy *E);
303 virtual void DeleteStmt(StmtTy *S);
304
Sebastian Redl798d1192008-12-13 16:23:55 +0000305 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000306 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000307 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000308 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000309 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000310 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000311 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
312
Chris Lattner9299f3f2008-08-23 03:19:52 +0000313 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000314
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000315 /// getLabelMap() - Return the current label map. If we're in a block, we
316 /// return it.
317 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
318 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
319 }
320
Chris Lattnerbcfce662009-04-18 20:10:59 +0000321 /// getSwitchStack - This is returns the switch stack for the current block or
322 /// function.
323 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
324 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
325 }
326
Reid Spencer5f016e22007-07-11 17:01:13 +0000327 //===--------------------------------------------------------------------===//
328 // Type Analysis / Processing: SemaType.cpp.
329 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000330 QualType adjustParameterType(QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000331 QualType ConvertDeclSpecToType(const DeclSpec &DS, SourceLocation DeclLoc,
332 bool &IsInvalid);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000333 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000334 QualType BuildPointerType(QualType T, unsigned Quals,
335 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000336 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000337 SourceLocation Loc, DeclarationName Entity);
338 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
339 Expr *ArraySize, unsigned Quals,
340 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor724651c2009-02-28 01:04:19 +0000341 QualType BuildFunctionType(QualType T,
342 QualType *ParamTypes, unsigned NumParamTypes,
343 bool Variadic, unsigned Quals,
344 SourceLocation Loc, DeclarationName Entity);
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000345 QualType GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip = 0);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000346 DeclarationName GetNameForDeclarator(Declarator &D);
347
Chris Lattnerb28317a2009-03-28 19:18:32 +0000348 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000349
Douglas Gregor57373262008-10-22 14:17:15 +0000350 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
351
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000352 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000353
Douglas Gregor86447ec2009-03-09 16:13:40 +0000354 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Douglas Gregor4ec339f2009-01-19 19:26:10 +0000355 SourceRange Range1 = SourceRange(),
356 SourceRange Range2 = SourceRange(),
357 QualType PrintType = QualType());
358
Douglas Gregore6258932009-03-19 00:39:20 +0000359 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
360
Reid Spencer5f016e22007-07-11 17:01:13 +0000361 //===--------------------------------------------------------------------===//
362 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
363 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000364
365 /// getDeclName - Return a pretty name for the specified decl if possible, or
366 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000367 virtual std::string getDeclName(DeclPtrTy D);
Chris Lattner21ff9c92009-03-05 01:25:28 +0000368
Chris Lattner682bf922009-03-29 16:50:03 +0000369 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
370
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000371 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregorb696ea32009-02-04 17:00:24 +0000372 Scope *S, const CXXScopeSpec *SS);
Chris Lattner4c97d762009-04-12 21:49:30 +0000373 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
374
Chris Lattner682bf922009-03-29 16:50:03 +0000375 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
376 return ActOnDeclarator(S, D, false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000377 }
Chris Lattner682bf922009-03-29 16:50:03 +0000378 DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D, bool IsFunctionDefinition);
Douglas Gregor63935192009-03-02 00:19:53 +0000379 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
380 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000381 void DiagnoseFunctionSpecifiers(Declarator& D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000382 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000383 QualType R, Decl* PrevDecl,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000384 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000385 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000386 QualType R, NamedDecl* PrevDecl,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000387 bool &Redeclaration);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000388 void CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000389 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000390 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattner682bf922009-03-29 16:50:03 +0000391 QualType R, NamedDecl* PrevDecl,
Douglas Gregor04495c82009-02-24 01:23:02 +0000392 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000393 bool &Redeclaration);
394 void CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000395 bool &Redeclaration,
396 bool &OverloadableAttrRequired);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000397 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
398 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000399 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000400 ExprArg defarg);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000401 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Douglas Gregor61366e92008-12-24 00:01:03 +0000402 SourceLocation EqualLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000403 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
404 virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
405 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
406 void ActOnUninitializedDecl(DeclPtrTy dcl);
407 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Chris Lattner682bf922009-03-29 16:50:03 +0000408 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, DeclPtrTy *Group,
409 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000410 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
411 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000412 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
413 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
414 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000415
Chris Lattnerb28317a2009-03-28 19:18:32 +0000416 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Chris Lattner5af280c2009-04-19 04:46:21 +0000417 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000418 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000419
Steve Naroffb216c882007-10-09 22:01:59 +0000420 /// Scope actions.
421 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
422 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000423
424 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
425 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000426 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000427
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000428 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
429 RecordDecl *AnonRecord);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000430 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
431 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000432
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000433 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
434 TagDecl::TagKind NewTag,
435 SourceLocation NewTagLoc,
436 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000437
Chris Lattnerb28317a2009-03-28 19:18:32 +0000438 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
439 SourceLocation KWLoc, const CXXScopeSpec &SS,
440 IdentifierInfo *Name, SourceLocation NameLoc,
441 AttributeList *Attr, AccessSpecifier AS);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000442
Chris Lattnerb28317a2009-03-28 19:18:32 +0000443 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000444 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000445 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
446 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
447 SourceLocation DeclStart,
448 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000449
450 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000451 Declarator &D, Expr *BitfieldWidth,
452 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000453
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000454 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
455 RecordDecl *Record, SourceLocation Loc,
456 bool Mutable, Expr *BitfieldWidth,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000457 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000458 Declarator *D = 0);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000459
Chris Lattnerb28317a2009-03-28 19:18:32 +0000460 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
461 Declarator &D, ExprTy *BitfieldWidth,
462 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000463
Steve Narofff13271f2007-09-14 23:09:53 +0000464 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000465 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000466 SourceLocation RecLoc, DeclPtrTy TagDecl,
467 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000468 SourceLocation LBrac, SourceLocation RBrac,
469 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000470
471 /// ActOnTagStartDefinition - Invoked when we have entered the
472 /// scope of a tag's definition (e.g., for an enumeration, class,
473 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000474 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000475
476 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
477 /// the definition of a tag (enumeration, class, struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000478 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000479
Douglas Gregor879fd492009-03-17 19:05:46 +0000480 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
481 EnumConstantDecl *LastEnumConst,
482 SourceLocation IdLoc,
483 IdentifierInfo *Id,
484 ExprArg val);
485
Chris Lattnerb28317a2009-03-28 19:18:32 +0000486 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
487 DeclPtrTy LastEnumConstant,
488 SourceLocation IdLoc, IdentifierInfo *Id,
489 SourceLocation EqualLoc, ExprTy *Val);
490 virtual void ActOnEnumBody(SourceLocation EnumLoc, DeclPtrTy EnumDecl,
491 DeclPtrTy *Elements, unsigned NumElements);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000492
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000493 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000494
Chris Lattner0ed844b2008-04-04 06:12:32 +0000495 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000496 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000497 void PopDeclContext();
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000498
Chris Lattner371f2582008-12-04 23:50:19 +0000499 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
500 /// to the function decl for the function being parsed. If we're currently
501 /// in a 'block', this returns the containing context.
502 FunctionDecl *getCurFunctionDecl();
503
504 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
505 /// the method decl for the method being parsed. If we're currently
506 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000507 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000508
Chris Lattner371f2582008-12-04 23:50:19 +0000509 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
510 /// or C function we're in, otherwise return null. If we're currently
511 /// in a 'block', this returns the containing context.
512 NamedDecl *getCurFunctionOrMethodDecl();
513
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000514 /// Add this decl to the scope shadowed decl chains.
515 void PushOnScopeChains(NamedDecl *D, Scope *S);
516
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000517 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
518 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
519 /// true if 'D' belongs to the given declaration context.
520 bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000521 return IdResolver.isDeclInScope(D, Ctx, Context, S);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000522 }
523
Eli Friedman8f17b662009-02-28 05:41:13 +0000524
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000525 /// Subroutines of ActOnDeclarator().
Chris Lattner682bf922009-03-29 16:50:03 +0000526 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000527 void MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000528 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000529 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000530 void MergeVarDecl(VarDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000531 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000532
533 /// C++ Overloading.
534 bool IsOverload(FunctionDecl *New, Decl* OldD,
535 OverloadedFunctionDecl::function_iterator &MatchedDecl);
Douglas Gregor225c41e2008-11-03 19:09:14 +0000536 ImplicitConversionSequence
537 TryImplicitConversion(Expr* From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000538 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +0000539 bool AllowExplicit = false,
540 bool ForceRValue = false);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000541 bool IsStandardConversion(Expr *From, QualType ToType,
542 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000543 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
544 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000545 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000546 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +0000547 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000548 bool isObjCPointerConversion(QualType FromType, QualType ToType,
549 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregor94b1dd22008-10-24 04:54:22 +0000550 bool CheckPointerConversion(Expr *From, QualType ToType);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000551 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
552 QualType &ConvertedType);
553 bool CheckMemberPointerConversion(Expr *From, QualType ToType);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000554 bool IsQualificationConversion(QualType FromType, QualType ToType);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000555 bool IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000556 UserDefinedConversionSequence& User,
Douglas Gregor734d9862009-01-30 23:27:23 +0000557 bool AllowConversionFunctions,
Sebastian Redle2b68332009-04-12 17:16:29 +0000558 bool AllowExplicit, bool ForceRValue);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000559
560 ImplicitConversionSequence::CompareKind
561 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
562 const ImplicitConversionSequence& ICS2);
563
564 ImplicitConversionSequence::CompareKind
565 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
566 const StandardConversionSequence& SCS2);
567
Douglas Gregor57373262008-10-22 14:17:15 +0000568 ImplicitConversionSequence::CompareKind
569 CompareQualificationConversions(const StandardConversionSequence& SCS1,
570 const StandardConversionSequence& SCS2);
571
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000572 ImplicitConversionSequence::CompareKind
573 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
574 const StandardConversionSequence& SCS2);
575
Douglas Gregor225c41e2008-11-03 19:09:14 +0000576 ImplicitConversionSequence
577 TryCopyInitialization(Expr* From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000578 bool SuppressUserConversions = false,
579 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000580 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000581 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000582
Douglas Gregor96176b32008-11-18 23:14:02 +0000583 ImplicitConversionSequence
584 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
585 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
586
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000587 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
588 bool PerformContextuallyConvertToBool(Expr *&From);
589
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000590 /// OverloadingResult - Capture the result of performing overload
591 /// resolution.
592 enum OverloadingResult {
593 OR_Success, ///< Overload resolution succeeded.
594 OR_No_Viable_Function, ///< No viable function found.
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000595 OR_Ambiguous, ///< Ambiguous candidates found.
596 OR_Deleted ///< Overload resoltuion refers to a deleted function.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000597 };
598
Douglas Gregor063daf62009-03-13 18:40:31 +0000599 typedef llvm::SmallPtrSet<FunctionDecl *, 16> FunctionSet;
600 typedef llvm::SmallPtrSet<NamespaceDecl *, 16> AssociatedNamespaceSet;
601 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
602
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000603 void AddOverloadCandidate(FunctionDecl *Function,
604 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000605 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000606 bool SuppressUserConversions = false,
607 bool ForceRValue = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000608 void AddFunctionCandidates(const FunctionSet &Functions,
609 Expr **Args, unsigned NumArgs,
610 OverloadCandidateSet& CandidateSet,
611 bool SuppressUserConversions = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000612 void AddMethodCandidate(CXXMethodDecl *Method,
613 Expr *Object, Expr **Args, unsigned NumArgs,
614 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000615 bool SuppressUserConversions = false,
616 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000617 void AddConversionCandidate(CXXConversionDecl *Conversion,
618 Expr *From, QualType ToType,
619 OverloadCandidateSet& CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000620 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000621 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000622 Expr *Object, Expr **Args, unsigned NumArgs,
623 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000624 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000625 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000626 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000627 OverloadCandidateSet& CandidateSet,
628 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000629 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
630 SourceLocation OpLoc,
631 Expr **Args, unsigned NumArgs,
632 OverloadCandidateSet& CandidateSet,
633 SourceRange OpRange = SourceRange());
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000634 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
635 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000636 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000637 bool IsAssignmentOperator = false,
638 unsigned NumContextualBoolArguments = 0);
Douglas Gregor74253732008-11-19 15:42:04 +0000639 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
640 Expr **Args, unsigned NumArgs,
641 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000642 void AddArgumentDependentLookupCandidates(DeclarationName Name,
643 Expr **Args, unsigned NumArgs,
644 OverloadCandidateSet& CandidateSet);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000645 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
646 const OverloadCandidate& Cand2);
647 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
648 OverloadCandidateSet::iterator& Best);
649 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
650 bool OnlyViable);
651
Douglas Gregor904eed32008-11-10 20:40:00 +0000652 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
653 bool Complain);
654 void FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
655
Douglas Gregor17330012009-02-04 15:01:18 +0000656 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn, NamedDecl *Callee,
657 DeclarationName UnqualifiedName,
Douglas Gregor0a396682008-11-26 06:01:48 +0000658 SourceLocation LParenLoc,
659 Expr **Args, unsigned NumArgs,
660 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +0000661 SourceLocation RParenLoc,
Douglas Gregor17330012009-02-04 15:01:18 +0000662 bool &ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +0000663
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000664 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
665 unsigned Opc,
666 FunctionSet &Functions,
667 ExprArg input);
668
Douglas Gregor063daf62009-03-13 18:40:31 +0000669 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
670 unsigned Opc,
671 FunctionSet &Functions,
672 Expr *LHS, Expr *RHS);
673
Douglas Gregor88a35142008-12-22 05:46:06 +0000674 ExprResult
675 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
676 SourceLocation LParenLoc, Expr **Args,
677 unsigned NumArgs, SourceLocation *CommaLocs,
678 SourceLocation RParenLoc);
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000679 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +0000680 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000681 Expr **Args, unsigned NumArgs,
682 SourceLocation *CommaLocs,
683 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000684
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000685 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
Douglas Gregor8ba10742008-11-20 16:27:02 +0000686 SourceLocation MemberLoc,
687 IdentifierInfo &Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000688
Chris Lattner823c44e2009-01-06 07:27:21 +0000689 /// Helpers for dealing with function parameters.
Chris Lattner04421082008-04-08 04:40:51 +0000690 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +0000691 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000692 void CheckExtraCXXDefaultArguments(Declarator &D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000693
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000694 Scope *getNonFieldDeclScope(Scope *S);
695
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000696 /// \name Name lookup
697 ///
698 /// These routines provide name lookup that is used during semantic
699 /// analysis to resolve the various kinds of names (identifiers,
700 /// overloaded operator names, constructor names, etc.) into zero or
701 /// more declarations within a particular scope. The major entry
702 /// points are LookupName, which performs unqualified name lookup,
703 /// and LookupQualifiedName, which performs qualified name lookup.
704 ///
705 /// All name lookup is performed based on some specific criteria,
706 /// which specify what names will be visible to name lookup and how
707 /// far name lookup should work. These criteria are important both
708 /// for capturing language semantics (certain lookups will ignore
709 /// certain names, for example) and for performance, since name
710 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000711 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000712 ///
713 /// The results of name lookup can vary based on the kind of name
714 /// lookup performed, the current language, and the translation
715 /// unit. In C, for example, name lookup will either return nothing
716 /// (no entity found) or a single declaration. In C++, name lookup
717 /// can additionally refer to a set of overloaded functions or
718 /// result in an ambiguity. All of the possible results of name
719 /// lookup are captured by the LookupResult class, which provides
720 /// the ability to distinguish among them.
721 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +0000722
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000723 /// @brief Describes the kind of name lookup to perform.
724 enum LookupNameKind {
725 /// Ordinary name lookup, which finds ordinary names (functions,
726 /// variables, typedefs, etc.) in C and most kinds of names
727 /// (functions, variables, members, types, etc.) in C++.
728 LookupOrdinaryName = 0,
729 /// Tag name lookup, which finds the names of enums, classes,
730 /// structs, and unions.
731 LookupTagName,
732 /// Member name lookup, which finds the names of
733 /// class/struct/union members.
734 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000735 // Look up of an operator name (e.g., operator+) for use with
736 // operator overloading. This lookup is similar to ordinary name
737 // lookup, but will ignore any declarations that are class
738 // members.
739 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000740 /// Look up of a name that precedes the '::' scope resolution
741 /// operator in C++. This lookup completely ignores operator,
742 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
743 LookupNestedNameSpecifierName,
744 /// Look up a namespace name within a C++ using directive or
745 /// namespace alias definition, ignoring non-namespace names (C++
746 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000747 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +0000748 /// Look up an ordinary name that is going to be redeclared as a
749 /// name with linkage. This lookup ignores any declarations that
750 /// are outside of the current scope unless they have linkage. See
751 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
752 LookupRedeclarationWithLinkage,
753 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000754 LookupObjCProtocolName,
755 /// Look up the name of an Objective-C implementation
756 LookupObjCImplementationName,
757 /// Look up the name of an Objective-C category implementation
758 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000759 };
760
761 /// @brief Represents the results of name lookup.
762 ///
763 /// An instance of the LookupResult class captures the results of a
764 /// single name lookup, which can return no result (nothing found),
765 /// a single declaration, a set of overloaded functions, or an
766 /// ambiguity. Use the getKind() method to determine which of these
767 /// results occurred for a given lookup.
768 ///
769 /// Any non-ambiguous lookup can be converted into a single
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000770 /// (possibly NULL) @c NamedDecl* via a conversion function or the
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000771 /// getAsDecl() method. This conversion permits the common-case
772 /// usage in C and Objective-C where name lookup will always return
773 /// a single declaration.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000774 struct LookupResult {
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000775 /// The kind of entity that is actually stored within the
776 /// LookupResult object.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000777 enum {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000778 /// First is a single declaration (a NamedDecl*), which may be NULL.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000779 SingleDecl,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000780
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000781 /// First is a single declaration (an OverloadedFunctionDecl*).
782 OverloadedDeclSingleDecl,
783
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000784 /// [First, Last) is an iterator range represented as opaque
785 /// pointers used to reconstruct IdentifierResolver::iterators.
786 OverloadedDeclFromIdResolver,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000787
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000788 /// [First, Last) is an iterator range represented as opaque
789 /// pointers used to reconstruct DeclContext::lookup_iterators.
790 OverloadedDeclFromDeclContext,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000791
792 /// First is a pointer to a BasePaths structure, which is owned
793 /// by the LookupResult. Last is non-zero to indicate that the
794 /// ambiguity is caused by two names found in base class
795 /// subobjects of different types.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000796 AmbiguousLookupStoresBasePaths,
797
798 /// [First, Last) is an iterator range represented as opaque
799 /// pointers used to reconstruct new'ed Decl*[] array containing
800 /// found ambiguous decls. LookupResult is owner of this array.
801 AmbiguousLookupStoresDecls
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000802 } StoredKind;
803
804 /// The first lookup result, whose contents depend on the kind of
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000805 /// lookup result. This may be a NamedDecl* (if StoredKind ==
806 /// SingleDecl), OverloadedFunctionDecl* (if StoredKind ==
807 /// OverloadedDeclSingleDecl), the opaque pointer from an
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000808 /// IdentifierResolver::iterator (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000809 /// OverloadedDeclFromIdResolver), a DeclContext::lookup_iterator
810 /// (if StoredKind == OverloadedDeclFromDeclContext), or a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000811 /// BasePaths pointer (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000812 mutable uintptr_t First;
813
814 /// The last lookup result, whose contents depend on the kind of
815 /// lookup result. This may be unused (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000816 /// SingleDecl), it may have the same type as First (for
817 /// overloaded function declarations), or is may be used as a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000818 /// Boolean value (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000819 mutable uintptr_t Last;
820
821 /// Context - The context in which we will build any
822 /// OverloadedFunctionDecl nodes needed by the conversion to
823 /// Decl*.
824 ASTContext *Context;
825
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000826 /// @brief The kind of entity found by name lookup.
827 enum LookupKind {
828 /// @brief No entity found met the criteria.
829 NotFound = 0,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000830
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000831 /// @brief Name lookup found a single declaration that met the
Douglas Gregor7176fff2009-01-15 00:26:24 +0000832 /// criteria. getAsDecl will return this declaration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000833 Found,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000834
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000835 /// @brief Name lookup found a set of overloaded functions that
Douglas Gregor7176fff2009-01-15 00:26:24 +0000836 /// met the criteria. getAsDecl will turn this set of overloaded
837 /// functions into an OverloadedFunctionDecl.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000838 FoundOverloaded,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000839
840 /// Name lookup results in an ambiguity because multiple
841 /// entities that meet the lookup criteria were found in
842 /// subobjects of different types. For example:
843 /// @code
844 /// struct A { void f(int); }
845 /// struct B { void f(double); }
846 /// struct C : A, B { };
847 /// void test(C c) {
848 /// c.f(0); // error: A::f and B::f come from subobjects of different
849 /// // types. overload resolution is not performed.
850 /// }
851 /// @endcode
852 AmbiguousBaseSubobjectTypes,
853
854 /// Name lookup results in an ambiguity because multiple
855 /// nonstatic entities that meet the lookup criteria were found
856 /// in different subobjects of the same type. For example:
857 /// @code
858 /// struct A { int x; };
859 /// struct B : A { };
860 /// struct C : A { };
861 /// struct D : B, C { };
862 /// int test(D d) {
863 /// return d.x; // error: 'x' is found in two A subobjects (of B and C)
864 /// }
865 /// @endcode
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000866 AmbiguousBaseSubobjects,
867
868 /// Name lookup results in an ambiguity because multiple definitions
869 /// of entity that meet the lookup criteria were found in different
870 /// declaration contexts.
871 /// @code
872 /// namespace A {
873 /// int i;
874 /// namespace B { int i; }
875 /// int test() {
876 /// using namespace B;
877 /// return i; // error 'i' is found in namespace A and A::B
878 /// }
879 /// }
880 /// @endcode
881 AmbiguousReference
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000882 };
883
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000884 static LookupResult CreateLookupResult(ASTContext &Context, NamedDecl *D);
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000885
Douglas Gregor69d993a2009-01-17 01:13:24 +0000886 static LookupResult CreateLookupResult(ASTContext &Context,
887 IdentifierResolver::iterator F,
888 IdentifierResolver::iterator L);
Douglas Gregor7176fff2009-01-15 00:26:24 +0000889
Douglas Gregor69d993a2009-01-17 01:13:24 +0000890 static LookupResult CreateLookupResult(ASTContext &Context,
891 DeclContext::lookup_iterator F,
892 DeclContext::lookup_iterator L);
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000893
Douglas Gregor69d993a2009-01-17 01:13:24 +0000894 static LookupResult CreateLookupResult(ASTContext &Context, BasePaths *Paths,
895 bool DifferentSubobjectTypes) {
896 LookupResult Result;
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000897 Result.StoredKind = AmbiguousLookupStoresBasePaths;
Douglas Gregor69d993a2009-01-17 01:13:24 +0000898 Result.First = reinterpret_cast<uintptr_t>(Paths);
899 Result.Last = DifferentSubobjectTypes? 1 : 0;
900 Result.Context = &Context;
901 return Result;
902 }
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000903
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000904 template <typename Iterator>
905 static LookupResult CreateLookupResult(ASTContext &Context,
906 Iterator B, std::size_t Len) {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000907 NamedDecl ** Array = new NamedDecl*[Len];
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000908 for (std::size_t Idx = 0; Idx < Len; ++Idx, ++B)
909 Array[Idx] = *B;
910 LookupResult Result;
911 Result.StoredKind = AmbiguousLookupStoresDecls;
912 Result.First = reinterpret_cast<uintptr_t>(Array);
913 Result.Last = reinterpret_cast<uintptr_t>(Array + Len);
914 Result.Context = &Context;
915 return Result;
916 }
917
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000918 LookupKind getKind() const;
919
920 /// @brief Determine whether name look found something.
921 operator bool() const { return getKind() != NotFound; }
922
Douglas Gregor7176fff2009-01-15 00:26:24 +0000923 /// @brief Determines whether the lookup resulted in an ambiguity.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000924 bool isAmbiguous() const {
925 return StoredKind == AmbiguousLookupStoresBasePaths ||
926 StoredKind == AmbiguousLookupStoresDecls;
927 }
Douglas Gregor7176fff2009-01-15 00:26:24 +0000928
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000929 /// @brief Allows conversion of a lookup result into a
930 /// declaration, with the same behavior as getAsDecl.
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000931 operator NamedDecl*() const { return getAsDecl(); }
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000932
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000933 NamedDecl* getAsDecl() const;
Douglas Gregor7176fff2009-01-15 00:26:24 +0000934
935 BasePaths *getBasePaths() const;
Douglas Gregord8635172009-02-02 21:35:47 +0000936
937 /// \brief Iterate over the results of name lookup.
938 ///
939 /// The @c iterator class provides iteration over the results of a
940 /// non-ambiguous name lookup.
941 class iterator {
942 /// The LookupResult structure we're iterating through.
943 LookupResult *Result;
944
945 /// The current position of this iterator within the sequence of
946 /// results. This value will have the same representation as the
947 /// @c First field in the LookupResult structure.
948 mutable uintptr_t Current;
949
950 public:
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000951 typedef NamedDecl * value_type;
952 typedef NamedDecl * reference;
953 typedef NamedDecl * pointer;
Douglas Gregord8635172009-02-02 21:35:47 +0000954 typedef std::ptrdiff_t difference_type;
955 typedef std::forward_iterator_tag iterator_category;
956
957 iterator() : Result(0), Current(0) { }
958
959 iterator(LookupResult *Res, uintptr_t Cur) : Result(Res), Current(Cur) { }
960
961 reference operator*() const;
962
963 pointer operator->() const { return **this; }
964
965 iterator &operator++();
966
967 iterator operator++(int) {
968 iterator tmp(*this);
969 ++(*this);
970 return tmp;
971 }
972
973 friend inline bool operator==(iterator const& x, iterator const& y) {
974 return x.Current == y.Current;
975 }
976
977 friend inline bool operator!=(iterator const& x, iterator const& y) {
978 return x.Current != y.Current;
979 }
980 };
981 friend class iterator;
982
983 iterator begin();
984 iterator end();
Douglas Gregor31a19b62009-04-01 21:51:26 +0000985
986 /// \brief Free the memory associated with this lookup.
987 void Destroy();
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000988 };
989
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000990private:
991 typedef llvm::SmallVector<LookupResult, 3> LookupResultsVecTy;
992
993 std::pair<bool, LookupResult> CppLookupName(Scope *S, DeclarationName Name,
994 LookupNameKind NameKind,
995 bool RedeclarationOnly);
Fariborz Jahanianef79bc92009-04-07 18:28:06 +0000996 ObjCMethodDecl *FindMethodInNestedImplementations(
997 const ObjCInterfaceDecl *IFace,
998 const Selector &Sel);
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000999
1000public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001001 /// Determines whether D is a suitable lookup result according to the
1002 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001003 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001004 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001005 switch (NameKind) {
1006 case Sema::LookupOrdinaryName:
1007 case Sema::LookupTagName:
1008 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001009 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001010 case Sema::LookupObjCProtocolName:
1011 case Sema::LookupObjCImplementationName:
1012 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001013 return D->isInIdentifierNamespace(IDNS);
1014
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001015 case Sema::LookupOperatorName:
1016 return D->isInIdentifierNamespace(IDNS) &&
1017 !D->getDeclContext()->isRecord();
1018
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001019 case Sema::LookupNestedNameSpecifierName:
1020 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
1021
1022 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001023 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001024 }
1025
1026 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001027 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001028 return false;
1029 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001030
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001031 LookupResult LookupName(Scope *S, DeclarationName Name,
1032 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001033 bool RedeclarationOnly = false,
1034 bool AllowBuiltinCreation = true,
1035 SourceLocation Loc = SourceLocation());
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001036 LookupResult LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
1037 LookupNameKind NameKind,
1038 bool RedeclarationOnly = false);
1039 LookupResult LookupParsedName(Scope *S, const CXXScopeSpec *SS,
1040 DeclarationName Name,
1041 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001042 bool RedeclarationOnly = false,
1043 bool AllowBuiltinCreation = true,
1044 SourceLocation Loc = SourceLocation());
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001045
Douglas Gregor6e378de2009-04-23 23:18:26 +00001046 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001047 ObjCImplementationDecl *LookupObjCImplementation(IdentifierInfo *II);
1048 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001049
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001050 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
1051 QualType T1, QualType T2,
1052 FunctionSet &Functions);
1053
1054 void ArgumentDependentLookup(DeclarationName Name,
1055 Expr **Args, unsigned NumArgs,
1056 FunctionSet &Functions);
1057
Douglas Gregorfa047642009-02-04 00:32:51 +00001058 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1059 AssociatedNamespaceSet &AssociatedNamespaces,
1060 AssociatedClassSet &AssociatedClasses);
1061
Douglas Gregor7176fff2009-01-15 00:26:24 +00001062 bool DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
1063 SourceLocation NameLoc,
1064 SourceRange LookupRange = SourceRange());
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001065 //@}
1066
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001067 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001068 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001069 Scope *S, bool ForRedeclaration,
1070 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001071 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1072 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001073 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001074
1075 // More parsing and symbol table subroutines.
1076
Reid Spencer5f016e22007-07-11 17:01:13 +00001077 // Decl attributes - this routine is the top level dispatcher.
Chris Lattnere5c5ee12008-06-29 00:16:31 +00001078 void ProcessDeclAttributes(Decl *D, const Declarator &PD);
Chris Lattnerf2e4bd52008-06-28 23:58:55 +00001079 void ProcessDeclAttributeList(Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001080
Steve Naroff3c2eb662008-02-10 21:38:56 +00001081 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1082 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001083 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1084 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001085
1086 NamespaceDecl *GetStdNamespace();
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001087
1088 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001089 ObjCInterfaceDecl *IDecl);
Steve Naroff3c2eb662008-02-10 21:38:56 +00001090
Chris Lattner823c44e2009-01-06 07:27:21 +00001091 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001092 /// methods declared in protocol, and those referenced by it.
1093 /// \param IDecl - Used for checking for methods which may have been
1094 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001095 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1096 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001097 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001098 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001099 const llvm::DenseSet<Selector> &ClsMap,
1100 ObjCInterfaceDecl *IDecl);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001101
Steve Naroffa5997c42007-10-02 21:43:37 +00001102 /// CheckImplementationIvars - This routine checks if the instance variables
1103 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001104 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1105 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001106 SourceLocation Loc);
Steve Naroffa5997c42007-10-02 21:43:37 +00001107
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001108 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001109 /// remains unimplemented in the class or category @implementation.
1110 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1111 ObjCContainerDecl* IDecl,
1112 bool IncompleteImpl = false);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001113
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001114 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1115 /// true, or false, accordingly.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001116 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001117 const ObjCMethodDecl *PrevMethod,
1118 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001119
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001120 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1121 /// or protocol against those declared in their implementations.
1122 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1123 const llvm::DenseSet<Selector> &ClsMap,
1124 llvm::DenseSet<Selector> &InsMapSeen,
1125 llvm::DenseSet<Selector> &ClsMapSeen,
1126 ObjCImplDecl* IMPDecl,
1127 ObjCContainerDecl* IDecl,
1128 bool &IncompleteImpl,
1129 bool ImmediateClass);
1130
Steve Naroff58ff9e82007-10-14 00:58:41 +00001131 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1132 /// unit are added to a global pool. This allows us to efficiently associate
1133 /// a selector with a method declaraation for purposes of typechecking
1134 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001135 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff58ff9e82007-10-14 00:58:41 +00001136
Steve Naroff037cda52008-09-30 14:38:43 +00001137 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1138 /// there are multiple signatures.
1139 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001140
1141 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1142 /// there are multiple signatures.
1143 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Steve Naroff037cda52008-09-30 14:38:43 +00001144
Steve Naroff58ff9e82007-10-14 00:58:41 +00001145 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001146 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001147 //===--------------------------------------------------------------------===//
1148 // Statement Parsing Callbacks: SemaStmt.cpp.
1149public:
Sebastian Redla60528c2008-12-21 12:04:03 +00001150 virtual OwningStmtResult ActOnExprStmt(ExprArg Expr);
1151
1152 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1153 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1154 MultiStmtArg Elts,
1155 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001156 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001157 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001158 SourceLocation EndLoc);
Sebastian Redl117054a2008-12-28 16:13:43 +00001159 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1160 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001161 SourceLocation ColonLoc);
1162 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
1163
Sebastian Redl117054a2008-12-28 16:13:43 +00001164 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1165 SourceLocation ColonLoc,
1166 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001167 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1168 IdentifierInfo *II,
1169 SourceLocation ColonLoc,
1170 StmtArg SubStmt);
1171 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc, ExprArg CondVal,
1172 StmtArg ThenVal, SourceLocation ElseLoc,
1173 StmtArg ElseVal);
1174 virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond);
1175 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1176 StmtArg Switch, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001177 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc, ExprArg Cond,
1178 StmtArg Body);
1179 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
1180 SourceLocation WhileLoc, ExprArg Cond);
1181
1182 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1183 SourceLocation LParenLoc,
1184 StmtArg First, ExprArg Second,
1185 ExprArg Third, SourceLocation RParenLoc,
1186 StmtArg Body);
1187 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1188 SourceLocation LParenLoc,
1189 StmtArg First, ExprArg Second,
1190 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001191
1192 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1193 SourceLocation LabelLoc,
1194 IdentifierInfo *LabelII);
1195 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1196 SourceLocation StarLoc,
1197 ExprArg DestExp);
1198 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1199 Scope *CurScope);
1200 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1201 Scope *CurScope);
1202
1203 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
1204 ExprArg RetValExp);
1205 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1206 Expr *RetValExp);
1207
Sebastian Redl3037ed02009-01-18 16:53:17 +00001208 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1209 bool IsSimple,
1210 bool IsVolatile,
1211 unsigned NumOutputs,
1212 unsigned NumInputs,
1213 std::string *Names,
1214 MultiExprArg Constraints,
1215 MultiExprArg Exprs,
1216 ExprArg AsmString,
1217 MultiExprArg Clobbers,
1218 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001219
1220 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1221 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001222 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001223 StmtArg CatchList);
1224
1225 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1226 StmtArg Body);
1227
1228 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1229 StmtArg Try,
1230 StmtArg Catch, StmtArg Finally);
1231
1232 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001233 ExprArg Throw,
1234 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001235 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1236 ExprArg SynchExpr,
1237 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001238
Chris Lattnerb28317a2009-03-28 19:18:32 +00001239 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Sebastian Redl4b07b292008-12-22 19:15:10 +00001240 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001241 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001242 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001243 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1244 StmtArg TryBlock,
1245 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001246 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001247
Reid Spencer5f016e22007-07-11 17:01:13 +00001248 //===--------------------------------------------------------------------===//
1249 // Expression Parsing Callbacks: SemaExpr.cpp.
1250
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001251 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001252 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
1253 ObjCMethodDecl *Getter,
1254 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001255 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1256 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001257
Reid Spencer5f016e22007-07-11 17:01:13 +00001258 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001259 virtual SourceRange getExprRange(ExprTy *E) const;
1260
Sebastian Redlcd965b92009-01-18 18:53:16 +00001261 virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
1262 IdentifierInfo &II,
1263 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001264 const CXXScopeSpec *SS = 0,
1265 bool isAddressOfOperand = false);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001266 virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001267 SourceLocation OperatorLoc,
1268 OverloadedOperatorKind Op,
1269 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001270 const CXXScopeSpec &SS,
1271 bool isAddressOfOperand);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001272 virtual OwningExprResult ActOnCXXConversionFunctionExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001273 SourceLocation OperatorLoc,
1274 TypeTy *Ty,
1275 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001276 const CXXScopeSpec &SS,
1277 bool isAddressOfOperand);
Douglas Gregor1a49af92009-01-06 05:10:23 +00001278 DeclRefExpr *BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
1279 bool TypeDependent, bool ValueDependent,
1280 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001281 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1282 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001283 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001284 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1285 FieldDecl *Field,
1286 Expr *BaseObjectExpr = 0,
1287 SourceLocation OpLoc = SourceLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001288 OwningExprResult ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
1289 DeclarationName Name,
1290 bool HasTrailingLParen,
1291 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001292 bool isAddressOfOperand = false);
Douglas Gregor10c42622008-11-18 15:03:34 +00001293
Sebastian Redlcd965b92009-01-18 18:53:16 +00001294 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1295 tok::TokenKind Kind);
1296 virtual OwningExprResult ActOnNumericConstant(const Token &);
1297 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1298 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1299 ExprArg Val);
Reid Spencer5f016e22007-07-11 17:01:13 +00001300
Steve Narofff69936d2007-09-16 03:34:24 +00001301 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001302 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001303 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1304 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001305
Reid Spencer5f016e22007-07-11 17:01:13 +00001306 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001307 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
1308 unsigned OpcIn,
1309 ExprArg InputArg);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001310 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1311 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001312
Douglas Gregorba498172009-03-13 21:01:28 +00001313 OwningExprResult CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1314 bool isSizeOf, SourceRange R);
1315 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1316 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001317 virtual OwningExprResult
1318 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1319 void *TyOrEx, const SourceRange &ArgRange);
Douglas Gregorba498172009-03-13 21:01:28 +00001320
Chris Lattner31e21e02009-01-24 20:17:12 +00001321 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001322 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1323 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001324
1325 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1326 tok::TokenKind Kind,
1327 ExprArg Input);
1328
1329 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1330 SourceLocation LLoc,
1331 ExprArg Idx,
1332 SourceLocation RLoc);
1333 virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
1334 SourceLocation OpLoc,
1335 tok::TokenKind OpKind,
1336 SourceLocation MemberLoc,
Fariborz Jahaniana6e3ac52009-03-04 22:30:12 +00001337 IdentifierInfo &Member,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001338 DeclPtrTy ImplDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001339 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001340 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001341 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001342 Expr **Args, unsigned NumArgs,
1343 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001344
Steve Narofff69936d2007-09-16 03:34:24 +00001345 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001346 /// This provides the location of the left/right parens and a list of comma
1347 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001348 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1349 SourceLocation LParenLoc,
1350 MultiExprArg Args,
1351 SourceLocation *CommaLocs,
1352 SourceLocation RParenLoc);
1353
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001354 virtual OwningExprResult ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
1355 SourceLocation RParenLoc, ExprArg Op);
1356
1357 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1358 TypeTy *Ty,
1359 SourceLocation RParenLoc,
1360 ExprArg Op);
1361
1362 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1363 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001364 SourceLocation RParenLoc);
1365
Douglas Gregor05c13a32009-01-22 00:58:24 +00001366 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1367 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001368 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001369 OwningExprResult Init);
1370
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001371 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1372 tok::TokenKind Kind,
1373 ExprArg LHS, ExprArg RHS);
1374 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1375 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001376
Steve Narofff69936d2007-09-16 03:34:24 +00001377 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001378 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001379 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1380 SourceLocation ColonLoc,
1381 ExprArg Cond, ExprArg LHS,
1382 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001383
Steve Naroff1b273c42007-09-16 14:56:35 +00001384 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001385 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1386 SourceLocation LabLoc,
1387 IdentifierInfo *LabelII);
1388
1389 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1390 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001391
1392 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001393 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1394 SourceLocation BuiltinLoc,
1395 SourceLocation TypeLoc,
1396 TypeTy *Arg1,
1397 OffsetOfComponent *CompPtr,
1398 unsigned NumComponents,
1399 SourceLocation RParenLoc);
1400
Steve Naroffd34e9152007-08-01 22:05:33 +00001401 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001402 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1403 TypeTy *arg1, TypeTy *arg2,
1404 SourceLocation RPLoc);
1405
Steve Naroffd04fdd52007-08-03 21:21:27 +00001406 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001407 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1408 ExprArg cond, ExprArg expr1,
1409 ExprArg expr2, SourceLocation RPLoc);
1410
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001411 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001412 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1413 ExprArg expr, TypeTy *type,
1414 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001415
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001416 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001417 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001418
Steve Naroff4eb206b2008-09-03 18:15:37 +00001419 //===------------------------- "Block" Extension ------------------------===//
1420
1421 /// ActOnBlockStart - This callback is invoked when a block literal is
1422 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001423 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001424
Steve Naroff090276f2008-10-10 01:28:17 +00001425 /// ActOnBlockArguments - This callback allows processing of block arguments.
1426 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001427 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001428
Steve Naroff4eb206b2008-09-03 18:15:37 +00001429 /// ActOnBlockError - If there is an error parsing a block, this callback
1430 /// is invoked to pop the information about the block from the action impl.
1431 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001432
Steve Naroff4eb206b2008-09-03 18:15:37 +00001433 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1434 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001435 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1436 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001437
Chris Lattner76a642f2009-02-15 22:43:40 +00001438 //===---------------------------- C++ Features --------------------------===//
1439
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001440 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001441 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1442 IdentifierInfo *Ident,
1443 SourceLocation LBrace);
1444 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001445
Chris Lattnerb28317a2009-03-28 19:18:32 +00001446 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1447 SourceLocation UsingLoc,
1448 SourceLocation NamespcLoc,
1449 const CXXScopeSpec &SS,
1450 SourceLocation IdentLoc,
1451 IdentifierInfo *NamespcName,
1452 AttributeList *AttrList);
Anders Carlssondbb00942009-03-28 05:27:17 +00001453
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001454 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1455
Chris Lattnerb28317a2009-03-28 19:18:32 +00001456 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001457 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001458 SourceLocation AliasLoc,
1459 IdentifierInfo *Alias,
1460 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001461 SourceLocation IdentLoc,
1462 IdentifierInfo *Ident);
Anders Carlssondbb00942009-03-28 05:27:17 +00001463
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001464 /// AddCXXDirectInitializerToDecl - This action is called immediately after
1465 /// ActOnDeclarator, when a C++ direct initializer is present.
1466 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001467 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001468 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001469 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001470 SourceLocation *CommaLocs,
1471 SourceLocation RParenLoc);
1472
Anders Carlsson49d44012009-04-24 05:16:06 +00001473 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1474 /// and sets it as the initializer for the the passed in VarDecl.
Anders Carlsson930e8d02009-04-16 23:50:50 +00001475 void InitializeVarWithConstructor(VarDecl *VD,
1476 CXXConstructorDecl *Constructor,
1477 QualType DeclInitType,
1478 Expr **Exprs, unsigned NumExprs);
1479
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001480 /// InitializationKind - Represents which kind of C++ initialization
1481 /// [dcl.init] a routine is to perform.
1482 enum InitializationKind {
1483 IK_Direct, ///< Direct initialization
1484 IK_Copy, ///< Copy initialization
1485 IK_Default ///< Default initialization
1486 };
1487
Douglas Gregor18fe5682008-11-03 20:45:27 +00001488 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001489 PerformInitializationByConstructor(QualType ClassType,
1490 Expr **Args, unsigned NumArgs,
1491 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001492 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001493 InitializationKind Kind);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001494
Douglas Gregor49badde2008-10-27 19:41:14 +00001495 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001496 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1497 tok::TokenKind Kind,
1498 SourceLocation LAngleBracketLoc,
1499 TypeTy *Ty,
1500 SourceLocation RAngleBracketLoc,
1501 SourceLocation LParenLoc,
1502 ExprArg E,
1503 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001504
Sebastian Redlf53597f2009-03-15 17:47:39 +00001505 /// ActOnCXXTypeid - Parse typeid( something ).
1506 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1507 SourceLocation LParenLoc, bool isType,
1508 void *TyOrExpr,
1509 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001510
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001511 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001512 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001513
Steve Naroff1b273c42007-09-16 14:56:35 +00001514 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001515 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1516 tok::TokenKind Kind);
1517
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001518 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1519 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1520
Chris Lattner50dd2892008-02-26 00:51:44 +00001521 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001522 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1523 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001524 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001525
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001526 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1527 /// Can be interpreted either as function-style casting ("int(x)")
1528 /// or class type construction ("ClassType(x,y,z)")
1529 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001530 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1531 TypeTy *TypeRep,
1532 SourceLocation LParenLoc,
1533 MultiExprArg Exprs,
1534 SourceLocation *CommaLocs,
1535 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001536
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001537 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001538 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1539 SourceLocation PlacementLParen,
1540 MultiExprArg PlacementArgs,
1541 SourceLocation PlacementRParen,
1542 bool ParenTypeId, Declarator &D,
1543 SourceLocation ConstructorLParen,
1544 MultiExprArg ConstructorArgs,
1545 SourceLocation ConstructorRParen);
Sebastian Redlcee63fb2008-12-02 14:43:59 +00001546 bool CheckAllocatedType(QualType AllocType, const Declarator &D);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001547 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1548 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001549 Expr **PlaceArgs, unsigned NumPlaceArgs,
1550 FunctionDecl *&OperatorNew,
1551 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001552 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1553 DeclarationName Name, Expr** Args,
1554 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001555 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001556 void DeclareGlobalNewDelete();
1557 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1558 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001559
1560 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001561 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1562 bool UseGlobal, bool ArrayForm,
1563 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001564
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001565 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
1566 /// C++ if/switch/while/for statement.
1567 /// e.g: "if (int x = f()) {...}"
Sebastian Redlf53597f2009-03-15 17:47:39 +00001568 virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001569 SourceLocation StartLoc,
1570 Declarator &D,
1571 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001572 ExprArg AssignExprVal);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001573
Sebastian Redl64b45f72009-01-05 20:52:13 +00001574 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1575 /// pseudo-functions.
1576 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1577 SourceLocation KWLoc,
1578 SourceLocation LParen,
1579 TypeTy *Ty,
1580 SourceLocation RParen);
1581
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001582 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001583
1584 DeclContext *computeDeclContext(const CXXScopeSpec &SS);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001585 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001586 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1587 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001588
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001589 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1590 /// global scope ('::').
1591 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1592 SourceLocation CCLoc);
1593
1594 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1595 /// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
1596 /// we want to resolve "bar::". 'SS' is empty or the previously parsed
1597 /// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
1598 /// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
1599 /// Returns a CXXScopeTy* object representing the C++ scope.
1600 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1601 const CXXScopeSpec &SS,
1602 SourceLocation IdLoc,
1603 SourceLocation CCLoc,
Douglas Gregor2def4832008-11-17 20:34:05 +00001604 IdentifierInfo &II);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001605
Douglas Gregor39a8de12009-02-25 19:37:18 +00001606 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1607 /// nested-name-specifier that involves a template-id, e.g.,
1608 /// "foo::bar<int, float>::", and now we need to build a scope
1609 /// specifier. \p SS is empty or the previously parsed nested-name
1610 /// part ("foo::"), \p Type is the already-parsed class template
1611 /// specialization (or other template-id that names a type), \p
1612 /// TypeRange is the source range where the type is located, and \p
1613 /// CCLoc is the location of the trailing '::'.
1614 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1615 const CXXScopeSpec &SS,
1616 TypeTy *Type,
1617 SourceRange TypeRange,
1618 SourceLocation CCLoc);
1619
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001620 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1621 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1622 /// After this method is called, according to [C++ 3.4.3p3], names should be
1623 /// looked up in the declarator-id's scope, until the declarator is parsed and
1624 /// ActOnCXXExitDeclaratorScope is called.
1625 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1626 virtual void ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
1627
1628 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1629 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1630 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1631 /// Used to indicate that names should revert to being looked up in the
1632 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00001633 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001634
Anders Carlsson55085182007-08-21 17:43:55 +00001635 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00001636 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
1637 ExprTy **Strings,
1638 unsigned NumStrings);
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001639 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00001640 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001641 SourceLocation LParenLoc,
1642 TypeTy *Ty,
1643 SourceLocation RParenLoc);
1644
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001645 // ParseObjCSelectorExpression - Build selector expression for @selector
1646 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
1647 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00001648 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001649 SourceLocation LParenLoc,
1650 SourceLocation RParenLoc);
1651
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001652 // ParseObjCProtocolExpression - Build protocol expression for @protocol
1653 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
1654 SourceLocation AtLoc,
1655 SourceLocation ProtoLoc,
1656 SourceLocation LParenLoc,
1657 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001658
1659 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00001660 // C++ Declarations
1661 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00001662 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
1663 SourceLocation ExternLoc,
1664 SourceLocation LangLoc,
1665 const char *Lang,
1666 unsigned StrSize,
1667 SourceLocation LBraceLoc);
1668 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
1669 DeclPtrTy LinkageSpec,
1670 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00001671
1672
1673 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001674 // C++ Classes
1675 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001676 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
1677 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00001678
Chris Lattnerb28317a2009-03-28 19:18:32 +00001679 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
1680 Declarator &D,
1681 ExprTy *BitfieldWidth,
Sebastian Redle2b68332009-04-12 17:16:29 +00001682 ExprTy *Init,
1683 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001684
Chris Lattnerb28317a2009-03-28 19:18:32 +00001685 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001686 Scope *S,
1687 IdentifierInfo *MemberOrBase,
1688 SourceLocation IdLoc,
1689 SourceLocation LParenLoc,
1690 ExprTy **Args, unsigned NumArgs,
1691 SourceLocation *CommaLocs,
1692 SourceLocation RParenLoc);
1693
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001694 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
1695
Chris Lattnerb28317a2009-03-28 19:18:32 +00001696 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00001697 SourceLocation ColonLoc,
1698 MemInitTy **MemInits, unsigned NumMemInits);
1699
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001700 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001701 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001702 SourceLocation LBrac,
1703 SourceLocation RBrac);
1704
Chris Lattnerb28317a2009-03-28 19:18:32 +00001705 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
1706 DeclPtrTy Method);
1707 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
1708 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
1709 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00001710
Chris Lattnerb28317a2009-03-28 19:18:32 +00001711 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
1712 ExprArg AssertExpr,
1713 ExprArg AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00001714
Anders Carlsson00338362009-05-11 22:55:49 +00001715 virtual bool ActOnFriendDecl(Scope *S, SourceLocation FriendLoc,
1716 DeclPtrTy Dcl);
1717
Chris Lattner65401802009-04-25 08:28:21 +00001718 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
1719 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00001720 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00001721 QualType CheckDestructorDeclarator(Declarator &D,
1722 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00001723 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001724 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001725 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001726
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001727 //===--------------------------------------------------------------------===//
1728 // C++ Derived Classes
1729 //
1730
1731 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00001732 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
1733 SourceRange SpecifierRange,
1734 bool Virtual, AccessSpecifier Access,
1735 QualType BaseType,
1736 SourceLocation BaseLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001737 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001738 SourceRange SpecifierRange,
1739 bool Virtual, AccessSpecifier Access,
Douglas Gregor2943aed2009-03-03 04:44:36 +00001740 TypeTy *basetype, SourceLocation
1741 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001742
Douglas Gregor2943aed2009-03-03 04:44:36 +00001743 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
1744 unsigned NumBases);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001745 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001746 unsigned NumBases);
1747
1748 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001749 bool IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths);
Douglas Gregor7176fff2009-01-15 00:26:24 +00001750 bool LookupInBases(CXXRecordDecl *Class, const MemberLookupCriteria& Criteria,
1751 BasePaths &Paths);
Douglas Gregor0575d4a2008-10-24 16:17:19 +00001752 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1753 SourceLocation Loc, SourceRange Range);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00001754 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1755 unsigned InaccessibleBaseID,
1756 unsigned AmbigiousBaseConvID,
1757 SourceLocation Loc, SourceRange Range,
1758 DeclarationName Name);
1759
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +00001760 std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
Anders Carlssond7ba27d2009-05-14 01:09:04 +00001761
1762 /// CheckReturnTypeCovariance - Checks whether two types are covariant,
1763 /// according to C++ [class.virtual]p5.
1764 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
1765 const CXXMethodDecl *Old);
1766
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001767
Anders Carlsson29f006b2009-03-27 05:05:05 +00001768 //===--------------------------------------------------------------------===//
1769 // C++ Access Control
1770 //
1771
1772 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
1773 NamedDecl *PrevMemberDecl,
1774 AccessSpecifier LexicalAS);
1775
1776 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00001777 unsigned InaccessibleBaseID,
1778 BasePaths& Paths, SourceLocation AccessLoc,
1779 DeclarationName Name);
Anders Carlsson29f006b2009-03-27 05:05:05 +00001780
1781
Anders Carlsson8211eff2009-03-24 01:19:16 +00001782 enum AbstractDiagSelID {
1783 AbstractNone = -1,
1784 AbstractReturnType,
1785 AbstractParamType,
1786 AbstractVariableType,
1787 AbstractFieldType
1788 };
1789
1790 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001791 AbstractDiagSelID SelID = AbstractNone,
1792 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001793
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001794 //===--------------------------------------------------------------------===//
1795 // C++ Overloaded Operators [C++ 13.5]
1796 //
1797
1798 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
1799
Douglas Gregor72c3f312008-12-05 18:15:24 +00001800 //===--------------------------------------------------------------------===//
1801 // C++ Templates [C++ 14]
1802 //
Douglas Gregorc45c2322009-03-31 00:43:58 +00001803 virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
Douglas Gregor7532dc62009-03-30 22:58:21 +00001804 TemplateTy &Template,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001805 const CXXScopeSpec *SS = 0);
Douglas Gregor72c3f312008-12-05 18:15:24 +00001806 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001807 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001808
Chris Lattnerb28317a2009-03-28 19:18:32 +00001809 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename,
1810 SourceLocation KeyLoc,
1811 IdentifierInfo *ParamName,
1812 SourceLocation ParamNameLoc,
1813 unsigned Depth, unsigned Position);
1814 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001815 SourceLocation EqualLoc,
1816 SourceLocation DefaultLoc,
1817 TypeTy *Default);
1818
Douglas Gregor2943aed2009-03-03 04:44:36 +00001819 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001820 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
1821 unsigned Depth,
1822 unsigned Position);
1823 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001824 SourceLocation EqualLoc,
1825 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001826 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
1827 SourceLocation TmpLoc,
1828 TemplateParamsTy *Params,
1829 IdentifierInfo *ParamName,
1830 SourceLocation ParamNameLoc,
1831 unsigned Depth,
1832 unsigned Position);
1833 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001834 SourceLocation EqualLoc,
1835 ExprArg Default);
1836
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001837 virtual TemplateParamsTy *
1838 ActOnTemplateParameterList(unsigned Depth,
1839 SourceLocation ExportLoc,
1840 SourceLocation TemplateLoc,
1841 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001842 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001843 SourceLocation RAngleLoc);
Douglas Gregord684b002009-02-10 19:49:53 +00001844 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
1845 TemplateParameterList *OldParams);
1846
Douglas Gregor212e81c2009-03-25 00:13:59 +00001847 virtual DeclResult
Douglas Gregorddc29e12009-02-06 22:42:48 +00001848 ActOnClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
1849 SourceLocation KWLoc, const CXXScopeSpec &SS,
1850 IdentifierInfo *Name, SourceLocation NameLoc,
1851 AttributeList *Attr,
Anders Carlsson5aeccdb2009-03-26 00:52:18 +00001852 MultiTemplateParamsArg TemplateParameterLists,
1853 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00001854
Douglas Gregor7532dc62009-03-30 22:58:21 +00001855 QualType CheckTemplateIdType(TemplateName Template,
1856 SourceLocation TemplateLoc,
1857 SourceLocation LAngleLoc,
1858 const TemplateArgument *TemplateArgs,
1859 unsigned NumTemplateArgs,
1860 SourceLocation RAngleLoc);
Douglas Gregor40808ce2009-03-09 23:48:35 +00001861
Douglas Gregorcc636682009-02-17 23:15:12 +00001862 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00001863 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
1864 SourceLocation LAngleLoc,
1865 ASTTemplateArgsPtr TemplateArgs,
1866 SourceLocation *TemplateArgLocs,
1867 SourceLocation RAngleLoc);
Douglas Gregorcc636682009-02-17 23:15:12 +00001868
Douglas Gregorc45c2322009-03-31 00:43:58 +00001869 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
1870 const IdentifierInfo &Name,
1871 SourceLocation NameLoc,
1872 const CXXScopeSpec &SS);
1873
Douglas Gregor88b70942009-02-25 22:02:03 +00001874 bool CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
1875 ClassTemplateSpecializationDecl *PrevDecl,
1876 SourceLocation TemplateNameLoc,
Douglas Gregorff668032009-05-13 18:28:20 +00001877 SourceRange ScopeSpecifierRange,
1878 bool ExplicitInstantiation);
Douglas Gregor88b70942009-02-25 22:02:03 +00001879
Douglas Gregor212e81c2009-03-25 00:13:59 +00001880 virtual DeclResult
Douglas Gregorcc636682009-02-17 23:15:12 +00001881 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
1882 SourceLocation KWLoc,
1883 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00001884 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00001885 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001886 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00001887 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregorc15cb382009-02-09 23:23:08 +00001888 SourceLocation *TemplateArgLocs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001889 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00001890 AttributeList *Attr,
1891 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001892
Douglas Gregor93dfdb12009-05-13 00:25:59 +00001893 virtual DeclResult
1894 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
1895 unsigned TagSpec,
1896 SourceLocation KWLoc,
1897 const CXXScopeSpec &SS,
1898 TemplateTy Template,
1899 SourceLocation TemplateNameLoc,
1900 SourceLocation LAngleLoc,
1901 ASTTemplateArgsPtr TemplateArgs,
1902 SourceLocation *TemplateArgLocs,
1903 SourceLocation RAngleLoc,
1904 AttributeList *Attr);
1905
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00001906 virtual DeclResult
1907 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
1908 unsigned TagSpec,
1909 SourceLocation KWLoc,
1910 const CXXScopeSpec &SS,
1911 IdentifierInfo *Name,
1912 SourceLocation NameLoc,
1913 AttributeList *Attr);
1914
Douglas Gregorc15cb382009-02-09 23:23:08 +00001915 bool CheckTemplateArgumentList(TemplateDecl *Template,
1916 SourceLocation TemplateLoc,
1917 SourceLocation LAngleLoc,
Douglas Gregor40808ce2009-03-09 23:48:35 +00001918 const TemplateArgument *TemplateArgs,
1919 unsigned NumTemplateArgs,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001920 SourceLocation RAngleLoc,
1921 llvm::SmallVectorImpl<TemplateArgument> &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001922
1923 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg,
1924 SourceLocation ArgLoc);
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001925 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
1926 NamedDecl *&Entity);
1927 bool CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001928 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
1929 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001930 llvm::SmallVectorImpl<TemplateArgument> *Converted = 0);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001931 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param, DeclRefExpr *Arg);
Douglas Gregorddc29e12009-02-06 22:42:48 +00001932 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
1933 TemplateParameterList *Old,
1934 bool Complain,
Douglas Gregordd0574e2009-02-10 00:24:35 +00001935 bool IsTemplateTemplateParm = false,
1936 SourceLocation TemplateArgLoc
1937 = SourceLocation());
Douglas Gregorddc29e12009-02-06 22:42:48 +00001938
1939 bool CheckTemplateDeclScope(Scope *S,
1940 MultiTemplateParamsArg &TemplateParameterLists);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001941
Douglas Gregord57959a2009-03-27 23:10:48 +00001942 /// \brief Called when the parser has parsed a C++ typename
1943 /// specifier, e.g., "typename T::type".
1944 ///
1945 /// \param TypenameLoc the location of the 'typename' keyword
1946 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
1947 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
1948 /// \param IdLoc the location of the identifier.
1949 virtual TypeResult
1950 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
1951 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00001952
1953 /// \brief Called when the parser has parsed a C++ typename
1954 /// specifier that ends in a template-id, e.g.,
1955 /// "typename MetaFun::template apply<T1, T2>".
1956 ///
1957 /// \param TypenameLoc the location of the 'typename' keyword
1958 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
1959 /// \param TemplateLoc the location of the 'template' keyword, if any.
1960 /// \param Ty the type that the typename specifier refers to.
1961 virtual TypeResult
1962 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
1963 SourceLocation TemplateLoc, TypeTy *Ty);
1964
Douglas Gregord57959a2009-03-27 23:10:48 +00001965 QualType CheckTypenameType(NestedNameSpecifier *NNS,
1966 const IdentifierInfo &II,
1967 SourceRange Range);
1968
Douglas Gregor99ebf652009-02-27 19:31:52 +00001969 //===--------------------------------------------------------------------===//
1970 // C++ Template Instantiation
1971 //
Douglas Gregor26dce442009-03-10 00:06:19 +00001972
1973 /// \brief A template instantiation that is currently in progress.
1974 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00001975 /// \brief The kind of template instantiation we are performing
1976 enum {
1977 /// We are instantiating a template declaration. The entity is
Douglas Gregord475b8d2009-03-25 21:17:03 +00001978 /// the declaration we're instantiation (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00001979 TemplateInstantiation,
1980
1981 /// We are instantiating a default argument for a template
1982 /// parameter. The Entity is the template, and
1983 /// TemplateArgs/NumTemplateArguments provides the template
1984 /// arguments as specified.
1985 DefaultTemplateArgumentInstantiation
1986 } Kind;
1987
Douglas Gregor26dce442009-03-10 00:06:19 +00001988 /// \brief The point of instantiation within the source code.
1989 SourceLocation PointOfInstantiation;
1990
1991 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00001992 uintptr_t Entity;
1993
1994 // \brief If this the instantiation of a default template
Douglas Gregor7e063902009-05-11 23:53:27 +00001995 // argument, the list of template arguments.
Douglas Gregordf667e72009-03-10 20:44:00 +00001996 const TemplateArgument *TemplateArgs;
1997
1998 /// \brief The number of template arguments in TemplateArgs.
1999 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002000
2001 /// \brief The source range that covers the construct that cause
2002 /// the instantiation, e.g., the template-id that causes a class
2003 /// template instantiation.
2004 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002005
2006 friend bool operator==(const ActiveTemplateInstantiation &X,
2007 const ActiveTemplateInstantiation &Y) {
2008 if (X.Kind != Y.Kind)
2009 return false;
2010
2011 if (X.Entity != Y.Entity)
2012 return false;
2013
2014 switch (X.Kind) {
2015 case TemplateInstantiation:
2016 return true;
2017
2018 case DefaultTemplateArgumentInstantiation:
2019 return X.TemplateArgs == Y.TemplateArgs;
2020 }
2021
2022 return true;
2023 }
2024
2025 friend bool operator!=(const ActiveTemplateInstantiation &X,
2026 const ActiveTemplateInstantiation &Y) {
2027 return !(X == Y);
2028 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002029 };
2030
2031 /// \brief List of active template instantiations.
2032 ///
2033 /// This vector is treated as a stack. As one template instantiation
2034 /// requires another template instantiation, additional
2035 /// instantiations are pushed onto the stack up to a
2036 /// user-configurable limit LangOptions::InstantiationDepth.
2037 llvm::SmallVector<ActiveTemplateInstantiation, 16>
2038 ActiveTemplateInstantiations;
2039
Douglas Gregor27b152f2009-03-10 18:52:44 +00002040 /// \brief The last template from which a template instantiation
2041 /// error or warning was produced.
2042 ///
2043 /// This value is used to suppress printing of redundant template
2044 /// instantiation backtraces when there are multiple errors in the
2045 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2046 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002047 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002048
Douglas Gregor26dce442009-03-10 00:06:19 +00002049 /// \brief A stack object to be created when performing template
2050 /// instantiation.
2051 ///
2052 /// Construction of an object of type \c InstantiatingTemplate
2053 /// pushes the current instantiation onto the stack of active
2054 /// instantiations. If the size of this stack exceeds the maximum
2055 /// number of recursive template instantiations, construction
2056 /// produces an error and evaluates true.
2057 ///
2058 /// Destruction of this object will pop the named instantiation off
2059 /// the stack.
2060 struct InstantiatingTemplate {
Douglas Gregordf667e72009-03-10 20:44:00 +00002061 /// \brief Note that we are instantiating a class template.
Douglas Gregor26dce442009-03-10 00:06:19 +00002062 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregord475b8d2009-03-25 21:17:03 +00002063 CXXRecordDecl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002064 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002065
2066 /// \brief Note that we are instantiating a default argument in a
2067 /// template-id.
2068 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2069 TemplateDecl *Template,
2070 const TemplateArgument *TemplateArgs,
2071 unsigned NumTemplateArgs,
2072 SourceRange InstantiationRange = SourceRange());
2073
Douglas Gregor26dce442009-03-10 00:06:19 +00002074 ~InstantiatingTemplate();
2075
2076 /// \brief Determines whether we have exceeded the maximum
2077 /// recursive template instantiations.
2078 operator bool() const { return Invalid; }
2079
2080 private:
2081 Sema &SemaRef;
2082 bool Invalid;
2083
Douglas Gregordf667e72009-03-10 20:44:00 +00002084 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2085 SourceRange InstantiationRange);
2086
Douglas Gregor26dce442009-03-10 00:06:19 +00002087 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2088
2089 InstantiatingTemplate&
2090 operator=(const InstantiatingTemplate&); // not implemented
2091 };
2092
Douglas Gregoree1828a2009-03-10 18:03:33 +00002093 void PrintInstantiationStack();
2094
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002095 /// \brief A stack-allocated class that identifies which local
2096 /// variable declaration instantiations are present in this scope.
2097 ///
2098 /// A new instance of this class type will be created whenever we
2099 /// instantiate a new function declaration, which will have its own
2100 /// set of parameter declarations.
2101 class LocalInstantiationScope {
2102 /// \brief Reference to the semantic analysis that is performing
2103 /// this template instantiation.
2104 Sema &SemaRef;
2105
2106 /// \brief A mapping from local variable declarations that occur
2107 /// within a template to their instantiations.
2108 ///
2109 /// This mapping is used during instantiation to keep track of,
2110 /// e.g., function parameter and variable declarations. For example,
2111 /// given:
2112 ///
2113 /// \code
2114 /// template<typename T> T add(T x, T y) { return x + y; }
2115 /// \endcode
2116 ///
2117 /// when we instantiate add<int>, we will introduce a mapping from
2118 /// the ParmVarDecl for 'x' that occurs in the template to the
2119 /// instantiated ParmVarDecl for 'x'.
2120 llvm::DenseMap<VarDecl *, VarDecl *> LocalDecls;
2121
2122 /// \brief The outer scope, in which contains local variable
2123 /// definitions from some other instantiation (that is not
2124 /// relevant to this particular scope).
2125 LocalInstantiationScope *Outer;
2126
2127 // This class is non-copyable
2128 LocalInstantiationScope(const LocalInstantiationScope &);
2129 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
2130
2131 public:
2132 LocalInstantiationScope(Sema &SemaRef)
2133 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
2134 SemaRef.CurrentInstantiationScope = this;
2135 }
2136
2137 ~LocalInstantiationScope() {
2138 SemaRef.CurrentInstantiationScope = Outer;
2139 }
2140
2141 VarDecl *getInstantiationOf(VarDecl *Var) {
2142 VarDecl *Result = LocalDecls[Var];
2143 assert(Result && "Variable was not instantiated in this scope!");
2144 return Result;
2145 }
2146
2147 ParmVarDecl *getInstantiationOf(ParmVarDecl *Var) {
2148 return cast<ParmVarDecl>(getInstantiationOf(cast<VarDecl>(Var)));
2149 }
2150
2151 void InstantiatedLocal(VarDecl *Var, VarDecl *VarInst) {
2152 VarDecl *&Stored = LocalDecls[Var];
2153 assert(!Stored && "Already instantiated this local variable");
2154 Stored = VarInst;
2155 }
2156 };
2157
2158 /// \brief The current instantiation scope used to store local
2159 /// variables.
2160 LocalInstantiationScope *CurrentInstantiationScope;
2161
Douglas Gregor7e063902009-05-11 23:53:27 +00002162 QualType InstantiateType(QualType T, const TemplateArgumentList &TemplateArgs,
Douglas Gregor99ebf652009-02-27 19:31:52 +00002163 SourceLocation Loc, DeclarationName Entity);
Douglas Gregora0e500d2009-03-12 16:53:44 +00002164
2165 OwningExprResult InstantiateExpr(Expr *E,
Douglas Gregor7e063902009-05-11 23:53:27 +00002166 const TemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00002167
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002168 Decl *InstantiateDecl(Decl *D, DeclContext *Owner,
Douglas Gregor7e063902009-05-11 23:53:27 +00002169 const TemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002170
Douglas Gregor2943aed2009-03-03 04:44:36 +00002171 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00002172 InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
2173 CXXRecordDecl *Pattern,
Douglas Gregor7e063902009-05-11 23:53:27 +00002174 const TemplateArgumentList &TemplateArgs);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002175
2176 bool
2177 InstantiateClass(SourceLocation PointOfInstantiation,
2178 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002179 const TemplateArgumentList &TemplateArgs,
2180 bool ExplicitInstantiation);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002181
Douglas Gregor2943aed2009-03-03 04:44:36 +00002182 bool
2183 InstantiateClassTemplateSpecialization(
2184 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2185 bool ExplicitInstantiation);
Douglas Gregor99ebf652009-02-27 19:31:52 +00002186
Douglas Gregora58861f2009-05-13 20:28:22 +00002187 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
2188 CXXRecordDecl *Instantiation,
2189 const TemplateArgumentList &TemplateArgs);
2190
2191 void InstantiateClassTemplateSpecializationMembers(
2192 SourceLocation PointOfInstantiation,
2193 ClassTemplateSpecializationDecl *ClassTemplateSpec);
2194
Douglas Gregorab452ba2009-03-26 23:50:42 +00002195 NestedNameSpecifier *
2196 InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
2197 SourceRange Range,
Douglas Gregor7e063902009-05-11 23:53:27 +00002198 const TemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00002199
Douglas Gregorde650ae2009-03-31 18:38:02 +00002200 TemplateName
2201 InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregor7e063902009-05-11 23:53:27 +00002202 const TemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00002203
Douglas Gregora58861f2009-05-13 20:28:22 +00002204 void InstantiateFunctionDefinition(FunctionDecl *Function);
2205 void InstantiateVariableDefinition(VarDecl *Var);
2206
Anders Carlssona135fb42009-03-15 18:34:13 +00002207 // Simple function for cloning expressions.
2208 template<typename T>
2209 OwningExprResult Clone(T *E) {
2210 assert(!E->isValueDependent() && !E->isTypeDependent() &&
2211 "expression is value or type dependent!");
2212 return Owned(E->Clone(Context));
2213 }
2214
Steve Naroff3536b442007-09-06 21:24:23 +00002215 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002216 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
2217 IdentifierInfo *ClassName,
2218 SourceLocation ClassLoc,
2219 IdentifierInfo *SuperName,
2220 SourceLocation SuperLoc,
2221 const DeclPtrTy *ProtoRefs,
2222 unsigned NumProtoRefs,
2223 SourceLocation EndProtoLoc,
2224 AttributeList *AttrList);
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002225
Chris Lattnerb28317a2009-03-28 19:18:32 +00002226 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002227 SourceLocation AtCompatibilityAliasLoc,
2228 IdentifierInfo *AliasName, SourceLocation AliasLocation,
2229 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00002230
2231 void CheckForwardProtocolDeclarationForCircularDependency(
2232 IdentifierInfo *PName,
2233 SourceLocation &PLoc, SourceLocation PrevLoc,
2234 const ObjCList<ObjCProtocolDecl> &PList);
Steve Naroff3536b442007-09-06 21:24:23 +00002235
Chris Lattnerb28317a2009-03-28 19:18:32 +00002236 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002237 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002238 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002239 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00002240 SourceLocation EndProtoLoc,
2241 AttributeList *AttrList);
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002242
Chris Lattnerb28317a2009-03-28 19:18:32 +00002243 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
2244 IdentifierInfo *ClassName,
2245 SourceLocation ClassLoc,
2246 IdentifierInfo *CategoryName,
2247 SourceLocation CategoryLoc,
2248 const DeclPtrTy *ProtoRefs,
2249 unsigned NumProtoRefs,
2250 SourceLocation EndProtoLoc);
Fariborz Jahanianfd225cc2007-09-18 20:26:58 +00002251
Chris Lattnerb28317a2009-03-28 19:18:32 +00002252 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002253 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00002254 IdentifierInfo *ClassName, SourceLocation ClassLoc,
2255 IdentifierInfo *SuperClassname,
2256 SourceLocation SuperClassLoc);
2257
Chris Lattnerb28317a2009-03-28 19:18:32 +00002258 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00002259 SourceLocation AtCatImplLoc,
2260 IdentifierInfo *ClassName,
2261 SourceLocation ClassLoc,
2262 IdentifierInfo *CatName,
2263 SourceLocation CatLoc);
2264
Chris Lattnerb28317a2009-03-28 19:18:32 +00002265 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroff37e58d12007-10-02 22:39:18 +00002266 IdentifierInfo **IdentList,
2267 unsigned NumElts);
Fariborz Jahanian894c57f2007-09-21 15:40:54 +00002268
Chris Lattnerb28317a2009-03-28 19:18:32 +00002269 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002270 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00002271 unsigned NumElts,
2272 AttributeList *attrList);
Fariborz Jahanian245f92a2007-10-05 21:01:53 +00002273
Chris Lattnere13b9592008-07-26 04:03:38 +00002274 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002275 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002276 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002277 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002278
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00002279 /// Ensure attributes are consistent with type.
2280 /// \param [in, out] Attributes The attributes to check; they will
2281 /// be modified to be consistent with \arg PropertyTy.
2282 void CheckObjCPropertyAttributes(QualType PropertyTy,
2283 SourceLocation Loc,
2284 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00002285 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002286 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
2287 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00002288 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002289 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Fariborz Jahanianb5e02242008-04-24 19:58:34 +00002290
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002291 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002292 DeclPtrTy MergeProtocols);
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002293
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00002294 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
2295 ObjCInterfaceDecl *ID);
2296
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002297 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002298 ObjCProtocolDecl *PDecl);
2299
Chris Lattnerb28317a2009-03-28 19:18:32 +00002300 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
2301 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
2302 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00002303 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002304
Chris Lattnerb28317a2009-03-28 19:18:32 +00002305 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
2306 FieldDeclarator &FD, ObjCDeclSpec &ODS,
2307 Selector GetterSel, Selector SetterSel,
2308 DeclPtrTy ClassCategory,
2309 bool *OverridingProperty,
2310 tok::ObjCKeywordKind MethodImplKind);
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00002311
Chris Lattnerb28317a2009-03-28 19:18:32 +00002312 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
2313 SourceLocation PropertyLoc,
2314 bool ImplKind,DeclPtrTy ClassImplDecl,
2315 IdentifierInfo *PropertyId,
2316 IdentifierInfo *PropertyIvar);
Fariborz Jahanianf624f812008-04-18 00:19:30 +00002317
Chris Lattnerb28317a2009-03-28 19:18:32 +00002318 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00002319 SourceLocation BeginLoc, // location of the + or -.
2320 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +00002321 tok::TokenKind MethodType,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002322 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00002323 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00002324 // optional arguments. The number of types/arguments is obtained
2325 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00002326 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00002327 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00002328 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
2329 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00002330
Steve Narofff1afaf62009-02-26 15:55:06 +00002331 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
2332 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00002333 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00002334 // Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +00002335 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
2336 ObjCInterfaceDecl *CDecl);
2337 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
2338 ObjCInterfaceDecl *ClassDecl);
Steve Narofff1afaf62009-02-26 15:55:06 +00002339
Steve Naroff61f72cb2009-03-09 21:12:44 +00002340 virtual OwningExprResult ActOnClassPropertyRefExpr(
2341 IdentifierInfo &receiverName,
2342 IdentifierInfo &propertyName,
2343 SourceLocation &receiverNameLoc,
2344 SourceLocation &propertyNameLoc);
2345
Steve Naroff68d331a2007-09-27 14:38:14 +00002346 // ActOnClassMessage - used for both unary and keyword messages.
2347 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002348 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002349 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00002350 Scope *S,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002351 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
2352 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002353 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00002354
2355 // ActOnInstanceMessage - used for both unary and keyword messages.
2356 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002357 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002358 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00002359 ExprTy *receiver, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002360 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002361 ExprTy **ArgExprs, unsigned NumArgs);
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002362
2363 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
2364 virtual void ActOnPragmaPack(PragmaPackKind Kind,
2365 IdentifierInfo *Name,
2366 ExprTy *Alignment,
2367 SourceLocation PragmaLoc,
2368 SourceLocation LParenLoc,
2369 SourceLocation RParenLoc);
Chris Lattner574aa402009-02-17 01:09:29 +00002370
Ted Kremenek4726d032009-03-23 22:28:25 +00002371 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
2372 virtual void ActOnPragmaUnused(ExprTy **Exprs, unsigned NumExprs,
2373 SourceLocation PragmaLoc,
2374 SourceLocation LParenLoc,
2375 SourceLocation RParenLoc);
2376
Chris Lattner574aa402009-02-17 01:09:29 +00002377 /// getPragmaPackAlignment() - Return the current alignment as specified by
2378 /// the current #pragma pack directive, or 0 if none is currently active.
2379 unsigned getPragmaPackAlignment() const;
2380
2381 /// FreePackedContext - Deallocate and null out PackContext.
2382 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002383
Chris Lattner1e0a3902008-01-16 19:17:22 +00002384 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
2385 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002386 /// If isLvalue, the result of the cast is an lvalue.
2387 void ImpCastExprToType(Expr *&Expr, QualType Type, bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00002388
Reid Spencer5f016e22007-07-11 17:01:13 +00002389 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00002390 // functions and arrays to their respective pointers (C99 6.3.2.1).
2391 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00002392
Steve Naroffc80b4ee2007-07-16 21:54:35 +00002393 // DefaultFunctionArrayConversion - converts functions and arrays
2394 // to their respective pointers (C99 6.3.2.1).
2395 void DefaultFunctionArrayConversion(Expr *&expr);
Steve Naroff90045e82007-07-13 23:32:42 +00002396
Steve Naroffb291ab62007-08-28 23:30:39 +00002397 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
2398 // do not have a prototype. Integer promotions are performed on each
2399 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00002400 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00002401
2402 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
2403 enum VariadicCallType {
2404 VariadicFunction,
2405 VariadicBlock,
2406 VariadicMethod
2407 };
2408
2409 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
2410 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00002411 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Steve Naroffb291ab62007-08-28 23:30:39 +00002412
Reid Spencer5f016e22007-07-11 17:01:13 +00002413 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
2414 // operands and then handles various conversions that are common to binary
2415 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
2416 // routine returns the first non-arithmetic type found. The client is
2417 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002418 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
2419 bool isCompAssign = false);
Chris Lattnerb7b61152008-01-04 18:22:42 +00002420
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002421 /// UsualArithmeticConversionsType - handles the various conversions
2422 /// that are common to binary operators (C99 6.3.1.8, C++ [expr]p9)
2423 /// and returns the result type of that conversion.
2424 QualType UsualArithmeticConversionsType(QualType lhs, QualType rhs);
2425
2426
Chris Lattnerb7b61152008-01-04 18:22:42 +00002427 /// AssignConvertType - All of the 'assignment' semantic checks return this
2428 /// enum to indicate whether the assignment was allowed. These checks are
2429 /// done for simple assignments, as well as initialization, return from
2430 /// function, argument passing, etc. The query is phrased in terms of a
2431 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002432 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00002433 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00002434 Compatible,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002435
2436 /// PointerToInt - The assignment converts a pointer to an int, which we
2437 /// accept as an extension.
2438 PointerToInt,
2439
2440 /// IntToPointer - The assignment converts an int to a pointer, which we
2441 /// accept as an extension.
2442 IntToPointer,
2443
2444 /// FunctionVoidPointer - The assignment is between a function pointer and
2445 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00002446 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002447
2448 /// IncompatiblePointer - The assignment is between two pointers types that
2449 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00002450 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00002451
2452 /// IncompatiblePointer - The assignment is between two pointers types which
2453 /// point to integers which have a different sign, but are otherwise identical.
2454 /// This is a subset of the above, but broken out because it's by far the most
2455 /// common case of incompatible pointers.
2456 IncompatiblePointerSign,
2457
Chris Lattnerb7b61152008-01-04 18:22:42 +00002458 /// CompatiblePointerDiscardsQualifiers - The assignment discards
2459 /// c/v/r qualifiers, which we accept as an extension.
2460 CompatiblePointerDiscardsQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00002461
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00002462 /// IncompatibleVectors - The assignment is between two vector types that
2463 /// have the same size, which we accept as an extension.
2464 IncompatibleVectors,
2465
Steve Naroffbfdcae62008-09-04 15:31:07 +00002466 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002467 /// pointer. We disallow this.
2468 IntToBlockPointer,
2469
Steve Naroffbfdcae62008-09-04 15:31:07 +00002470 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002471 /// pointers types that are not compatible.
2472 IncompatibleBlockPointer,
2473
Steve Naroff39579072008-10-14 22:18:38 +00002474 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
2475 /// id type and something else (that is incompatible with it). For example,
2476 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
2477 IncompatibleObjCQualifiedId,
2478
Chris Lattnerb7b61152008-01-04 18:22:42 +00002479 /// Incompatible - We reject this conversion outright, it is invalid to
2480 /// represent it in the AST.
2481 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00002482 };
Chris Lattner5cf216b2008-01-04 18:04:52 +00002483
2484 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
2485 /// assignment conversion type specified by ConvTy. This returns true if the
2486 /// conversion was invalid or false if the conversion was accepted.
2487 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
2488 SourceLocation Loc,
2489 QualType DstType, QualType SrcType,
2490 Expr *SrcExpr, const char *Flavor);
2491
2492 /// CheckAssignmentConstraints - Perform type checking for assignment,
2493 /// argument passing, variable initialization, and function return values.
2494 /// This routine is only used by the following two methods. C99 6.5.16.
2495 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00002496
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002497 // CheckSingleAssignmentConstraints - Currently used by
Steve Naroff1b273c42007-09-16 14:56:35 +00002498 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00002499 // this routine performs the default function/array converions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002500 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
2501 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002502
2503 // \brief If the lhs type is a transparent union, check whether we
2504 // can initialize the transparent union with the given expression.
2505 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
2506 Expr *&rExpr);
2507
Steve Naroff90045e82007-07-13 23:32:42 +00002508 // CheckCompoundAssignmentConstraints - Type check without performing any
2509 // conversions. For compound assignments, the "Check...Operands" methods
2510 // perform the necessary conversions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002511 AssignConvertType CheckCompoundAssignmentConstraints(QualType lhs,
2512 QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00002513
Reid Spencer5f016e22007-07-11 17:01:13 +00002514 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner5cf216b2008-01-04 18:04:52 +00002515 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
2516 QualType rhsType);
Steve Naroff1c7d0672008-09-04 15:10:53 +00002517
2518 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002519 // block pointer types.
Steve Naroff1c7d0672008-09-04 15:10:53 +00002520 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
2521 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00002522
2523 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002524
Douglas Gregor45920e82008-12-19 17:40:08 +00002525 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00002526 const char *Flavor,
2527 bool AllowExplicit = false,
2528 bool Elidable = false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002529 bool PerformImplicitConversion(Expr *&From, QualType ToType,
2530 const ImplicitConversionSequence& ICS,
Douglas Gregor45920e82008-12-19 17:40:08 +00002531 const char *Flavor);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002532 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00002533 const StandardConversionSequence& SCS,
2534 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00002535
Reid Spencer5f016e22007-07-11 17:01:13 +00002536 /// the following "Check" methods will return a valid/converted QualType
2537 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00002538
2539 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00002540 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00002541 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002542 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00002543 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002544 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002545 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002546 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002547 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00002548 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00002549 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00002550 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00002551 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002552 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002553 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00002554 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00002555 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00002556 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002557 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00002558 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002559 // CheckAssignmentOperands is used for both simple and compound assignment.
2560 // For simple assignment, pass both expressions and a null converted type.
2561 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00002562 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00002563 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00002564 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00002565 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00002566 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00002567 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002568 QualType CXXCheckConditionalOperands( // C++ 5.16
2569 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002570 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00002571
2572 /// type checking for vector binary operators.
2573 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
2574 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
2575 SourceLocation l, bool isRel);
Reid Spencer5f016e22007-07-11 17:01:13 +00002576
Steve Narofff69936d2007-09-16 03:34:24 +00002577 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00002578 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00002579 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
2580 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002581 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
2582 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00002583 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002584
2585 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00002586 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002587 IdentifierInfo &Comp, SourceLocation CmpLoc);
2588
Steve Narofff0090632007-09-02 02:04:30 +00002589 /// type checking declaration initializers (C99 6.7.8)
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002590 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002591 SourceLocation InitLoc,DeclarationName InitEntity,
2592 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002593 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00002594 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroff2fdc3742007-12-10 22:44:33 +00002595
Douglas Gregor87fd7032009-02-02 17:43:21 +00002596 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002597
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002598 // type checking C++ declaration initializers (C++ [dcl.init]).
2599
2600 /// ReferenceCompareResult - Expresses the result of comparing two
2601 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
2602 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
2603 enum ReferenceCompareResult {
2604 /// Ref_Incompatible - The two types are incompatible, so direct
2605 /// reference binding is not possible.
2606 Ref_Incompatible = 0,
2607 /// Ref_Related - The two types are reference-related, which means
2608 /// that their unqualified forms (T1 and T2) are either the same
2609 /// or T1 is a base class of T2.
2610 Ref_Related,
2611 /// Ref_Compatible_With_Added_Qualification - The two types are
2612 /// reference-compatible with added qualification, meaning that
2613 /// they are reference-compatible and the qualifiers on T1 (cv1)
2614 /// are greater than the qualifiers on T2 (cv2).
2615 Ref_Compatible_With_Added_Qualification,
2616 /// Ref_Compatible - The two types are reference-compatible and
2617 /// have equivalent qualifiers (cv1 == cv2).
2618 Ref_Compatible
2619 };
2620
Douglas Gregor15da57e2008-10-29 02:00:59 +00002621 ReferenceCompareResult CompareReferenceRelationship(QualType T1, QualType T2,
2622 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002623
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002624 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00002625 ImplicitConversionSequence *ICS = 0,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002626 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +00002627 bool AllowExplicit = false,
2628 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002629
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002630 /// CheckCastTypes - Check type constraints for casting between types.
Daniel Dunbar58d5ebb2008-08-20 03:55:42 +00002631 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr);
Steve Naroffa49e1fa2008-01-22 00:55:40 +00002632
Anders Carlsson584b2472007-11-27 07:16:40 +00002633 // CheckVectorCast - check type constraints for vectors.
2634 // Since vectors are an extension, there are no C standard reference for this.
2635 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00002636 // returns true if the cast is invalid
2637 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
2638
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002639 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
2640 /// \param Method - May be null.
2641 /// \param [out] ReturnType - The return type of the send.
2642 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00002643 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00002644 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002645 SourceLocation lbrac, SourceLocation rbrac,
2646 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002647
2648 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
2649 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Steve Naroff81bfde92007-10-16 23:12:48 +00002650
Chris Lattnerf4021e72007-08-23 05:46:52 +00002651 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
2652 /// the specified width and sign. If an overflow occurs, detect it and emit
2653 /// the specified diagnostic.
2654 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
2655 unsigned NewWidth, bool NewSign,
2656 SourceLocation Loc, unsigned DiagID);
2657
Chris Lattnereca7be62008-04-07 05:30:13 +00002658 bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
2659 bool ForCompare);
2660
Anders Carlsson15281452008-11-04 16:57:32 +00002661 /// Checks that the Objective-C declaration is declared in the global scope.
2662 /// Emits an error and marks the declaration as invalid if it's not declared
2663 /// in the global scope.
2664 bool CheckObjCDeclScope(Decl *D);
2665
Anders Carlsson7c50aca2007-10-15 20:28:48 +00002666 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00002667
Anders Carlssone21555e2008-11-30 19:50:32 +00002668 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
2669 /// and reports the appropriate diagnostics. Returns false on success.
2670 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002671 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00002672
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002673 /// VerifyBitField - verifies that a bit field expression is an ICE and has
2674 /// the correct width, and that the field type is valid.
2675 /// Returns false on success.
2676 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
2677 QualType FieldTy, const Expr *BitWidth);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002678
Chris Lattner59907c42007-08-10 20:18:51 +00002679 //===--------------------------------------------------------------------===//
2680 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00002681private:
Sebastian Redl0eb23302009-01-19 00:08:26 +00002682 Action::OwningExprResult CheckFunctionCall(FunctionDecl *FDecl,
2683 CallExpr *TheCall);
Chris Lattner60800082009-02-18 17:49:48 +00002684 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
2685 unsigned ByteNo) const;
Chris Lattner69039812009-02-18 06:01:06 +00002686 bool CheckObjCString(Expr *Arg);
Chris Lattner925e60d2007-12-28 05:29:59 +00002687 bool SemaBuiltinVAStart(CallExpr *TheCall);
2688 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00002689 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002690 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Daniel Dunbar4493f792008-07-21 22:59:13 +00002691 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00002692 bool SemaBuiltinObjectSize(CallExpr *TheCall);
2693 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00002694 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00002695 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
2696 bool HasVAListArg, unsigned format_idx,
2697 unsigned firstDataArg);
2698 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
2699 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002700 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek082d9362009-03-20 21:35:28 +00002701 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002702 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00002703 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
2704 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00002705 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00002706};
2707
Mike Stumpb83d2872009-02-19 22:01:56 +00002708
Ted Kremenek8189cde2009-02-07 01:47:29 +00002709//===--------------------------------------------------------------------===//
2710// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
2711template <typename T>
2712class ExprOwningPtr : public Action::ExprArg {
2713public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00002714 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Ted Kremenek8189cde2009-02-07 01:47:29 +00002715
2716 void reset(T* p) { Action::ExprArg::operator=(p); }
2717 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
2718 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
2719 T* release() { return take(); }
2720
2721 T& operator*() const { return *get(); }
2722 T* operator->() const { return get(); }
2723};
2724
Reid Spencer5f016e22007-07-11 17:01:13 +00002725} // end namespace clang
2726
2727#endif