blob: bd41072d3a648c4666de0676100825b43b31cb05 [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 Gregord1102432009-08-28 17:37:35 +000021#include "SemaTemplate.h"
Douglas Gregore0762c92009-06-19 23:52:42 +000022#include "clang/AST/Attr.h"
Douglas Gregoreb11cd02009-01-14 22:20:51 +000023#include "clang/AST/DeclBase.h"
Douglas Gregore0762c92009-06-19 23:52:42 +000024#include "clang/AST/Decl.h"
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000025#include "clang/AST/DeclObjC.h"
Anders Carlsson1c5976e2009-06-05 03:43:12 +000026#include "clang/AST/DeclTemplate.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000027#include "clang/Parse/Action.h"
Chris Lattner500d3292009-01-29 05:15:15 +000028#include "clang/Sema/SemaDiagnostic.h"
Anders Carlssonc1fcb772007-07-22 07:07:56 +000029#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian85ff2642007-10-05 18:00:57 +000030#include "llvm/ADT/DenseSet.h"
Chris Lattnerf3876682007-10-07 01:13:46 +000031#include "llvm/ADT/SmallPtrSet.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000032#include "llvm/ADT/OwningPtr.h"
Douglas Gregorb33fe2f2009-06-30 17:20:14 +000033#include <deque>
Douglas Gregorac7610d2009-06-22 20:57:11 +000034#include <list>
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +000035#include <string>
Douglas Gregor94b1dd22008-10-24 04:54:22 +000036#include <vector>
Reid Spencer5f016e22007-07-11 17:01:13 +000037
Chris Lattnerf4021e72007-08-23 05:46:52 +000038namespace llvm {
39 class APSInt;
40}
41
Reid Spencer5f016e22007-07-11 17:01:13 +000042namespace clang {
43 class ASTContext;
Chris Lattner2ae34ed2008-02-06 00:46:58 +000044 class ASTConsumer;
Douglas Gregor81b747b2009-09-17 21:32:03 +000045 class CodeCompleteConsumer;
Reid Spencer5f016e22007-07-11 17:01:13 +000046 class Preprocessor;
47 class Decl;
Chris Lattnerb048c982008-04-06 04:47:34 +000048 class DeclContext;
Daniel Dunbar12bc6922008-08-11 03:27:53 +000049 class DeclSpec;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000050 class ExternalSemaSource;
Steve Naroffe8043c32008-04-01 23:04:06 +000051 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000052 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000053 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000054 class InitListExpr;
Nate Begeman2ef13e52009-08-10 23:49:36 +000055 class ParenListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000056 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000057 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000058 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class VarDecl;
60 class ParmVarDecl;
61 class TypedefDecl;
62 class FunctionDecl;
63 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000064 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000065 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000066 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000067 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000068 class ArrayType;
69 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000070 class SwitchStmt;
Sebastian Redl13e88542009-04-27 21:33:24 +000071 class CXXTryStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000072 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000073 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000074 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000075 class TemplateArgument;
John McCall833ca992009-10-29 08:12:44 +000076 class TemplateArgumentLoc;
Douglas Gregor7e063902009-05-11 23:53:27 +000077 class TemplateArgumentList;
Douglas Gregorddc29e12009-02-06 22:42:48 +000078 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000079 class TemplateTemplateParmDecl;
Douglas Gregorc8ab2562009-05-31 09:31:02 +000080 class ClassTemplatePartialSpecializationDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000081 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000082 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000083 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000084 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000085 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000086 class ObjCImplementationDecl;
87 class ObjCCategoryImplDecl;
88 class ObjCCategoryDecl;
89 class ObjCIvarDecl;
90 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000091 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000092 class ObjCContainerDecl;
Sebastian Redl4994d2d2009-07-04 11:39:00 +000093 class FunctionProtoType;
Douglas Gregora8f32e02009-10-06 17:59:45 +000094 class CXXBasePaths;
Anders Carlssonff6b3d62009-05-30 21:05:25 +000095 class CXXTemporary;
John McCall7d384dd2009-11-18 07:57:50 +000096 class LookupResult;
Steve Naroffbea0b342007-07-29 16:33:31 +000097
Chris Lattnerea29a3a2009-04-18 20:01:55 +000098/// BlockSemaInfo - When a block is being parsed, this contains information
99/// about the block. It is pointed to from Sema::CurBlock.
100struct BlockSemaInfo {
101 llvm::SmallVector<ParmVarDecl*, 8> Params;
102 bool hasPrototype;
103 bool isVariadic;
104 bool hasBlockDeclRefExprs;
Mike Stump1eb44332009-09-09 15:08:12 +0000105
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000106 BlockDecl *TheDecl;
Mike Stump1eb44332009-09-09 15:08:12 +0000107
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000108 /// TheScope - This is the scope for the block itself, which contains
109 /// arguments etc.
110 Scope *TheScope;
Mike Stump1eb44332009-09-09 15:08:12 +0000111
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000112 /// ReturnType - This will get set to block result type, by looking at
113 /// return types, if any, in the block body.
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +0000114 QualType ReturnType;
Mike Stump1eb44332009-09-09 15:08:12 +0000115
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000116 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
117 /// it (which acts like the label decl in some ways). Forward referenced
118 /// labels have a LabelStmt created for them with a null location & SubStmt.
119 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
Mike Stump1eb44332009-09-09 15:08:12 +0000120
Chris Lattnerbcfce662009-04-18 20:10:59 +0000121 /// SwitchStack - This is the current set of active switch statements in the
122 /// block.
123 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
Mike Stump1eb44332009-09-09 15:08:12 +0000124
Chris Lattner17a78302009-04-19 05:28:12 +0000125 /// SavedFunctionNeedsScopeChecking - This is the value of
126 /// CurFunctionNeedsScopeChecking at the point when the block started.
127 bool SavedFunctionNeedsScopeChecking;
Mike Stump1eb44332009-09-09 15:08:12 +0000128
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000129 /// PrevBlockInfo - If this is nested inside another block, this points
130 /// to the outer block.
131 BlockSemaInfo *PrevBlockInfo;
132};
133
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000134/// \brief Holds a QualType and a DeclaratorInfo* that came out of a declarator
135/// parsing.
136///
137/// LocInfoType is a "transient" type, only needed for passing to/from Parser
138/// and Sema, when we want to preserve type source info for a parsed type.
139/// It will not participate in the type system semantics in any way.
140class LocInfoType : public Type {
141 enum {
142 // The last number that can fit in Type's TC.
Mike Stump1eb44332009-09-09 15:08:12 +0000143 // Avoids conflict with an existing Type class.
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000144 LocInfo = (1 << TypeClassBitSize) - 1
145 };
146
147 DeclaratorInfo *DeclInfo;
148
149 LocInfoType(QualType ty, DeclaratorInfo *DInfo)
150 : Type((TypeClass)LocInfo, ty, ty->isDependentType()), DeclInfo(DInfo) {
151 assert(getTypeClass() == (TypeClass)LocInfo && "LocInfo didn't fit in TC?");
152 }
153 friend class Sema;
154
155public:
156 QualType getType() const { return getCanonicalTypeInternal(); }
157 DeclaratorInfo *getDeclaratorInfo() const { return DeclInfo; }
158
159 virtual void getAsStringInternal(std::string &Str,
160 const PrintingPolicy &Policy) const;
161
162 static bool classof(const Type *T) {
163 return T->getTypeClass() == (TypeClass)LocInfo;
164 }
165 static bool classof(const LocInfoType *) { return true; }
166};
167
Reid Spencer5f016e22007-07-11 17:01:13 +0000168/// Sema - This implements semantic analysis and AST building for C.
169class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +0000170 Sema(const Sema&); // DO NOT IMPLEMENT
171 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +0000172public:
Chris Lattner53ebff32009-01-22 19:21:44 +0000173 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +0000174 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +0000175 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000176 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +0000177 Diagnostic &Diags;
178 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +0000179
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000180 /// \brief Source of additional semantic information.
181 ExternalSemaSource *ExternalSource;
182
Douglas Gregor81b747b2009-09-17 21:32:03 +0000183 /// \brief Code-completion consumer.
184 CodeCompleteConsumer *CodeCompleter;
185
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000186 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +0000187 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +0000188
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000189 /// PreDeclaratorDC - Keeps the declaration context before switching to the
190 /// context of a declarator's nested-name-specifier.
191 DeclContext *PreDeclaratorDC;
192
Steve Naroff4eb206b2008-09-03 18:15:37 +0000193 /// CurBlock - If inside of a block definition, this contains a pointer to
194 /// the active block object that represents it.
195 BlockSemaInfo *CurBlock;
196
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000197 /// PackContext - Manages the stack for #pragma pack. An alignment
198 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000199 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000200
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000201 /// FunctionLabelMap - This is a mapping from label identifiers to the
202 /// LabelStmt for it (which acts like the label decl in some ways). Forward
203 /// referenced labels have a LabelStmt created for them with a null location &
204 /// SubStmt.
205 ///
206 /// Note that this should always be accessed through getLabelMap() in order
207 /// to handle blocks properly.
208 llvm::DenseMap<IdentifierInfo*, LabelStmt*> FunctionLabelMap;
Mike Stump1eb44332009-09-09 15:08:12 +0000209
Chris Lattnerbcfce662009-04-18 20:10:59 +0000210 /// FunctionSwitchStack - This is the current set of active switch statements
211 /// in the top level function. Clients should always use getSwitchStack() to
212 /// handle the case when they are in a block.
213 llvm::SmallVector<SwitchStmt*, 8> FunctionSwitchStack;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000214
Mike Stump1eb44332009-09-09 15:08:12 +0000215 /// ExprTemporaries - This is the stack of temporaries that are created by
Anders Carlsson165a0a02009-05-17 18:41:29 +0000216 /// the current full expression.
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000217 llvm::SmallVector<CXXTemporary*, 8> ExprTemporaries;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000218
Chris Lattner38c5ebd2009-04-19 05:21:20 +0000219 /// CurFunctionNeedsScopeChecking - This is set to true when a function or
220 /// ObjC method body contains a VLA or an ObjC try block, which introduce
221 /// scopes that need to be checked for goto conditions. If a function does
222 /// not contain this, then it need not have the jump checker run on it.
223 bool CurFunctionNeedsScopeChecking;
Mike Stump1eb44332009-09-09 15:08:12 +0000224
Nate Begeman213541a2008-04-18 23:10:10 +0000225 /// ExtVectorDecls - This is a list all the extended vector types. This allows
226 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000227 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000228 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Mike Stump1eb44332009-09-09 15:08:12 +0000229
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000230 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
231 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
232
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000233 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
Mike Stump1eb44332009-09-09 15:08:12 +0000234
235 /// PureVirtualClassDiagSet - a set of class declarations which we have
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000236 /// emitted a list of pure virtual functions. Used to prevent emitting the
237 /// same list more than once.
238 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
Mike Stump1eb44332009-09-09 15:08:12 +0000239
Douglas Gregor63935192009-03-02 00:19:53 +0000240 /// \brief A mapping from external names to the most recent
241 /// locally-scoped external declaration with that name.
242 ///
243 /// This map contains external declarations introduced in local
244 /// scoped, e.g.,
245 ///
246 /// \code
247 /// void f() {
248 /// void foo(int, int);
249 /// }
250 /// \endcode
251 ///
252 /// Here, the name "foo" will be associated with the declaration on
253 /// "foo" within f. This name is not visible outside of
254 /// "f". However, we still find it in two cases:
255 ///
256 /// - If we are declaring another external with the name "foo", we
257 /// can find "foo" as a previous declaration, so that the types
258 /// of this external declaration can be checked for
259 /// compatibility.
260 ///
261 /// - If we would implicitly declare "foo" (e.g., due to a call to
262 /// "foo" in C when no prototype or definition is visible), then
263 /// we find this declaration of "foo" and complain that it is
264 /// not visible.
265 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
266
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000267 /// \brief The set of tentative declarations seen so far in this
268 /// translation unit for which no definition has been seen.
269 ///
270 /// The tentative declarations are indexed by the name of the
271 /// declaration, and only the most recent tentative declaration for
272 /// a given variable will be recorded here.
273 llvm::DenseMap<DeclarationName, VarDecl *> TentativeDefinitions;
Chris Lattner63d65f82009-09-08 18:19:27 +0000274 std::vector<DeclarationName> TentativeDefinitionList;
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000275
John McCall54abf7d2009-11-04 02:18:39 +0000276 /// \brief The collection of delayed deprecation warnings.
277 llvm::SmallVector<std::pair<SourceLocation,NamedDecl*>, 8>
278 DelayedDeprecationWarnings;
279
280 /// \brief The depth of the current ParsingDeclaration stack.
281 /// If nonzero, we are currently parsing a declaration (and
282 /// hence should delay deprecation warnings).
283 unsigned ParsingDeclDepth;
284
Ryan Flynne25ff832009-07-30 03:15:39 +0000285 /// WeakUndeclaredIdentifiers - Identifiers contained in
286 /// #pragma weak before declared. rare. may alias another
287 /// identifier, declared or undeclared
288 class WeakInfo {
289 IdentifierInfo *alias; // alias (optional)
290 SourceLocation loc; // for diagnostics
291 bool used; // identifier later declared?
292 public:
293 WeakInfo()
294 : alias(0), loc(SourceLocation()), used(false) {}
295 WeakInfo(IdentifierInfo *Alias, SourceLocation Loc)
296 : alias(Alias), loc(Loc), used(false) {}
297 inline IdentifierInfo * getAlias() const { return alias; }
298 inline SourceLocation getLocation() const { return loc; }
299 void setUsed(bool Used=true) { used = Used; }
300 inline bool getUsed() { return used; }
301 bool operator==(WeakInfo RHS) const {
302 return alias == RHS.getAlias() && loc == RHS.getLocation();
303 }
304 bool operator!=(WeakInfo RHS) const { return !(*this == RHS); }
305 };
306 llvm::DenseMap<IdentifierInfo*,WeakInfo> WeakUndeclaredIdentifiers;
307
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000308 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
309 /// #pragma weak during processing of other Decls.
310 /// I couldn't figure out a clean way to generate these in-line, so
311 /// we store them here and handle separately -- which is a hack.
312 /// It would be best to refactor this.
313 llvm::SmallVector<Decl*,2> WeakTopLevelDecl;
314
Chris Lattner7f925cc2008-04-11 07:00:53 +0000315 IdentifierResolver IdResolver;
316
Steve Naroffe440eb82007-10-10 17:32:04 +0000317 /// Translation Unit Scope - useful to Objective-C actions that need
318 /// to lookup file scope declarations in the "ordinary" C decl namespace.
319 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000320 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000321
Douglas Gregor7adb10f2009-09-15 22:30:29 +0000322 /// \brief The C++ "std" namespace, where the standard library resides.
Sebastian Redlc42e1182008-11-11 11:37:55 +0000323 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000324
Douglas Gregor7adb10f2009-09-15 22:30:29 +0000325 /// \brief The C++ "std::bad_alloc" class, which is defined by the C++
326 /// standard library.
327 CXXRecordDecl *StdBadAlloc;
328
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000329 /// A flag to remember whether the implicit forms of operator new and delete
330 /// have been declared.
331 bool GlobalNewDeleteDeclared;
Douglas Gregorf807fe02009-04-14 16:27:31 +0000332
Douglas Gregor2afce722009-11-26 00:44:06 +0000333 /// \brief The set of declarations that have been referenced within
334 /// a potentially evaluated expression.
335 typedef std::vector<std::pair<SourceLocation, Decl *> >
Douglas Gregorac7610d2009-06-22 20:57:11 +0000336 PotentiallyReferencedDecls;
Mike Stump1eb44332009-09-09 15:08:12 +0000337
Douglas Gregor2afce722009-11-26 00:44:06 +0000338 /// \brief Data structure used to record current or nested
339 /// expression evaluation contexts.
340 struct ExpressionEvaluationContextRecord {
341 /// \brief The expression evaluation context.
342 ExpressionEvaluationContext Context;
343
344 /// \brief The number of temporaries that were active when we
345 /// entered this expression evaluation context.
346 unsigned NumTemporaries;
347
348 /// \brief The set of declarations referenced within a
349 /// potentially potentially-evaluated context.
350 ///
351 /// When leaving a potentially potentially-evaluated context, each
352 /// of these elements will be as referenced if the corresponding
353 /// potentially potentially evaluated expression is potentially
354 /// evaluated.
355 PotentiallyReferencedDecls *PotentiallyReferenced;
356
357 ExpressionEvaluationContextRecord(ExpressionEvaluationContext Context,
358 unsigned NumTemporaries)
359 : Context(Context), NumTemporaries(NumTemporaries),
360 PotentiallyReferenced(0) { }
361
362 void addReferencedDecl(SourceLocation Loc, Decl *Decl) {
363 if (!PotentiallyReferenced)
364 PotentiallyReferenced = new PotentiallyReferencedDecls;
365 PotentiallyReferenced->push_back(std::make_pair(Loc, Decl));
366 }
367
368 void Destroy() {
369 delete PotentiallyReferenced;
370 PotentiallyReferenced = 0;
371 }
372 };
373
374 /// A stack of expression evaluation contexts.
375 llvm::SmallVector<ExpressionEvaluationContextRecord, 8> ExprEvalContexts;
Mike Stump1eb44332009-09-09 15:08:12 +0000376
Douglas Gregorf807fe02009-04-14 16:27:31 +0000377 /// \brief Whether the code handled by Sema should be considered a
378 /// complete translation unit or not.
379 ///
380 /// When true (which is generally the case), Sema will perform
381 /// end-of-translation-unit semantic tasks (such as creating
382 /// initializers for tentative definitions in C) once parsing has
383 /// completed. This flag will be false when building PCH files,
384 /// since a PCH file is by definition not a complete translation
385 /// unit.
386 bool CompleteTranslationUnit;
387
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000388 llvm::BumpPtrAllocator BumpAlloc;
389
Douglas Gregorbb260412009-06-14 08:02:22 +0000390 /// \brief The number of SFINAE diagnostics that have been trapped.
391 unsigned NumSFINAEErrors;
392
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000393 typedef llvm::DenseMap<Selector, ObjCMethodList> MethodPool;
394
Steve Naroff58ff9e82007-10-14 00:58:41 +0000395 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
396 /// messages to "id". We need to maintain a list, since selectors can have
Mike Stump1eb44332009-09-09 15:08:12 +0000397 /// differing signatures across classes. In Cocoa, this happens to be
Steve Naroff58ff9e82007-10-14 00:58:41 +0000398 /// extremely uncommon (only 1% of selectors are "overloaded").
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000399 MethodPool InstanceMethodPool;
400 MethodPool FactoryMethodPool;
Mike Stump1eb44332009-09-09 15:08:12 +0000401
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000402 MethodPool::iterator ReadMethodPool(Selector Sel, bool isInstance);
403
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000404 /// Private Helper predicate to check for 'self'.
405 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000406public:
Douglas Gregorf807fe02009-04-14 16:27:31 +0000407 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Daniel Dunbar3a2838d2009-11-13 08:58:20 +0000408 bool CompleteTranslationUnit = true,
409 CodeCompleteConsumer *CompletionConsumer = 0);
Chris Lattner574aa402009-02-17 01:09:29 +0000410 ~Sema() {
411 if (PackContext) FreePackedContext();
412 }
Mike Stump1eb44332009-09-09 15:08:12 +0000413
Chris Lattner53ebff32009-01-22 19:21:44 +0000414 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000415 Diagnostic &getDiagnostics() const { return Diags; }
416 SourceManager &getSourceManager() const { return SourceMgr; }
417
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000418 /// \brief Helper class that creates diagnostics with optional
419 /// template instantiation stacks.
420 ///
421 /// This class provides a wrapper around the basic DiagnosticBuilder
422 /// class that emits diagnostics. SemaDiagnosticBuilder is
423 /// responsible for emitting the diagnostic (as DiagnosticBuilder
424 /// does) and, if the diagnostic comes from inside a template
425 /// instantiation, printing the template instantiation stack as
426 /// well.
427 class SemaDiagnosticBuilder : public DiagnosticBuilder {
428 Sema &SemaRef;
429 unsigned DiagID;
430
431 public:
432 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
433 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
434
Mike Stump1eb44332009-09-09 15:08:12 +0000435 explicit SemaDiagnosticBuilder(Sema &SemaRef)
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000436 : DiagnosticBuilder(DiagnosticBuilder::Suppress), SemaRef(SemaRef) { }
437
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000438 ~SemaDiagnosticBuilder();
439 };
440
441 /// \brief Emit a diagnostic.
442 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000443 if (isSFINAEContext() && Diagnostic::isBuiltinSFINAEDiag(DiagID)) {
444 // If we encountered an error during template argument
445 // deduction, and that error is one of the SFINAE errors,
Douglas Gregorbb260412009-06-14 08:02:22 +0000446 // suppress the diagnostic.
Douglas Gregor8439fac2009-06-15 16:52:15 +0000447 ++NumSFINAEErrors;
Douglas Gregor0b60d9e2009-09-25 23:53:26 +0000448 Diags.setLastDiagnosticIgnored();
Douglas Gregor8439fac2009-06-15 16:52:15 +0000449 return SemaDiagnosticBuilder(*this);
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000450 }
451
Douglas Gregoree1828a2009-03-10 18:03:33 +0000452 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000453 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000454 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000455
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000456 /// \brief Emit a partial diagnostic.
457 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
458
Chris Lattner394a3fd2007-08-31 04:53:24 +0000459 virtual void DeleteExpr(ExprTy *E);
460 virtual void DeleteStmt(StmtTy *S);
461
John McCall129e2df2009-11-30 22:42:35 +0000462 OwningExprResult Owned(Expr* E) {
463 assert(!E || E->isRetained());
464 return OwningExprResult(*this, E);
465 }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000466 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000467 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000468 return ExprError();
John McCall129e2df2009-11-30 22:42:35 +0000469 assert(!R.get() || ((Expr*) R.get())->isRetained());
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000470 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000471 }
John McCall129e2df2009-11-30 22:42:35 +0000472 OwningStmtResult Owned(Stmt* S) {
473 assert(!S || S->isRetained());
474 return OwningStmtResult(*this, S);
475 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000476
Chris Lattner9299f3f2008-08-23 03:19:52 +0000477 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000478
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000479 /// getLabelMap() - Return the current label map. If we're in a block, we
480 /// return it.
481 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
482 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
483 }
Mike Stump1eb44332009-09-09 15:08:12 +0000484
Chris Lattnerbcfce662009-04-18 20:10:59 +0000485 /// getSwitchStack - This is returns the switch stack for the current block or
486 /// function.
487 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
488 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
489 }
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000490
491 /// WeakTopLevelDeclDecls - access to #pragma weak-generated Decls
492 llvm::SmallVector<Decl*,2> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
Mike Stump1eb44332009-09-09 15:08:12 +0000493
Douglas Gregor2e222532009-07-02 17:08:52 +0000494 virtual void ActOnComment(SourceRange Comment);
495
Reid Spencer5f016e22007-07-11 17:01:13 +0000496 //===--------------------------------------------------------------------===//
497 // Type Analysis / Processing: SemaType.cpp.
498 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000499 QualType adjustParameterType(QualType T);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000500 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Mike Stump1eb44332009-09-09 15:08:12 +0000501 QualType BuildPointerType(QualType T, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000502 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000503 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000504 SourceLocation Loc, DeclarationName Entity);
505 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
506 Expr *ArraySize, unsigned Quals,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +0000507 SourceRange Brackets, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000508 QualType BuildExtVectorType(QualType T, ExprArg ArraySize,
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000509 SourceLocation AttrLoc);
Douglas Gregor724651c2009-02-28 01:04:19 +0000510 QualType BuildFunctionType(QualType T,
511 QualType *ParamTypes, unsigned NumParamTypes,
512 bool Variadic, unsigned Quals,
513 SourceLocation Loc, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000514 QualType BuildMemberPointerType(QualType T, QualType Class,
515 unsigned Quals, SourceLocation Loc,
Douglas Gregor949bf692009-06-09 22:17:39 +0000516 DeclarationName Entity);
Anders Carlsson9a917e42009-06-12 22:56:54 +0000517 QualType BuildBlockPointerType(QualType T, unsigned Quals,
518 SourceLocation Loc, DeclarationName Entity);
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000519 QualType GetTypeForDeclarator(Declarator &D, Scope *S,
520 DeclaratorInfo **DInfo = 0,
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000521 TagDecl **OwnedDecl = 0);
522 DeclaratorInfo *GetDeclaratorInfoForDeclarator(Declarator &D, QualType T);
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000523 /// \brief Create a LocInfoType to hold the given QualType and DeclaratorInfo.
524 QualType CreateLocInfoType(QualType T, DeclaratorInfo *DInfo);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000525 DeclarationName GetNameForDeclarator(Declarator &D);
John McCall129e2df2009-11-30 22:42:35 +0000526 DeclarationName GetNameFromUnqualifiedId(const UnqualifiedId &Name);
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000527 static QualType GetTypeFromParser(TypeTy *Ty, DeclaratorInfo **DInfo = 0);
Sebastian Redlef65f062009-05-29 18:02:33 +0000528 bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
Sebastian Redl6a7330c2009-05-29 15:01:05 +0000529 bool CheckDistantExceptionSpec(QualType T);
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000530 bool CheckEquivalentExceptionSpec(
531 const FunctionProtoType *Old, SourceLocation OldLoc,
532 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000533 bool CheckEquivalentExceptionSpec(
534 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redldced2262009-10-11 09:03:14 +0000535 const FunctionProtoType *Old, SourceLocation OldLoc,
536 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000537 bool CheckExceptionSpecSubset(
538 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redl23c7d062009-07-07 20:29:57 +0000539 const FunctionProtoType *Superset, SourceLocation SuperLoc,
540 const FunctionProtoType *Subset, SourceLocation SubLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000541 bool CheckParamExceptionSpec(const PartialDiagnostic & NoteID,
Sebastian Redldced2262009-10-11 09:03:14 +0000542 const FunctionProtoType *Target, SourceLocation TargetLoc,
543 const FunctionProtoType *Source, SourceLocation SourceLoc);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000544
Chris Lattnerb28317a2009-03-28 19:18:32 +0000545 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000546
Douglas Gregor57373262008-10-22 14:17:15 +0000547 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
548
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000549 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000550
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000551 bool RequireCompleteType(SourceLocation Loc, QualType T,
Anders Carlsson8c8d9192009-10-09 23:51:55 +0000552 const PartialDiagnostic &PD,
553 std::pair<SourceLocation,
554 PartialDiagnostic> Note =
555 std::make_pair(SourceLocation(), PDiag()));
Mike Stump1eb44332009-09-09 15:08:12 +0000556
Douglas Gregore6258932009-03-19 00:39:20 +0000557 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
558
Anders Carlssonaf017e62009-06-29 22:58:55 +0000559 QualType BuildTypeofExprType(Expr *E);
560 QualType BuildDecltypeType(Expr *E);
Mike Stump1eb44332009-09-09 15:08:12 +0000561
Reid Spencer5f016e22007-07-11 17:01:13 +0000562 //===--------------------------------------------------------------------===//
563 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
564 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000565
566 /// getDeclName - Return a pretty name for the specified decl if possible, or
Mike Stump1eb44332009-09-09 15:08:12 +0000567 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000568 virtual std::string getDeclName(DeclPtrTy D);
Mike Stump1eb44332009-09-09 15:08:12 +0000569
Chris Lattner682bf922009-03-29 16:50:03 +0000570 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
571
Mike Stump1eb44332009-09-09 15:08:12 +0000572 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregor42c39f32009-08-26 18:27:52 +0000573 Scope *S, const CXXScopeSpec *SS,
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000574 bool isClassName = false,
575 TypeTy *ObjectType = 0);
Chris Lattner4c97d762009-04-12 21:49:30 +0000576 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
Douglas Gregora786fdb2009-10-13 23:27:22 +0000577 virtual bool DiagnoseUnknownTypeName(const IdentifierInfo &II,
578 SourceLocation IILoc,
579 Scope *S,
580 const CXXScopeSpec *SS,
581 TypeTy *&SuggestedType);
582
Chris Lattner682bf922009-03-29 16:50:03 +0000583 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregore542c862009-06-23 23:11:28 +0000584 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this), false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000585 }
Mike Stump1eb44332009-09-09 15:08:12 +0000586
587 DeclPtrTy HandleDeclarator(Scope *S, Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +0000588 MultiTemplateParamsArg TemplateParameterLists,
589 bool IsFunctionDefinition);
John McCall68263142009-11-18 22:49:29 +0000590 void RegisterLocallyScopedExternCDecl(NamedDecl *ND,
591 const LookupResult &Previous,
Douglas Gregor63935192009-03-02 00:19:53 +0000592 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000593 void DiagnoseFunctionSpecifiers(Declarator& D);
John McCall68263142009-11-18 22:49:29 +0000594 bool CheckRedeclaration(DeclContext *DC,
595 DeclarationName Name,
596 SourceLocation NameLoc,
597 unsigned Diagnostic);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000598 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000599 QualType R, DeclaratorInfo *DInfo,
John McCall68263142009-11-18 22:49:29 +0000600 LookupResult &Previous, bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000601 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000602 QualType R, DeclaratorInfo *DInfo,
John McCall68263142009-11-18 22:49:29 +0000603 LookupResult &Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +0000604 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000605 bool &Redeclaration);
John McCall68263142009-11-18 22:49:29 +0000606 void CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000607 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000608 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000609 QualType R, DeclaratorInfo *DInfo,
John McCall68263142009-11-18 22:49:29 +0000610 LookupResult &Previous,
Douglas Gregore542c862009-06-23 23:11:28 +0000611 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregor04495c82009-02-24 01:23:02 +0000612 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000613 bool &Redeclaration);
Sebastian Redla165da02009-11-18 21:51:29 +0000614 void AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
John McCall68263142009-11-18 22:49:29 +0000615 void CheckFunctionDeclaration(FunctionDecl *NewFD, LookupResult &Previous,
Douglas Gregorfd056bc2009-10-13 16:30:37 +0000616 bool IsExplicitSpecialization,
Mike Stump1eb44332009-09-09 15:08:12 +0000617 bool &Redeclaration,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000618 bool &OverloadableAttrRequired);
John McCall8c4859a2009-07-24 03:03:21 +0000619 void CheckMain(FunctionDecl *FD);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000620 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
621 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000622 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000623 ExprArg defarg);
Mike Stump1eb44332009-09-09 15:08:12 +0000624 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000625 SourceLocation EqualLoc,
626 SourceLocation ArgLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000627 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
Anders Carlssoned961f92009-08-25 02:29:20 +0000628 bool SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
629 SourceLocation EqualLoc);
630
Mike Stump1eb44332009-09-09 15:08:12 +0000631
Anders Carlsson5e300d12009-06-12 16:51:40 +0000632 // Contains the locations of the beginning of unparsed default
633 // argument locations.
634 llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
635
Anders Carlsson9abf2ae2009-08-16 05:13:48 +0000636 virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000637 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
Anders Carlsson6a75cd92009-07-11 00:34:39 +0000638 void ActOnUninitializedDecl(DeclPtrTy dcl, bool TypeContainsUndeducedAuto);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000639 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000640 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
641 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +0000642 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000643 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
644 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000645 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
646 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
647 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000648
Chris Lattnerb28317a2009-03-28 19:18:32 +0000649 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Douglas Gregore2c31ff2009-05-15 17:59:04 +0000650 DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body,
651 bool IsInstantiation);
Mike Stump1eb44332009-09-09 15:08:12 +0000652
Douglas Gregore0762c92009-06-19 23:52:42 +0000653 /// \brief Diagnose any unused parameters in the given sequence of
654 /// ParmVarDecl pointers.
655 template<typename InputIterator>
656 void DiagnoseUnusedParameters(InputIterator Param, InputIterator ParamEnd) {
657 for (; Param != ParamEnd; ++Param) {
Mike Stump1eb44332009-09-09 15:08:12 +0000658 if (!(*Param)->isUsed() && (*Param)->getDeclName() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000659 !(*Param)->template hasAttr<UnusedAttr>())
Douglas Gregore0762c92009-06-19 23:52:42 +0000660 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
661 << (*Param)->getDeclName();
662 }
663 }
Mike Stump1eb44332009-09-09 15:08:12 +0000664
Chris Lattner5af280c2009-04-19 04:46:21 +0000665 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000666 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000667
Steve Naroffb216c882007-10-09 22:01:59 +0000668 /// Scope actions.
669 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
670 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000671
672 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
673 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000674 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Mike Stump1eb44332009-09-09 15:08:12 +0000675
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000676 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
677 RecordDecl *AnonRecord);
Mike Stump1eb44332009-09-09 15:08:12 +0000678 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000679 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000680
Mike Stump1eb44332009-09-09 15:08:12 +0000681 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000682 TagDecl::TagKind NewTag,
683 SourceLocation NewTagLoc,
684 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000685
John McCall0f434ec2009-07-31 02:45:11 +0000686 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000687 SourceLocation KWLoc, const CXXScopeSpec &SS,
688 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +0000689 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000690 MultiTemplateParamsArg TemplateParameterLists,
John McCallc4e70192009-09-11 04:59:25 +0000691 bool &OwnedDecl, bool &IsDependent);
692
693 virtual TypeResult ActOnDependentTag(Scope *S,
694 unsigned TagSpec,
695 TagUseKind TUK,
696 const CXXScopeSpec &SS,
697 IdentifierInfo *Name,
698 SourceLocation TagLoc,
699 SourceLocation NameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000700
Chris Lattnerb28317a2009-03-28 19:18:32 +0000701 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000702 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000703 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
704 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
705 SourceLocation DeclStart,
706 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000707
708 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000709 Declarator &D, Expr *BitfieldWidth,
710 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000711
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000712 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
Mike Stump1eb44332009-09-09 15:08:12 +0000713 DeclaratorInfo *DInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000714 RecordDecl *Record, SourceLocation Loc,
715 bool Mutable, Expr *BitfieldWidth,
Steve Naroffea218b82009-07-14 14:58:18 +0000716 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000717 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000718 Declarator *D = 0);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000719
720 enum CXXSpecialMember {
721 CXXDefaultConstructor = 0,
722 CXXCopyConstructor = 1,
723 CXXCopyAssignment = 2,
724 CXXDestructor = 3
725 };
726 void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
Mike Stump1eb44332009-09-09 15:08:12 +0000727
Chris Lattnerb28317a2009-03-28 19:18:32 +0000728 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +0000729 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000730 Declarator &D, ExprTy *BitfieldWidth,
731 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000732
Steve Narofff13271f2007-09-14 23:09:53 +0000733 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000734 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000735 SourceLocation RecLoc, DeclPtrTy TagDecl,
736 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000737 SourceLocation LBrac, SourceLocation RBrac,
738 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000739
740 /// ActOnTagStartDefinition - Invoked when we have entered the
741 /// scope of a tag's definition (e.g., for an enumeration, class,
742 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000743 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000744
745 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
746 /// the definition of a tag (enumeration, class, struct, or union).
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +0000747 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
748 SourceLocation RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +0000749
Douglas Gregor879fd492009-03-17 19:05:46 +0000750 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
751 EnumConstantDecl *LastEnumConst,
752 SourceLocation IdLoc,
753 IdentifierInfo *Id,
754 ExprArg val);
755
Chris Lattnerb28317a2009-03-28 19:18:32 +0000756 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
757 DeclPtrTy LastEnumConstant,
758 SourceLocation IdLoc, IdentifierInfo *Id,
759 SourceLocation EqualLoc, ExprTy *Val);
Mike Stumpc6e35aa2009-05-16 07:06:02 +0000760 virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
761 SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
Edward O'Callaghanfee13812009-08-08 14:36:57 +0000762 DeclPtrTy *Elements, unsigned NumElements,
763 Scope *S, AttributeList *Attr);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000764
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000765 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000766
Chris Lattner0ed844b2008-04-04 06:12:32 +0000767 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000768 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000769 void PopDeclContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000770
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000771 /// EnterDeclaratorContext - Used when we must lookup names in the context
772 /// of a declarator's nested name specifier.
773 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
774 void ExitDeclaratorContext(Scope *S);
Mike Stump1eb44332009-09-09 15:08:12 +0000775
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000776 DeclContext *getFunctionLevelDeclContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000777
Chris Lattner371f2582008-12-04 23:50:19 +0000778 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
779 /// to the function decl for the function being parsed. If we're currently
780 /// in a 'block', this returns the containing context.
781 FunctionDecl *getCurFunctionDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000782
Chris Lattner371f2582008-12-04 23:50:19 +0000783 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
784 /// the method decl for the method being parsed. If we're currently
785 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000786 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000787
Chris Lattner371f2582008-12-04 23:50:19 +0000788 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
789 /// or C function we're in, otherwise return null. If we're currently
790 /// in a 'block', this returns the containing context.
791 NamedDecl *getCurFunctionOrMethodDecl();
792
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000793 /// Add this decl to the scope shadowed decl chains.
John McCallab88d972009-08-31 22:39:49 +0000794 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000795
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000796 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
797 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
798 /// true if 'D' belongs to the given declaration context.
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000799 bool isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S = 0);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000800
John McCallab88d972009-08-31 22:39:49 +0000801 /// Finds the scope corresponding to the given decl context, if it
802 /// happens to be an enclosing scope. Otherwise return NULL.
803 Scope *getScopeForDeclContext(Scope *S, DeclContext *DC) {
John McCall1a26c272009-09-02 01:07:03 +0000804 DeclContext *TargetDC = DC->getPrimaryContext();
John McCallab88d972009-08-31 22:39:49 +0000805 do {
John McCall1a26c272009-09-02 01:07:03 +0000806 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity())
807 if (ScopeDC->getPrimaryContext() == TargetDC)
808 return S;
John McCallab88d972009-08-31 22:39:49 +0000809 } while ((S = S->getParent()));
810
811 return NULL;
812 }
813
Fariborz Jahanian34acd3e2009-09-15 19:12:21 +0000814 /// OverloadingResult - Capture the result of performing overload
815 /// resolution.
816 enum OverloadingResult {
817 OR_Success, ///< Overload resolution succeeded.
818 OR_No_Viable_Function, ///< No viable function found.
819 OR_Ambiguous, ///< Ambiguous candidates found.
820 OR_Deleted ///< Overload resoltuion refers to a deleted function.
821 };
822
Eli Friedman8f17b662009-02-28 05:41:13 +0000823
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000824 /// Subroutines of ActOnDeclarator().
John McCallba6a9bd2009-10-24 08:00:42 +0000825 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
826 DeclaratorInfo *DInfo);
John McCall68263142009-11-18 22:49:29 +0000827 void MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000828 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000829 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
John McCall68263142009-11-18 22:49:29 +0000830 void MergeVarDecl(VarDecl *New, LookupResult &OldDecls);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000831 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000832
833 /// C++ Overloading.
John McCall68263142009-11-18 22:49:29 +0000834 bool IsOverload(FunctionDecl *New, LookupResult &OldDecls,
835 NamedDecl *&OldDecl);
836 bool IsOverload(FunctionDecl *New, FunctionDecl *Old);
837
Mike Stump1eb44332009-09-09 15:08:12 +0000838 ImplicitConversionSequence
Anders Carlsson2974b5c2009-08-27 17:14:02 +0000839 TryImplicitConversion(Expr* From, QualType ToType,
Anders Carlssonda7a18b2009-08-27 17:24:15 +0000840 bool SuppressUserConversions,
841 bool AllowExplicit,
Anders Carlsson08972922009-08-28 15:33:32 +0000842 bool ForceRValue,
Fariborz Jahanian249cead2009-10-01 20:39:51 +0000843 bool InOverloadResolution,
844 bool UserCast = false);
Anders Carlsson08972922009-08-28 15:33:32 +0000845 bool IsStandardConversion(Expr *From, QualType ToType,
846 bool InOverloadResolution,
Douglas Gregor60d62c22008-10-31 16:23:19 +0000847 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000848 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
849 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000850 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000851 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Anders Carlsson08972922009-08-28 15:33:32 +0000852 bool InOverloadResolution,
Douglas Gregor45920e82008-12-19 17:40:08 +0000853 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000854 bool isObjCPointerConversion(QualType FromType, QualType ToType,
855 QualType& ConvertedType, bool &IncompatibleObjC);
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000856 bool CheckPointerConversion(Expr *From, QualType ToType,
857 CastExpr::CastKind &Kind,
858 bool IgnoreBaseAccess);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000859 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregorce940492009-09-25 04:25:58 +0000860 bool InOverloadResolution,
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000861 QualType &ConvertedType);
Anders Carlsson27a5b9b2009-08-22 23:33:40 +0000862 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000863 CastExpr::CastKind &Kind,
864 bool IgnoreBaseAccess);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000865 bool IsQualificationConversion(QualType FromType, QualType ToType);
Fariborz Jahanian34acd3e2009-09-15 19:12:21 +0000866 OverloadingResult IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000867 UserDefinedConversionSequence& User,
Fariborz Jahanian78cf9a22009-09-15 00:10:11 +0000868 OverloadCandidateSet& Conversions,
Douglas Gregor734d9862009-01-30 23:27:23 +0000869 bool AllowConversionFunctions,
Fariborz Jahanian249cead2009-10-01 20:39:51 +0000870 bool AllowExplicit, bool ForceRValue,
871 bool UserCast = false);
Fariborz Jahaniancc5306a2009-11-18 18:26:29 +0000872 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
Fariborz Jahanian17c7a5d2009-09-22 20:24:30 +0000873
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000874
Mike Stump1eb44332009-09-09 15:08:12 +0000875 ImplicitConversionSequence::CompareKind
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000876 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
877 const ImplicitConversionSequence& ICS2);
878
Mike Stump1eb44332009-09-09 15:08:12 +0000879 ImplicitConversionSequence::CompareKind
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000880 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
881 const StandardConversionSequence& SCS2);
882
Mike Stump1eb44332009-09-09 15:08:12 +0000883 ImplicitConversionSequence::CompareKind
Douglas Gregor57373262008-10-22 14:17:15 +0000884 CompareQualificationConversions(const StandardConversionSequence& SCS1,
885 const StandardConversionSequence& SCS2);
886
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000887 ImplicitConversionSequence::CompareKind
888 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
889 const StandardConversionSequence& SCS2);
890
Mike Stump1eb44332009-09-09 15:08:12 +0000891 ImplicitConversionSequence
Douglas Gregor225c41e2008-11-03 19:09:14 +0000892 TryCopyInitialization(Expr* From, QualType ToType,
Anders Carlsson7b361b52009-08-27 17:37:39 +0000893 bool SuppressUserConversions, bool ForceRValue,
894 bool InOverloadResolution);
Mike Stump1eb44332009-09-09 15:08:12 +0000895 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000896 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000897
Douglas Gregor96176b32008-11-18 23:14:02 +0000898 ImplicitConversionSequence
899 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
900 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
901
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000902 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
903 bool PerformContextuallyConvertToBool(Expr *&From);
Mike Stump1eb44332009-09-09 15:08:12 +0000904
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000905 bool PerformObjectMemberConversion(Expr *&From, NamedDecl *Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000906
John McCall6ff07852009-08-07 22:18:02 +0000907 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
908 // TODO: make this is a typesafe union.
909 typedef llvm::SmallPtrSet<DeclContext *, 16> AssociatedNamespaceSet;
910
Douglas Gregor364e0212009-06-27 21:05:07 +0000911 typedef llvm::SmallPtrSet<AnyFunctionDecl, 16> FunctionSet;
Douglas Gregor063daf62009-03-13 18:40:31 +0000912 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
913
Mike Stump1eb44332009-09-09 15:08:12 +0000914 void AddOverloadCandidate(FunctionDecl *Function,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000915 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000916 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000917 bool SuppressUserConversions = false,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000918 bool ForceRValue = false,
919 bool PartialOverloading = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000920 void AddFunctionCandidates(const FunctionSet &Functions,
921 Expr **Args, unsigned NumArgs,
922 OverloadCandidateSet& CandidateSet,
923 bool SuppressUserConversions = false);
John McCall314be4e2009-11-17 07:50:12 +0000924 void AddMethodCandidate(NamedDecl *Decl,
925 Expr *Object, Expr **Args, unsigned NumArgs,
926 OverloadCandidateSet& CandidateSet,
927 bool SuppressUserConversion = false,
928 bool ForceRValue = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000929 void AddMethodCandidate(CXXMethodDecl *Method,
930 Expr *Object, Expr **Args, unsigned NumArgs,
931 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000932 bool SuppressUserConversions = false,
933 bool ForceRValue = false);
Douglas Gregor6b906862009-08-21 00:16:32 +0000934 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
John McCalld5532b62009-11-23 01:53:49 +0000935 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor6b906862009-08-21 00:16:32 +0000936 Expr *Object, Expr **Args, unsigned NumArgs,
937 OverloadCandidateSet& CandidateSet,
938 bool SuppressUserConversions = false,
939 bool ForceRValue = false);
Douglas Gregore53060f2009-06-25 22:08:12 +0000940 void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +0000941 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +0000942 Expr **Args, unsigned NumArgs,
943 OverloadCandidateSet& CandidateSet,
944 bool SuppressUserConversions = false,
945 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000946 void AddConversionCandidate(CXXConversionDecl *Conversion,
947 Expr *From, QualType ToType,
948 OverloadCandidateSet& CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +0000949 void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
950 Expr *From, QualType ToType,
951 OverloadCandidateSet &CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000952 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000953 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000954 Expr *Object, Expr **Args, unsigned NumArgs,
955 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000956 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000957 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000958 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000959 OverloadCandidateSet& CandidateSet,
960 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000961 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
962 SourceLocation OpLoc,
963 Expr **Args, unsigned NumArgs,
964 OverloadCandidateSet& CandidateSet,
965 SourceRange OpRange = SourceRange());
Mike Stump1eb44332009-09-09 15:08:12 +0000966 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000967 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000968 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000969 bool IsAssignmentOperator = false,
970 unsigned NumContextualBoolArguments = 0);
Mike Stump1eb44332009-09-09 15:08:12 +0000971 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
Douglas Gregor573d9c32009-10-21 23:19:44 +0000972 SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000973 Expr **Args, unsigned NumArgs,
Douglas Gregor74253732008-11-19 15:42:04 +0000974 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000975 void AddArgumentDependentLookupCandidates(DeclarationName Name,
976 Expr **Args, unsigned NumArgs,
John McCalld5532b62009-11-23 01:53:49 +0000977 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000978 OverloadCandidateSet& CandidateSet,
979 bool PartialOverloading = false);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000980 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
981 const OverloadCandidate& Cand2);
982 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
Douglas Gregore0762c92009-06-19 23:52:42 +0000983 SourceLocation Loc,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000984 OverloadCandidateSet::iterator& Best);
985 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
Fariborz Jahanian16a5eac2009-10-09 00:13:15 +0000986 bool OnlyViable,
Fariborz Jahanian2ebe7eb2009-10-12 20:11:40 +0000987 const char *Opc=0,
Fariborz Jahanian16a5eac2009-10-09 00:13:15 +0000988 SourceLocation Loc=SourceLocation());
Mike Stump1eb44332009-09-09 15:08:12 +0000989
Douglas Gregor904eed32008-11-10 20:40:00 +0000990 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
991 bool Complain);
Anders Carlsson96ad5332009-10-21 17:16:23 +0000992 Expr *FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
Douglas Gregor904eed32008-11-10 20:40:00 +0000993
John McCallba135432009-11-21 08:51:07 +0000994 void AddOverloadedCallCandidates(llvm::SmallVectorImpl<NamedDecl*>& Callees,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000995 DeclarationName &UnqualifiedName,
John McCalld2ede7d2009-11-21 09:38:42 +0000996 bool ArgumentDependentLookup,
John McCalld5532b62009-11-23 01:53:49 +0000997 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000998 Expr **Args, unsigned NumArgs,
999 OverloadCandidateSet &CandidateSet,
1000 bool PartialOverloading = false);
1001
John McCallba135432009-11-21 08:51:07 +00001002 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn,
1003 llvm::SmallVectorImpl<NamedDecl*> &Fns,
Douglas Gregor17330012009-02-04 15:01:18 +00001004 DeclarationName UnqualifiedName,
John McCalld5532b62009-11-23 01:53:49 +00001005 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor0a396682008-11-26 06:01:48 +00001006 SourceLocation LParenLoc,
1007 Expr **Args, unsigned NumArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00001008 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +00001009 SourceLocation RParenLoc,
John McCalld2ede7d2009-11-21 09:38:42 +00001010 bool ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +00001011
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001012 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
1013 unsigned Opc,
1014 FunctionSet &Functions,
1015 ExprArg input);
1016
Douglas Gregor063daf62009-03-13 18:40:31 +00001017 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
1018 unsigned Opc,
1019 FunctionSet &Functions,
1020 Expr *LHS, Expr *RHS);
1021
Sebastian Redlf322ed62009-10-29 20:17:01 +00001022 OwningExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
1023 SourceLocation RLoc,
1024 ExprArg Base,ExprArg Idx);
1025
John McCallaa81e162009-12-01 22:10:20 +00001026 OwningExprResult
Douglas Gregor88a35142008-12-22 05:46:06 +00001027 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00001028 SourceLocation LParenLoc, Expr **Args,
Douglas Gregor88a35142008-12-22 05:46:06 +00001029 unsigned NumArgs, SourceLocation *CommaLocs,
1030 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001031 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +00001032 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +00001033 Expr **Args, unsigned NumArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00001034 SourceLocation *CommaLocs,
Douglas Gregorf9eb9052008-11-19 21:05:33 +00001035 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001036
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001037 OwningExprResult BuildOverloadedArrowExpr(Scope *S, ExprArg Base,
1038 SourceLocation OpLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001039
Anders Carlsson8c8d9192009-10-09 23:51:55 +00001040 /// CheckCallReturnType - Checks that a call expression's return type is
1041 /// complete. Returns true on failure. The location passed in is the location
1042 /// that best represents the call.
1043 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
1044 CallExpr *CE, FunctionDecl *FD);
1045
Mike Stump56925862009-07-28 22:04:01 +00001046 /// Helpers for dealing with blocks and functions.
Mike Stumpb1682c52009-07-22 23:56:57 +00001047 void CheckFallThroughForFunctionDef(Decl *D, Stmt *Body);
Mike Stump56925862009-07-28 22:04:01 +00001048 void CheckFallThroughForBlock(QualType BlockTy, Stmt *Body);
Chris Lattner04421082008-04-08 04:40:51 +00001049 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +00001050 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001051 void CheckExtraCXXDefaultArguments(Declarator &D);
Mike Stumpb1682c52009-07-22 23:56:57 +00001052 enum ControlFlowKind { NeverFallThrough = 0, MaybeFallThrough = 1,
Mike Stump1d7e7672009-10-27 01:59:05 +00001053 AlwaysFallThrough = 2, NeverFallThroughOrReturn = 3 };
Mike Stumpb1682c52009-07-22 23:56:57 +00001054 ControlFlowKind CheckFallThrough(Stmt *);
Reid Spencer5f016e22007-07-11 17:01:13 +00001055
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00001056 Scope *getNonFieldDeclScope(Scope *S);
1057
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001058 /// \name Name lookup
1059 ///
1060 /// These routines provide name lookup that is used during semantic
1061 /// analysis to resolve the various kinds of names (identifiers,
1062 /// overloaded operator names, constructor names, etc.) into zero or
1063 /// more declarations within a particular scope. The major entry
1064 /// points are LookupName, which performs unqualified name lookup,
Mike Stump1eb44332009-09-09 15:08:12 +00001065 /// and LookupQualifiedName, which performs qualified name lookup.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001066 ///
1067 /// All name lookup is performed based on some specific criteria,
1068 /// which specify what names will be visible to name lookup and how
1069 /// far name lookup should work. These criteria are important both
1070 /// for capturing language semantics (certain lookups will ignore
1071 /// certain names, for example) and for performance, since name
1072 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001073 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001074 ///
1075 /// The results of name lookup can vary based on the kind of name
1076 /// lookup performed, the current language, and the translation
1077 /// unit. In C, for example, name lookup will either return nothing
1078 /// (no entity found) or a single declaration. In C++, name lookup
1079 /// can additionally refer to a set of overloaded functions or
1080 /// result in an ambiguity. All of the possible results of name
1081 /// lookup are captured by the LookupResult class, which provides
1082 /// the ability to distinguish among them.
1083 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +00001084
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001085 /// @brief Describes the kind of name lookup to perform.
1086 enum LookupNameKind {
1087 /// Ordinary name lookup, which finds ordinary names (functions,
1088 /// variables, typedefs, etc.) in C and most kinds of names
1089 /// (functions, variables, members, types, etc.) in C++.
1090 LookupOrdinaryName = 0,
1091 /// Tag name lookup, which finds the names of enums, classes,
1092 /// structs, and unions.
1093 LookupTagName,
1094 /// Member name lookup, which finds the names of
1095 /// class/struct/union members.
1096 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001097 // Look up of an operator name (e.g., operator+) for use with
1098 // operator overloading. This lookup is similar to ordinary name
1099 // lookup, but will ignore any declarations that are class
1100 // members.
1101 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001102 /// Look up of a name that precedes the '::' scope resolution
1103 /// operator in C++. This lookup completely ignores operator,
1104 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
1105 LookupNestedNameSpecifierName,
1106 /// Look up a namespace name within a C++ using directive or
1107 /// namespace alias definition, ignoring non-namespace names (C++
1108 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001109 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +00001110 /// Look up an ordinary name that is going to be redeclared as a
1111 /// name with linkage. This lookup ignores any declarations that
Mike Stump1eb44332009-09-09 15:08:12 +00001112 /// are outside of the current scope unless they have linkage. See
Douglas Gregor6e378de2009-04-23 23:18:26 +00001113 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
1114 LookupRedeclarationWithLinkage,
1115 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001116 LookupObjCProtocolName,
1117 /// Look up the name of an Objective-C implementation
1118 LookupObjCImplementationName,
1119 /// Look up the name of an Objective-C category implementation
1120 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001121 };
1122
John McCall7d384dd2009-11-18 07:57:50 +00001123 enum RedeclarationKind {
1124 NotForRedeclaration,
1125 ForRedeclaration
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001126 };
1127
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001128private:
John McCalla24dc2e2009-11-17 02:14:36 +00001129 bool CppLookupName(LookupResult &R, Scope *S);
1130
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001131public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001132 /// Determines whether D is a suitable lookup result according to the
1133 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001134 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001135 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001136 switch (NameKind) {
1137 case Sema::LookupOrdinaryName:
1138 case Sema::LookupTagName:
1139 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001140 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001141 case Sema::LookupObjCProtocolName:
1142 case Sema::LookupObjCImplementationName:
1143 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001144 return D->isInIdentifierNamespace(IDNS);
Mike Stump1eb44332009-09-09 15:08:12 +00001145
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001146 case Sema::LookupOperatorName:
Mike Stump1eb44332009-09-09 15:08:12 +00001147 return D->isInIdentifierNamespace(IDNS) &&
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001148 !D->getDeclContext()->isRecord();
1149
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001150 case Sema::LookupNestedNameSpecifierName:
1151 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
Mike Stump1eb44332009-09-09 15:08:12 +00001152
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001153 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001154 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001155 }
Mike Stump1eb44332009-09-09 15:08:12 +00001156
1157 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001158 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001159 return false;
1160 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001161
John McCallf36e02d2009-10-09 21:13:30 +00001162 /// \brief Look up a name, looking for a single declaration. Return
John McCall1bcee0a2009-12-02 08:25:40 +00001163 /// null if the results were absent, ambiguous, or overloaded.
John McCallf36e02d2009-10-09 21:13:30 +00001164 ///
1165 /// It is preferable to use the elaborated form and explicitly handle
1166 /// ambiguity and overloaded.
1167 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
1168 LookupNameKind NameKind,
John McCall7d384dd2009-11-18 07:57:50 +00001169 RedeclarationKind Redecl
1170 = NotForRedeclaration);
John McCallf36e02d2009-10-09 21:13:30 +00001171 bool LookupName(LookupResult &R, Scope *S,
John McCalla24dc2e2009-11-17 02:14:36 +00001172 bool AllowBuiltinCreation = false);
1173 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx);
John McCallf36e02d2009-10-09 21:13:30 +00001174 bool LookupParsedName(LookupResult &R, Scope *S, const CXXScopeSpec *SS,
John McCallf36e02d2009-10-09 21:13:30 +00001175 bool AllowBuiltinCreation = false,
John McCallf36e02d2009-10-09 21:13:30 +00001176 bool EnteringContext = false);
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001177
Douglas Gregor6e378de2009-04-23 23:18:26 +00001178 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001179 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001180
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001181 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00001182 QualType T1, QualType T2,
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001183 FunctionSet &Functions);
Mike Stump1eb44332009-09-09 15:08:12 +00001184
Sebastian Redl644be852009-10-23 19:23:15 +00001185 void ArgumentDependentLookup(DeclarationName Name, bool Operator,
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001186 Expr **Args, unsigned NumArgs,
1187 FunctionSet &Functions);
1188
Douglas Gregorfa047642009-02-04 00:32:51 +00001189 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1190 AssociatedNamespaceSet &AssociatedNamespaces,
John McCall6ff07852009-08-07 22:18:02 +00001191 AssociatedClassSet &AssociatedClasses);
Douglas Gregorfa047642009-02-04 00:32:51 +00001192
John McCalla24dc2e2009-11-17 02:14:36 +00001193 bool DiagnoseAmbiguousLookup(LookupResult &Result);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001194 //@}
Mike Stump1eb44332009-09-09 15:08:12 +00001195
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001196 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Mike Stump1eb44332009-09-09 15:08:12 +00001197 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001198 Scope *S, bool ForRedeclaration,
1199 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001200 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1201 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001202 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001203
1204 // More parsing and symbol table subroutines.
1205
Mike Stump1eb44332009-09-09 15:08:12 +00001206 // Decl attributes - this routine is the top level dispatcher.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001207 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
1208 void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001209
Steve Naroff3c2eb662008-02-10 21:38:56 +00001210 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1211 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001212 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1213 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001214
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001215 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001216 ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001217
Chris Lattner823c44e2009-01-06 07:27:21 +00001218 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001219 /// methods declared in protocol, and those referenced by it.
1220 /// \param IDecl - Used for checking for methods which may have been
1221 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001222 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1223 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001224 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001225 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001226 const llvm::DenseSet<Selector> &ClsMap,
1227 ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001228
Steve Naroffa5997c42007-10-02 21:43:37 +00001229 /// CheckImplementationIvars - This routine checks if the instance variables
Mike Stump1eb44332009-09-09 15:08:12 +00001230 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001231 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1232 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001233 SourceLocation Loc);
Mike Stump1eb44332009-09-09 15:08:12 +00001234
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001235 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001236 /// remains unimplemented in the class or category @implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00001237 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1238 ObjCContainerDecl* IDecl,
Chris Lattnercddc8882009-03-01 00:56:52 +00001239 bool IncompleteImpl = false);
Fariborz Jahanian7ca8b062009-11-11 22:40:11 +00001240
1241 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
1242 /// warning) when atomic property has one but not the other user-declared
1243 /// setter or getter.
1244 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
1245 ObjCContainerDecl* IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001246
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001247 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1248 /// true, or false, accordingly.
Mike Stump1eb44332009-09-09 15:08:12 +00001249 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001250 const ObjCMethodDecl *PrevMethod,
Mike Stump1eb44332009-09-09 15:08:12 +00001251 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001252
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001253 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1254 /// or protocol against those declared in their implementations.
1255 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1256 const llvm::DenseSet<Selector> &ClsMap,
1257 llvm::DenseSet<Selector> &InsMapSeen,
1258 llvm::DenseSet<Selector> &ClsMapSeen,
1259 ObjCImplDecl* IMPDecl,
1260 ObjCContainerDecl* IDecl,
1261 bool &IncompleteImpl,
1262 bool ImmediateClass);
1263
Steve Naroff58ff9e82007-10-14 00:58:41 +00001264 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1265 /// unit are added to a global pool. This allows us to efficiently associate
1266 /// a selector with a method declaraation for purposes of typechecking
1267 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001268 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Mike Stump1eb44332009-09-09 15:08:12 +00001269
Steve Naroff037cda52008-09-30 14:38:43 +00001270 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1271 /// there are multiple signatures.
Fariborz Jahanian835ed7f2009-08-22 21:13:55 +00001272 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
1273 bool warn=true);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001274
1275 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1276 /// there are multiple signatures.
1277 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Mike Stump1eb44332009-09-09 15:08:12 +00001278
Steve Naroff58ff9e82007-10-14 00:58:41 +00001279 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001280 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001281 //===--------------------------------------------------------------------===//
1282 // Statement Parsing Callbacks: SemaStmt.cpp.
1283public:
Anders Carlsson6b1d2832009-05-17 21:11:30 +00001284 virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr);
Sebastian Redla60528c2008-12-21 12:04:03 +00001285
1286 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1287 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1288 MultiStmtArg Elts,
1289 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001290 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001291 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001292 SourceLocation EndLoc);
Fariborz Jahaniana7cf23a2009-11-19 22:12:37 +00001293 virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
Sebastian Redl117054a2008-12-28 16:13:43 +00001294 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1295 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001296 SourceLocation ColonLoc);
1297 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
Mike Stump1eb44332009-09-09 15:08:12 +00001298
Sebastian Redl117054a2008-12-28 16:13:43 +00001299 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1300 SourceLocation ColonLoc,
1301 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001302 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1303 IdentifierInfo *II,
1304 SourceLocation ColonLoc,
1305 StmtArg SubStmt);
Mike Stump1eb44332009-09-09 15:08:12 +00001306 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001307 FullExprArg CondVal, DeclPtrTy CondVar,
1308 StmtArg ThenVal,
Anders Carlssona99fad82009-05-17 18:26:53 +00001309 SourceLocation ElseLoc, StmtArg ElseVal);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001310 virtual OwningStmtResult ActOnStartOfSwitchStmt(FullExprArg Cond,
1311 DeclPtrTy CondVar);
Sebastian Redlde307472009-01-11 00:38:46 +00001312 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1313 StmtArg Switch, StmtArg Body);
Mike Stump1eb44332009-09-09 15:08:12 +00001314 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001315 FullExprArg Cond,
1316 DeclPtrTy CondVar, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001317 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
Chris Lattner98913592009-06-12 23:04:47 +00001318 SourceLocation WhileLoc,
1319 SourceLocation CondLParen, ExprArg Cond,
1320 SourceLocation CondRParen);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001321
1322 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1323 SourceLocation LParenLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001324 StmtArg First, FullExprArg Second,
1325 DeclPtrTy SecondVar,
1326 FullExprArg Third,
1327 SourceLocation RParenLoc,
Sebastian Redlf05b1522009-01-16 23:28:06 +00001328 StmtArg Body);
1329 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1330 SourceLocation LParenLoc,
1331 StmtArg First, ExprArg Second,
1332 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001333
1334 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1335 SourceLocation LabelLoc,
1336 IdentifierInfo *LabelII);
1337 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1338 SourceLocation StarLoc,
1339 ExprArg DestExp);
1340 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1341 Scope *CurScope);
1342 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1343 Scope *CurScope);
1344
1345 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Anders Carlssonf53b4432009-08-18 16:11:00 +00001346 ExprArg RetValExp);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001347 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1348 Expr *RetValExp);
1349
Sebastian Redl3037ed02009-01-18 16:53:17 +00001350 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1351 bool IsSimple,
1352 bool IsVolatile,
1353 unsigned NumOutputs,
1354 unsigned NumInputs,
1355 std::string *Names,
1356 MultiExprArg Constraints,
1357 MultiExprArg Exprs,
1358 ExprArg AsmString,
1359 MultiExprArg Clobbers,
1360 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001361
1362 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1363 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001364 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001365 StmtArg CatchList);
1366
1367 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1368 StmtArg Body);
1369
1370 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1371 StmtArg Try,
1372 StmtArg Catch, StmtArg Finally);
1373
1374 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001375 ExprArg Throw,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001376 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001377 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1378 ExprArg SynchExpr,
1379 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001380
Douglas Gregord308e622009-05-18 20:51:54 +00001381 VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001382 DeclaratorInfo *DInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00001383 IdentifierInfo *Name,
1384 SourceLocation Loc,
1385 SourceRange Range);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001386 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Douglas Gregord308e622009-05-18 20:51:54 +00001387
Sebastian Redl4b07b292008-12-22 19:15:10 +00001388 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001389 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001390 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001391 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1392 StmtArg TryBlock,
1393 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001394 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001395
Anders Carlsson636463e2009-07-30 22:17:18 +00001396 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
1397 /// whose result is unused, warn.
1398 void DiagnoseUnusedExprResult(const Stmt *S);
Mike Stump1eb44332009-09-09 15:08:12 +00001399
John McCall54abf7d2009-11-04 02:18:39 +00001400 ParsingDeclStackState PushParsingDeclaration();
1401 void PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy D);
1402 void EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc);
1403
Reid Spencer5f016e22007-07-11 17:01:13 +00001404 //===--------------------------------------------------------------------===//
1405 // Expression Parsing Callbacks: SemaExpr.cpp.
1406
John McCall54abf7d2009-11-04 02:18:39 +00001407 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Mike Stump1eb44332009-09-09 15:08:12 +00001408 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001409 ObjCMethodDecl *Getter,
1410 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001411 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1412 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001413
John McCallb13c87f2009-11-05 09:23:39 +00001414 void CheckSignCompare(Expr *LHS, Expr *RHS, SourceLocation Loc,
John McCall5dbad3d2009-11-06 08:49:08 +00001415 const PartialDiagnostic &PD,
1416 bool Equality = false);
John McCallb13c87f2009-11-05 09:23:39 +00001417
Douglas Gregor2afce722009-11-26 00:44:06 +00001418 virtual void
Douglas Gregorac7610d2009-06-22 20:57:11 +00001419 PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext);
Mike Stump1eb44332009-09-09 15:08:12 +00001420
Douglas Gregor2afce722009-11-26 00:44:06 +00001421 virtual void PopExpressionEvaluationContext();
Mike Stump1eb44332009-09-09 15:08:12 +00001422
Douglas Gregore0762c92009-06-19 23:52:42 +00001423 void MarkDeclarationReferenced(SourceLocation Loc, Decl *D);
Mike Stump1eb44332009-09-09 15:08:12 +00001424
Reid Spencer5f016e22007-07-11 17:01:13 +00001425 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001426 virtual SourceRange getExprRange(ExprTy *E) const;
1427
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001428 virtual OwningExprResult ActOnIdExpression(Scope *S,
1429 const CXXScopeSpec &SS,
1430 UnqualifiedId &Name,
1431 bool HasTrailingLParen,
1432 bool IsAddressOfOperand);
John McCallf7a1a742009-11-24 19:00:30 +00001433
1434 OwningExprResult LookupInObjCMethod(LookupResult &R,
1435 Scope *S,
1436 IdentifierInfo *II);
1437
1438 OwningExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
1439 DeclarationName Name,
1440 SourceLocation NameLoc,
John McCall2f841ba2009-12-02 03:53:29 +00001441 bool isAddressOfOperand,
John McCallf7a1a742009-11-24 19:00:30 +00001442 const TemplateArgumentListInfo *TemplateArgs);
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001443
Mike Stump1eb44332009-09-09 15:08:12 +00001444 OwningExprResult BuildDeclRefExpr(NamedDecl *D, QualType Ty,
Douglas Gregor0da76df2009-11-23 11:41:28 +00001445 SourceLocation Loc,
Anders Carlssone41590d2009-06-24 00:10:43 +00001446 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001447 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1448 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001449 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001450 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1451 FieldDecl *Field,
1452 Expr *BaseObjectExpr = 0,
1453 SourceLocation OpLoc = SourceLocation());
John McCallaa81e162009-12-01 22:10:20 +00001454 OwningExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS,
1455 LookupResult &R,
1456 const TemplateArgumentListInfo *TemplateArgs,
1457 bool IsDefiniteInstance);
John McCallf7a1a742009-11-24 19:00:30 +00001458 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
John McCall5b3f9132009-11-22 01:44:31 +00001459 const LookupResult &R,
1460 bool HasTrailingLParen);
John McCallf7a1a742009-11-24 19:00:30 +00001461
1462 OwningExprResult BuildQualifiedDeclarationNameExpr(const CXXScopeSpec &SS,
1463 DeclarationName Name,
1464 SourceLocation NameLoc);
1465 OwningExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
1466 DeclarationName Name,
1467 SourceLocation NameLoc,
1468 const TemplateArgumentListInfo *TemplateArgs);
1469
1470 OwningExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
1471 LookupResult &R,
1472 bool ADL);
1473 OwningExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
John McCallba135432009-11-21 08:51:07 +00001474 SourceLocation Loc,
1475 NamedDecl *D);
Mike Stump1eb44332009-09-09 15:08:12 +00001476
Sebastian Redlcd965b92009-01-18 18:53:16 +00001477 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1478 tok::TokenKind Kind);
1479 virtual OwningExprResult ActOnNumericConstant(const Token &);
1480 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1481 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1482 ExprArg Val);
Fariborz Jahanianf88f7ab2009-11-25 01:26:41 +00001483 virtual OwningExprResult ActOnParenOrParenListExpr(SourceLocation L,
Nate Begeman2ef13e52009-08-10 23:49:36 +00001484 SourceLocation R,
Fariborz Jahanianf88f7ab2009-11-25 01:26:41 +00001485 MultiExprArg Val,
1486 TypeTy *TypeOfCast=0);
Mike Stump1eb44332009-09-09 15:08:12 +00001487
Steve Narofff69936d2007-09-16 03:34:24 +00001488 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001489 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001490 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1491 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001492
Reid Spencer5f016e22007-07-11 17:01:13 +00001493 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001494 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001495 unsigned OpcIn,
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001496 ExprArg InputArg);
Douglas Gregor6ca7cfb2009-11-05 00:51:44 +00001497 OwningExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
1498 UnaryOperator::Opcode Opc, ExprArg input);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001499 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1500 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001501
John McCall5ab75172009-11-04 07:28:41 +00001502 OwningExprResult CreateSizeOfAlignOfExpr(DeclaratorInfo *T,
1503 SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001504 bool isSizeOf, SourceRange R);
Mike Stump1eb44332009-09-09 15:08:12 +00001505 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001506 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001507 virtual OwningExprResult
1508 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1509 void *TyOrEx, const SourceRange &ArgRange);
Mike Stump1eb44332009-09-09 15:08:12 +00001510
Chris Lattner31e21e02009-01-24 20:17:12 +00001511 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001512 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1513 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001514
1515 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1516 tok::TokenKind Kind,
1517 ExprArg Input);
1518
1519 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1520 SourceLocation LLoc,
1521 ExprArg Idx,
1522 SourceLocation RLoc);
Sebastian Redlf322ed62009-10-29 20:17:01 +00001523 OwningExprResult CreateBuiltinArraySubscriptExpr(ExprArg Base,
1524 SourceLocation LLoc,
1525 ExprArg Idx,
1526 SourceLocation RLoc);
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001527
John McCall129e2df2009-11-30 22:42:35 +00001528 OwningExprResult BuildMemberReferenceExpr(ExprArg Base,
John McCallaa81e162009-12-01 22:10:20 +00001529 QualType BaseType,
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001530 SourceLocation OpLoc,
John McCall129e2df2009-11-30 22:42:35 +00001531 bool IsArrow,
1532 const CXXScopeSpec &SS,
1533 NamedDecl *FirstQualifierInScope,
1534 DeclarationName Name,
1535 SourceLocation NameLoc,
1536 const TemplateArgumentListInfo *TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00001537
John McCall129e2df2009-11-30 22:42:35 +00001538 OwningExprResult BuildMemberReferenceExpr(ExprArg Base,
John McCallaa81e162009-12-01 22:10:20 +00001539 QualType BaseType,
John McCall129e2df2009-11-30 22:42:35 +00001540 SourceLocation OpLoc, bool IsArrow,
1541 const CXXScopeSpec &SS,
1542 LookupResult &R,
1543 const TemplateArgumentListInfo *TemplateArgs);
1544
1545 OwningExprResult LookupMemberExpr(LookupResult &R, Expr *&Base,
1546 bool IsArrow, SourceLocation OpLoc,
1547 const CXXScopeSpec &SS,
1548 NamedDecl *FirstQualifierInScope,
1549 DeclPtrTy ObjCImpDecl);
1550
1551 bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType,
John McCall2f841ba2009-12-02 03:53:29 +00001552 const CXXScopeSpec &SS,
John McCall129e2df2009-11-30 22:42:35 +00001553 const LookupResult &R);
1554
1555 OwningExprResult ActOnDependentMemberExpr(ExprArg Base,
John McCallaa81e162009-12-01 22:10:20 +00001556 QualType BaseType,
John McCall129e2df2009-11-30 22:42:35 +00001557 bool IsArrow,
Anders Carlsson8f28f992009-08-26 18:25:21 +00001558 SourceLocation OpLoc,
John McCall129e2df2009-11-30 22:42:35 +00001559 const CXXScopeSpec &SS,
1560 NamedDecl *FirstQualifierInScope,
1561 DeclarationName Name,
1562 SourceLocation NameLoc,
1563 const TemplateArgumentListInfo *TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00001564
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001565 virtual OwningExprResult ActOnMemberAccessExpr(Scope *S, ExprArg Base,
1566 SourceLocation OpLoc,
1567 tok::TokenKind OpKind,
1568 const CXXScopeSpec &SS,
1569 UnqualifiedId &Member,
1570 DeclPtrTy ObjCImpDecl,
1571 bool HasTrailingLParen);
1572
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001573 virtual void ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001574 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001575 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001576 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001577 Expr **Args, unsigned NumArgs,
1578 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001579
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001580 void DeconstructCallFunction(Expr *FnExpr,
John McCallba135432009-11-21 08:51:07 +00001581 llvm::SmallVectorImpl<NamedDecl*>& Fns,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001582 DeclarationName &Name,
1583 NestedNameSpecifier *&Qualifier,
1584 SourceRange &QualifierRange,
1585 bool &ArgumentDependentLookup,
John McCall7453ed42009-11-22 00:44:51 +00001586 bool &Overloaded,
John McCalld5532b62009-11-23 01:53:49 +00001587 bool &HasExplicitTemplateArgs,
1588 TemplateArgumentListInfo &ExplicitTemplateArgs);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001589
Steve Narofff69936d2007-09-16 03:34:24 +00001590 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001591 /// This provides the location of the left/right parens and a list of comma
1592 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001593 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1594 SourceLocation LParenLoc,
1595 MultiExprArg Args,
1596 SourceLocation *CommaLocs,
1597 SourceLocation RParenLoc);
John McCallaa81e162009-12-01 22:10:20 +00001598 OwningExprResult BuildResolvedCallExpr(Expr *Fn,
1599 NamedDecl *NDecl,
1600 SourceLocation LParenLoc,
1601 Expr **Args, unsigned NumArgs,
1602 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001603
Nate Begeman2ef13e52009-08-10 23:49:36 +00001604 virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
1605 TypeTy *Ty, SourceLocation RParenLoc,
1606 ExprArg Op);
Fariborz Jahaniana79f8b32009-11-23 19:51:43 +00001607 virtual bool TypeIsVectorType(TypeTy *Ty) {
1608 return GetTypeFromParser(Ty)->isVectorType();
1609 }
Mike Stump1eb44332009-09-09 15:08:12 +00001610
Nate Begeman2ef13e52009-08-10 23:49:36 +00001611 OwningExprResult MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg ME);
1612 OwningExprResult ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
1613 SourceLocation RParenLoc, ExprArg E,
1614 QualType Ty);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001615
1616 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1617 TypeTy *Ty,
1618 SourceLocation RParenLoc,
1619 ExprArg Op);
1620
1621 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1622 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001623 SourceLocation RParenLoc);
1624
Douglas Gregor05c13a32009-01-22 00:58:24 +00001625 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1626 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001627 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001628 OwningExprResult Init);
1629
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001630 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1631 tok::TokenKind Kind,
1632 ExprArg LHS, ExprArg RHS);
Douglas Gregor6ca7cfb2009-11-05 00:51:44 +00001633 OwningExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
1634 BinaryOperator::Opcode Opc,
1635 Expr *lhs, Expr *rhs);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001636 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1637 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001638
Steve Narofff69936d2007-09-16 03:34:24 +00001639 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001640 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001641 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1642 SourceLocation ColonLoc,
1643 ExprArg Cond, ExprArg LHS,
1644 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001645
Steve Naroff1b273c42007-09-16 14:56:35 +00001646 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001647 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1648 SourceLocation LabLoc,
1649 IdentifierInfo *LabelII);
1650
1651 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1652 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001653
1654 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001655 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1656 SourceLocation BuiltinLoc,
1657 SourceLocation TypeLoc,
1658 TypeTy *Arg1,
1659 OffsetOfComponent *CompPtr,
1660 unsigned NumComponents,
1661 SourceLocation RParenLoc);
1662
Steve Naroffd34e9152007-08-01 22:05:33 +00001663 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001664 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1665 TypeTy *arg1, TypeTy *arg2,
1666 SourceLocation RPLoc);
1667
Steve Naroffd04fdd52007-08-03 21:21:27 +00001668 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001669 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1670 ExprArg cond, ExprArg expr1,
1671 ExprArg expr2, SourceLocation RPLoc);
1672
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001673 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001674 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1675 ExprArg expr, TypeTy *type,
1676 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001677
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001678 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001679 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001680
Steve Naroff4eb206b2008-09-03 18:15:37 +00001681 //===------------------------- "Block" Extension ------------------------===//
1682
1683 /// ActOnBlockStart - This callback is invoked when a block literal is
1684 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001685 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001686
Steve Naroff090276f2008-10-10 01:28:17 +00001687 /// ActOnBlockArguments - This callback allows processing of block arguments.
1688 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001689 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001690
Steve Naroff4eb206b2008-09-03 18:15:37 +00001691 /// ActOnBlockError - If there is an error parsing a block, this callback
1692 /// is invoked to pop the information about the block from the action impl.
1693 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001694
Steve Naroff4eb206b2008-09-03 18:15:37 +00001695 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1696 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001697 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1698 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001699
Chris Lattner76a642f2009-02-15 22:43:40 +00001700 //===---------------------------- C++ Features --------------------------===//
1701
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001702 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001703 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1704 IdentifierInfo *Ident,
1705 SourceLocation LBrace);
1706 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001707
Chris Lattnerb28317a2009-03-28 19:18:32 +00001708 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1709 SourceLocation UsingLoc,
1710 SourceLocation NamespcLoc,
1711 const CXXScopeSpec &SS,
1712 SourceLocation IdentLoc,
1713 IdentifierInfo *NamespcName,
1714 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00001715
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001716 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1717
Chris Lattnerb28317a2009-03-28 19:18:32 +00001718 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001719 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001720 SourceLocation AliasLoc,
1721 IdentifierInfo *Alias,
1722 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001723 SourceLocation IdentLoc,
1724 IdentifierInfo *Ident);
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001725
John McCall9488ea12009-11-17 05:59:44 +00001726 NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
1727 SourceLocation UsingLoc,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001728 const CXXScopeSpec &SS,
1729 SourceLocation IdentLoc,
1730 DeclarationName Name,
1731 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00001732 bool IsInstantiation,
1733 bool IsTypeName,
1734 SourceLocation TypenameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001735
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001736 virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope,
Anders Carlsson595adc12009-08-29 19:54:19 +00001737 AccessSpecifier AS,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001738 SourceLocation UsingLoc,
1739 const CXXScopeSpec &SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00001740 UnqualifiedId &Name,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001741 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00001742 bool IsTypeName,
1743 SourceLocation TypenameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001744
1745 /// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001746 /// ActOnDeclarator, when a C++ direct initializer is present.
1747 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001748 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001749 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001750 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001751 SourceLocation *CommaLocs,
1752 SourceLocation RParenLoc);
1753
Anders Carlsson49d44012009-04-24 05:16:06 +00001754 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1755 /// and sets it as the initializer for the the passed in VarDecl.
Mike Stump1eb44332009-09-09 15:08:12 +00001756 bool InitializeVarWithConstructor(VarDecl *VD,
Anders Carlsson930e8d02009-04-16 23:50:50 +00001757 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001758 MultiExprArg Exprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001759
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001760 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
1761 /// including handling of its default argument expressions.
Mike Stump1eb44332009-09-09 15:08:12 +00001762 OwningExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc,
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001763 QualType DeclInitType,
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001764 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001765 MultiExprArg Exprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001766
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001767 // FIXME: Can re remove this and have the above BuildCXXConstructExpr check if
1768 // the constructor can be elidable?
Mike Stump1eb44332009-09-09 15:08:12 +00001769 OwningExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc,
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001770 QualType DeclInitType,
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001771 CXXConstructorDecl *Constructor,
1772 bool Elidable,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001773 MultiExprArg Exprs);
Mike Stump1eb44332009-09-09 15:08:12 +00001774
1775 OwningExprResult BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Cons,
1776 QualType writtenTy,
1777 SourceLocation tyBeginLoc,
Anders Carlssone7624a72009-08-27 05:08:22 +00001778 MultiExprArg Args,
1779 SourceLocation rParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001780
Anders Carlsson0aebc812009-09-09 21:33:21 +00001781 OwningExprResult BuildCXXCastArgument(SourceLocation CastLoc,
1782 QualType Ty,
1783 CastExpr::CastKind Kind,
1784 CXXMethodDecl *Method,
1785 ExprArg Arg);
1786
Anders Carlsson56c5e332009-08-25 03:49:14 +00001787 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
1788 /// the default expr if needed.
1789 OwningExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
1790 FunctionDecl *FD,
1791 ParmVarDecl *Param);
Mike Stump1eb44332009-09-09 15:08:12 +00001792
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00001793 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
1794 /// constructed variable.
1795 void FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001796
1797 /// DefineImplicitDefaultConstructor - Checks for feasibility of
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001798 /// defining this constructor as the default constructor.
1799 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1800 CXXConstructorDecl *Constructor);
Mike Stump1eb44332009-09-09 15:08:12 +00001801
1802 /// DefineImplicitDestructor - Checks for feasibility of
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00001803 /// defining this destructor as the default destructor.
1804 void DefineImplicitDestructor(SourceLocation CurrentLocation,
1805 CXXDestructorDecl *Destructor);
Mike Stump1eb44332009-09-09 15:08:12 +00001806
1807 /// DefineImplicitCopyConstructor - Checks for feasibility of
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001808 /// defining this constructor as the copy constructor.
1809 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
1810 CXXConstructorDecl *Constructor,
1811 unsigned TypeQuals);
Mike Stump1eb44332009-09-09 15:08:12 +00001812
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001813 /// DefineImplicitOverloadedAssign - Checks for feasibility of
1814 /// defining implicit this overloaded assignment operator.
Mike Stump1eb44332009-09-09 15:08:12 +00001815 void DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001816 CXXMethodDecl *MethodDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001817
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001818 /// getAssignOperatorMethod - Returns the default copy assignmment operator
1819 /// for the class.
1820 CXXMethodDecl *getAssignOperatorMethod(ParmVarDecl *Decl,
Mike Stump1eb44332009-09-09 15:08:12 +00001821 CXXRecordDecl *ClassDecl);
Anders Carlssondef11992009-05-30 20:36:53 +00001822
1823 /// MaybeBindToTemporary - If the passed in expression has a record type with
1824 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
1825 /// it simply returns the passed in expression.
1826 OwningExprResult MaybeBindToTemporary(Expr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001827
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001828 /// InitializationKind - Represents which kind of C++ initialization
1829 /// [dcl.init] a routine is to perform.
1830 enum InitializationKind {
1831 IK_Direct, ///< Direct initialization
1832 IK_Copy, ///< Copy initialization
1833 IK_Default ///< Default initialization
1834 };
1835
Douglas Gregor18fe5682008-11-03 20:45:27 +00001836 CXXConstructorDecl *
Douglas Gregor19aeac62009-11-14 03:27:21 +00001837 TryInitializationByConstructor(QualType ClassType,
1838 Expr **Args, unsigned NumArgs,
1839 SourceLocation Loc,
1840 InitializationKind Kind);
1841
1842 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001843 PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00001844 MultiExprArg ArgsPtr,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001845 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001846 DeclarationName InitEntity,
Douglas Gregor39da0b82009-09-09 23:08:42 +00001847 InitializationKind Kind,
1848 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001849
Douglas Gregor39da0b82009-09-09 23:08:42 +00001850 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
1851 MultiExprArg ArgsPtr,
1852 SourceLocation Loc,
1853 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs);
1854
Douglas Gregor49badde2008-10-27 19:41:14 +00001855 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001856 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1857 tok::TokenKind Kind,
1858 SourceLocation LAngleBracketLoc,
1859 TypeTy *Ty,
1860 SourceLocation RAngleBracketLoc,
1861 SourceLocation LParenLoc,
1862 ExprArg E,
1863 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001864
Sebastian Redlf53597f2009-03-15 17:47:39 +00001865 /// ActOnCXXTypeid - Parse typeid( something ).
1866 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1867 SourceLocation LParenLoc, bool isType,
1868 void *TyOrExpr,
1869 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001870
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001871 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001872 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001873
Steve Naroff1b273c42007-09-16 14:56:35 +00001874 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001875 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1876 tok::TokenKind Kind);
1877
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001878 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1879 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1880
Chris Lattner50dd2892008-02-26 00:51:44 +00001881 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001882 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1883 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001884 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001885
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001886 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1887 /// Can be interpreted either as function-style casting ("int(x)")
1888 /// or class type construction ("ClassType(x,y,z)")
1889 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001890 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1891 TypeTy *TypeRep,
1892 SourceLocation LParenLoc,
1893 MultiExprArg Exprs,
1894 SourceLocation *CommaLocs,
1895 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001896
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001897 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001898 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1899 SourceLocation PlacementLParen,
1900 MultiExprArg PlacementArgs,
1901 SourceLocation PlacementRParen,
1902 bool ParenTypeId, Declarator &D,
1903 SourceLocation ConstructorLParen,
1904 MultiExprArg ConstructorArgs,
1905 SourceLocation ConstructorRParen);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001906 OwningExprResult BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
1907 SourceLocation PlacementLParen,
1908 MultiExprArg PlacementArgs,
1909 SourceLocation PlacementRParen,
Mike Stump1eb44332009-09-09 15:08:12 +00001910 bool ParenTypeId,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001911 QualType AllocType,
1912 SourceLocation TypeLoc,
1913 SourceRange TypeRange,
1914 ExprArg ArraySize,
1915 SourceLocation ConstructorLParen,
1916 MultiExprArg ConstructorArgs,
1917 SourceLocation ConstructorRParen);
Mike Stump1eb44332009-09-09 15:08:12 +00001918
Douglas Gregor3433cf72009-05-21 00:00:09 +00001919 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1920 SourceRange R);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001921 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1922 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001923 Expr **PlaceArgs, unsigned NumPlaceArgs,
1924 FunctionDecl *&OperatorNew,
1925 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001926 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1927 DeclarationName Name, Expr** Args,
1928 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001929 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001930 void DeclareGlobalNewDelete();
1931 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1932 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001933
Anders Carlsson78f74552009-11-15 18:45:20 +00001934 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00001935 DeclarationName Name, FunctionDecl* &Operator);
Anders Carlsson78f74552009-11-15 18:45:20 +00001936
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001937 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001938 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1939 bool UseGlobal, bool ArrayForm,
1940 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001941
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001942 virtual DeclResult ActOnCXXConditionDeclaration(Scope *S,
1943 Declarator &D);
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001944 OwningExprResult CheckConditionVariable(VarDecl *ConditionVar);
1945
Sebastian Redl64b45f72009-01-05 20:52:13 +00001946 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1947 /// pseudo-functions.
1948 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1949 SourceLocation KWLoc,
1950 SourceLocation LParen,
1951 TypeTy *Ty,
1952 SourceLocation RParen);
Mike Stump1eb44332009-09-09 15:08:12 +00001953
Douglas Gregor2dd078a2009-09-02 22:59:36 +00001954 virtual OwningExprResult ActOnStartCXXMemberReference(Scope *S,
1955 ExprArg Base,
1956 SourceLocation OpLoc,
1957 tok::TokenKind OpKind,
1958 TypeTy *&ObjectType);
Mike Stump1eb44332009-09-09 15:08:12 +00001959
Mike Stump1eb44332009-09-09 15:08:12 +00001960 /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001961 /// non-empty, will create a new CXXExprWithTemporaries expression.
1962 /// Otherwise, just returs the passed in expression.
Anders Carlssonf54741e2009-06-16 03:37:31 +00001963 Expr *MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1964 bool ShouldDestroyTemporaries);
Mike Stump1eb44332009-09-09 15:08:12 +00001965
Anders Carlsson165a0a02009-05-17 18:41:29 +00001966 virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr);
1967
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001968 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Mike Stump1eb44332009-09-09 15:08:12 +00001969
Douglas Gregor2dd078a2009-09-02 22:59:36 +00001970 DeclContext *computeDeclContext(QualType T);
Mike Stump1eb44332009-09-09 15:08:12 +00001971 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
Douglas Gregorf59a56e2009-07-21 23:53:31 +00001972 bool EnteringContext = false);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001973 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001974 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1975 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001976
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001977 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1978 /// global scope ('::').
1979 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1980 SourceLocation CCLoc);
1981
Douglas Gregor374929f2009-09-18 15:37:17 +00001982 bool isAcceptableNestedNameSpecifier(NamedDecl *SD);
Douglas Gregorc68afe22009-09-03 21:38:09 +00001983 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
Mike Stump1eb44332009-09-09 15:08:12 +00001984
Douglas Gregorc68afe22009-09-03 21:38:09 +00001985
1986 CXXScopeTy *BuildCXXNestedNameSpecifier(Scope *S,
1987 const CXXScopeSpec &SS,
1988 SourceLocation IdLoc,
1989 SourceLocation CCLoc,
1990 IdentifierInfo &II,
1991 QualType ObjectType,
1992 NamedDecl *ScopeLookupResult,
1993 bool EnteringContext);
Mike Stump1eb44332009-09-09 15:08:12 +00001994
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001995 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1996 const CXXScopeSpec &SS,
1997 SourceLocation IdLoc,
1998 SourceLocation CCLoc,
Douglas Gregor495c35d2009-08-25 22:51:20 +00001999 IdentifierInfo &II,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002000 TypeTy *ObjectType,
Douglas Gregor495c35d2009-08-25 22:51:20 +00002001 bool EnteringContext);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002002
Douglas Gregor39a8de12009-02-25 19:37:18 +00002003 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
2004 /// nested-name-specifier that involves a template-id, e.g.,
2005 /// "foo::bar<int, float>::", and now we need to build a scope
2006 /// specifier. \p SS is empty or the previously parsed nested-name
2007 /// part ("foo::"), \p Type is the already-parsed class template
2008 /// specialization (or other template-id that names a type), \p
2009 /// TypeRange is the source range where the type is located, and \p
2010 /// CCLoc is the location of the trailing '::'.
2011 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
2012 const CXXScopeSpec &SS,
2013 TypeTy *Type,
2014 SourceRange TypeRange,
2015 SourceLocation CCLoc);
2016
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002017 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
2018 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
2019 /// After this method is called, according to [C++ 3.4.3p3], names should be
2020 /// looked up in the declarator-id's scope, until the declarator is parsed and
2021 /// ActOnCXXExitDeclaratorScope is called.
2022 /// The 'SS' should be a non-empty valid CXXScopeSpec.
Douglas Gregor7dfd0fb2009-09-24 23:39:01 +00002023 virtual bool ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002024
2025 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
2026 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
2027 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
2028 /// Used to indicate that names should revert to being looked up in the
2029 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00002030 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002031
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00002032 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
2033 /// initializer for the declaration 'Dcl'.
2034 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
2035 /// static data member of class X, names should be looked up in the scope of
2036 /// class X.
2037 virtual void ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl);
2038
2039 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
2040 /// initializer for the declaration 'Dcl'.
2041 virtual void ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl);
2042
Anders Carlsson55085182007-08-21 17:43:55 +00002043 // ParseObjCStringLiteral - Parse Objective-C string literals.
Mike Stump1eb44332009-09-09 15:08:12 +00002044 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00002045 ExprTy **Strings,
2046 unsigned NumStrings);
Mike Stump1eb44332009-09-09 15:08:12 +00002047
2048 Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
Anders Carlssonfc0f0212009-06-07 18:45:35 +00002049 QualType EncodedType,
Mike Stump1eb44332009-09-09 15:08:12 +00002050 SourceLocation RParenLoc);
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002051 CXXMemberCallExpr *BuildCXXMemberCallExpr(Expr *Exp, CXXMethodDecl *Method);
2052
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002053 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00002054 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002055 SourceLocation LParenLoc,
2056 TypeTy *Ty,
2057 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002058
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002059 // ParseObjCSelectorExpression - Build selector expression for @selector
2060 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
2061 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00002062 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002063 SourceLocation LParenLoc,
2064 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002065
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00002066 // ParseObjCProtocolExpression - Build protocol expression for @protocol
2067 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
2068 SourceLocation AtLoc,
2069 SourceLocation ProtoLoc,
2070 SourceLocation LParenLoc,
2071 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002072
2073 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00002074 // C++ Declarations
2075 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00002076 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
2077 SourceLocation ExternLoc,
2078 SourceLocation LangLoc,
2079 const char *Lang,
2080 unsigned StrSize,
2081 SourceLocation LBraceLoc);
2082 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
2083 DeclPtrTy LinkageSpec,
2084 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00002085
2086
2087 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002088 // C++ Classes
2089 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002090 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
2091 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00002092
Chris Lattnerb28317a2009-03-28 19:18:32 +00002093 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
2094 Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +00002095 MultiTemplateParamsArg TemplateParameterLists,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002096 ExprTy *BitfieldWidth,
Sebastian Redld1a78462009-11-24 23:38:44 +00002097 ExprTy *Init, bool IsDefinition,
Sebastian Redle2b68332009-04-12 17:16:29 +00002098 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002099
Chris Lattnerb28317a2009-03-28 19:18:32 +00002100 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002101 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002102 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002103 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +00002104 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002105 SourceLocation IdLoc,
2106 SourceLocation LParenLoc,
2107 ExprTy **Args, unsigned NumArgs,
2108 SourceLocation *CommaLocs,
2109 SourceLocation RParenLoc);
2110
Eli Friedman59c04372009-07-29 19:44:27 +00002111 MemInitResult BuildMemberInitializer(FieldDecl *Member, Expr **Args,
2112 unsigned NumArgs, SourceLocation IdLoc,
Douglas Gregor802ab452009-12-02 22:36:29 +00002113 SourceLocation LParenLoc,
Eli Friedman59c04372009-07-29 19:44:27 +00002114 SourceLocation RParenLoc);
2115
Douglas Gregor802ab452009-12-02 22:36:29 +00002116 MemInitResult BuildBaseInitializer(QualType BaseType,
2117 DeclaratorInfo *BaseDInfo,
2118 Expr **Args, unsigned NumArgs,
2119 SourceLocation LParenLoc,
Eli Friedman59c04372009-07-29 19:44:27 +00002120 SourceLocation RParenLoc,
2121 CXXRecordDecl *ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00002122
Benjamin Kramer3f17a372009-11-09 20:14:44 +00002123 bool SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00002124 CXXBaseOrMemberInitializer **Initializers,
2125 unsigned NumInitializers,
Eli Friedman49c16da2009-11-09 01:05:47 +00002126 bool IsImplicitConstructor);
Mike Stump1eb44332009-09-09 15:08:12 +00002127
Anders Carlsson9f853df2009-11-17 04:44:12 +00002128 /// MarkBaseAndMemberDestructorsReferenced - Given a destructor decl,
2129 /// mark all its non-trivial member and base destructor declarations
2130 /// as referenced.
2131 void MarkBaseAndMemberDestructorsReferenced(CXXDestructorDecl *Destructor);
Mike Stump1eb44332009-09-09 15:08:12 +00002132
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002133 /// MaybeMarkVirtualImplicitMembersReferenced - If the passed in method is the
2134 /// key function of the record decl, will mark virtual member functions as
2135 /// referenced.
2136 void MaybeMarkVirtualImplicitMembersReferenced(SourceLocation Loc,
2137 CXXMethodDecl *MD);
2138
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002139 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
2140
Mike Stump1eb44332009-09-09 15:08:12 +00002141 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00002142 SourceLocation ColonLoc,
2143 MemInitTy **MemInits, unsigned NumMemInits);
Mike Stump1eb44332009-09-09 15:08:12 +00002144
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002145 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002146 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002147 SourceLocation LBrac,
2148 SourceLocation RBrac);
2149
Douglas Gregor6569d682009-05-27 23:11:45 +00002150 virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002151 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
2152 DeclPtrTy Method);
2153 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
2154 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
2155 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002156
Mike Stump1eb44332009-09-09 15:08:12 +00002157 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002158 ExprArg AssertExpr,
2159 ExprArg AssertMessageExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00002160
John McCalldd4a3b02009-09-16 22:47:08 +00002161 DeclPtrTy ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
2162 MultiTemplateParamsArg TemplateParams);
John McCallbbbcdd92009-09-11 21:02:39 +00002163 DeclPtrTy ActOnFriendFunctionDecl(Scope *S, Declarator &D, bool IsDefinition,
2164 MultiTemplateParamsArg TemplateParams);
Anders Carlsson00338362009-05-11 22:55:49 +00002165
Chris Lattner65401802009-04-25 08:28:21 +00002166 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
2167 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002168 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00002169 QualType CheckDestructorDeclarator(Declarator &D,
2170 FunctionDecl::StorageClass& SC);
Anders Carlsson5ec02ae2009-12-02 17:15:43 +00002171 bool CheckDestructor(CXXDestructorDecl *Destructor);
Chris Lattner6e475012009-04-25 08:35:12 +00002172 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002173 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002174 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002175
John McCall129e2df2009-11-30 22:42:35 +00002176 bool isImplicitMemberReference(const LookupResult &R, QualType &ThisType);
Douglas Gregore961afb2009-10-22 07:08:30 +00002177
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002178 //===--------------------------------------------------------------------===//
2179 // C++ Derived Classes
2180 //
2181
2182 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00002183 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
2184 SourceRange SpecifierRange,
2185 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +00002186 QualType BaseType,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002187 SourceLocation BaseLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002188 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002189 SourceRange SpecifierRange,
2190 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +00002191 TypeTy *basetype, SourceLocation
Douglas Gregor2943aed2009-03-03 04:44:36 +00002192 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002193
Douglas Gregor2943aed2009-03-03 04:44:36 +00002194 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
2195 unsigned NumBases);
Mike Stump1eb44332009-09-09 15:08:12 +00002196 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002197 unsigned NumBases);
2198
2199 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregora8f32e02009-10-06 17:59:45 +00002200 bool IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths);
2201
Douglas Gregor0575d4a2008-10-24 16:17:19 +00002202 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00002203 SourceLocation Loc, SourceRange Range,
2204 bool IgnoreAccess = false);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002205 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2206 unsigned InaccessibleBaseID,
2207 unsigned AmbigiousBaseConvID,
2208 SourceLocation Loc, SourceRange Range,
2209 DeclarationName Name);
Mike Stump1eb44332009-09-09 15:08:12 +00002210
Douglas Gregora8f32e02009-10-06 17:59:45 +00002211 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
Mike Stump1eb44332009-09-09 15:08:12 +00002212
Sebastian Redl23c7d062009-07-07 20:29:57 +00002213 /// CheckOverridingFunctionReturnType - Checks whether the return types are
2214 /// covariant, according to C++ [class.virtual]p5.
2215 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002216 const CXXMethodDecl *Old);
Sebastian Redl23c7d062009-07-07 20:29:57 +00002217
2218 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
2219 /// spec is a subset of base spec.
2220 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
2221 const CXXMethodDecl *Old);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002222
Sean Huntbbd37c62009-11-21 08:43:09 +00002223 /// CheckOverridingFunctionAttributes - Checks whether attributes are
2224 /// incompatible or prevent overriding.
2225 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
2226 const CXXMethodDecl *Old);
2227
Douglas Gregor4ba31362009-12-01 17:24:26 +00002228 bool CheckPureMethod(CXXMethodDecl *Method, SourceRange InitRange);
Anders Carlsson29f006b2009-03-27 05:05:05 +00002229 //===--------------------------------------------------------------------===//
2230 // C++ Access Control
2231 //
Sebastian Redl726212f2009-07-18 14:32:15 +00002232
Mike Stump1eb44332009-09-09 15:08:12 +00002233 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
Anders Carlsson29f006b2009-03-27 05:05:05 +00002234 NamedDecl *PrevMemberDecl,
2235 AccessSpecifier LexicalAS);
Sebastian Redl726212f2009-07-18 14:32:15 +00002236
2237 const CXXBaseSpecifier *FindInaccessibleBase(QualType Derived, QualType Base,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002238 CXXBasePaths &Paths,
Sebastian Redl726212f2009-07-18 14:32:15 +00002239 bool NoPrivileges = false);
2240
2241 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002242 unsigned InaccessibleBaseID,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002243 CXXBasePaths& Paths, SourceLocation AccessLoc,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002244 DeclarationName Name);
Sebastian Redl726212f2009-07-18 14:32:15 +00002245
2246
Anders Carlsson8211eff2009-03-24 01:19:16 +00002247 enum AbstractDiagSelID {
2248 AbstractNone = -1,
2249 AbstractReturnType,
2250 AbstractParamType,
2251 AbstractVariableType,
2252 AbstractFieldType
2253 };
Mike Stump1eb44332009-09-09 15:08:12 +00002254
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00002255 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
2256 const PartialDiagnostic &PD,
2257 const CXXRecordDecl *CurrentRD = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002258
2259 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00002260 AbstractDiagSelID SelID = AbstractNone,
2261 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002262
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002263 //===--------------------------------------------------------------------===//
2264 // C++ Overloaded Operators [C++ 13.5]
2265 //
2266
2267 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
2268
Douglas Gregor72c3f312008-12-05 18:15:24 +00002269 //===--------------------------------------------------------------------===//
2270 // C++ Templates [C++ 14]
2271 //
John McCallf7a1a742009-11-24 19:00:30 +00002272 void LookupTemplateName(LookupResult &R, Scope *S, const CXXScopeSpec &SS,
2273 QualType ObjectType, bool EnteringContext);
2274
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002275 virtual TemplateNameKind isTemplateName(Scope *S,
Douglas Gregor014e88d2009-11-03 23:16:33 +00002276 const CXXScopeSpec &SS,
2277 UnqualifiedId &Name,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002278 TypeTy *ObjectType,
Douglas Gregor495c35d2009-08-25 22:51:20 +00002279 bool EnteringContext,
2280 TemplateTy &Template);
Douglas Gregor72c3f312008-12-05 18:15:24 +00002281 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002282 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002283
Mike Stump1eb44332009-09-09 15:08:12 +00002284 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
Anders Carlsson941df7d2009-06-12 19:58:00 +00002285 SourceLocation EllipsisLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002286 SourceLocation KeyLoc,
2287 IdentifierInfo *ParamName,
2288 SourceLocation ParamNameLoc,
2289 unsigned Depth, unsigned Position);
Mike Stump1eb44332009-09-09 15:08:12 +00002290 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002291 SourceLocation EqualLoc,
2292 SourceLocation DefaultLoc,
2293 TypeTy *Default);
2294
Douglas Gregor2943aed2009-03-03 04:44:36 +00002295 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002296 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
2297 unsigned Depth,
2298 unsigned Position);
2299 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002300 SourceLocation EqualLoc,
2301 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002302 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
2303 SourceLocation TmpLoc,
2304 TemplateParamsTy *Params,
2305 IdentifierInfo *ParamName,
2306 SourceLocation ParamNameLoc,
2307 unsigned Depth,
2308 unsigned Position);
2309 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002310 SourceLocation EqualLoc,
Douglas Gregor788cd062009-11-11 01:00:40 +00002311 const ParsedTemplateArgument &Default);
Douglas Gregord684b002009-02-10 19:49:53 +00002312
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002313 virtual TemplateParamsTy *
2314 ActOnTemplateParameterList(unsigned Depth,
2315 SourceLocation ExportLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002316 SourceLocation TemplateLoc,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002317 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002318 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002319 SourceLocation RAngleLoc);
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00002320
2321 /// \brief The context in which we are checking a template parameter
2322 /// list.
2323 enum TemplateParamListContext {
2324 TPC_ClassTemplate,
2325 TPC_FunctionTemplate,
2326 TPC_ClassTemplateMember,
2327 TPC_FriendFunctionTemplate
2328 };
2329
Douglas Gregord684b002009-02-10 19:49:53 +00002330 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00002331 TemplateParameterList *OldParams,
2332 TemplateParamListContext TPC);
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002333 TemplateParameterList *
2334 MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
2335 const CXXScopeSpec &SS,
2336 TemplateParameterList **ParamLists,
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002337 unsigned NumParamLists,
2338 bool &IsExplicitSpecialization);
Mike Stump1eb44332009-09-09 15:08:12 +00002339
John McCall0f434ec2009-07-31 02:45:11 +00002340 DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002341 SourceLocation KWLoc, const CXXScopeSpec &SS,
2342 IdentifierInfo *Name, SourceLocation NameLoc,
2343 AttributeList *Attr,
Douglas Gregor05396e22009-08-25 17:23:04 +00002344 TemplateParameterList *TemplateParams,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002345 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002346
John McCalld5532b62009-11-23 01:53:49 +00002347 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
2348 TemplateArgumentListInfo &Out);
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002349
Douglas Gregor7532dc62009-03-30 22:58:21 +00002350 QualType CheckTemplateIdType(TemplateName Template,
2351 SourceLocation TemplateLoc,
John McCalld5532b62009-11-23 01:53:49 +00002352 const TemplateArgumentListInfo &TemplateArgs);
Douglas Gregor40808ce2009-03-09 23:48:35 +00002353
Douglas Gregorcc636682009-02-17 23:15:12 +00002354 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00002355 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
2356 SourceLocation LAngleLoc,
2357 ASTTemplateArgsPtr TemplateArgs,
John McCall6b2becf2009-09-08 17:47:29 +00002358 SourceLocation RAngleLoc);
2359
2360 virtual TypeResult ActOnTagTemplateIdType(TypeResult Type,
2361 TagUseKind TUK,
2362 DeclSpec::TST TagSpec,
2363 SourceLocation TagLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002364
John McCallf7a1a742009-11-24 19:00:30 +00002365 OwningExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
2366 LookupResult &R,
2367 bool RequiresADL,
John McCalld5532b62009-11-23 01:53:49 +00002368 const TemplateArgumentListInfo &TemplateArgs);
John McCallf7a1a742009-11-24 19:00:30 +00002369 OwningExprResult BuildQualifiedTemplateIdExpr(const CXXScopeSpec &SS,
2370 DeclarationName Name,
2371 SourceLocation NameLoc,
2372 const TemplateArgumentListInfo &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00002373
Douglas Gregorc45c2322009-03-31 00:43:58 +00002374 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002375 const CXXScopeSpec &SS,
Douglas Gregor014e88d2009-11-03 23:16:33 +00002376 UnqualifiedId &Name,
Douglas Gregora481edb2009-11-20 23:39:24 +00002377 TypeTy *ObjectType,
2378 bool EnteringContext);
Douglas Gregorc45c2322009-03-31 00:43:58 +00002379
Douglas Gregore94866f2009-06-12 21:21:02 +00002380 bool CheckClassTemplatePartialSpecializationArgs(
2381 TemplateParameterList *TemplateParams,
Anders Carlsson6360be72009-06-13 18:20:51 +00002382 const TemplateArgumentListBuilder &TemplateArgs,
Douglas Gregor6aa75cf2009-06-12 22:08:06 +00002383 bool &MirrorsPrimaryTemplate);
Douglas Gregore94866f2009-06-12 21:21:02 +00002384
Douglas Gregor212e81c2009-03-25 00:13:59 +00002385 virtual DeclResult
John McCall0f434ec2009-07-31 02:45:11 +00002386 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
Mike Stump1eb44332009-09-09 15:08:12 +00002387 SourceLocation KWLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002388 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00002389 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00002390 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002391 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00002392 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002393 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002394 AttributeList *Attr,
2395 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002396
Mike Stump1eb44332009-09-09 15:08:12 +00002397 virtual DeclPtrTy ActOnTemplateDeclarator(Scope *S,
Douglas Gregore542c862009-06-23 23:11:28 +00002398 MultiTemplateParamsArg TemplateParameterLists,
2399 Declarator &D);
Mike Stump1eb44332009-09-09 15:08:12 +00002400
2401 virtual DeclPtrTy ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
Douglas Gregor52591bf2009-06-24 00:54:41 +00002402 MultiTemplateParamsArg TemplateParameterLists,
2403 Declarator &D);
Mike Stump1eb44332009-09-09 15:08:12 +00002404
Douglas Gregor0d035142009-10-27 18:42:08 +00002405 bool
2406 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
2407 TemplateSpecializationKind NewTSK,
2408 NamedDecl *PrevDecl,
2409 TemplateSpecializationKind PrevTSK,
2410 SourceLocation PrevPointOfInstantiation,
2411 bool &SuppressNew);
2412
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002413 bool CheckFunctionTemplateSpecialization(FunctionDecl *FD,
John McCalld5532b62009-11-23 01:53:49 +00002414 const TemplateArgumentListInfo *ExplicitTemplateArgs,
John McCall68263142009-11-18 22:49:29 +00002415 LookupResult &Previous);
2416 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002417
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002418 virtual DeclResult
Mike Stump1eb44332009-09-09 15:08:12 +00002419 ActOnExplicitInstantiation(Scope *S,
Douglas Gregor45f96552009-09-04 06:33:52 +00002420 SourceLocation ExternLoc,
2421 SourceLocation TemplateLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002422 unsigned TagSpec,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002423 SourceLocation KWLoc,
2424 const CXXScopeSpec &SS,
2425 TemplateTy Template,
2426 SourceLocation TemplateNameLoc,
2427 SourceLocation LAngleLoc,
2428 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002429 SourceLocation RAngleLoc,
2430 AttributeList *Attr);
2431
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002432 virtual DeclResult
Mike Stump1eb44332009-09-09 15:08:12 +00002433 ActOnExplicitInstantiation(Scope *S,
Douglas Gregor45f96552009-09-04 06:33:52 +00002434 SourceLocation ExternLoc,
2435 SourceLocation TemplateLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002436 unsigned TagSpec,
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002437 SourceLocation KWLoc,
2438 const CXXScopeSpec &SS,
2439 IdentifierInfo *Name,
2440 SourceLocation NameLoc,
2441 AttributeList *Attr);
2442
Douglas Gregord5a423b2009-09-25 18:43:00 +00002443 virtual DeclResult ActOnExplicitInstantiation(Scope *S,
2444 SourceLocation ExternLoc,
2445 SourceLocation TemplateLoc,
2446 Declarator &D);
2447
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002448 TemplateArgumentLoc
2449 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
2450 SourceLocation TemplateLoc,
2451 SourceLocation RAngleLoc,
2452 Decl *Param,
2453 TemplateArgumentListBuilder &Converted);
2454
Douglas Gregore7526412009-11-11 19:31:23 +00002455 bool CheckTemplateArgument(NamedDecl *Param,
2456 const TemplateArgumentLoc &Arg,
Douglas Gregore7526412009-11-11 19:31:23 +00002457 TemplateDecl *Template,
2458 SourceLocation TemplateLoc,
Douglas Gregore7526412009-11-11 19:31:23 +00002459 SourceLocation RAngleLoc,
2460 TemplateArgumentListBuilder &Converted);
2461
Douglas Gregorc15cb382009-02-09 23:23:08 +00002462 bool CheckTemplateArgumentList(TemplateDecl *Template,
2463 SourceLocation TemplateLoc,
John McCalld5532b62009-11-23 01:53:49 +00002464 const TemplateArgumentListInfo &TemplateArgs,
Douglas Gregor16134c62009-07-01 00:28:38 +00002465 bool PartialTemplateArgs,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00002466 TemplateArgumentListBuilder &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002467
Mike Stump1eb44332009-09-09 15:08:12 +00002468 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
John McCall833ca992009-10-29 08:12:44 +00002469 const TemplateArgumentLoc &Arg,
Anders Carlsson436b1562009-06-13 00:33:33 +00002470 TemplateArgumentListBuilder &Converted);
2471
John McCall833ca992009-10-29 08:12:44 +00002472 bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
2473 DeclaratorInfo *Arg);
Mike Stump1eb44332009-09-09 15:08:12 +00002474 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002475 NamedDecl *&Entity);
Douglas Gregorcaddba02009-11-12 18:38:13 +00002476 bool CheckTemplateArgumentPointerToMember(Expr *Arg,
2477 TemplateArgument &Converted);
Mike Stump1eb44332009-09-09 15:08:12 +00002478 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002479 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor02cbbd22009-06-11 18:10:32 +00002480 TemplateArgument &Converted);
Douglas Gregor788cd062009-11-11 01:00:40 +00002481 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param,
2482 const TemplateArgumentLoc &Arg);
Douglas Gregorfb898e12009-11-12 16:20:59 +00002483
2484 /// \brief Enumeration describing how template parameter lists are compared
2485 /// for equality.
2486 enum TemplateParameterListEqualKind {
2487 /// \brief We are matching the template parameter lists of two templates
2488 /// that might be redeclarations.
2489 ///
2490 /// \code
2491 /// template<typename T> struct X;
2492 /// template<typename T> struct X;
2493 /// \endcode
2494 TPL_TemplateMatch,
2495
2496 /// \brief We are matching the template parameter lists of two template
2497 /// template parameters as part of matching the template parameter lists
2498 /// of two templates that might be redeclarations.
2499 ///
2500 /// \code
2501 /// template<template<int I> class TT> struct X;
2502 /// template<template<int Value> class Other> struct X;
2503 /// \endcode
2504 TPL_TemplateTemplateParmMatch,
2505
2506 /// \brief We are matching the template parameter lists of a template
2507 /// template argument against the template parameter lists of a template
2508 /// template parameter.
2509 ///
2510 /// \code
2511 /// template<template<int Value> class Metafun> struct X;
2512 /// template<int Value> struct integer_c;
2513 /// X<integer_c> xic;
2514 /// \endcode
2515 TPL_TemplateTemplateArgumentMatch
2516 };
2517
Douglas Gregorddc29e12009-02-06 22:42:48 +00002518 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
2519 TemplateParameterList *Old,
2520 bool Complain,
Douglas Gregorfb898e12009-11-12 16:20:59 +00002521 TemplateParameterListEqualKind Kind,
Douglas Gregordd0574e2009-02-10 00:24:35 +00002522 SourceLocation TemplateArgLoc
Douglas Gregor788cd062009-11-11 01:00:40 +00002523 = SourceLocation());
Mike Stump1eb44332009-09-09 15:08:12 +00002524
Douglas Gregor05396e22009-08-25 17:23:04 +00002525 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002526
Douglas Gregord57959a2009-03-27 23:10:48 +00002527 /// \brief Called when the parser has parsed a C++ typename
2528 /// specifier, e.g., "typename T::type".
2529 ///
2530 /// \param TypenameLoc the location of the 'typename' keyword
2531 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2532 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
2533 /// \param IdLoc the location of the identifier.
2534 virtual TypeResult
2535 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2536 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00002537
2538 /// \brief Called when the parser has parsed a C++ typename
Mike Stump1eb44332009-09-09 15:08:12 +00002539 /// specifier that ends in a template-id, e.g.,
Douglas Gregor17343172009-04-01 00:28:59 +00002540 /// "typename MetaFun::template apply<T1, T2>".
2541 ///
2542 /// \param TypenameLoc the location of the 'typename' keyword
2543 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2544 /// \param TemplateLoc the location of the 'template' keyword, if any.
2545 /// \param Ty the type that the typename specifier refers to.
2546 virtual TypeResult
2547 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2548 SourceLocation TemplateLoc, TypeTy *Ty);
2549
Douglas Gregord57959a2009-03-27 23:10:48 +00002550 QualType CheckTypenameType(NestedNameSpecifier *NNS,
2551 const IdentifierInfo &II,
2552 SourceRange Range);
Douglas Gregorc8ab2562009-05-31 09:31:02 +00002553
Douglas Gregor4a959d82009-08-06 16:20:37 +00002554 QualType RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc,
2555 DeclarationName Name);
2556
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002557 std::string
2558 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
2559 const TemplateArgumentList &Args);
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002560
2561 std::string
2562 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
2563 const TemplateArgument *Args,
2564 unsigned NumArgs);
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002565
Douglas Gregorf67875d2009-06-12 18:26:56 +00002566 /// \brief Describes the result of template argument deduction.
2567 ///
2568 /// The TemplateDeductionResult enumeration describes the result of
2569 /// template argument deduction, as returned from
2570 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
2571 /// structure provides additional information about the results of
2572 /// template argument deduction, e.g., the deduced template argument
2573 /// list (if successful) or the specific template parameters or
2574 /// deduced arguments that were involved in the failure.
2575 enum TemplateDeductionResult {
2576 /// \brief Template argument deduction was successful.
2577 TDK_Success = 0,
2578 /// \brief Template argument deduction exceeded the maximum template
2579 /// instantiation depth (which has already been diagnosed).
2580 TDK_InstantiationDepth,
2581 /// \brief Template argument deduction did not deduce a value
2582 /// for every template parameter.
2583 TDK_Incomplete,
2584 /// \brief Template argument deduction produced inconsistent
2585 /// deduced values for the given template parameter.
2586 TDK_Inconsistent,
2587 /// \brief Template argument deduction failed due to inconsistent
2588 /// cv-qualifiers on a template parameter type that would
2589 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
2590 /// but were given a non-const "X".
2591 TDK_InconsistentQuals,
2592 /// \brief Substitution of the deduced template argument values
2593 /// resulted in an error.
2594 TDK_SubstitutionFailure,
2595 /// \brief Substitution of the deduced template argument values
2596 /// into a non-deduced context produced a type or value that
2597 /// produces a type that does not match the original template
2598 /// arguments provided.
Douglas Gregore53060f2009-06-25 22:08:12 +00002599 TDK_NonDeducedMismatch,
Mike Stump1eb44332009-09-09 15:08:12 +00002600 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002601 /// template, there were too many call arguments.
2602 TDK_TooManyArguments,
Mike Stump1eb44332009-09-09 15:08:12 +00002603 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002604 /// template, there were too few call arguments.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002605 TDK_TooFewArguments,
2606 /// \brief The explicitly-specified template arguments were not valid
2607 /// template arguments for the given template.
2608 TDK_InvalidExplicitArguments
Douglas Gregorf67875d2009-06-12 18:26:56 +00002609 };
2610
2611 /// \brief Provides information about an attempted template argument
2612 /// deduction, whose success or failure was described by a
2613 /// TemplateDeductionResult value.
2614 class TemplateDeductionInfo {
2615 /// \brief The context in which the template arguments are stored.
2616 ASTContext &Context;
2617
2618 /// \brief The deduced template argument list.
2619 ///
2620 TemplateArgumentList *Deduced;
2621
2622 // do not implement these
2623 TemplateDeductionInfo(const TemplateDeductionInfo&);
2624 TemplateDeductionInfo &operator=(const TemplateDeductionInfo&);
2625
2626 public:
2627 TemplateDeductionInfo(ASTContext &Context) : Context(Context), Deduced(0) { }
2628
2629 ~TemplateDeductionInfo() {
2630 // FIXME: if (Deduced) Deduced->Destroy(Context);
2631 }
2632
2633 /// \brief Take ownership of the deduced template argument list.
Mike Stump1eb44332009-09-09 15:08:12 +00002634 TemplateArgumentList *take() {
Douglas Gregorf67875d2009-06-12 18:26:56 +00002635 TemplateArgumentList *Result = Deduced;
2636 Deduced = 0;
2637 return Result;
2638 }
2639
2640 /// \brief Provide a new template argument list that contains the
2641 /// results of template argument deduction.
2642 void reset(TemplateArgumentList *NewDeduced) {
2643 // FIXME: if (Deduced) Deduced->Destroy(Context);
2644 Deduced = NewDeduced;
2645 }
2646
2647 /// \brief The template parameter to which a template argument
2648 /// deduction failure refers.
2649 ///
2650 /// Depending on the result of template argument deduction, this
2651 /// template parameter may have different meanings:
2652 ///
2653 /// TDK_Incomplete: this is the first template parameter whose
2654 /// corresponding template argument was not deduced.
2655 ///
2656 /// TDK_Inconsistent: this is the template parameter for which
2657 /// two different template argument values were deduced.
2658 TemplateParameter Param;
2659
2660 /// \brief The first template argument to which the template
2661 /// argument deduction failure refers.
2662 ///
2663 /// Depending on the result of the template argument deduction,
2664 /// this template argument may have different meanings:
2665 ///
2666 /// TDK_Inconsistent: this argument is the first value deduced
2667 /// for the corresponding template parameter.
2668 ///
2669 /// TDK_SubstitutionFailure: this argument is the template
2670 /// argument we were instantiating when we encountered an error.
2671 ///
2672 /// TDK_NonDeducedMismatch: this is the template argument
2673 /// provided in the source code.
2674 TemplateArgument FirstArg;
2675
2676 /// \brief The second template argument to which the template
2677 /// argument deduction failure refers.
2678 ///
2679 /// FIXME: Finish documenting this.
2680 TemplateArgument SecondArg;
2681 };
2682
2683 TemplateDeductionResult
Douglas Gregor199d9912009-06-05 00:53:49 +00002684 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002685 const TemplateArgumentList &TemplateArgs,
2686 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002687
Douglas Gregor83314aa2009-07-08 20:55:45 +00002688 TemplateDeductionResult
2689 SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002690 const TemplateArgumentListInfo &ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002691 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2692 llvm::SmallVectorImpl<QualType> &ParamTypes,
2693 QualType *FunctionType,
2694 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002695
2696 TemplateDeductionResult
Douglas Gregor83314aa2009-07-08 20:55:45 +00002697 FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
2698 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2699 FunctionDecl *&Specialization,
2700 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002701
Douglas Gregore53060f2009-06-25 22:08:12 +00002702 TemplateDeductionResult
2703 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002704 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +00002705 Expr **Args, unsigned NumArgs,
2706 FunctionDecl *&Specialization,
2707 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002708
2709 TemplateDeductionResult
2710 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002711 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002712 QualType ArgFunctionType,
2713 FunctionDecl *&Specialization,
2714 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002715
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002716 TemplateDeductionResult
2717 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2718 QualType ToType,
2719 CXXConversionDecl *&Specialization,
2720 TemplateDeductionInfo &Info);
2721
2722 FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
2723 FunctionTemplateDecl *FT2,
Douglas Gregor8a514912009-09-14 18:39:43 +00002724 TemplatePartialOrderingContext TPOC);
Douglas Gregord5a423b2009-09-25 18:43:00 +00002725 FunctionDecl *getMostSpecialized(FunctionDecl **Specializations,
2726 unsigned NumSpecializations,
2727 TemplatePartialOrderingContext TPOC,
2728 SourceLocation Loc,
2729 const PartialDiagnostic &NoneDiag,
2730 const PartialDiagnostic &AmbigDiag,
2731 const PartialDiagnostic &CandidateDiag,
2732 unsigned *Index = 0);
2733
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002734 ClassTemplatePartialSpecializationDecl *
2735 getMoreSpecializedPartialSpecialization(
2736 ClassTemplatePartialSpecializationDecl *PS1,
2737 ClassTemplatePartialSpecializationDecl *PS2);
2738
Douglas Gregore73bb602009-09-14 21:25:05 +00002739 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
2740 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00002741 unsigned Depth,
Douglas Gregor63f07c52009-09-18 23:21:38 +00002742 llvm::SmallVectorImpl<bool> &Used);
2743 void MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate,
2744 llvm::SmallVectorImpl<bool> &Deduced);
2745
Douglas Gregor99ebf652009-02-27 19:31:52 +00002746 //===--------------------------------------------------------------------===//
2747 // C++ Template Instantiation
2748 //
Douglas Gregor26dce442009-03-10 00:06:19 +00002749
Douglas Gregor0f8716b2009-11-09 19:17:50 +00002750 MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D,
2751 const TemplateArgumentList *Innermost = 0);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002752
Douglas Gregor26dce442009-03-10 00:06:19 +00002753 /// \brief A template instantiation that is currently in progress.
2754 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00002755 /// \brief The kind of template instantiation we are performing
Douglas Gregorcca9e962009-07-01 22:01:06 +00002756 enum InstantiationKind {
Douglas Gregordf667e72009-03-10 20:44:00 +00002757 /// We are instantiating a template declaration. The entity is
Douglas Gregorb9f1b8d2009-05-15 00:01:03 +00002758 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00002759 TemplateInstantiation,
2760
2761 /// We are instantiating a default argument for a template
2762 /// parameter. The Entity is the template, and
2763 /// TemplateArgs/NumTemplateArguments provides the template
2764 /// arguments as specified.
Douglas Gregor637a4092009-06-10 23:47:09 +00002765 /// FIXME: Use a TemplateArgumentList
2766 DefaultTemplateArgumentInstantiation,
2767
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002768 /// We are instantiating a default argument for a function.
2769 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
2770 /// provides the template arguments as specified.
2771 DefaultFunctionArgumentInstantiation,
2772
Mike Stump1eb44332009-09-09 15:08:12 +00002773 /// We are substituting explicit template arguments provided for
Douglas Gregorcca9e962009-07-01 22:01:06 +00002774 /// a function template. The entity is a FunctionTemplateDecl.
2775 ExplicitTemplateArgumentSubstitution,
Mike Stump1eb44332009-09-09 15:08:12 +00002776
Douglas Gregorcca9e962009-07-01 22:01:06 +00002777 /// We are substituting template argument determined as part of
2778 /// template argument deduction for either a class template
2779 /// partial specialization or a function template. The
2780 /// Entity is either a ClassTemplatePartialSpecializationDecl or
2781 /// a FunctionTemplateDecl.
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002782 DeducedTemplateArgumentSubstitution,
2783
2784 /// We are substituting prior template arguments into a new
2785 /// template parameter. The template parameter itself is either a
2786 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
Douglas Gregorf35f8282009-11-11 21:54:23 +00002787 PriorTemplateArgumentSubstitution,
2788
2789 /// We are checking the validity of a default template argument that
2790 /// has been used when naming a template-id.
2791 DefaultTemplateArgumentChecking
Douglas Gregordf667e72009-03-10 20:44:00 +00002792 } Kind;
2793
Douglas Gregor26dce442009-03-10 00:06:19 +00002794 /// \brief The point of instantiation within the source code.
2795 SourceLocation PointOfInstantiation;
2796
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002797 /// \brief The template in which we are performing the instantiation,
2798 /// for substitutions of prior template arguments.
2799 TemplateDecl *Template;
2800
Douglas Gregor26dce442009-03-10 00:06:19 +00002801 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00002802 uintptr_t Entity;
2803
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002804 /// \brief The list of template arguments we are substituting, if they
2805 /// are not part of the entity.
Douglas Gregordf667e72009-03-10 20:44:00 +00002806 const TemplateArgument *TemplateArgs;
2807
2808 /// \brief The number of template arguments in TemplateArgs.
2809 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002810
2811 /// \brief The source range that covers the construct that cause
2812 /// the instantiation, e.g., the template-id that causes a class
2813 /// template instantiation.
2814 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002815
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002816 ActiveTemplateInstantiation()
2817 : Kind(TemplateInstantiation), Template(0), Entity(0), TemplateArgs(0),
2818 NumTemplateArgs(0) {}
Eli Friedman2ebcc6b2009-08-15 22:50:33 +00002819
Douglas Gregorf35f8282009-11-11 21:54:23 +00002820 /// \brief Determines whether this template is an actual instantiation
2821 /// that should be counted toward the maximum instantiation depth.
2822 bool isInstantiationRecord() const;
2823
Douglas Gregordf667e72009-03-10 20:44:00 +00002824 friend bool operator==(const ActiveTemplateInstantiation &X,
2825 const ActiveTemplateInstantiation &Y) {
2826 if (X.Kind != Y.Kind)
2827 return false;
2828
2829 if (X.Entity != Y.Entity)
2830 return false;
2831
2832 switch (X.Kind) {
2833 case TemplateInstantiation:
2834 return true;
2835
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002836 case PriorTemplateArgumentSubstitution:
Douglas Gregorf35f8282009-11-11 21:54:23 +00002837 case DefaultTemplateArgumentChecking:
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002838 if (X.Template != Y.Template)
2839 return false;
2840
2841 // Fall through
2842
Douglas Gregordf667e72009-03-10 20:44:00 +00002843 case DefaultTemplateArgumentInstantiation:
Douglas Gregorcca9e962009-07-01 22:01:06 +00002844 case ExplicitTemplateArgumentSubstitution:
2845 case DeducedTemplateArgumentSubstitution:
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002846 case DefaultFunctionArgumentInstantiation:
Douglas Gregordf667e72009-03-10 20:44:00 +00002847 return X.TemplateArgs == Y.TemplateArgs;
Mike Stump1eb44332009-09-09 15:08:12 +00002848
Douglas Gregordf667e72009-03-10 20:44:00 +00002849 }
2850
2851 return true;
2852 }
2853
2854 friend bool operator!=(const ActiveTemplateInstantiation &X,
2855 const ActiveTemplateInstantiation &Y) {
2856 return !(X == Y);
2857 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002858 };
2859
2860 /// \brief List of active template instantiations.
2861 ///
2862 /// This vector is treated as a stack. As one template instantiation
2863 /// requires another template instantiation, additional
2864 /// instantiations are pushed onto the stack up to a
2865 /// user-configurable limit LangOptions::InstantiationDepth.
Mike Stump1eb44332009-09-09 15:08:12 +00002866 llvm::SmallVector<ActiveTemplateInstantiation, 16>
Douglas Gregor26dce442009-03-10 00:06:19 +00002867 ActiveTemplateInstantiations;
2868
Douglas Gregorf35f8282009-11-11 21:54:23 +00002869 /// \brief The number of ActiveTemplateInstantiation entries in
2870 /// \c ActiveTemplateInstantiations that are not actual instantiations and,
2871 /// therefore, should not be counted as part of the instantiation depth.
2872 unsigned NonInstantiationEntries;
2873
Douglas Gregor27b152f2009-03-10 18:52:44 +00002874 /// \brief The last template from which a template instantiation
2875 /// error or warning was produced.
2876 ///
2877 /// This value is used to suppress printing of redundant template
2878 /// instantiation backtraces when there are multiple errors in the
2879 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2880 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002881 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002882
Douglas Gregor26dce442009-03-10 00:06:19 +00002883 /// \brief A stack object to be created when performing template
2884 /// instantiation.
2885 ///
2886 /// Construction of an object of type \c InstantiatingTemplate
2887 /// pushes the current instantiation onto the stack of active
2888 /// instantiations. If the size of this stack exceeds the maximum
2889 /// number of recursive template instantiations, construction
2890 /// produces an error and evaluates true.
2891 ///
2892 /// Destruction of this object will pop the named instantiation off
2893 /// the stack.
2894 struct InstantiatingTemplate {
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002895 /// \brief Note that we are instantiating a class template,
2896 /// function template, or a member thereof.
Douglas Gregor26dce442009-03-10 00:06:19 +00002897 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002898 Decl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002899 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002900
2901 /// \brief Note that we are instantiating a default argument in a
2902 /// template-id.
2903 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2904 TemplateDecl *Template,
2905 const TemplateArgument *TemplateArgs,
2906 unsigned NumTemplateArgs,
2907 SourceRange InstantiationRange = SourceRange());
2908
Douglas Gregorcca9e962009-07-01 22:01:06 +00002909 /// \brief Note that we are instantiating a default argument in a
2910 /// template-id.
2911 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2912 FunctionTemplateDecl *FunctionTemplate,
2913 const TemplateArgument *TemplateArgs,
2914 unsigned NumTemplateArgs,
2915 ActiveTemplateInstantiation::InstantiationKind Kind,
2916 SourceRange InstantiationRange = SourceRange());
Mike Stump1eb44332009-09-09 15:08:12 +00002917
Douglas Gregor637a4092009-06-10 23:47:09 +00002918 /// \brief Note that we are instantiating as part of template
2919 /// argument deduction for a class template partial
2920 /// specialization.
2921 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2922 ClassTemplatePartialSpecializationDecl *PartialSpec,
2923 const TemplateArgument *TemplateArgs,
2924 unsigned NumTemplateArgs,
2925 SourceRange InstantiationRange = SourceRange());
2926
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002927 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2928 ParmVarDecl *Param,
2929 const TemplateArgument *TemplateArgs,
2930 unsigned NumTemplateArgs,
2931 SourceRange InstantiationRange = SourceRange());
2932
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002933 /// \brief Note that we are substituting prior template arguments into a
2934 /// non-type or template template parameter.
2935 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2936 TemplateDecl *Template,
2937 NonTypeTemplateParmDecl *Param,
2938 const TemplateArgument *TemplateArgs,
2939 unsigned NumTemplateArgs,
2940 SourceRange InstantiationRange);
2941
2942 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2943 TemplateDecl *Template,
2944 TemplateTemplateParmDecl *Param,
2945 const TemplateArgument *TemplateArgs,
2946 unsigned NumTemplateArgs,
2947 SourceRange InstantiationRange);
2948
Douglas Gregorf35f8282009-11-11 21:54:23 +00002949 /// \brief Note that we are checking the default template argument
2950 /// against the template parameter for a given template-id.
2951 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2952 TemplateDecl *Template,
2953 NamedDecl *Param,
2954 const TemplateArgument *TemplateArgs,
2955 unsigned NumTemplateArgs,
2956 SourceRange InstantiationRange);
2957
2958
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002959 /// \brief Note that we have finished instantiating this template.
2960 void Clear();
2961
2962 ~InstantiatingTemplate() { Clear(); }
Douglas Gregor26dce442009-03-10 00:06:19 +00002963
2964 /// \brief Determines whether we have exceeded the maximum
2965 /// recursive template instantiations.
2966 operator bool() const { return Invalid; }
2967
2968 private:
2969 Sema &SemaRef;
2970 bool Invalid;
2971
Douglas Gregordf667e72009-03-10 20:44:00 +00002972 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2973 SourceRange InstantiationRange);
2974
Douglas Gregor26dce442009-03-10 00:06:19 +00002975 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2976
Mike Stump1eb44332009-09-09 15:08:12 +00002977 InstantiatingTemplate&
Douglas Gregor26dce442009-03-10 00:06:19 +00002978 operator=(const InstantiatingTemplate&); // not implemented
2979 };
2980
Douglas Gregoree1828a2009-03-10 18:03:33 +00002981 void PrintInstantiationStack();
2982
Douglas Gregor5e9f35c2009-06-14 07:33:30 +00002983 /// \brief Determines whether we are currently in a context where
2984 /// template argument substitution failures are not considered
2985 /// errors.
2986 ///
2987 /// When this routine returns true, the emission of most diagnostics
2988 /// will be suppressed and there will be no local error recovery.
2989 bool isSFINAEContext() const;
2990
Douglas Gregorbb260412009-06-14 08:02:22 +00002991 /// \brief RAII class used to determine whether SFINAE has
2992 /// trapped any errors that occur during template argument
2993 /// deduction.
2994 class SFINAETrap {
2995 Sema &SemaRef;
2996 unsigned PrevSFINAEErrors;
2997 public:
2998 explicit SFINAETrap(Sema &SemaRef)
2999 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors) { }
3000
3001 ~SFINAETrap() { SemaRef.NumSFINAEErrors = PrevSFINAEErrors; }
3002
3003 /// \brief Determine whether any SFINAE errors have been trapped.
Mike Stump1eb44332009-09-09 15:08:12 +00003004 bool hasErrorOccurred() const {
3005 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
Douglas Gregorbb260412009-06-14 08:02:22 +00003006 }
3007 };
3008
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003009 /// \brief A stack-allocated class that identifies which local
3010 /// variable declaration instantiations are present in this scope.
3011 ///
3012 /// A new instance of this class type will be created whenever we
3013 /// instantiate a new function declaration, which will have its own
3014 /// set of parameter declarations.
3015 class LocalInstantiationScope {
3016 /// \brief Reference to the semantic analysis that is performing
3017 /// this template instantiation.
3018 Sema &SemaRef;
3019
Douglas Gregor815215d2009-05-27 05:35:12 +00003020 /// \brief A mapping from local declarations that occur
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003021 /// within a template to their instantiations.
3022 ///
3023 /// This mapping is used during instantiation to keep track of,
3024 /// e.g., function parameter and variable declarations. For example,
3025 /// given:
3026 ///
3027 /// \code
3028 /// template<typename T> T add(T x, T y) { return x + y; }
3029 /// \endcode
3030 ///
3031 /// when we instantiate add<int>, we will introduce a mapping from
3032 /// the ParmVarDecl for 'x' that occurs in the template to the
3033 /// instantiated ParmVarDecl for 'x'.
Douglas Gregor815215d2009-05-27 05:35:12 +00003034 llvm::DenseMap<const Decl *, Decl *> LocalDecls;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003035
3036 /// \brief The outer scope, in which contains local variable
Douglas Gregor550d9b22009-10-31 17:21:17 +00003037 /// definitions from some other instantiation (that may not be
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003038 /// relevant to this particular scope).
3039 LocalInstantiationScope *Outer;
3040
3041 // This class is non-copyable
3042 LocalInstantiationScope(const LocalInstantiationScope &);
3043 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
3044
3045 public:
Douglas Gregor550d9b22009-10-31 17:21:17 +00003046 LocalInstantiationScope(Sema &SemaRef, bool CombineWithOuterScope = false)
Mike Stump1eb44332009-09-09 15:08:12 +00003047 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
Douglas Gregor550d9b22009-10-31 17:21:17 +00003048 if (!CombineWithOuterScope)
3049 SemaRef.CurrentInstantiationScope = this;
3050 else
3051 assert(SemaRef.CurrentInstantiationScope &&
3052 "No outer instantiation scope?");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003053 }
3054
3055 ~LocalInstantiationScope() {
3056 SemaRef.CurrentInstantiationScope = Outer;
3057 }
3058
Douglas Gregor815215d2009-05-27 05:35:12 +00003059 Decl *getInstantiationOf(const Decl *D) {
3060 Decl *Result = LocalDecls[D];
3061 assert(Result && "declaration was not instantiated in this scope!");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003062 return Result;
3063 }
3064
Douglas Gregor815215d2009-05-27 05:35:12 +00003065 VarDecl *getInstantiationOf(const VarDecl *Var) {
3066 return cast<VarDecl>(getInstantiationOf(cast<Decl>(Var)));
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003067 }
3068
Douglas Gregor815215d2009-05-27 05:35:12 +00003069 ParmVarDecl *getInstantiationOf(const ParmVarDecl *Var) {
3070 return cast<ParmVarDecl>(getInstantiationOf(cast<Decl>(Var)));
3071 }
3072
Douglas Gregor550d9b22009-10-31 17:21:17 +00003073 NonTypeTemplateParmDecl *getInstantiationOf(
3074 const NonTypeTemplateParmDecl *Var) {
3075 return cast<NonTypeTemplateParmDecl>(getInstantiationOf(cast<Decl>(Var)));
3076 }
3077
Douglas Gregor815215d2009-05-27 05:35:12 +00003078 void InstantiatedLocal(const Decl *D, Decl *Inst) {
3079 Decl *&Stored = LocalDecls[D];
3080 assert(!Stored && "Already instantiated this local");
3081 Stored = Inst;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003082 }
3083 };
3084
3085 /// \brief The current instantiation scope used to store local
3086 /// variables.
3087 LocalInstantiationScope *CurrentInstantiationScope;
3088
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003089 /// \brief An entity for which implicit template instantiation is required.
3090 ///
Mike Stump1eb44332009-09-09 15:08:12 +00003091 /// The source location associated with the declaration is the first place in
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003092 /// the source code where the declaration was "used". It is not necessarily
Mike Stump1eb44332009-09-09 15:08:12 +00003093 /// the point of instantiation (which will be either before or after the
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003094 /// namespace-scope declaration that triggered this implicit instantiation),
3095 /// However, it is the location that diagnostics should generally refer to,
3096 /// because users will need to know what code triggered the instantiation.
3097 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
Mike Stump1eb44332009-09-09 15:08:12 +00003098
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003099 /// \brief The queue of implicit template instantiations that are required
3100 /// but have not yet been performed.
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00003101 std::deque<PendingImplicitInstantiation> PendingImplicitInstantiations;
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003102
3103 void PerformPendingImplicitInstantiations();
Mike Stump1eb44332009-09-09 15:08:12 +00003104
John McCallcd7ba1c2009-10-21 00:58:09 +00003105 DeclaratorInfo *SubstType(DeclaratorInfo *T,
3106 const MultiLevelTemplateArgumentList &TemplateArgs,
3107 SourceLocation Loc, DeclarationName Entity);
3108
Mike Stump1eb44332009-09-09 15:08:12 +00003109 QualType SubstType(QualType T,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003110 const MultiLevelTemplateArgumentList &TemplateArgs,
John McCallce3ff2b2009-08-25 22:02:44 +00003111 SourceLocation Loc, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +00003112
3113 OwningExprResult SubstExpr(Expr *E,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003114 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00003115
Mike Stump1eb44332009-09-09 15:08:12 +00003116 OwningStmtResult SubstStmt(Stmt *S,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003117 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00003118
John McCallce3ff2b2009-08-25 22:02:44 +00003119 Decl *SubstDecl(Decl *D, DeclContext *Owner,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003120 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00003121
Mike Stump1eb44332009-09-09 15:08:12 +00003122 bool
John McCallce3ff2b2009-08-25 22:02:44 +00003123 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
3124 CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003125 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCalle29ba202009-08-20 01:44:21 +00003126
3127 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00003128 InstantiateClass(SourceLocation PointOfInstantiation,
3129 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003130 const MultiLevelTemplateArgumentList &TemplateArgs,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003131 TemplateSpecializationKind TSK,
Douglas Gregor5842ba92009-08-24 15:23:48 +00003132 bool Complain = true);
Douglas Gregord475b8d2009-03-25 21:17:03 +00003133
Mike Stump1eb44332009-09-09 15:08:12 +00003134 bool
Douglas Gregor972e6ce2009-10-27 06:26:26 +00003135 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
Douglas Gregor2943aed2009-03-03 04:44:36 +00003136 ClassTemplateSpecializationDecl *ClassTemplateSpec,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003137 TemplateSpecializationKind TSK,
3138 bool Complain = true);
Douglas Gregor99ebf652009-02-27 19:31:52 +00003139
Douglas Gregora58861f2009-05-13 20:28:22 +00003140 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
3141 CXXRecordDecl *Instantiation,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003142 const MultiLevelTemplateArgumentList &TemplateArgs,
3143 TemplateSpecializationKind TSK);
Douglas Gregora58861f2009-05-13 20:28:22 +00003144
3145 void InstantiateClassTemplateSpecializationMembers(
3146 SourceLocation PointOfInstantiation,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003147 ClassTemplateSpecializationDecl *ClassTemplateSpec,
3148 TemplateSpecializationKind TSK);
Douglas Gregora58861f2009-05-13 20:28:22 +00003149
Douglas Gregorab452ba2009-03-26 23:50:42 +00003150 NestedNameSpecifier *
John McCallce3ff2b2009-08-25 22:02:44 +00003151 SubstNestedNameSpecifier(NestedNameSpecifier *NNS,
3152 SourceRange Range,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003153 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00003154
Douglas Gregorde650ae2009-03-31 18:38:02 +00003155 TemplateName
John McCallce3ff2b2009-08-25 22:02:44 +00003156 SubstTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003157 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCall833ca992009-10-29 08:12:44 +00003158 bool Subst(const TemplateArgumentLoc &Arg, TemplateArgumentLoc &Result,
3159 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00003160
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00003161 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00003162 FunctionDecl *Function,
Douglas Gregore2d3a3d2009-10-15 14:05:49 +00003163 bool Recursive = false,
3164 bool DefinitionRequired = false);
Douglas Gregor7caa6822009-07-24 20:34:43 +00003165 void InstantiateStaticDataMemberDefinition(
John McCallce3ff2b2009-08-25 22:02:44 +00003166 SourceLocation PointOfInstantiation,
3167 VarDecl *Var,
Douglas Gregore2d3a3d2009-10-15 14:05:49 +00003168 bool Recursive = false,
3169 bool DefinitionRequired = false);
Douglas Gregora58861f2009-05-13 20:28:22 +00003170
Anders Carlsson09025312009-08-29 05:16:22 +00003171 void InstantiateMemInitializers(CXXConstructorDecl *New,
3172 const CXXConstructorDecl *Tmpl,
3173 const MultiLevelTemplateArgumentList &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003174
Douglas Gregore95b4092009-09-16 18:34:49 +00003175 NamedDecl *FindInstantiatedDecl(NamedDecl *D,
3176 const MultiLevelTemplateArgumentList &TemplateArgs);
3177 DeclContext *FindInstantiatedContext(DeclContext *DC,
3178 const MultiLevelTemplateArgumentList &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003179
Steve Naroff3536b442007-09-06 21:24:23 +00003180 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003181 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
3182 IdentifierInfo *ClassName,
3183 SourceLocation ClassLoc,
3184 IdentifierInfo *SuperName,
3185 SourceLocation SuperLoc,
3186 const DeclPtrTy *ProtoRefs,
3187 unsigned NumProtoRefs,
3188 SourceLocation EndProtoLoc,
3189 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003190
Chris Lattnerb28317a2009-03-28 19:18:32 +00003191 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00003192 SourceLocation AtCompatibilityAliasLoc,
3193 IdentifierInfo *AliasName, SourceLocation AliasLocation,
3194 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00003195
3196 void CheckForwardProtocolDeclarationForCircularDependency(
3197 IdentifierInfo *PName,
3198 SourceLocation &PLoc, SourceLocation PrevLoc,
3199 const ObjCList<ObjCProtocolDecl> &PList);
Mike Stump1eb44332009-09-09 15:08:12 +00003200
Chris Lattnerb28317a2009-03-28 19:18:32 +00003201 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00003202 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00003203 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003204 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00003205 SourceLocation EndProtoLoc,
3206 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003207
Chris Lattnerb28317a2009-03-28 19:18:32 +00003208 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
3209 IdentifierInfo *ClassName,
3210 SourceLocation ClassLoc,
3211 IdentifierInfo *CategoryName,
3212 SourceLocation CategoryLoc,
3213 const DeclPtrTy *ProtoRefs,
3214 unsigned NumProtoRefs,
3215 SourceLocation EndProtoLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003216
Chris Lattnerb28317a2009-03-28 19:18:32 +00003217 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00003218 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00003219 IdentifierInfo *ClassName, SourceLocation ClassLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003220 IdentifierInfo *SuperClassname,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00003221 SourceLocation SuperClassLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003222
Chris Lattnerb28317a2009-03-28 19:18:32 +00003223 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00003224 SourceLocation AtCatImplLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003225 IdentifierInfo *ClassName,
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00003226 SourceLocation ClassLoc,
3227 IdentifierInfo *CatName,
3228 SourceLocation CatLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003229
Chris Lattnerb28317a2009-03-28 19:18:32 +00003230 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Ted Kremenekc09cba62009-11-17 23:12:20 +00003231 IdentifierInfo **IdentList,
3232 SourceLocation *IdentLocs,
3233 unsigned NumElts);
Mike Stump1eb44332009-09-09 15:08:12 +00003234
Chris Lattnerb28317a2009-03-28 19:18:32 +00003235 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003236 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00003237 unsigned NumElts,
3238 AttributeList *attrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003239
Chris Lattnere13b9592008-07-26 04:03:38 +00003240 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003241 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00003242 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003243 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Mike Stump1eb44332009-09-09 15:08:12 +00003244
3245 /// Ensure attributes are consistent with type.
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00003246 /// \param [in, out] Attributes The attributes to check; they will
3247 /// be modified to be consistent with \arg PropertyTy.
Mike Stump1eb44332009-09-09 15:08:12 +00003248 void CheckObjCPropertyAttributes(QualType PropertyTy,
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00003249 SourceLocation Loc,
3250 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00003251 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Mike Stump1eb44332009-09-09 15:08:12 +00003252 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003253 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00003254 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003255 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003256
3257 void CompareMethodParamsInBaseAndSuper(Decl *IDecl,
Fariborz Jahaniandbdec8b2009-08-04 01:07:16 +00003258 ObjCMethodDecl *MethodDecl,
3259 bool IsInstance);
Mike Stump1eb44332009-09-09 15:08:12 +00003260
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003261 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003262 DeclPtrTy MergeProtocols);
Mike Stump1eb44332009-09-09 15:08:12 +00003263
3264 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00003265 ObjCInterfaceDecl *ID);
Mike Stump1eb44332009-09-09 15:08:12 +00003266
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003267 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00003268 ObjCProtocolDecl *PDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003269
Chris Lattnerb28317a2009-03-28 19:18:32 +00003270 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
3271 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
3272 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00003273 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00003274
Chris Lattnerb28317a2009-03-28 19:18:32 +00003275 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
3276 FieldDeclarator &FD, ObjCDeclSpec &ODS,
3277 Selector GetterSel, Selector SetterSel,
3278 DeclPtrTy ClassCategory,
3279 bool *OverridingProperty,
3280 tok::ObjCKeywordKind MethodImplKind);
Mike Stump1eb44332009-09-09 15:08:12 +00003281
3282 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003283 SourceLocation PropertyLoc,
3284 bool ImplKind,DeclPtrTy ClassImplDecl,
3285 IdentifierInfo *PropertyId,
3286 IdentifierInfo *PropertyIvar);
Mike Stump1eb44332009-09-09 15:08:12 +00003287
Chris Lattnerb28317a2009-03-28 19:18:32 +00003288 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00003289 SourceLocation BeginLoc, // location of the + or -.
3290 SourceLocation EndLoc, // location of the ; or {.
Mike Stump1eb44332009-09-09 15:08:12 +00003291 tok::TokenKind MethodType,
3292 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00003293 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00003294 // optional arguments. The number of types/arguments is obtained
3295 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00003296 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00003297 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00003298 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
3299 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00003300
Steve Narofff1afaf62009-02-26 15:55:06 +00003301 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
3302 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00003303 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00003304 // Returns 0 if no method is found.
Mike Stump1eb44332009-09-09 15:08:12 +00003305 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
Steve Naroff5609ec02009-03-08 18:56:13 +00003306 ObjCInterfaceDecl *CDecl);
3307 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
3308 ObjCInterfaceDecl *ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003309
Steve Naroff61f72cb2009-03-09 21:12:44 +00003310 virtual OwningExprResult ActOnClassPropertyRefExpr(
3311 IdentifierInfo &receiverName,
3312 IdentifierInfo &propertyName,
3313 SourceLocation &receiverNameLoc,
3314 SourceLocation &propertyNameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003315
Steve Naroff68d331a2007-09-27 14:38:14 +00003316 // ActOnClassMessage - used for both unary and keyword messages.
3317 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003318 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003319 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00003320 Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00003321 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
3322 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003323 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00003324
3325 // ActOnInstanceMessage - used for both unary and keyword messages.
3326 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003327 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003328 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00003329 ExprTy *receiver, Selector Sel,
Mike Stump1eb44332009-09-09 15:08:12 +00003330 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003331 ExprTy **ArgExprs, unsigned NumArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003332
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003333 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
3334 virtual void ActOnPragmaPack(PragmaPackKind Kind,
3335 IdentifierInfo *Name,
3336 ExprTy *Alignment,
Mike Stump1eb44332009-09-09 15:08:12 +00003337 SourceLocation PragmaLoc,
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003338 SourceLocation LParenLoc,
3339 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003340
Ted Kremenek4726d032009-03-23 22:28:25 +00003341 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
Ted Kremenek7a02a372009-08-03 23:24:57 +00003342 virtual void ActOnPragmaUnused(const Token *Identifiers,
3343 unsigned NumIdentifiers, Scope *curScope,
Mike Stump1eb44332009-09-09 15:08:12 +00003344 SourceLocation PragmaLoc,
Ted Kremenek4726d032009-03-23 22:28:25 +00003345 SourceLocation LParenLoc,
3346 SourceLocation RParenLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003347
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00003348 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II);
3349 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
Ryan Flynne25ff832009-07-30 03:15:39 +00003350
Eli Friedmandec7c762009-06-05 06:28:29 +00003351 /// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003352 virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
3353 SourceLocation PragmaLoc,
3354 SourceLocation WeakNameLoc);
3355
Eli Friedmandec7c762009-06-05 06:28:29 +00003356 /// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003357 virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
3358 IdentifierInfo* AliasName,
3359 SourceLocation PragmaLoc,
3360 SourceLocation WeakNameLoc,
3361 SourceLocation AliasNameLoc);
3362
Chris Lattner574aa402009-02-17 01:09:29 +00003363 /// getPragmaPackAlignment() - Return the current alignment as specified by
3364 /// the current #pragma pack directive, or 0 if none is currently active.
3365 unsigned getPragmaPackAlignment() const;
Mike Stump1eb44332009-09-09 15:08:12 +00003366
Chris Lattner574aa402009-02-17 01:09:29 +00003367 /// FreePackedContext - Deallocate and null out PackContext.
3368 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003369
Chris Lattner1e0a3902008-01-16 19:17:22 +00003370 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
3371 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003372 /// If isLvalue, the result of the cast is an lvalue.
Eli Friedman73c39ab2009-10-20 08:27:19 +00003373 void ImpCastExprToType(Expr *&Expr, QualType Type, CastExpr::CastKind Kind,
Anders Carlsson3503d042009-07-31 01:23:52 +00003374 bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00003375
Reid Spencer5f016e22007-07-11 17:01:13 +00003376 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00003377 // functions and arrays to their respective pointers (C99 6.3.2.1).
Mike Stump1eb44332009-09-09 15:08:12 +00003378 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00003379
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003380 // DefaultFunctionArrayConversion - converts functions and arrays
Mike Stump1eb44332009-09-09 15:08:12 +00003381 // to their respective pointers (C99 6.3.2.1).
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003382 void DefaultFunctionArrayConversion(Expr *&expr);
Mike Stump1eb44332009-09-09 15:08:12 +00003383
Steve Naroffb291ab62007-08-28 23:30:39 +00003384 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
Mike Stump1eb44332009-09-09 15:08:12 +00003385 // do not have a prototype. Integer promotions are performed on each
Steve Naroffb291ab62007-08-28 23:30:39 +00003386 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00003387 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003388
3389 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
3390 enum VariadicCallType {
3391 VariadicFunction,
3392 VariadicBlock,
Anders Carlssond74d4142009-09-08 01:48:42 +00003393 VariadicMethod,
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003394 VariadicConstructor,
3395 VariadicDoesNotApply
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003396 };
Mike Stump1eb44332009-09-09 15:08:12 +00003397
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003398 /// GatherArgumentsForCall - Collector argument expressions for various
3399 /// form of call prototypes.
3400 bool GatherArgumentsForCall(SourceLocation CallLoc,
3401 FunctionDecl *FDecl,
3402 const FunctionProtoType *Proto,
3403 unsigned FirstProtoArg,
3404 Expr **Args, unsigned NumArgs,
3405 llvm::SmallVector<Expr *, 8> &AllArgs,
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003406 VariadicCallType CallType = VariadicDoesNotApply);
3407
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003408 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
3409 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00003410 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Mike Stump1eb44332009-09-09 15:08:12 +00003411
Reid Spencer5f016e22007-07-11 17:01:13 +00003412 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
3413 // operands and then handles various conversions that are common to binary
3414 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
Mike Stump1eb44332009-09-09 15:08:12 +00003415 // routine returns the first non-arithmetic type found. The client is
Reid Spencer5f016e22007-07-11 17:01:13 +00003416 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003417 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
3418 bool isCompAssign = false);
Mike Stump1eb44332009-09-09 15:08:12 +00003419
Chris Lattnerb7b61152008-01-04 18:22:42 +00003420 /// AssignConvertType - All of the 'assignment' semantic checks return this
3421 /// enum to indicate whether the assignment was allowed. These checks are
3422 /// done for simple assignments, as well as initialization, return from
3423 /// function, argument passing, etc. The query is phrased in terms of a
3424 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003425 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00003426 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00003427 Compatible,
Mike Stump1eb44332009-09-09 15:08:12 +00003428
Chris Lattnerb7b61152008-01-04 18:22:42 +00003429 /// PointerToInt - The assignment converts a pointer to an int, which we
3430 /// accept as an extension.
3431 PointerToInt,
Mike Stump1eb44332009-09-09 15:08:12 +00003432
Chris Lattnerb7b61152008-01-04 18:22:42 +00003433 /// IntToPointer - The assignment converts an int to a pointer, which we
3434 /// accept as an extension.
3435 IntToPointer,
Mike Stump1eb44332009-09-09 15:08:12 +00003436
Chris Lattnerb7b61152008-01-04 18:22:42 +00003437 /// FunctionVoidPointer - The assignment is between a function pointer and
3438 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003439 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003440
3441 /// IncompatiblePointer - The assignment is between two pointers types that
3442 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00003443 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003444
3445 /// IncompatiblePointer - The assignment is between two pointers types which
3446 /// point to integers which have a different sign, but are otherwise identical.
3447 /// This is a subset of the above, but broken out because it's by far the most
3448 /// common case of incompatible pointers.
3449 IncompatiblePointerSign,
3450
Chris Lattnerb7b61152008-01-04 18:22:42 +00003451 /// CompatiblePointerDiscardsQualifiers - The assignment discards
3452 /// c/v/r qualifiers, which we accept as an extension.
3453 CompatiblePointerDiscardsQualifiers,
Fariborz Jahanian36a862f2009-11-07 20:20:40 +00003454
Sean Huntc9132b62009-11-08 07:46:34 +00003455 /// IncompatibleNestedPointerQualifiers - The assignment is between two
3456 /// nested pointer types, and the qualifiers other than the first two
Fariborz Jahaniand288baf2009-11-09 22:28:08 +00003457 /// levels differ e.g. char ** -> const char **, but we accept them as an
3458 /// extension.
Sean Huntc9132b62009-11-08 07:46:34 +00003459 IncompatibleNestedPointerQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003460
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00003461 /// IncompatibleVectors - The assignment is between two vector types that
3462 /// have the same size, which we accept as an extension.
3463 IncompatibleVectors,
Mike Stump1eb44332009-09-09 15:08:12 +00003464
3465 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003466 /// pointer. We disallow this.
3467 IntToBlockPointer,
3468
Mike Stump1eb44332009-09-09 15:08:12 +00003469 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003470 /// pointers types that are not compatible.
3471 IncompatibleBlockPointer,
Mike Stump1eb44332009-09-09 15:08:12 +00003472
Steve Naroff39579072008-10-14 22:18:38 +00003473 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
3474 /// id type and something else (that is incompatible with it). For example,
3475 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
3476 IncompatibleObjCQualifiedId,
Mike Stump1eb44332009-09-09 15:08:12 +00003477
Chris Lattnerb7b61152008-01-04 18:22:42 +00003478 /// Incompatible - We reject this conversion outright, it is invalid to
3479 /// represent it in the AST.
3480 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00003481 };
Mike Stump1eb44332009-09-09 15:08:12 +00003482
Chris Lattner5cf216b2008-01-04 18:04:52 +00003483 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
3484 /// assignment conversion type specified by ConvTy. This returns true if the
3485 /// conversion was invalid or false if the conversion was accepted.
3486 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
3487 SourceLocation Loc,
3488 QualType DstType, QualType SrcType,
3489 Expr *SrcExpr, const char *Flavor);
Mike Stump1eb44332009-09-09 15:08:12 +00003490
3491 /// CheckAssignmentConstraints - Perform type checking for assignment,
3492 /// argument passing, variable initialization, and function return values.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003493 /// This routine is only used by the following two methods. C99 6.5.16.
3494 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Mike Stump1eb44332009-09-09 15:08:12 +00003495
3496 // CheckSingleAssignmentConstraints - Currently used by
3497 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00003498 // this routine performs the default function/array converions.
Mike Stump1eb44332009-09-09 15:08:12 +00003499 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
Chris Lattner5cf216b2008-01-04 18:04:52 +00003500 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003501
3502 // \brief If the lhs type is a transparent union, check whether we
3503 // can initialize the transparent union with the given expression.
Mike Stump1eb44332009-09-09 15:08:12 +00003504 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003505 Expr *&rExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00003506
Reid Spencer5f016e22007-07-11 17:01:13 +00003507 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Mike Stump1eb44332009-09-09 15:08:12 +00003508 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
Chris Lattner5cf216b2008-01-04 18:04:52 +00003509 QualType rhsType);
Mike Stump1eb44332009-09-09 15:08:12 +00003510
Steve Naroff1c7d0672008-09-04 15:10:53 +00003511 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003512 // block pointer types.
Mike Stump1eb44332009-09-09 15:08:12 +00003513 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003514 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00003515
3516 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003517
Sebastian Redl2c7588f2009-10-10 12:04:10 +00003518 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
3519
Mike Stump1eb44332009-09-09 15:08:12 +00003520 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00003521 const char *Flavor,
3522 bool AllowExplicit = false,
3523 bool Elidable = false);
Mike Stump1eb44332009-09-09 15:08:12 +00003524 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00003525 const char *Flavor,
3526 bool AllowExplicit,
3527 bool Elidable,
3528 ImplicitConversionSequence& ICS);
3529 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003530 const ImplicitConversionSequence& ICS,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003531 const char *Flavor,
3532 bool IgnoreBaseAccess = false);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003533 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00003534 const StandardConversionSequence& SCS,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003535 const char *Flavor, bool IgnoreBaseAccess);
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00003536
3537 bool BuildCXXDerivedToBaseExpr(Expr *&From, CastExpr::CastKind CastKind,
3538 const ImplicitConversionSequence& ICS,
3539 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00003540
Reid Spencer5f016e22007-07-11 17:01:13 +00003541 /// the following "Check" methods will return a valid/converted QualType
3542 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00003543
3544 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00003545 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003546 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003547 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00003548 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003549 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003550 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003551 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003552 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003553 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003554 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003555 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003556 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003557 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003558 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00003559 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00003560 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00003561 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003562 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00003563 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003564 // CheckAssignmentOperands is used for both simple and compound assignment.
3565 // For simple assignment, pass both expressions and a null converted type.
3566 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00003567 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00003568 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00003569 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00003570 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00003571 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00003572 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003573 QualType CXXCheckConditionalOperands( // C++ 5.16
3574 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003575 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00003576
3577 /// type checking for vector binary operators.
3578 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
3579 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
3580 SourceLocation l, bool isRel);
Mike Stump1eb44332009-09-09 15:08:12 +00003581
Steve Narofff69936d2007-09-16 03:34:24 +00003582 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00003583 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00003584 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
3585 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003586 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
3587 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00003588 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Mike Stump1eb44332009-09-09 15:08:12 +00003589
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003590 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00003591 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003592 const IdentifierInfo *Comp,
Anders Carlsson8f28f992009-08-26 18:25:21 +00003593 SourceLocation CmpLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003594
Steve Narofff0090632007-09-02 02:04:30 +00003595 /// type checking declaration initializers (C99 6.7.8)
Mike Stump1eb44332009-09-09 15:08:12 +00003596
Douglas Gregorf03d7c72008-11-05 15:29:30 +00003597 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003598 SourceLocation InitLoc,DeclarationName InitEntity,
Anders Carlsson0f5f2c62009-05-30 20:41:30 +00003599 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00003600 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00003601 bool CheckForConstantInitializer(Expr *e, QualType t);
Mike Stump1eb44332009-09-09 15:08:12 +00003602
Douglas Gregor87fd7032009-02-02 17:43:21 +00003603 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003604
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003605 // type checking C++ declaration initializers (C++ [dcl.init]).
3606
3607 /// ReferenceCompareResult - Expresses the result of comparing two
3608 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
3609 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
3610 enum ReferenceCompareResult {
3611 /// Ref_Incompatible - The two types are incompatible, so direct
3612 /// reference binding is not possible.
3613 Ref_Incompatible = 0,
3614 /// Ref_Related - The two types are reference-related, which means
3615 /// that their unqualified forms (T1 and T2) are either the same
3616 /// or T1 is a base class of T2.
3617 Ref_Related,
3618 /// Ref_Compatible_With_Added_Qualification - The two types are
3619 /// reference-compatible with added qualification, meaning that
3620 /// they are reference-compatible and the qualifiers on T1 (cv1)
3621 /// are greater than the qualifiers on T2 (cv2).
3622 Ref_Compatible_With_Added_Qualification,
3623 /// Ref_Compatible - The two types are reference-compatible and
3624 /// have equivalent qualifiers (cv1 == cv2).
3625 Ref_Compatible
3626 };
3627
Douglas Gregor393896f2009-11-05 13:06:35 +00003628 ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc,
3629 QualType T1, QualType T2,
Douglas Gregor15da57e2008-10-29 02:00:59 +00003630 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003631
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003632 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Douglas Gregor739d8282009-09-23 23:04:10 +00003633 SourceLocation DeclLoc,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00003634 bool SuppressUserConversions,
3635 bool AllowExplicit,
3636 bool ForceRValue,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003637 ImplicitConversionSequence *ICS = 0,
3638 bool IgnoreBaseAccess = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003639
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003640 /// CheckCastTypes - Check type constraints for casting between types under
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003641 /// C semantics, or forward to CXXCheckCStyleCast in C++.
3642 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00003643 CastExpr::CastKind &Kind,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003644 CXXMethodDecl *& ConversionDecl,
3645 bool FunctionalStyle = false);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003646
Mike Stump1eb44332009-09-09 15:08:12 +00003647 // CheckVectorCast - check type constraints for vectors.
Anders Carlsson584b2472007-11-27 07:16:40 +00003648 // Since vectors are an extension, there are no C standard reference for this.
3649 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00003650 // returns true if the cast is invalid
Anders Carlssonc3516322009-10-16 02:48:28 +00003651 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
3652 CastExpr::CastKind &Kind);
Mike Stump1eb44332009-09-09 15:08:12 +00003653
3654 // CheckExtVectorCast - check type constraints for extended vectors.
Nate Begeman58d29a42009-06-26 00:50:28 +00003655 // Since vectors are an extension, there are no C standard reference for this.
3656 // We allow casting between vectors and integer datatypes of the same size,
3657 // or vectors and the element type of that vector.
3658 // returns true if the cast is invalid
Anders Carlsson16a89042009-10-16 05:23:41 +00003659 bool CheckExtVectorCast(SourceRange R, QualType VectorTy, Expr *&CastExpr,
3660 CastExpr::CastKind &Kind);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003661
3662 /// CXXCheckCStyleCast - Check constraints of a C-style or function-style
3663 /// cast under C++ semantics.
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003664 bool CXXCheckCStyleCast(SourceRange R, QualType CastTy, Expr *&CastExpr,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003665 CastExpr::CastKind &Kind, bool FunctionalStyle,
3666 CXXMethodDecl *&ConversionDecl);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003667
Mike Stump1eb44332009-09-09 15:08:12 +00003668 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003669 /// \param Method - May be null.
3670 /// \param [out] ReturnType - The return type of the send.
3671 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00003672 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00003673 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003674 SourceLocation lbrac, SourceLocation rbrac,
Mike Stump1eb44332009-09-09 15:08:12 +00003675 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003676
John McCall5a881bb2009-10-12 21:59:07 +00003677 /// CheckBooleanCondition - Diagnose problems involving the use of
3678 /// the given expression as a boolean condition (e.g. in an if
3679 /// statement). Also performs the standard function and array
3680 /// decays, possibly changing the input variable.
3681 ///
3682 /// \param Loc - A location associated with the condition, e.g. the
3683 /// 'if' keyword.
3684 /// \return true iff there were any errors
3685 bool CheckBooleanCondition(Expr *&CondExpr, SourceLocation Loc);
3686
3687 /// DiagnoseAssignmentAsCondition - Given that an expression is
3688 /// being used as a boolean condition, warn if it's an assignment.
3689 void DiagnoseAssignmentAsCondition(Expr *E);
3690
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003691 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
3692 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003693
Chris Lattnerf4021e72007-08-23 05:46:52 +00003694 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
3695 /// the specified width and sign. If an overflow occurs, detect it and emit
3696 /// the specified diagnostic.
Mike Stump1eb44332009-09-09 15:08:12 +00003697 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
Chris Lattnerf4021e72007-08-23 05:46:52 +00003698 unsigned NewWidth, bool NewSign,
3699 SourceLocation Loc, unsigned DiagID);
Mike Stump1eb44332009-09-09 15:08:12 +00003700
Anders Carlsson15281452008-11-04 16:57:32 +00003701 /// Checks that the Objective-C declaration is declared in the global scope.
3702 /// Emits an error and marks the declaration as invalid if it's not declared
3703 /// in the global scope.
3704 bool CheckObjCDeclScope(Decl *D);
3705
Anders Carlsson7c50aca2007-10-15 20:28:48 +00003706 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00003707
Anders Carlssone21555e2008-11-30 19:50:32 +00003708 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
3709 /// and reports the appropriate diagnostics. Returns false on success.
3710 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003711 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00003712
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003713 /// VerifyBitField - verifies that a bit field expression is an ICE and has
Mike Stump1eb44332009-09-09 15:08:12 +00003714 /// the correct width, and that the field type is valid.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003715 /// Returns false on success.
Eli Friedman1d954f62009-08-15 21:55:26 +00003716 /// Can optionally return whether the bit-field is of width 0
Mike Stump1eb44332009-09-09 15:08:12 +00003717 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
3718 QualType FieldTy, const Expr *BitWidth,
Eli Friedman1d954f62009-08-15 21:55:26 +00003719 bool *ZeroWidth = 0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00003720
Douglas Gregor81b747b2009-09-17 21:32:03 +00003721 /// \name Code completion
3722 //@{
Douglas Gregor791215b2009-09-21 20:51:25 +00003723 virtual void CodeCompleteOrdinaryName(Scope *S);
Douglas Gregor81b747b2009-09-17 21:32:03 +00003724 virtual void CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *Base,
3725 SourceLocation OpLoc,
3726 bool IsArrow);
Douglas Gregor374929f2009-09-18 15:37:17 +00003727 virtual void CodeCompleteTag(Scope *S, unsigned TagSpec);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003728 virtual void CodeCompleteCase(Scope *S);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003729 virtual void CodeCompleteCall(Scope *S, ExprTy *Fn,
3730 ExprTy **Args, unsigned NumArgs);
Douglas Gregor81b747b2009-09-17 21:32:03 +00003731 virtual void CodeCompleteQualifiedId(Scope *S, const CXXScopeSpec &SS,
3732 bool EnteringContext);
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003733 virtual void CodeCompleteUsing(Scope *S);
3734 virtual void CodeCompleteUsingDirective(Scope *S);
3735 virtual void CodeCompleteNamespaceDecl(Scope *S);
3736 virtual void CodeCompleteNamespaceAliasDecl(Scope *S);
Douglas Gregored8d3222009-09-18 20:05:18 +00003737 virtual void CodeCompleteOperatorName(Scope *S);
Steve Naroffece8e712009-10-08 21:55:05 +00003738
Douglas Gregora93b1082009-11-18 23:08:07 +00003739 virtual void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
Douglas Gregor4ad96852009-11-19 07:41:15 +00003740 virtual void CodeCompleteObjCPropertyGetter(Scope *S, DeclPtrTy ClassDecl,
3741 DeclPtrTy *Methods,
3742 unsigned NumMethods);
3743 virtual void CodeCompleteObjCPropertySetter(Scope *S, DeclPtrTy ClassDecl,
3744 DeclPtrTy *Methods,
3745 unsigned NumMethods);
3746
Douglas Gregor60b01cc2009-11-17 23:31:36 +00003747 virtual void CodeCompleteObjCClassMessage(Scope *S, IdentifierInfo *FName,
Douglas Gregord3c68542009-11-19 01:08:35 +00003748 SourceLocation FNameLoc,
3749 IdentifierInfo **SelIdents,
3750 unsigned NumSelIdents);
3751 virtual void CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver,
3752 IdentifierInfo **SelIdents,
3753 unsigned NumSelIdents);
Douglas Gregor55385fe2009-11-18 04:19:12 +00003754 virtual void CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
3755 unsigned NumProtocols);
Douglas Gregor083128f2009-11-18 04:49:41 +00003756 virtual void CodeCompleteObjCProtocolDecl(Scope *S);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00003757 virtual void CodeCompleteObjCInterfaceDecl(Scope *S);
3758 virtual void CodeCompleteObjCSuperclass(Scope *S,
3759 IdentifierInfo *ClassName);
3760 virtual void CodeCompleteObjCImplementationDecl(Scope *S);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00003761 virtual void CodeCompleteObjCInterfaceCategory(Scope *S,
3762 IdentifierInfo *ClassName);
3763 virtual void CodeCompleteObjCImplementationCategory(Scope *S,
3764 IdentifierInfo *ClassName);
Douglas Gregor424b2a52009-11-18 22:56:13 +00003765 virtual void CodeCompleteObjCPropertyDefinition(Scope *S,
Douglas Gregor322328b2009-11-18 22:32:06 +00003766 DeclPtrTy ObjCImpDecl);
3767 virtual void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
3768 IdentifierInfo *PropertyName,
3769 DeclPtrTy ObjCImpDecl);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00003770 //@}
Douglas Gregor81b747b2009-09-17 21:32:03 +00003771
Chris Lattner59907c42007-08-10 20:18:51 +00003772 //===--------------------------------------------------------------------===//
3773 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00003774private:
Anders Carlssond406bf02009-08-16 01:56:34 +00003775 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall);
3776 bool CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall);
Mike Stump1eb44332009-09-09 15:08:12 +00003777
Chris Lattner60800082009-02-18 17:49:48 +00003778 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
3779 unsigned ByteNo) const;
Ryan Flynn4403a5e2009-08-06 03:00:50 +00003780 bool CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall);
Chris Lattner69039812009-02-18 06:01:06 +00003781 bool CheckObjCString(Expr *Arg);
Anders Carlssond406bf02009-08-16 01:56:34 +00003782
3783 Action::OwningExprResult CheckBuiltinFunctionCall(unsigned BuiltinID,
3784 CallExpr *TheCall);
Chris Lattner925e60d2007-12-28 05:29:59 +00003785 bool SemaBuiltinVAStart(CallExpr *TheCall);
3786 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman9ac6f622009-08-31 20:06:00 +00003787 bool SemaBuiltinUnaryFP(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00003788 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003789
3790public:
3791 // Used by C++ template instantiation.
Sebastian Redl0eb23302009-01-19 00:08:26 +00003792 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003793
3794private:
Mike Stump1eb44332009-09-09 15:08:12 +00003795 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00003796 bool SemaBuiltinObjectSize(CallExpr *TheCall);
3797 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00003798 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Chris Lattner21fb98e2009-09-23 06:06:36 +00003799 bool SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003800 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
3801 bool HasVAListArg, unsigned format_idx,
3802 unsigned firstDataArg);
3803 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
3804 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003805 unsigned format_idx, unsigned firstDataArg);
Mike Stump1eb44332009-09-09 15:08:12 +00003806 void CheckNonNullArguments(const NonNullAttr *NonNull,
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +00003807 const CallExpr *TheCall);
Mike Stump1eb44332009-09-09 15:08:12 +00003808 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003809 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00003810 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
3811 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00003812 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00003813};
3814
Ted Kremenek8189cde2009-02-07 01:47:29 +00003815//===--------------------------------------------------------------------===//
3816// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
3817template <typename T>
3818class ExprOwningPtr : public Action::ExprArg {
3819public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00003820 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Mike Stump1eb44332009-09-09 15:08:12 +00003821
Ted Kremenek8189cde2009-02-07 01:47:29 +00003822 void reset(T* p) { Action::ExprArg::operator=(p); }
3823 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
3824 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
3825 T* release() { return take(); }
Mike Stump1eb44332009-09-09 15:08:12 +00003826
Ted Kremenek8189cde2009-02-07 01:47:29 +00003827 T& operator*() const { return *get(); }
3828 T* operator->() const { return get(); }
3829};
Douglas Gregord7e27052009-05-20 22:33:37 +00003830
Reid Spencer5f016e22007-07-11 17:01:13 +00003831} // end namespace clang
3832
3833#endif