blob: 5577cbd7d744a31c88ca180273bd66b4ead5bcba [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
Sebastian Redl798d1192008-12-13 16:23:55 +0000462 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000463 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000464 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000465 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000466 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000467 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000468 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
469
Chris Lattner9299f3f2008-08-23 03:19:52 +0000470 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000471
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000472 /// getLabelMap() - Return the current label map. If we're in a block, we
473 /// return it.
474 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
475 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
476 }
Mike Stump1eb44332009-09-09 15:08:12 +0000477
Chris Lattnerbcfce662009-04-18 20:10:59 +0000478 /// getSwitchStack - This is returns the switch stack for the current block or
479 /// function.
480 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
481 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
482 }
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000483
484 /// WeakTopLevelDeclDecls - access to #pragma weak-generated Decls
485 llvm::SmallVector<Decl*,2> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
Mike Stump1eb44332009-09-09 15:08:12 +0000486
Douglas Gregor2e222532009-07-02 17:08:52 +0000487 virtual void ActOnComment(SourceRange Comment);
488
Reid Spencer5f016e22007-07-11 17:01:13 +0000489 //===--------------------------------------------------------------------===//
490 // Type Analysis / Processing: SemaType.cpp.
491 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000492 QualType adjustParameterType(QualType T);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000493 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Mike Stump1eb44332009-09-09 15:08:12 +0000494 QualType BuildPointerType(QualType T, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000495 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000496 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000497 SourceLocation Loc, DeclarationName Entity);
498 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
499 Expr *ArraySize, unsigned Quals,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +0000500 SourceRange Brackets, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000501 QualType BuildExtVectorType(QualType T, ExprArg ArraySize,
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000502 SourceLocation AttrLoc);
Douglas Gregor724651c2009-02-28 01:04:19 +0000503 QualType BuildFunctionType(QualType T,
504 QualType *ParamTypes, unsigned NumParamTypes,
505 bool Variadic, unsigned Quals,
506 SourceLocation Loc, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +0000507 QualType BuildMemberPointerType(QualType T, QualType Class,
508 unsigned Quals, SourceLocation Loc,
Douglas Gregor949bf692009-06-09 22:17:39 +0000509 DeclarationName Entity);
Anders Carlsson9a917e42009-06-12 22:56:54 +0000510 QualType BuildBlockPointerType(QualType T, unsigned Quals,
511 SourceLocation Loc, DeclarationName Entity);
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000512 QualType GetTypeForDeclarator(Declarator &D, Scope *S,
513 DeclaratorInfo **DInfo = 0,
Sebastian Redl8ce35b02009-10-25 21:45:37 +0000514 TagDecl **OwnedDecl = 0);
515 DeclaratorInfo *GetDeclaratorInfoForDeclarator(Declarator &D, QualType T);
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000516 /// \brief Create a LocInfoType to hold the given QualType and DeclaratorInfo.
517 QualType CreateLocInfoType(QualType T, DeclaratorInfo *DInfo);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000518 DeclarationName GetNameForDeclarator(Declarator &D);
Douglas Gregor02a24ee2009-11-03 16:56:39 +0000519 DeclarationName GetNameFromUnqualifiedId(UnqualifiedId &Name);
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000520 static QualType GetTypeFromParser(TypeTy *Ty, DeclaratorInfo **DInfo = 0);
Sebastian Redlef65f062009-05-29 18:02:33 +0000521 bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
Sebastian Redl6a7330c2009-05-29 15:01:05 +0000522 bool CheckDistantExceptionSpec(QualType T);
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000523 bool CheckEquivalentExceptionSpec(
524 const FunctionProtoType *Old, SourceLocation OldLoc,
525 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000526 bool CheckEquivalentExceptionSpec(
527 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redldced2262009-10-11 09:03:14 +0000528 const FunctionProtoType *Old, SourceLocation OldLoc,
529 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000530 bool CheckExceptionSpecSubset(
531 const PartialDiagnostic &DiagID, const PartialDiagnostic & NoteID,
Sebastian Redl23c7d062009-07-07 20:29:57 +0000532 const FunctionProtoType *Superset, SourceLocation SuperLoc,
533 const FunctionProtoType *Subset, SourceLocation SubLoc);
Sebastian Redl37c38ec2009-10-14 16:09:29 +0000534 bool CheckParamExceptionSpec(const PartialDiagnostic & NoteID,
Sebastian Redldced2262009-10-11 09:03:14 +0000535 const FunctionProtoType *Target, SourceLocation TargetLoc,
536 const FunctionProtoType *Source, SourceLocation SourceLoc);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000537
Chris Lattnerb28317a2009-03-28 19:18:32 +0000538 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000539
Douglas Gregor57373262008-10-22 14:17:15 +0000540 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
541
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000542 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000543
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000544 bool RequireCompleteType(SourceLocation Loc, QualType T,
Anders Carlsson8c8d9192009-10-09 23:51:55 +0000545 const PartialDiagnostic &PD,
546 std::pair<SourceLocation,
547 PartialDiagnostic> Note =
548 std::make_pair(SourceLocation(), PDiag()));
Mike Stump1eb44332009-09-09 15:08:12 +0000549
Douglas Gregore6258932009-03-19 00:39:20 +0000550 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
551
Anders Carlssonaf017e62009-06-29 22:58:55 +0000552 QualType BuildTypeofExprType(Expr *E);
553 QualType BuildDecltypeType(Expr *E);
Mike Stump1eb44332009-09-09 15:08:12 +0000554
Reid Spencer5f016e22007-07-11 17:01:13 +0000555 //===--------------------------------------------------------------------===//
556 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
557 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000558
559 /// getDeclName - Return a pretty name for the specified decl if possible, or
Mike Stump1eb44332009-09-09 15:08:12 +0000560 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000561 virtual std::string getDeclName(DeclPtrTy D);
Mike Stump1eb44332009-09-09 15:08:12 +0000562
Chris Lattner682bf922009-03-29 16:50:03 +0000563 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
564
Mike Stump1eb44332009-09-09 15:08:12 +0000565 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregor42c39f32009-08-26 18:27:52 +0000566 Scope *S, const CXXScopeSpec *SS,
Douglas Gregorf6e6fc82009-11-20 22:03:38 +0000567 bool isClassName = false,
568 TypeTy *ObjectType = 0);
Chris Lattner4c97d762009-04-12 21:49:30 +0000569 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
Douglas Gregora786fdb2009-10-13 23:27:22 +0000570 virtual bool DiagnoseUnknownTypeName(const IdentifierInfo &II,
571 SourceLocation IILoc,
572 Scope *S,
573 const CXXScopeSpec *SS,
574 TypeTy *&SuggestedType);
575
Chris Lattner682bf922009-03-29 16:50:03 +0000576 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregore542c862009-06-23 23:11:28 +0000577 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this), false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000578 }
Mike Stump1eb44332009-09-09 15:08:12 +0000579
580 DeclPtrTy HandleDeclarator(Scope *S, Declarator &D,
Douglas Gregore542c862009-06-23 23:11:28 +0000581 MultiTemplateParamsArg TemplateParameterLists,
582 bool IsFunctionDefinition);
John McCall68263142009-11-18 22:49:29 +0000583 void RegisterLocallyScopedExternCDecl(NamedDecl *ND,
584 const LookupResult &Previous,
Douglas Gregor63935192009-03-02 00:19:53 +0000585 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000586 void DiagnoseFunctionSpecifiers(Declarator& D);
John McCall68263142009-11-18 22:49:29 +0000587 bool CheckRedeclaration(DeclContext *DC,
588 DeclarationName Name,
589 SourceLocation NameLoc,
590 unsigned Diagnostic);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000591 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000592 QualType R, DeclaratorInfo *DInfo,
John McCall68263142009-11-18 22:49:29 +0000593 LookupResult &Previous, bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000594 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000595 QualType R, DeclaratorInfo *DInfo,
John McCall68263142009-11-18 22:49:29 +0000596 LookupResult &Previous,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +0000597 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000598 bool &Redeclaration);
John McCall68263142009-11-18 22:49:29 +0000599 void CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000600 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000601 NamedDecl* ActOnFunctionDeclarator(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 Gregore542c862009-06-23 23:11:28 +0000604 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregor04495c82009-02-24 01:23:02 +0000605 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000606 bool &Redeclaration);
Sebastian Redla165da02009-11-18 21:51:29 +0000607 void AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD);
John McCall68263142009-11-18 22:49:29 +0000608 void CheckFunctionDeclaration(FunctionDecl *NewFD, LookupResult &Previous,
Douglas Gregorfd056bc2009-10-13 16:30:37 +0000609 bool IsExplicitSpecialization,
Mike Stump1eb44332009-09-09 15:08:12 +0000610 bool &Redeclaration,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000611 bool &OverloadableAttrRequired);
John McCall8c4859a2009-07-24 03:03:21 +0000612 void CheckMain(FunctionDecl *FD);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000613 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
614 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000615 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000616 ExprArg defarg);
Mike Stump1eb44332009-09-09 15:08:12 +0000617 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000618 SourceLocation EqualLoc,
619 SourceLocation ArgLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000620 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
Anders Carlssoned961f92009-08-25 02:29:20 +0000621 bool SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
622 SourceLocation EqualLoc);
623
Mike Stump1eb44332009-09-09 15:08:12 +0000624
Anders Carlsson5e300d12009-06-12 16:51:40 +0000625 // Contains the locations of the beginning of unparsed default
626 // argument locations.
627 llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
628
Anders Carlsson9abf2ae2009-08-16 05:13:48 +0000629 virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000630 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
Anders Carlsson6a75cd92009-07-11 00:34:39 +0000631 void ActOnUninitializedDecl(DeclPtrTy dcl, bool TypeContainsUndeducedAuto);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000632 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000633 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
634 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +0000635 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000636 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
637 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000638 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
639 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
640 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000641
Chris Lattnerb28317a2009-03-28 19:18:32 +0000642 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Douglas Gregore2c31ff2009-05-15 17:59:04 +0000643 DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body,
644 bool IsInstantiation);
Mike Stump1eb44332009-09-09 15:08:12 +0000645
Douglas Gregore0762c92009-06-19 23:52:42 +0000646 /// \brief Diagnose any unused parameters in the given sequence of
647 /// ParmVarDecl pointers.
648 template<typename InputIterator>
649 void DiagnoseUnusedParameters(InputIterator Param, InputIterator ParamEnd) {
650 for (; Param != ParamEnd; ++Param) {
Mike Stump1eb44332009-09-09 15:08:12 +0000651 if (!(*Param)->isUsed() && (*Param)->getDeclName() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000652 !(*Param)->template hasAttr<UnusedAttr>())
Douglas Gregore0762c92009-06-19 23:52:42 +0000653 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
654 << (*Param)->getDeclName();
655 }
656 }
Mike Stump1eb44332009-09-09 15:08:12 +0000657
Chris Lattner5af280c2009-04-19 04:46:21 +0000658 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000659 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000660
Steve Naroffb216c882007-10-09 22:01:59 +0000661 /// Scope actions.
662 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
663 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000664
665 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
666 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000667 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Mike Stump1eb44332009-09-09 15:08:12 +0000668
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000669 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
670 RecordDecl *AnonRecord);
Mike Stump1eb44332009-09-09 15:08:12 +0000671 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000672 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000673
Mike Stump1eb44332009-09-09 15:08:12 +0000674 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000675 TagDecl::TagKind NewTag,
676 SourceLocation NewTagLoc,
677 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000678
John McCall0f434ec2009-07-31 02:45:11 +0000679 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000680 SourceLocation KWLoc, const CXXScopeSpec &SS,
681 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +0000682 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000683 MultiTemplateParamsArg TemplateParameterLists,
John McCallc4e70192009-09-11 04:59:25 +0000684 bool &OwnedDecl, bool &IsDependent);
685
686 virtual TypeResult ActOnDependentTag(Scope *S,
687 unsigned TagSpec,
688 TagUseKind TUK,
689 const CXXScopeSpec &SS,
690 IdentifierInfo *Name,
691 SourceLocation TagLoc,
692 SourceLocation NameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +0000693
Chris Lattnerb28317a2009-03-28 19:18:32 +0000694 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000695 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000696 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
697 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
698 SourceLocation DeclStart,
699 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000700
701 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000702 Declarator &D, Expr *BitfieldWidth,
703 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000704
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000705 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
Mike Stump1eb44332009-09-09 15:08:12 +0000706 DeclaratorInfo *DInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000707 RecordDecl *Record, SourceLocation Loc,
708 bool Mutable, Expr *BitfieldWidth,
Steve Naroffea218b82009-07-14 14:58:18 +0000709 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000710 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000711 Declarator *D = 0);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000712
713 enum CXXSpecialMember {
714 CXXDefaultConstructor = 0,
715 CXXCopyConstructor = 1,
716 CXXCopyAssignment = 2,
717 CXXDestructor = 3
718 };
719 void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
Mike Stump1eb44332009-09-09 15:08:12 +0000720
Chris Lattnerb28317a2009-03-28 19:18:32 +0000721 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +0000722 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000723 Declarator &D, ExprTy *BitfieldWidth,
724 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000725
Steve Narofff13271f2007-09-14 23:09:53 +0000726 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000727 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000728 SourceLocation RecLoc, DeclPtrTy TagDecl,
729 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000730 SourceLocation LBrac, SourceLocation RBrac,
731 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000732
733 /// ActOnTagStartDefinition - Invoked when we have entered the
734 /// scope of a tag's definition (e.g., for an enumeration, class,
735 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000736 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000737
738 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
739 /// the definition of a tag (enumeration, class, struct, or union).
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +0000740 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
741 SourceLocation RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +0000742
Douglas Gregor879fd492009-03-17 19:05:46 +0000743 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
744 EnumConstantDecl *LastEnumConst,
745 SourceLocation IdLoc,
746 IdentifierInfo *Id,
747 ExprArg val);
748
Chris Lattnerb28317a2009-03-28 19:18:32 +0000749 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
750 DeclPtrTy LastEnumConstant,
751 SourceLocation IdLoc, IdentifierInfo *Id,
752 SourceLocation EqualLoc, ExprTy *Val);
Mike Stumpc6e35aa2009-05-16 07:06:02 +0000753 virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
754 SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
Edward O'Callaghanfee13812009-08-08 14:36:57 +0000755 DeclPtrTy *Elements, unsigned NumElements,
756 Scope *S, AttributeList *Attr);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000757
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000758 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000759
Chris Lattner0ed844b2008-04-04 06:12:32 +0000760 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000761 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000762 void PopDeclContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000763
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000764 /// EnterDeclaratorContext - Used when we must lookup names in the context
765 /// of a declarator's nested name specifier.
766 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
767 void ExitDeclaratorContext(Scope *S);
Mike Stump1eb44332009-09-09 15:08:12 +0000768
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000769 DeclContext *getFunctionLevelDeclContext();
Mike Stump1eb44332009-09-09 15:08:12 +0000770
Chris Lattner371f2582008-12-04 23:50:19 +0000771 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
772 /// to the function decl for the function being parsed. If we're currently
773 /// in a 'block', this returns the containing context.
774 FunctionDecl *getCurFunctionDecl();
Mike Stump1eb44332009-09-09 15:08:12 +0000775
Chris Lattner371f2582008-12-04 23:50:19 +0000776 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
777 /// the method decl for the method being parsed. If we're currently
778 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000779 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000780
Chris Lattner371f2582008-12-04 23:50:19 +0000781 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
782 /// or C function we're in, otherwise return null. If we're currently
783 /// in a 'block', this returns the containing context.
784 NamedDecl *getCurFunctionOrMethodDecl();
785
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000786 /// Add this decl to the scope shadowed decl chains.
John McCallab88d972009-08-31 22:39:49 +0000787 void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext = true);
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000788
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000789 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
790 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
791 /// true if 'D' belongs to the given declaration context.
Douglas Gregor2531c2d2009-09-28 00:47:05 +0000792 bool isDeclInScope(NamedDecl *&D, DeclContext *Ctx, Scope *S = 0);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000793
John McCallab88d972009-08-31 22:39:49 +0000794 /// Finds the scope corresponding to the given decl context, if it
795 /// happens to be an enclosing scope. Otherwise return NULL.
796 Scope *getScopeForDeclContext(Scope *S, DeclContext *DC) {
John McCall1a26c272009-09-02 01:07:03 +0000797 DeclContext *TargetDC = DC->getPrimaryContext();
John McCallab88d972009-08-31 22:39:49 +0000798 do {
John McCall1a26c272009-09-02 01:07:03 +0000799 if (DeclContext *ScopeDC = (DeclContext*) S->getEntity())
800 if (ScopeDC->getPrimaryContext() == TargetDC)
801 return S;
John McCallab88d972009-08-31 22:39:49 +0000802 } while ((S = S->getParent()));
803
804 return NULL;
805 }
806
Fariborz Jahanian34acd3e2009-09-15 19:12:21 +0000807 /// OverloadingResult - Capture the result of performing overload
808 /// resolution.
809 enum OverloadingResult {
810 OR_Success, ///< Overload resolution succeeded.
811 OR_No_Viable_Function, ///< No viable function found.
812 OR_Ambiguous, ///< Ambiguous candidates found.
813 OR_Deleted ///< Overload resoltuion refers to a deleted function.
814 };
815
Eli Friedman8f17b662009-02-28 05:41:13 +0000816
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000817 /// Subroutines of ActOnDeclarator().
John McCallba6a9bd2009-10-24 08:00:42 +0000818 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
819 DeclaratorInfo *DInfo);
John McCall68263142009-11-18 22:49:29 +0000820 void MergeTypeDefDecl(TypedefDecl *New, LookupResult &OldDecls);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000821 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000822 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
John McCall68263142009-11-18 22:49:29 +0000823 void MergeVarDecl(VarDecl *New, LookupResult &OldDecls);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000824 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000825
826 /// C++ Overloading.
John McCall68263142009-11-18 22:49:29 +0000827 bool IsOverload(FunctionDecl *New, LookupResult &OldDecls,
828 NamedDecl *&OldDecl);
829 bool IsOverload(FunctionDecl *New, FunctionDecl *Old);
830
Mike Stump1eb44332009-09-09 15:08:12 +0000831 ImplicitConversionSequence
Anders Carlsson2974b5c2009-08-27 17:14:02 +0000832 TryImplicitConversion(Expr* From, QualType ToType,
Anders Carlssonda7a18b2009-08-27 17:24:15 +0000833 bool SuppressUserConversions,
834 bool AllowExplicit,
Anders Carlsson08972922009-08-28 15:33:32 +0000835 bool ForceRValue,
Fariborz Jahanian249cead2009-10-01 20:39:51 +0000836 bool InOverloadResolution,
837 bool UserCast = false);
Anders Carlsson08972922009-08-28 15:33:32 +0000838 bool IsStandardConversion(Expr *From, QualType ToType,
839 bool InOverloadResolution,
Douglas Gregor60d62c22008-10-31 16:23:19 +0000840 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000841 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
842 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000843 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000844 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Anders Carlsson08972922009-08-28 15:33:32 +0000845 bool InOverloadResolution,
Douglas Gregor45920e82008-12-19 17:40:08 +0000846 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000847 bool isObjCPointerConversion(QualType FromType, QualType ToType,
848 QualType& ConvertedType, bool &IncompatibleObjC);
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000849 bool CheckPointerConversion(Expr *From, QualType ToType,
850 CastExpr::CastKind &Kind,
851 bool IgnoreBaseAccess);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000852 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregorce940492009-09-25 04:25:58 +0000853 bool InOverloadResolution,
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000854 QualType &ConvertedType);
Anders Carlsson27a5b9b2009-08-22 23:33:40 +0000855 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
Sebastian Redla82e4ae2009-11-14 21:15:49 +0000856 CastExpr::CastKind &Kind,
857 bool IgnoreBaseAccess);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000858 bool IsQualificationConversion(QualType FromType, QualType ToType);
Fariborz Jahanian34acd3e2009-09-15 19:12:21 +0000859 OverloadingResult IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000860 UserDefinedConversionSequence& User,
Fariborz Jahanian78cf9a22009-09-15 00:10:11 +0000861 OverloadCandidateSet& Conversions,
Douglas Gregor734d9862009-01-30 23:27:23 +0000862 bool AllowConversionFunctions,
Fariborz Jahanian249cead2009-10-01 20:39:51 +0000863 bool AllowExplicit, bool ForceRValue,
864 bool UserCast = false);
Fariborz Jahaniancc5306a2009-11-18 18:26:29 +0000865 bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
Fariborz Jahanian17c7a5d2009-09-22 20:24:30 +0000866
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000867
Mike Stump1eb44332009-09-09 15:08:12 +0000868 ImplicitConversionSequence::CompareKind
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000869 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
870 const ImplicitConversionSequence& ICS2);
871
Mike Stump1eb44332009-09-09 15:08:12 +0000872 ImplicitConversionSequence::CompareKind
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000873 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
874 const StandardConversionSequence& SCS2);
875
Mike Stump1eb44332009-09-09 15:08:12 +0000876 ImplicitConversionSequence::CompareKind
Douglas Gregor57373262008-10-22 14:17:15 +0000877 CompareQualificationConversions(const StandardConversionSequence& SCS1,
878 const StandardConversionSequence& SCS2);
879
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000880 ImplicitConversionSequence::CompareKind
881 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
882 const StandardConversionSequence& SCS2);
883
Mike Stump1eb44332009-09-09 15:08:12 +0000884 ImplicitConversionSequence
Douglas Gregor225c41e2008-11-03 19:09:14 +0000885 TryCopyInitialization(Expr* From, QualType ToType,
Anders Carlsson7b361b52009-08-27 17:37:39 +0000886 bool SuppressUserConversions, bool ForceRValue,
887 bool InOverloadResolution);
Mike Stump1eb44332009-09-09 15:08:12 +0000888 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000889 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000890
Douglas Gregor96176b32008-11-18 23:14:02 +0000891 ImplicitConversionSequence
892 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
893 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
894
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000895 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
896 bool PerformContextuallyConvertToBool(Expr *&From);
Mike Stump1eb44332009-09-09 15:08:12 +0000897
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000898 bool PerformObjectMemberConversion(Expr *&From, NamedDecl *Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000899
John McCall6ff07852009-08-07 22:18:02 +0000900 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
901 // TODO: make this is a typesafe union.
902 typedef llvm::SmallPtrSet<DeclContext *, 16> AssociatedNamespaceSet;
903
Douglas Gregor364e0212009-06-27 21:05:07 +0000904 typedef llvm::SmallPtrSet<AnyFunctionDecl, 16> FunctionSet;
Douglas Gregor063daf62009-03-13 18:40:31 +0000905 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
906
Mike Stump1eb44332009-09-09 15:08:12 +0000907 void AddOverloadCandidate(FunctionDecl *Function,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000908 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000909 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000910 bool SuppressUserConversions = false,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000911 bool ForceRValue = false,
912 bool PartialOverloading = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000913 void AddFunctionCandidates(const FunctionSet &Functions,
914 Expr **Args, unsigned NumArgs,
915 OverloadCandidateSet& CandidateSet,
916 bool SuppressUserConversions = false);
John McCall314be4e2009-11-17 07:50:12 +0000917 void AddMethodCandidate(NamedDecl *Decl,
918 Expr *Object, Expr **Args, unsigned NumArgs,
919 OverloadCandidateSet& CandidateSet,
920 bool SuppressUserConversion = false,
921 bool ForceRValue = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000922 void AddMethodCandidate(CXXMethodDecl *Method,
923 Expr *Object, Expr **Args, unsigned NumArgs,
924 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000925 bool SuppressUserConversions = false,
926 bool ForceRValue = false);
Douglas Gregor6b906862009-08-21 00:16:32 +0000927 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
John McCalld5532b62009-11-23 01:53:49 +0000928 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor6b906862009-08-21 00:16:32 +0000929 Expr *Object, Expr **Args, unsigned NumArgs,
930 OverloadCandidateSet& CandidateSet,
931 bool SuppressUserConversions = false,
932 bool ForceRValue = false);
Douglas Gregore53060f2009-06-25 22:08:12 +0000933 void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +0000934 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +0000935 Expr **Args, unsigned NumArgs,
936 OverloadCandidateSet& CandidateSet,
937 bool SuppressUserConversions = false,
938 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000939 void AddConversionCandidate(CXXConversionDecl *Conversion,
940 Expr *From, QualType ToType,
941 OverloadCandidateSet& CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +0000942 void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
943 Expr *From, QualType ToType,
944 OverloadCandidateSet &CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000945 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000946 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000947 Expr *Object, Expr **Args, unsigned NumArgs,
948 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000949 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000950 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000951 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000952 OverloadCandidateSet& CandidateSet,
953 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000954 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
955 SourceLocation OpLoc,
956 Expr **Args, unsigned NumArgs,
957 OverloadCandidateSet& CandidateSet,
958 SourceRange OpRange = SourceRange());
Mike Stump1eb44332009-09-09 15:08:12 +0000959 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000960 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000961 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000962 bool IsAssignmentOperator = false,
963 unsigned NumContextualBoolArguments = 0);
Mike Stump1eb44332009-09-09 15:08:12 +0000964 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
Douglas Gregor573d9c32009-10-21 23:19:44 +0000965 SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +0000966 Expr **Args, unsigned NumArgs,
Douglas Gregor74253732008-11-19 15:42:04 +0000967 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000968 void AddArgumentDependentLookupCandidates(DeclarationName Name,
969 Expr **Args, unsigned NumArgs,
John McCalld5532b62009-11-23 01:53:49 +0000970 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000971 OverloadCandidateSet& CandidateSet,
972 bool PartialOverloading = false);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000973 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
974 const OverloadCandidate& Cand2);
975 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
Douglas Gregore0762c92009-06-19 23:52:42 +0000976 SourceLocation Loc,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000977 OverloadCandidateSet::iterator& Best);
978 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
Fariborz Jahanian16a5eac2009-10-09 00:13:15 +0000979 bool OnlyViable,
Fariborz Jahanian2ebe7eb2009-10-12 20:11:40 +0000980 const char *Opc=0,
Fariborz Jahanian16a5eac2009-10-09 00:13:15 +0000981 SourceLocation Loc=SourceLocation());
Mike Stump1eb44332009-09-09 15:08:12 +0000982
Douglas Gregor904eed32008-11-10 20:40:00 +0000983 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
984 bool Complain);
Anders Carlsson96ad5332009-10-21 17:16:23 +0000985 Expr *FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
Douglas Gregor904eed32008-11-10 20:40:00 +0000986
John McCallba135432009-11-21 08:51:07 +0000987 void AddOverloadedCallCandidates(llvm::SmallVectorImpl<NamedDecl*>& Callees,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000988 DeclarationName &UnqualifiedName,
John McCalld2ede7d2009-11-21 09:38:42 +0000989 bool ArgumentDependentLookup,
John McCalld5532b62009-11-23 01:53:49 +0000990 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +0000991 Expr **Args, unsigned NumArgs,
992 OverloadCandidateSet &CandidateSet,
993 bool PartialOverloading = false);
994
John McCallba135432009-11-21 08:51:07 +0000995 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn,
996 llvm::SmallVectorImpl<NamedDecl*> &Fns,
Douglas Gregor17330012009-02-04 15:01:18 +0000997 DeclarationName UnqualifiedName,
John McCalld5532b62009-11-23 01:53:49 +0000998 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor0a396682008-11-26 06:01:48 +0000999 SourceLocation LParenLoc,
1000 Expr **Args, unsigned NumArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00001001 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +00001002 SourceLocation RParenLoc,
John McCalld2ede7d2009-11-21 09:38:42 +00001003 bool ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +00001004
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001005 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
1006 unsigned Opc,
1007 FunctionSet &Functions,
1008 ExprArg input);
1009
Douglas Gregor063daf62009-03-13 18:40:31 +00001010 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
1011 unsigned Opc,
1012 FunctionSet &Functions,
1013 Expr *LHS, Expr *RHS);
1014
Sebastian Redlf322ed62009-10-29 20:17:01 +00001015 OwningExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
1016 SourceLocation RLoc,
1017 ExprArg Base,ExprArg Idx);
1018
Douglas Gregor88a35142008-12-22 05:46:06 +00001019 ExprResult
1020 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00001021 SourceLocation LParenLoc, Expr **Args,
Douglas Gregor88a35142008-12-22 05:46:06 +00001022 unsigned NumArgs, SourceLocation *CommaLocs,
1023 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001024 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +00001025 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +00001026 Expr **Args, unsigned NumArgs,
Mike Stump1eb44332009-09-09 15:08:12 +00001027 SourceLocation *CommaLocs,
Douglas Gregorf9eb9052008-11-19 21:05:33 +00001028 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +00001029
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001030 OwningExprResult BuildOverloadedArrowExpr(Scope *S, ExprArg Base,
1031 SourceLocation OpLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001032
Anders Carlsson8c8d9192009-10-09 23:51:55 +00001033 /// CheckCallReturnType - Checks that a call expression's return type is
1034 /// complete. Returns true on failure. The location passed in is the location
1035 /// that best represents the call.
1036 bool CheckCallReturnType(QualType ReturnType, SourceLocation Loc,
1037 CallExpr *CE, FunctionDecl *FD);
1038
Mike Stump56925862009-07-28 22:04:01 +00001039 /// Helpers for dealing with blocks and functions.
Mike Stumpb1682c52009-07-22 23:56:57 +00001040 void CheckFallThroughForFunctionDef(Decl *D, Stmt *Body);
Mike Stump56925862009-07-28 22:04:01 +00001041 void CheckFallThroughForBlock(QualType BlockTy, Stmt *Body);
Chris Lattner04421082008-04-08 04:40:51 +00001042 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +00001043 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +00001044 void CheckExtraCXXDefaultArguments(Declarator &D);
Mike Stumpb1682c52009-07-22 23:56:57 +00001045 enum ControlFlowKind { NeverFallThrough = 0, MaybeFallThrough = 1,
Mike Stump1d7e7672009-10-27 01:59:05 +00001046 AlwaysFallThrough = 2, NeverFallThroughOrReturn = 3 };
Mike Stumpb1682c52009-07-22 23:56:57 +00001047 ControlFlowKind CheckFallThrough(Stmt *);
Reid Spencer5f016e22007-07-11 17:01:13 +00001048
Douglas Gregor1a0d31a2009-01-12 18:45:55 +00001049 Scope *getNonFieldDeclScope(Scope *S);
1050
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001051 /// \name Name lookup
1052 ///
1053 /// These routines provide name lookup that is used during semantic
1054 /// analysis to resolve the various kinds of names (identifiers,
1055 /// overloaded operator names, constructor names, etc.) into zero or
1056 /// more declarations within a particular scope. The major entry
1057 /// points are LookupName, which performs unqualified name lookup,
Mike Stump1eb44332009-09-09 15:08:12 +00001058 /// and LookupQualifiedName, which performs qualified name lookup.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001059 ///
1060 /// All name lookup is performed based on some specific criteria,
1061 /// which specify what names will be visible to name lookup and how
1062 /// far name lookup should work. These criteria are important both
1063 /// for capturing language semantics (certain lookups will ignore
1064 /// certain names, for example) and for performance, since name
1065 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001066 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001067 ///
1068 /// The results of name lookup can vary based on the kind of name
1069 /// lookup performed, the current language, and the translation
1070 /// unit. In C, for example, name lookup will either return nothing
1071 /// (no entity found) or a single declaration. In C++, name lookup
1072 /// can additionally refer to a set of overloaded functions or
1073 /// result in an ambiguity. All of the possible results of name
1074 /// lookup are captured by the LookupResult class, which provides
1075 /// the ability to distinguish among them.
1076 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +00001077
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001078 /// @brief Describes the kind of name lookup to perform.
1079 enum LookupNameKind {
1080 /// Ordinary name lookup, which finds ordinary names (functions,
1081 /// variables, typedefs, etc.) in C and most kinds of names
1082 /// (functions, variables, members, types, etc.) in C++.
1083 LookupOrdinaryName = 0,
1084 /// Tag name lookup, which finds the names of enums, classes,
1085 /// structs, and unions.
1086 LookupTagName,
1087 /// Member name lookup, which finds the names of
1088 /// class/struct/union members.
1089 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001090 // Look up of an operator name (e.g., operator+) for use with
1091 // operator overloading. This lookup is similar to ordinary name
1092 // lookup, but will ignore any declarations that are class
1093 // members.
1094 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001095 /// Look up of a name that precedes the '::' scope resolution
1096 /// operator in C++. This lookup completely ignores operator,
1097 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
1098 LookupNestedNameSpecifierName,
1099 /// Look up a namespace name within a C++ using directive or
1100 /// namespace alias definition, ignoring non-namespace names (C++
1101 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001102 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +00001103 /// Look up an ordinary name that is going to be redeclared as a
1104 /// name with linkage. This lookup ignores any declarations that
Mike Stump1eb44332009-09-09 15:08:12 +00001105 /// are outside of the current scope unless they have linkage. See
Douglas Gregor6e378de2009-04-23 23:18:26 +00001106 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
1107 LookupRedeclarationWithLinkage,
1108 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001109 LookupObjCProtocolName,
1110 /// Look up the name of an Objective-C implementation
1111 LookupObjCImplementationName,
1112 /// Look up the name of an Objective-C category implementation
1113 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001114 };
1115
John McCall7d384dd2009-11-18 07:57:50 +00001116 enum RedeclarationKind {
1117 NotForRedeclaration,
1118 ForRedeclaration
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001119 };
1120
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001121private:
John McCalla24dc2e2009-11-17 02:14:36 +00001122 bool CppLookupName(LookupResult &R, Scope *S);
1123
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001124public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001125 /// Determines whether D is a suitable lookup result according to the
1126 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001127 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001128 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001129 switch (NameKind) {
1130 case Sema::LookupOrdinaryName:
1131 case Sema::LookupTagName:
1132 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001133 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001134 case Sema::LookupObjCProtocolName:
1135 case Sema::LookupObjCImplementationName:
1136 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001137 return D->isInIdentifierNamespace(IDNS);
Mike Stump1eb44332009-09-09 15:08:12 +00001138
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001139 case Sema::LookupOperatorName:
Mike Stump1eb44332009-09-09 15:08:12 +00001140 return D->isInIdentifierNamespace(IDNS) &&
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001141 !D->getDeclContext()->isRecord();
1142
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001143 case Sema::LookupNestedNameSpecifierName:
1144 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
Mike Stump1eb44332009-09-09 15:08:12 +00001145
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001146 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001147 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001148 }
Mike Stump1eb44332009-09-09 15:08:12 +00001149
1150 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001151 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001152 return false;
1153 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001154
John McCallf36e02d2009-10-09 21:13:30 +00001155 /// \brief Look up a name, looking for a single declaration. Return
1156 /// null if no unambiguous results were found.
1157 ///
1158 /// It is preferable to use the elaborated form and explicitly handle
1159 /// ambiguity and overloaded.
1160 NamedDecl *LookupSingleName(Scope *S, DeclarationName Name,
1161 LookupNameKind NameKind,
John McCall7d384dd2009-11-18 07:57:50 +00001162 RedeclarationKind Redecl
1163 = NotForRedeclaration);
John McCallf36e02d2009-10-09 21:13:30 +00001164 bool LookupName(LookupResult &R, Scope *S,
John McCalla24dc2e2009-11-17 02:14:36 +00001165 bool AllowBuiltinCreation = false);
1166 bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx);
John McCallf36e02d2009-10-09 21:13:30 +00001167 bool LookupParsedName(LookupResult &R, Scope *S, const CXXScopeSpec *SS,
John McCallf36e02d2009-10-09 21:13:30 +00001168 bool AllowBuiltinCreation = false,
John McCallf36e02d2009-10-09 21:13:30 +00001169 bool EnteringContext = false);
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001170
Douglas Gregor6e378de2009-04-23 23:18:26 +00001171 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001172 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001173
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001174 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00001175 QualType T1, QualType T2,
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001176 FunctionSet &Functions);
Mike Stump1eb44332009-09-09 15:08:12 +00001177
Sebastian Redl644be852009-10-23 19:23:15 +00001178 void ArgumentDependentLookup(DeclarationName Name, bool Operator,
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001179 Expr **Args, unsigned NumArgs,
1180 FunctionSet &Functions);
1181
Douglas Gregorfa047642009-02-04 00:32:51 +00001182 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1183 AssociatedNamespaceSet &AssociatedNamespaces,
John McCall6ff07852009-08-07 22:18:02 +00001184 AssociatedClassSet &AssociatedClasses);
Douglas Gregorfa047642009-02-04 00:32:51 +00001185
John McCalla24dc2e2009-11-17 02:14:36 +00001186 bool DiagnoseAmbiguousLookup(LookupResult &Result);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001187 //@}
Mike Stump1eb44332009-09-09 15:08:12 +00001188
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001189 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Mike Stump1eb44332009-09-09 15:08:12 +00001190 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001191 Scope *S, bool ForRedeclaration,
1192 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001193 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1194 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001195 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001196
1197 // More parsing and symbol table subroutines.
1198
Mike Stump1eb44332009-09-09 15:08:12 +00001199 // Decl attributes - this routine is the top level dispatcher.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001200 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
1201 void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001202
Steve Naroff3c2eb662008-02-10 21:38:56 +00001203 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1204 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001205 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1206 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001207
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001208 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001209 ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001210
Chris Lattner823c44e2009-01-06 07:27:21 +00001211 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001212 /// methods declared in protocol, and those referenced by it.
1213 /// \param IDecl - Used for checking for methods which may have been
1214 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001215 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1216 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001217 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001218 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001219 const llvm::DenseSet<Selector> &ClsMap,
1220 ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001221
Steve Naroffa5997c42007-10-02 21:43:37 +00001222 /// CheckImplementationIvars - This routine checks if the instance variables
Mike Stump1eb44332009-09-09 15:08:12 +00001223 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001224 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1225 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001226 SourceLocation Loc);
Mike Stump1eb44332009-09-09 15:08:12 +00001227
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001228 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001229 /// remains unimplemented in the class or category @implementation.
Mike Stump1eb44332009-09-09 15:08:12 +00001230 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1231 ObjCContainerDecl* IDecl,
Chris Lattnercddc8882009-03-01 00:56:52 +00001232 bool IncompleteImpl = false);
Fariborz Jahanian7ca8b062009-11-11 22:40:11 +00001233
1234 /// AtomicPropertySetterGetterRules - This routine enforces the rule (via
1235 /// warning) when atomic property has one but not the other user-declared
1236 /// setter or getter.
1237 void AtomicPropertySetterGetterRules(ObjCImplDecl* IMPDecl,
1238 ObjCContainerDecl* IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001239
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001240 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1241 /// true, or false, accordingly.
Mike Stump1eb44332009-09-09 15:08:12 +00001242 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001243 const ObjCMethodDecl *PrevMethod,
Mike Stump1eb44332009-09-09 15:08:12 +00001244 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001245
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001246 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1247 /// or protocol against those declared in their implementations.
1248 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1249 const llvm::DenseSet<Selector> &ClsMap,
1250 llvm::DenseSet<Selector> &InsMapSeen,
1251 llvm::DenseSet<Selector> &ClsMapSeen,
1252 ObjCImplDecl* IMPDecl,
1253 ObjCContainerDecl* IDecl,
1254 bool &IncompleteImpl,
1255 bool ImmediateClass);
1256
Steve Naroff58ff9e82007-10-14 00:58:41 +00001257 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1258 /// unit are added to a global pool. This allows us to efficiently associate
1259 /// a selector with a method declaraation for purposes of typechecking
1260 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001261 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Mike Stump1eb44332009-09-09 15:08:12 +00001262
Steve Naroff037cda52008-09-30 14:38:43 +00001263 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1264 /// there are multiple signatures.
Fariborz Jahanian835ed7f2009-08-22 21:13:55 +00001265 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
1266 bool warn=true);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001267
1268 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1269 /// there are multiple signatures.
1270 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Mike Stump1eb44332009-09-09 15:08:12 +00001271
Steve Naroff58ff9e82007-10-14 00:58:41 +00001272 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001273 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001274 //===--------------------------------------------------------------------===//
1275 // Statement Parsing Callbacks: SemaStmt.cpp.
1276public:
Anders Carlsson6b1d2832009-05-17 21:11:30 +00001277 virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr);
Sebastian Redla60528c2008-12-21 12:04:03 +00001278
1279 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1280 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1281 MultiStmtArg Elts,
1282 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001283 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001284 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001285 SourceLocation EndLoc);
Fariborz Jahaniana7cf23a2009-11-19 22:12:37 +00001286 virtual void ActOnForEachDeclStmt(DeclGroupPtrTy Decl);
Sebastian Redl117054a2008-12-28 16:13:43 +00001287 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1288 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001289 SourceLocation ColonLoc);
1290 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
Mike Stump1eb44332009-09-09 15:08:12 +00001291
Sebastian Redl117054a2008-12-28 16:13:43 +00001292 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1293 SourceLocation ColonLoc,
1294 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001295 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1296 IdentifierInfo *II,
1297 SourceLocation ColonLoc,
1298 StmtArg SubStmt);
Mike Stump1eb44332009-09-09 15:08:12 +00001299 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001300 FullExprArg CondVal, DeclPtrTy CondVar,
1301 StmtArg ThenVal,
Anders Carlssona99fad82009-05-17 18:26:53 +00001302 SourceLocation ElseLoc, StmtArg ElseVal);
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001303 virtual OwningStmtResult ActOnStartOfSwitchStmt(FullExprArg Cond,
1304 DeclPtrTy CondVar);
Sebastian Redlde307472009-01-11 00:38:46 +00001305 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1306 StmtArg Switch, StmtArg Body);
Mike Stump1eb44332009-09-09 15:08:12 +00001307 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001308 FullExprArg Cond,
1309 DeclPtrTy CondVar, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001310 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
Chris Lattner98913592009-06-12 23:04:47 +00001311 SourceLocation WhileLoc,
1312 SourceLocation CondLParen, ExprArg Cond,
1313 SourceLocation CondRParen);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001314
1315 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1316 SourceLocation LParenLoc,
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001317 StmtArg First, FullExprArg Second,
1318 DeclPtrTy SecondVar,
1319 FullExprArg Third,
1320 SourceLocation RParenLoc,
Sebastian Redlf05b1522009-01-16 23:28:06 +00001321 StmtArg Body);
1322 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1323 SourceLocation LParenLoc,
1324 StmtArg First, ExprArg Second,
1325 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001326
1327 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1328 SourceLocation LabelLoc,
1329 IdentifierInfo *LabelII);
1330 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1331 SourceLocation StarLoc,
1332 ExprArg DestExp);
1333 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1334 Scope *CurScope);
1335 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1336 Scope *CurScope);
1337
1338 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Anders Carlssonf53b4432009-08-18 16:11:00 +00001339 ExprArg RetValExp);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001340 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1341 Expr *RetValExp);
1342
Sebastian Redl3037ed02009-01-18 16:53:17 +00001343 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1344 bool IsSimple,
1345 bool IsVolatile,
1346 unsigned NumOutputs,
1347 unsigned NumInputs,
1348 std::string *Names,
1349 MultiExprArg Constraints,
1350 MultiExprArg Exprs,
1351 ExprArg AsmString,
1352 MultiExprArg Clobbers,
1353 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001354
1355 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1356 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001357 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001358 StmtArg CatchList);
1359
1360 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1361 StmtArg Body);
1362
1363 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1364 StmtArg Try,
1365 StmtArg Catch, StmtArg Finally);
1366
1367 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001368 ExprArg Throw,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001369 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001370 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1371 ExprArg SynchExpr,
1372 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001373
Douglas Gregord308e622009-05-18 20:51:54 +00001374 VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001375 DeclaratorInfo *DInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00001376 IdentifierInfo *Name,
1377 SourceLocation Loc,
1378 SourceRange Range);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001379 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Douglas Gregord308e622009-05-18 20:51:54 +00001380
Sebastian Redl4b07b292008-12-22 19:15:10 +00001381 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001382 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001383 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001384 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1385 StmtArg TryBlock,
1386 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001387 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001388
Anders Carlsson636463e2009-07-30 22:17:18 +00001389 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
1390 /// whose result is unused, warn.
1391 void DiagnoseUnusedExprResult(const Stmt *S);
Mike Stump1eb44332009-09-09 15:08:12 +00001392
John McCall54abf7d2009-11-04 02:18:39 +00001393 ParsingDeclStackState PushParsingDeclaration();
1394 void PopParsingDeclaration(ParsingDeclStackState S, DeclPtrTy D);
1395 void EmitDeprecationWarning(NamedDecl *D, SourceLocation Loc);
1396
Reid Spencer5f016e22007-07-11 17:01:13 +00001397 //===--------------------------------------------------------------------===//
1398 // Expression Parsing Callbacks: SemaExpr.cpp.
1399
John McCall54abf7d2009-11-04 02:18:39 +00001400 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Mike Stump1eb44332009-09-09 15:08:12 +00001401 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001402 ObjCMethodDecl *Getter,
1403 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001404 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1405 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001406
John McCallb13c87f2009-11-05 09:23:39 +00001407 void CheckSignCompare(Expr *LHS, Expr *RHS, SourceLocation Loc,
John McCall5dbad3d2009-11-06 08:49:08 +00001408 const PartialDiagnostic &PD,
1409 bool Equality = false);
John McCallb13c87f2009-11-05 09:23:39 +00001410
Douglas Gregor2afce722009-11-26 00:44:06 +00001411 virtual void
Douglas Gregorac7610d2009-06-22 20:57:11 +00001412 PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext);
Mike Stump1eb44332009-09-09 15:08:12 +00001413
Douglas Gregor2afce722009-11-26 00:44:06 +00001414 virtual void PopExpressionEvaluationContext();
Mike Stump1eb44332009-09-09 15:08:12 +00001415
Douglas Gregore0762c92009-06-19 23:52:42 +00001416 void MarkDeclarationReferenced(SourceLocation Loc, Decl *D);
Mike Stump1eb44332009-09-09 15:08:12 +00001417
Reid Spencer5f016e22007-07-11 17:01:13 +00001418 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001419 virtual SourceRange getExprRange(ExprTy *E) const;
1420
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001421 virtual OwningExprResult ActOnIdExpression(Scope *S,
1422 const CXXScopeSpec &SS,
1423 UnqualifiedId &Name,
1424 bool HasTrailingLParen,
1425 bool IsAddressOfOperand);
John McCallf7a1a742009-11-24 19:00:30 +00001426
1427 OwningExprResult LookupInObjCMethod(LookupResult &R,
1428 Scope *S,
1429 IdentifierInfo *II);
1430
1431 OwningExprResult ActOnDependentIdExpression(const CXXScopeSpec &SS,
1432 DeclarationName Name,
1433 SourceLocation NameLoc,
1434 bool CheckForImplicitMember,
1435 const TemplateArgumentListInfo *TemplateArgs);
Douglas Gregor02a24ee2009-11-03 16:56:39 +00001436
Mike Stump1eb44332009-09-09 15:08:12 +00001437 OwningExprResult BuildDeclRefExpr(NamedDecl *D, QualType Ty,
Douglas Gregor0da76df2009-11-23 11:41:28 +00001438 SourceLocation Loc,
Anders Carlssone41590d2009-06-24 00:10:43 +00001439 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001440 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1441 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001442 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001443 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1444 FieldDecl *Field,
1445 Expr *BaseObjectExpr = 0,
1446 SourceLocation OpLoc = SourceLocation());
John McCallf7a1a742009-11-24 19:00:30 +00001447 OwningExprResult BuildImplicitMemberReferenceExpr(const CXXScopeSpec &SS,
1448 LookupResult &R,
1449 const TemplateArgumentListInfo *TemplateArgs);
1450 bool UseArgumentDependentLookup(const CXXScopeSpec &SS,
John McCall5b3f9132009-11-22 01:44:31 +00001451 const LookupResult &R,
1452 bool HasTrailingLParen);
John McCallf7a1a742009-11-24 19:00:30 +00001453
1454 OwningExprResult BuildQualifiedDeclarationNameExpr(const CXXScopeSpec &SS,
1455 DeclarationName Name,
1456 SourceLocation NameLoc);
1457 OwningExprResult BuildDependentDeclRefExpr(const CXXScopeSpec &SS,
1458 DeclarationName Name,
1459 SourceLocation NameLoc,
1460 const TemplateArgumentListInfo *TemplateArgs);
1461
1462 OwningExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
1463 LookupResult &R,
1464 bool ADL);
1465 OwningExprResult BuildDeclarationNameExpr(const CXXScopeSpec &SS,
John McCallba135432009-11-21 08:51:07 +00001466 SourceLocation Loc,
1467 NamedDecl *D);
Mike Stump1eb44332009-09-09 15:08:12 +00001468
Sebastian Redlcd965b92009-01-18 18:53:16 +00001469 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1470 tok::TokenKind Kind);
1471 virtual OwningExprResult ActOnNumericConstant(const Token &);
1472 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1473 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1474 ExprArg Val);
Fariborz Jahanianf88f7ab2009-11-25 01:26:41 +00001475 virtual OwningExprResult ActOnParenOrParenListExpr(SourceLocation L,
Nate Begeman2ef13e52009-08-10 23:49:36 +00001476 SourceLocation R,
Fariborz Jahanianf88f7ab2009-11-25 01:26:41 +00001477 MultiExprArg Val,
1478 TypeTy *TypeOfCast=0);
Mike Stump1eb44332009-09-09 15:08:12 +00001479
Steve Narofff69936d2007-09-16 03:34:24 +00001480 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001481 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001482 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1483 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001484
Reid Spencer5f016e22007-07-11 17:01:13 +00001485 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001486 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00001487 unsigned OpcIn,
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001488 ExprArg InputArg);
Douglas Gregor6ca7cfb2009-11-05 00:51:44 +00001489 OwningExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
1490 UnaryOperator::Opcode Opc, ExprArg input);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001491 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1492 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001493
John McCall5ab75172009-11-04 07:28:41 +00001494 OwningExprResult CreateSizeOfAlignOfExpr(DeclaratorInfo *T,
1495 SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001496 bool isSizeOf, SourceRange R);
Mike Stump1eb44332009-09-09 15:08:12 +00001497 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
Douglas Gregorba498172009-03-13 21:01:28 +00001498 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001499 virtual OwningExprResult
1500 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1501 void *TyOrEx, const SourceRange &ArgRange);
Mike Stump1eb44332009-09-09 15:08:12 +00001502
Chris Lattner31e21e02009-01-24 20:17:12 +00001503 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001504 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1505 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001506
1507 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1508 tok::TokenKind Kind,
1509 ExprArg Input);
1510
1511 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1512 SourceLocation LLoc,
1513 ExprArg Idx,
1514 SourceLocation RLoc);
Sebastian Redlf322ed62009-10-29 20:17:01 +00001515 OwningExprResult CreateBuiltinArraySubscriptExpr(ExprArg Base,
1516 SourceLocation LLoc,
1517 ExprArg Idx,
1518 SourceLocation RLoc);
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001519
1520 OwningExprResult BuildMemberReferenceExpr(Scope *S, ExprArg Base,
1521 SourceLocation OpLoc,
1522 tok::TokenKind OpKind,
1523 SourceLocation MemberLoc,
1524 DeclarationName MemberName,
1525 DeclPtrTy ImplDecl,
Douglas Gregorc68afe22009-09-03 21:38:09 +00001526 const CXXScopeSpec *SS = 0,
1527 NamedDecl *FirstQualifierInScope = 0) {
Mike Stump1eb44332009-09-09 15:08:12 +00001528 // FIXME: Temporary helper while we migrate existing calls to
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001529 // BuildMemberReferenceExpr to support explicitly-specified template
1530 // arguments.
1531 return BuildMemberReferenceExpr(S, move(Base), OpLoc, OpKind, MemberLoc,
John McCalld5532b62009-11-23 01:53:49 +00001532 MemberName, 0, ImplDecl, SS,
Douglas Gregorc68afe22009-09-03 21:38:09 +00001533 FirstQualifierInScope);
Douglas Gregorc4bf26f2009-09-01 00:37:14 +00001534 }
Mike Stump1eb44332009-09-09 15:08:12 +00001535
Anders Carlsson8f28f992009-08-26 18:25:21 +00001536 OwningExprResult BuildMemberReferenceExpr(Scope *S, ExprArg Base,
1537 SourceLocation OpLoc,
1538 tok::TokenKind OpKind,
1539 SourceLocation MemberLoc,
1540 DeclarationName MemberName,
John McCalld5532b62009-11-23 01:53:49 +00001541 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Anders Carlsson8f28f992009-08-26 18:25:21 +00001542 DeclPtrTy ImplDecl,
Douglas Gregorc68afe22009-09-03 21:38:09 +00001543 const CXXScopeSpec *SS,
1544 NamedDecl *FirstQualifierInScope = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00001545
Douglas Gregor2d1c2142009-11-03 19:44:04 +00001546 virtual OwningExprResult ActOnMemberAccessExpr(Scope *S, ExprArg Base,
1547 SourceLocation OpLoc,
1548 tok::TokenKind OpKind,
1549 const CXXScopeSpec &SS,
1550 UnqualifiedId &Member,
1551 DeclPtrTy ObjCImpDecl,
1552 bool HasTrailingLParen);
1553
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001554 virtual void ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001555 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001556 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001557 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001558 Expr **Args, unsigned NumArgs,
1559 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001560
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001561 void DeconstructCallFunction(Expr *FnExpr,
John McCallba135432009-11-21 08:51:07 +00001562 llvm::SmallVectorImpl<NamedDecl*>& Fns,
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001563 DeclarationName &Name,
1564 NestedNameSpecifier *&Qualifier,
1565 SourceRange &QualifierRange,
1566 bool &ArgumentDependentLookup,
John McCall7453ed42009-11-22 00:44:51 +00001567 bool &Overloaded,
John McCalld5532b62009-11-23 01:53:49 +00001568 bool &HasExplicitTemplateArgs,
1569 TemplateArgumentListInfo &ExplicitTemplateArgs);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00001570
Steve Narofff69936d2007-09-16 03:34:24 +00001571 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001572 /// This provides the location of the left/right parens and a list of comma
1573 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001574 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1575 SourceLocation LParenLoc,
1576 MultiExprArg Args,
1577 SourceLocation *CommaLocs,
1578 SourceLocation RParenLoc);
1579
Nate Begeman2ef13e52009-08-10 23:49:36 +00001580 virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
1581 TypeTy *Ty, SourceLocation RParenLoc,
1582 ExprArg Op);
Fariborz Jahaniana79f8b32009-11-23 19:51:43 +00001583 virtual bool TypeIsVectorType(TypeTy *Ty) {
1584 return GetTypeFromParser(Ty)->isVectorType();
1585 }
Mike Stump1eb44332009-09-09 15:08:12 +00001586
Nate Begeman2ef13e52009-08-10 23:49:36 +00001587 OwningExprResult MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg ME);
1588 OwningExprResult ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
1589 SourceLocation RParenLoc, ExprArg E,
1590 QualType Ty);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001591
1592 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1593 TypeTy *Ty,
1594 SourceLocation RParenLoc,
1595 ExprArg Op);
1596
1597 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1598 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001599 SourceLocation RParenLoc);
1600
Douglas Gregor05c13a32009-01-22 00:58:24 +00001601 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1602 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001603 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001604 OwningExprResult Init);
1605
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001606 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1607 tok::TokenKind Kind,
1608 ExprArg LHS, ExprArg RHS);
Douglas Gregor6ca7cfb2009-11-05 00:51:44 +00001609 OwningExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
1610 BinaryOperator::Opcode Opc,
1611 Expr *lhs, Expr *rhs);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001612 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1613 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001614
Steve Narofff69936d2007-09-16 03:34:24 +00001615 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001616 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001617 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1618 SourceLocation ColonLoc,
1619 ExprArg Cond, ExprArg LHS,
1620 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001621
Steve Naroff1b273c42007-09-16 14:56:35 +00001622 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001623 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1624 SourceLocation LabLoc,
1625 IdentifierInfo *LabelII);
1626
1627 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1628 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001629
1630 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001631 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1632 SourceLocation BuiltinLoc,
1633 SourceLocation TypeLoc,
1634 TypeTy *Arg1,
1635 OffsetOfComponent *CompPtr,
1636 unsigned NumComponents,
1637 SourceLocation RParenLoc);
1638
Steve Naroffd34e9152007-08-01 22:05:33 +00001639 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001640 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1641 TypeTy *arg1, TypeTy *arg2,
1642 SourceLocation RPLoc);
1643
Steve Naroffd04fdd52007-08-03 21:21:27 +00001644 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001645 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1646 ExprArg cond, ExprArg expr1,
1647 ExprArg expr2, SourceLocation RPLoc);
1648
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001649 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001650 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1651 ExprArg expr, TypeTy *type,
1652 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001653
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001654 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001655 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001656
Steve Naroff4eb206b2008-09-03 18:15:37 +00001657 //===------------------------- "Block" Extension ------------------------===//
1658
1659 /// ActOnBlockStart - This callback is invoked when a block literal is
1660 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001661 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001662
Steve Naroff090276f2008-10-10 01:28:17 +00001663 /// ActOnBlockArguments - This callback allows processing of block arguments.
1664 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001665 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001666
Steve Naroff4eb206b2008-09-03 18:15:37 +00001667 /// ActOnBlockError - If there is an error parsing a block, this callback
1668 /// is invoked to pop the information about the block from the action impl.
1669 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001670
Steve Naroff4eb206b2008-09-03 18:15:37 +00001671 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1672 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001673 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1674 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001675
Chris Lattner76a642f2009-02-15 22:43:40 +00001676 //===---------------------------- C++ Features --------------------------===//
1677
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001678 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001679 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1680 IdentifierInfo *Ident,
1681 SourceLocation LBrace);
1682 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001683
Chris Lattnerb28317a2009-03-28 19:18:32 +00001684 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1685 SourceLocation UsingLoc,
1686 SourceLocation NamespcLoc,
1687 const CXXScopeSpec &SS,
1688 SourceLocation IdentLoc,
1689 IdentifierInfo *NamespcName,
1690 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00001691
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001692 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1693
Chris Lattnerb28317a2009-03-28 19:18:32 +00001694 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001695 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001696 SourceLocation AliasLoc,
1697 IdentifierInfo *Alias,
1698 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001699 SourceLocation IdentLoc,
1700 IdentifierInfo *Ident);
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001701
John McCall9488ea12009-11-17 05:59:44 +00001702 NamedDecl *BuildUsingDeclaration(Scope *S, AccessSpecifier AS,
1703 SourceLocation UsingLoc,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001704 const CXXScopeSpec &SS,
1705 SourceLocation IdentLoc,
1706 DeclarationName Name,
1707 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00001708 bool IsInstantiation,
1709 bool IsTypeName,
1710 SourceLocation TypenameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001711
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001712 virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope,
Anders Carlsson595adc12009-08-29 19:54:19 +00001713 AccessSpecifier AS,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001714 SourceLocation UsingLoc,
1715 const CXXScopeSpec &SS,
Douglas Gregor12c118a2009-11-04 16:30:06 +00001716 UnqualifiedId &Name,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001717 AttributeList *AttrList,
John McCall7ba107a2009-11-18 02:36:19 +00001718 bool IsTypeName,
1719 SourceLocation TypenameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001720
1721 /// AddCXXDirectInitializerToDecl - This action is called immediately after
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001722 /// ActOnDeclarator, when a C++ direct initializer is present.
1723 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001724 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001725 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001726 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001727 SourceLocation *CommaLocs,
1728 SourceLocation RParenLoc);
1729
Anders Carlsson49d44012009-04-24 05:16:06 +00001730 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1731 /// and sets it as the initializer for the the passed in VarDecl.
Mike Stump1eb44332009-09-09 15:08:12 +00001732 bool InitializeVarWithConstructor(VarDecl *VD,
Anders Carlsson930e8d02009-04-16 23:50:50 +00001733 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001734 MultiExprArg Exprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001735
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001736 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
1737 /// including handling of its default argument expressions.
Mike Stump1eb44332009-09-09 15:08:12 +00001738 OwningExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc,
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001739 QualType DeclInitType,
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001740 CXXConstructorDecl *Constructor,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001741 MultiExprArg Exprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001742
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001743 // FIXME: Can re remove this and have the above BuildCXXConstructExpr check if
1744 // the constructor can be elidable?
Mike Stump1eb44332009-09-09 15:08:12 +00001745 OwningExprResult BuildCXXConstructExpr(SourceLocation ConstructLoc,
Anders Carlssonec8e5ea2009-09-05 07:40:38 +00001746 QualType DeclInitType,
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001747 CXXConstructorDecl *Constructor,
1748 bool Elidable,
Anders Carlssonf47511a2009-09-07 22:23:31 +00001749 MultiExprArg Exprs);
Mike Stump1eb44332009-09-09 15:08:12 +00001750
1751 OwningExprResult BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Cons,
1752 QualType writtenTy,
1753 SourceLocation tyBeginLoc,
Anders Carlssone7624a72009-08-27 05:08:22 +00001754 MultiExprArg Args,
1755 SourceLocation rParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00001756
Anders Carlsson0aebc812009-09-09 21:33:21 +00001757 OwningExprResult BuildCXXCastArgument(SourceLocation CastLoc,
1758 QualType Ty,
1759 CastExpr::CastKind Kind,
1760 CXXMethodDecl *Method,
1761 ExprArg Arg);
1762
Anders Carlsson56c5e332009-08-25 03:49:14 +00001763 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
1764 /// the default expr if needed.
1765 OwningExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
1766 FunctionDecl *FD,
1767 ParmVarDecl *Param);
Mike Stump1eb44332009-09-09 15:08:12 +00001768
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00001769 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
1770 /// constructed variable.
1771 void FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType);
Mike Stump1eb44332009-09-09 15:08:12 +00001772
1773 /// DefineImplicitDefaultConstructor - Checks for feasibility of
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001774 /// defining this constructor as the default constructor.
1775 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1776 CXXConstructorDecl *Constructor);
Mike Stump1eb44332009-09-09 15:08:12 +00001777
1778 /// DefineImplicitDestructor - Checks for feasibility of
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00001779 /// defining this destructor as the default destructor.
1780 void DefineImplicitDestructor(SourceLocation CurrentLocation,
1781 CXXDestructorDecl *Destructor);
Mike Stump1eb44332009-09-09 15:08:12 +00001782
1783 /// DefineImplicitCopyConstructor - Checks for feasibility of
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001784 /// defining this constructor as the copy constructor.
1785 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
1786 CXXConstructorDecl *Constructor,
1787 unsigned TypeQuals);
Mike Stump1eb44332009-09-09 15:08:12 +00001788
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001789 /// DefineImplicitOverloadedAssign - Checks for feasibility of
1790 /// defining implicit this overloaded assignment operator.
Mike Stump1eb44332009-09-09 15:08:12 +00001791 void DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001792 CXXMethodDecl *MethodDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00001793
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001794 /// getAssignOperatorMethod - Returns the default copy assignmment operator
1795 /// for the class.
1796 CXXMethodDecl *getAssignOperatorMethod(ParmVarDecl *Decl,
Mike Stump1eb44332009-09-09 15:08:12 +00001797 CXXRecordDecl *ClassDecl);
Anders Carlssondef11992009-05-30 20:36:53 +00001798
1799 /// MaybeBindToTemporary - If the passed in expression has a record type with
1800 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
1801 /// it simply returns the passed in expression.
1802 OwningExprResult MaybeBindToTemporary(Expr *E);
Mike Stump1eb44332009-09-09 15:08:12 +00001803
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001804 /// InitializationKind - Represents which kind of C++ initialization
1805 /// [dcl.init] a routine is to perform.
1806 enum InitializationKind {
1807 IK_Direct, ///< Direct initialization
1808 IK_Copy, ///< Copy initialization
1809 IK_Default ///< Default initialization
1810 };
1811
Douglas Gregor18fe5682008-11-03 20:45:27 +00001812 CXXConstructorDecl *
Douglas Gregor19aeac62009-11-14 03:27:21 +00001813 TryInitializationByConstructor(QualType ClassType,
1814 Expr **Args, unsigned NumArgs,
1815 SourceLocation Loc,
1816 InitializationKind Kind);
1817
1818 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001819 PerformInitializationByConstructor(QualType ClassType,
Douglas Gregor39da0b82009-09-09 23:08:42 +00001820 MultiExprArg ArgsPtr,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001821 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001822 DeclarationName InitEntity,
Douglas Gregor39da0b82009-09-09 23:08:42 +00001823 InitializationKind Kind,
1824 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001825
Douglas Gregor39da0b82009-09-09 23:08:42 +00001826 bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
1827 MultiExprArg ArgsPtr,
1828 SourceLocation Loc,
1829 ASTOwningVector<&ActionBase::DeleteExpr> &ConvertedArgs);
1830
Douglas Gregor49badde2008-10-27 19:41:14 +00001831 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001832 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1833 tok::TokenKind Kind,
1834 SourceLocation LAngleBracketLoc,
1835 TypeTy *Ty,
1836 SourceLocation RAngleBracketLoc,
1837 SourceLocation LParenLoc,
1838 ExprArg E,
1839 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001840
Sebastian Redlf53597f2009-03-15 17:47:39 +00001841 /// ActOnCXXTypeid - Parse typeid( something ).
1842 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1843 SourceLocation LParenLoc, bool isType,
1844 void *TyOrExpr,
1845 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001846
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001847 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001848 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001849
Steve Naroff1b273c42007-09-16 14:56:35 +00001850 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001851 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1852 tok::TokenKind Kind);
1853
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001854 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1855 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1856
Chris Lattner50dd2892008-02-26 00:51:44 +00001857 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001858 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1859 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001860 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001861
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001862 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1863 /// Can be interpreted either as function-style casting ("int(x)")
1864 /// or class type construction ("ClassType(x,y,z)")
1865 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001866 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1867 TypeTy *TypeRep,
1868 SourceLocation LParenLoc,
1869 MultiExprArg Exprs,
1870 SourceLocation *CommaLocs,
1871 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001872
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001873 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001874 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1875 SourceLocation PlacementLParen,
1876 MultiExprArg PlacementArgs,
1877 SourceLocation PlacementRParen,
1878 bool ParenTypeId, Declarator &D,
1879 SourceLocation ConstructorLParen,
1880 MultiExprArg ConstructorArgs,
1881 SourceLocation ConstructorRParen);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001882 OwningExprResult BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
1883 SourceLocation PlacementLParen,
1884 MultiExprArg PlacementArgs,
1885 SourceLocation PlacementRParen,
Mike Stump1eb44332009-09-09 15:08:12 +00001886 bool ParenTypeId,
Douglas Gregor3433cf72009-05-21 00:00:09 +00001887 QualType AllocType,
1888 SourceLocation TypeLoc,
1889 SourceRange TypeRange,
1890 ExprArg ArraySize,
1891 SourceLocation ConstructorLParen,
1892 MultiExprArg ConstructorArgs,
1893 SourceLocation ConstructorRParen);
Mike Stump1eb44332009-09-09 15:08:12 +00001894
Douglas Gregor3433cf72009-05-21 00:00:09 +00001895 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1896 SourceRange R);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001897 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1898 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001899 Expr **PlaceArgs, unsigned NumPlaceArgs,
1900 FunctionDecl *&OperatorNew,
1901 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001902 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1903 DeclarationName Name, Expr** Args,
1904 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001905 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001906 void DeclareGlobalNewDelete();
1907 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1908 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001909
Anders Carlsson78f74552009-11-15 18:45:20 +00001910 bool FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD,
1911 DeclarationName Name, FunctionDecl* &Operator);
1912
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001913 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001914 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1915 bool UseGlobal, bool ArrayForm,
1916 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001917
Douglas Gregor99e9b4d2009-11-25 00:27:52 +00001918 virtual DeclResult ActOnCXXConditionDeclaration(Scope *S,
1919 Declarator &D);
Douglas Gregor8cfe5a72009-11-23 23:44:04 +00001920 OwningExprResult CheckConditionVariable(VarDecl *ConditionVar);
1921
Sebastian Redl64b45f72009-01-05 20:52:13 +00001922 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1923 /// pseudo-functions.
1924 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1925 SourceLocation KWLoc,
1926 SourceLocation LParen,
1927 TypeTy *Ty,
1928 SourceLocation RParen);
Mike Stump1eb44332009-09-09 15:08:12 +00001929
Douglas Gregor2dd078a2009-09-02 22:59:36 +00001930 virtual OwningExprResult ActOnStartCXXMemberReference(Scope *S,
1931 ExprArg Base,
1932 SourceLocation OpLoc,
1933 tok::TokenKind OpKind,
1934 TypeTy *&ObjectType);
Mike Stump1eb44332009-09-09 15:08:12 +00001935
Mike Stump1eb44332009-09-09 15:08:12 +00001936 /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001937 /// non-empty, will create a new CXXExprWithTemporaries expression.
1938 /// Otherwise, just returs the passed in expression.
Anders Carlssonf54741e2009-06-16 03:37:31 +00001939 Expr *MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1940 bool ShouldDestroyTemporaries);
Mike Stump1eb44332009-09-09 15:08:12 +00001941
Anders Carlsson165a0a02009-05-17 18:41:29 +00001942 virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr);
1943
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001944 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Mike Stump1eb44332009-09-09 15:08:12 +00001945
Douglas Gregor2dd078a2009-09-02 22:59:36 +00001946 DeclContext *computeDeclContext(QualType T);
Mike Stump1eb44332009-09-09 15:08:12 +00001947 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
Douglas Gregorf59a56e2009-07-21 23:53:31 +00001948 bool EnteringContext = false);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001949 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001950 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1951 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001952
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001953 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1954 /// global scope ('::').
1955 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1956 SourceLocation CCLoc);
1957
Douglas Gregor374929f2009-09-18 15:37:17 +00001958 bool isAcceptableNestedNameSpecifier(NamedDecl *SD);
Douglas Gregorc68afe22009-09-03 21:38:09 +00001959 NamedDecl *FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS);
Mike Stump1eb44332009-09-09 15:08:12 +00001960
Douglas Gregorc68afe22009-09-03 21:38:09 +00001961
1962 CXXScopeTy *BuildCXXNestedNameSpecifier(Scope *S,
1963 const CXXScopeSpec &SS,
1964 SourceLocation IdLoc,
1965 SourceLocation CCLoc,
1966 IdentifierInfo &II,
1967 QualType ObjectType,
1968 NamedDecl *ScopeLookupResult,
1969 bool EnteringContext);
Mike Stump1eb44332009-09-09 15:08:12 +00001970
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001971 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1972 const CXXScopeSpec &SS,
1973 SourceLocation IdLoc,
1974 SourceLocation CCLoc,
Douglas Gregor495c35d2009-08-25 22:51:20 +00001975 IdentifierInfo &II,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00001976 TypeTy *ObjectType,
Douglas Gregor495c35d2009-08-25 22:51:20 +00001977 bool EnteringContext);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001978
Douglas Gregor39a8de12009-02-25 19:37:18 +00001979 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1980 /// nested-name-specifier that involves a template-id, e.g.,
1981 /// "foo::bar<int, float>::", and now we need to build a scope
1982 /// specifier. \p SS is empty or the previously parsed nested-name
1983 /// part ("foo::"), \p Type is the already-parsed class template
1984 /// specialization (or other template-id that names a type), \p
1985 /// TypeRange is the source range where the type is located, and \p
1986 /// CCLoc is the location of the trailing '::'.
1987 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1988 const CXXScopeSpec &SS,
1989 TypeTy *Type,
1990 SourceRange TypeRange,
1991 SourceLocation CCLoc);
1992
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001993 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1994 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1995 /// After this method is called, according to [C++ 3.4.3p3], names should be
1996 /// looked up in the declarator-id's scope, until the declarator is parsed and
1997 /// ActOnCXXExitDeclaratorScope is called.
1998 /// The 'SS' should be a non-empty valid CXXScopeSpec.
Douglas Gregor7dfd0fb2009-09-24 23:39:01 +00001999 virtual bool ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002000
2001 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
2002 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
2003 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
2004 /// Used to indicate that names should revert to being looked up in the
2005 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00002006 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002007
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00002008 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
2009 /// initializer for the declaration 'Dcl'.
2010 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
2011 /// static data member of class X, names should be looked up in the scope of
2012 /// class X.
2013 virtual void ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl);
2014
2015 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
2016 /// initializer for the declaration 'Dcl'.
2017 virtual void ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl);
2018
Anders Carlsson55085182007-08-21 17:43:55 +00002019 // ParseObjCStringLiteral - Parse Objective-C string literals.
Mike Stump1eb44332009-09-09 15:08:12 +00002020 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00002021 ExprTy **Strings,
2022 unsigned NumStrings);
Mike Stump1eb44332009-09-09 15:08:12 +00002023
2024 Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
Anders Carlssonfc0f0212009-06-07 18:45:35 +00002025 QualType EncodedType,
Mike Stump1eb44332009-09-09 15:08:12 +00002026 SourceLocation RParenLoc);
Fariborz Jahanianb7400232009-09-28 23:23:40 +00002027 CXXMemberCallExpr *BuildCXXMemberCallExpr(Expr *Exp, CXXMethodDecl *Method);
2028
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002029 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00002030 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002031 SourceLocation LParenLoc,
2032 TypeTy *Ty,
2033 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002034
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002035 // ParseObjCSelectorExpression - Build selector expression for @selector
2036 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
2037 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00002038 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002039 SourceLocation LParenLoc,
2040 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002041
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00002042 // ParseObjCProtocolExpression - Build protocol expression for @protocol
2043 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
2044 SourceLocation AtLoc,
2045 SourceLocation ProtoLoc,
2046 SourceLocation LParenLoc,
2047 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002048
2049 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00002050 // C++ Declarations
2051 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00002052 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
2053 SourceLocation ExternLoc,
2054 SourceLocation LangLoc,
2055 const char *Lang,
2056 unsigned StrSize,
2057 SourceLocation LBraceLoc);
2058 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
2059 DeclPtrTy LinkageSpec,
2060 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00002061
2062
2063 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002064 // C++ Classes
2065 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002066 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
2067 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00002068
Chris Lattnerb28317a2009-03-28 19:18:32 +00002069 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
2070 Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +00002071 MultiTemplateParamsArg TemplateParameterLists,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002072 ExprTy *BitfieldWidth,
Sebastian Redld1a78462009-11-24 23:38:44 +00002073 ExprTy *Init, bool IsDefinition,
Sebastian Redle2b68332009-04-12 17:16:29 +00002074 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002075
Chris Lattnerb28317a2009-03-28 19:18:32 +00002076 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002077 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002078 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002079 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +00002080 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002081 SourceLocation IdLoc,
2082 SourceLocation LParenLoc,
2083 ExprTy **Args, unsigned NumArgs,
2084 SourceLocation *CommaLocs,
2085 SourceLocation RParenLoc);
2086
Eli Friedman59c04372009-07-29 19:44:27 +00002087 MemInitResult BuildMemberInitializer(FieldDecl *Member, Expr **Args,
2088 unsigned NumArgs, SourceLocation IdLoc,
2089 SourceLocation RParenLoc);
2090
2091 MemInitResult BuildBaseInitializer(QualType BaseType, Expr **Args,
2092 unsigned NumArgs, SourceLocation IdLoc,
2093 SourceLocation RParenLoc,
2094 CXXRecordDecl *ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00002095
Benjamin Kramer3f17a372009-11-09 20:14:44 +00002096 bool SetBaseOrMemberInitializers(CXXConstructorDecl *Constructor,
Fariborz Jahanian80545ad2009-09-03 19:36:46 +00002097 CXXBaseOrMemberInitializer **Initializers,
2098 unsigned NumInitializers,
Eli Friedman49c16da2009-11-09 01:05:47 +00002099 bool IsImplicitConstructor);
Mike Stump1eb44332009-09-09 15:08:12 +00002100
Anders Carlsson9f853df2009-11-17 04:44:12 +00002101 /// MarkBaseAndMemberDestructorsReferenced - Given a destructor decl,
2102 /// mark all its non-trivial member and base destructor declarations
2103 /// as referenced.
2104 void MarkBaseAndMemberDestructorsReferenced(CXXDestructorDecl *Destructor);
Mike Stump1eb44332009-09-09 15:08:12 +00002105
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002106 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
2107
Mike Stump1eb44332009-09-09 15:08:12 +00002108 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00002109 SourceLocation ColonLoc,
2110 MemInitTy **MemInits, unsigned NumMemInits);
Mike Stump1eb44332009-09-09 15:08:12 +00002111
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002112 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002113 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002114 SourceLocation LBrac,
2115 SourceLocation RBrac);
2116
Douglas Gregor6569d682009-05-27 23:11:45 +00002117 virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002118 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
2119 DeclPtrTy Method);
2120 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
2121 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
2122 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002123
Mike Stump1eb44332009-09-09 15:08:12 +00002124 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002125 ExprArg AssertExpr,
2126 ExprArg AssertMessageExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00002127
John McCalldd4a3b02009-09-16 22:47:08 +00002128 DeclPtrTy ActOnFriendTypeDecl(Scope *S, const DeclSpec &DS,
2129 MultiTemplateParamsArg TemplateParams);
John McCallbbbcdd92009-09-11 21:02:39 +00002130 DeclPtrTy ActOnFriendFunctionDecl(Scope *S, Declarator &D, bool IsDefinition,
2131 MultiTemplateParamsArg TemplateParams);
Anders Carlsson00338362009-05-11 22:55:49 +00002132
Chris Lattner65401802009-04-25 08:28:21 +00002133 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
2134 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002135 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00002136 QualType CheckDestructorDeclarator(Declarator &D,
2137 FunctionDecl::StorageClass& SC);
Anders Carlsson6d701392009-11-15 22:49:34 +00002138 void CheckDestructor(CXXDestructorDecl *Destructor);
Chris Lattner6e475012009-04-25 08:35:12 +00002139 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002140 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002141 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002142
John McCallf7a1a742009-11-24 19:00:30 +00002143 bool isImplicitMemberReference(const CXXScopeSpec &SS, NamedDecl *D,
Douglas Gregore961afb2009-10-22 07:08:30 +00002144 SourceLocation NameLoc, QualType &ThisType,
2145 QualType &MemberType);
2146
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002147 //===--------------------------------------------------------------------===//
2148 // C++ Derived Classes
2149 //
2150
2151 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00002152 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
2153 SourceRange SpecifierRange,
2154 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +00002155 QualType BaseType,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002156 SourceLocation BaseLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002157 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002158 SourceRange SpecifierRange,
2159 bool Virtual, AccessSpecifier Access,
Mike Stump1eb44332009-09-09 15:08:12 +00002160 TypeTy *basetype, SourceLocation
Douglas Gregor2943aed2009-03-03 04:44:36 +00002161 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002162
Douglas Gregor2943aed2009-03-03 04:44:36 +00002163 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
2164 unsigned NumBases);
Mike Stump1eb44332009-09-09 15:08:12 +00002165 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002166 unsigned NumBases);
2167
2168 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregora8f32e02009-10-06 17:59:45 +00002169 bool IsDerivedFrom(QualType Derived, QualType Base, CXXBasePaths &Paths);
2170
Douglas Gregor0575d4a2008-10-24 16:17:19 +00002171 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00002172 SourceLocation Loc, SourceRange Range,
2173 bool IgnoreAccess = false);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002174 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2175 unsigned InaccessibleBaseID,
2176 unsigned AmbigiousBaseConvID,
2177 SourceLocation Loc, SourceRange Range,
2178 DeclarationName Name);
Mike Stump1eb44332009-09-09 15:08:12 +00002179
Douglas Gregora8f32e02009-10-06 17:59:45 +00002180 std::string getAmbiguousPathsDisplayString(CXXBasePaths &Paths);
Mike Stump1eb44332009-09-09 15:08:12 +00002181
Sebastian Redl23c7d062009-07-07 20:29:57 +00002182 /// CheckOverridingFunctionReturnType - Checks whether the return types are
2183 /// covariant, according to C++ [class.virtual]p5.
2184 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002185 const CXXMethodDecl *Old);
Sebastian Redl23c7d062009-07-07 20:29:57 +00002186
2187 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
2188 /// spec is a subset of base spec.
2189 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
2190 const CXXMethodDecl *Old);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002191
Sean Huntbbd37c62009-11-21 08:43:09 +00002192 /// CheckOverridingFunctionAttributes - Checks whether attributes are
2193 /// incompatible or prevent overriding.
2194 bool CheckOverridingFunctionAttributes(const CXXMethodDecl *New,
2195 const CXXMethodDecl *Old);
2196
Anders Carlsson29f006b2009-03-27 05:05:05 +00002197 //===--------------------------------------------------------------------===//
2198 // C++ Access Control
2199 //
Sebastian Redl726212f2009-07-18 14:32:15 +00002200
Mike Stump1eb44332009-09-09 15:08:12 +00002201 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
Anders Carlsson29f006b2009-03-27 05:05:05 +00002202 NamedDecl *PrevMemberDecl,
2203 AccessSpecifier LexicalAS);
Sebastian Redl726212f2009-07-18 14:32:15 +00002204
2205 const CXXBaseSpecifier *FindInaccessibleBase(QualType Derived, QualType Base,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002206 CXXBasePaths &Paths,
Sebastian Redl726212f2009-07-18 14:32:15 +00002207 bool NoPrivileges = false);
2208
2209 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002210 unsigned InaccessibleBaseID,
Douglas Gregora8f32e02009-10-06 17:59:45 +00002211 CXXBasePaths& Paths, SourceLocation AccessLoc,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002212 DeclarationName Name);
Sebastian Redl726212f2009-07-18 14:32:15 +00002213
2214
Anders Carlsson8211eff2009-03-24 01:19:16 +00002215 enum AbstractDiagSelID {
2216 AbstractNone = -1,
2217 AbstractReturnType,
2218 AbstractParamType,
2219 AbstractVariableType,
2220 AbstractFieldType
2221 };
Mike Stump1eb44332009-09-09 15:08:12 +00002222
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00002223 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
2224 const PartialDiagnostic &PD,
2225 const CXXRecordDecl *CurrentRD = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00002226
2227 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00002228 AbstractDiagSelID SelID = AbstractNone,
2229 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002230
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002231 //===--------------------------------------------------------------------===//
2232 // C++ Overloaded Operators [C++ 13.5]
2233 //
2234
2235 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
2236
Douglas Gregor72c3f312008-12-05 18:15:24 +00002237 //===--------------------------------------------------------------------===//
2238 // C++ Templates [C++ 14]
2239 //
John McCallf7a1a742009-11-24 19:00:30 +00002240 void LookupTemplateName(LookupResult &R, Scope *S, const CXXScopeSpec &SS,
2241 QualType ObjectType, bool EnteringContext);
2242
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002243 virtual TemplateNameKind isTemplateName(Scope *S,
Douglas Gregor014e88d2009-11-03 23:16:33 +00002244 const CXXScopeSpec &SS,
2245 UnqualifiedId &Name,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002246 TypeTy *ObjectType,
Douglas Gregor495c35d2009-08-25 22:51:20 +00002247 bool EnteringContext,
2248 TemplateTy &Template);
Douglas Gregor72c3f312008-12-05 18:15:24 +00002249 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002250 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002251
Mike Stump1eb44332009-09-09 15:08:12 +00002252 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
Anders Carlsson941df7d2009-06-12 19:58:00 +00002253 SourceLocation EllipsisLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002254 SourceLocation KeyLoc,
2255 IdentifierInfo *ParamName,
2256 SourceLocation ParamNameLoc,
2257 unsigned Depth, unsigned Position);
Mike Stump1eb44332009-09-09 15:08:12 +00002258 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002259 SourceLocation EqualLoc,
2260 SourceLocation DefaultLoc,
2261 TypeTy *Default);
2262
Douglas Gregor2943aed2009-03-03 04:44:36 +00002263 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002264 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
2265 unsigned Depth,
2266 unsigned Position);
2267 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002268 SourceLocation EqualLoc,
2269 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002270 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
2271 SourceLocation TmpLoc,
2272 TemplateParamsTy *Params,
2273 IdentifierInfo *ParamName,
2274 SourceLocation ParamNameLoc,
2275 unsigned Depth,
2276 unsigned Position);
2277 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002278 SourceLocation EqualLoc,
Douglas Gregor788cd062009-11-11 01:00:40 +00002279 const ParsedTemplateArgument &Default);
Douglas Gregord684b002009-02-10 19:49:53 +00002280
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002281 virtual TemplateParamsTy *
2282 ActOnTemplateParameterList(unsigned Depth,
2283 SourceLocation ExportLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002284 SourceLocation TemplateLoc,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002285 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002286 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002287 SourceLocation RAngleLoc);
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00002288
2289 /// \brief The context in which we are checking a template parameter
2290 /// list.
2291 enum TemplateParamListContext {
2292 TPC_ClassTemplate,
2293 TPC_FunctionTemplate,
2294 TPC_ClassTemplateMember,
2295 TPC_FriendFunctionTemplate
2296 };
2297
Douglas Gregord684b002009-02-10 19:49:53 +00002298 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
Douglas Gregor5b6d70e2009-11-25 17:50:39 +00002299 TemplateParameterList *OldParams,
2300 TemplateParamListContext TPC);
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002301 TemplateParameterList *
2302 MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
2303 const CXXScopeSpec &SS,
2304 TemplateParameterList **ParamLists,
Douglas Gregor1fef4e62009-10-07 22:35:40 +00002305 unsigned NumParamLists,
2306 bool &IsExplicitSpecialization);
Mike Stump1eb44332009-09-09 15:08:12 +00002307
John McCall0f434ec2009-07-31 02:45:11 +00002308 DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002309 SourceLocation KWLoc, const CXXScopeSpec &SS,
2310 IdentifierInfo *Name, SourceLocation NameLoc,
2311 AttributeList *Attr,
Douglas Gregor05396e22009-08-25 17:23:04 +00002312 TemplateParameterList *TemplateParams,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002313 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002314
John McCalld5532b62009-11-23 01:53:49 +00002315 void translateTemplateArguments(const ASTTemplateArgsPtr &In,
2316 TemplateArgumentListInfo &Out);
Douglas Gregor0b60d9e2009-09-25 23:53:26 +00002317
Douglas Gregor7532dc62009-03-30 22:58:21 +00002318 QualType CheckTemplateIdType(TemplateName Template,
2319 SourceLocation TemplateLoc,
John McCalld5532b62009-11-23 01:53:49 +00002320 const TemplateArgumentListInfo &TemplateArgs);
Douglas Gregor40808ce2009-03-09 23:48:35 +00002321
Douglas Gregorcc636682009-02-17 23:15:12 +00002322 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00002323 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
2324 SourceLocation LAngleLoc,
2325 ASTTemplateArgsPtr TemplateArgs,
John McCall6b2becf2009-09-08 17:47:29 +00002326 SourceLocation RAngleLoc);
2327
2328 virtual TypeResult ActOnTagTemplateIdType(TypeResult Type,
2329 TagUseKind TUK,
2330 DeclSpec::TST TagSpec,
2331 SourceLocation TagLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00002332
John McCallf7a1a742009-11-24 19:00:30 +00002333 OwningExprResult BuildTemplateIdExpr(const CXXScopeSpec &SS,
2334 LookupResult &R,
2335 bool RequiresADL,
John McCalld5532b62009-11-23 01:53:49 +00002336 const TemplateArgumentListInfo &TemplateArgs);
John McCallf7a1a742009-11-24 19:00:30 +00002337 OwningExprResult BuildQualifiedTemplateIdExpr(const CXXScopeSpec &SS,
2338 DeclarationName Name,
2339 SourceLocation NameLoc,
2340 const TemplateArgumentListInfo &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00002341
Douglas Gregorc45c2322009-03-31 00:43:58 +00002342 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
Douglas Gregor2dd078a2009-09-02 22:59:36 +00002343 const CXXScopeSpec &SS,
Douglas Gregor014e88d2009-11-03 23:16:33 +00002344 UnqualifiedId &Name,
Douglas Gregora481edb2009-11-20 23:39:24 +00002345 TypeTy *ObjectType,
2346 bool EnteringContext);
Douglas Gregorc45c2322009-03-31 00:43:58 +00002347
Douglas Gregore94866f2009-06-12 21:21:02 +00002348 bool CheckClassTemplatePartialSpecializationArgs(
2349 TemplateParameterList *TemplateParams,
Anders Carlsson6360be72009-06-13 18:20:51 +00002350 const TemplateArgumentListBuilder &TemplateArgs,
Douglas Gregor6aa75cf2009-06-12 22:08:06 +00002351 bool &MirrorsPrimaryTemplate);
Douglas Gregore94866f2009-06-12 21:21:02 +00002352
Douglas Gregor212e81c2009-03-25 00:13:59 +00002353 virtual DeclResult
John McCall0f434ec2009-07-31 02:45:11 +00002354 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
Mike Stump1eb44332009-09-09 15:08:12 +00002355 SourceLocation KWLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002356 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00002357 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00002358 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002359 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00002360 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002361 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002362 AttributeList *Attr,
2363 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002364
Mike Stump1eb44332009-09-09 15:08:12 +00002365 virtual DeclPtrTy ActOnTemplateDeclarator(Scope *S,
Douglas Gregore542c862009-06-23 23:11:28 +00002366 MultiTemplateParamsArg TemplateParameterLists,
2367 Declarator &D);
Mike Stump1eb44332009-09-09 15:08:12 +00002368
2369 virtual DeclPtrTy ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
Douglas Gregor52591bf2009-06-24 00:54:41 +00002370 MultiTemplateParamsArg TemplateParameterLists,
2371 Declarator &D);
Mike Stump1eb44332009-09-09 15:08:12 +00002372
Douglas Gregor0d035142009-10-27 18:42:08 +00002373 bool
2374 CheckSpecializationInstantiationRedecl(SourceLocation NewLoc,
2375 TemplateSpecializationKind NewTSK,
2376 NamedDecl *PrevDecl,
2377 TemplateSpecializationKind PrevTSK,
2378 SourceLocation PrevPointOfInstantiation,
2379 bool &SuppressNew);
2380
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002381 bool CheckFunctionTemplateSpecialization(FunctionDecl *FD,
John McCalld5532b62009-11-23 01:53:49 +00002382 const TemplateArgumentListInfo *ExplicitTemplateArgs,
John McCall68263142009-11-18 22:49:29 +00002383 LookupResult &Previous);
2384 bool CheckMemberSpecialization(NamedDecl *Member, LookupResult &Previous);
Douglas Gregorb9aa6b22009-09-24 23:14:47 +00002385
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002386 virtual DeclResult
Mike Stump1eb44332009-09-09 15:08:12 +00002387 ActOnExplicitInstantiation(Scope *S,
Douglas Gregor45f96552009-09-04 06:33:52 +00002388 SourceLocation ExternLoc,
2389 SourceLocation TemplateLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002390 unsigned TagSpec,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002391 SourceLocation KWLoc,
2392 const CXXScopeSpec &SS,
2393 TemplateTy Template,
2394 SourceLocation TemplateNameLoc,
2395 SourceLocation LAngleLoc,
2396 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002397 SourceLocation RAngleLoc,
2398 AttributeList *Attr);
2399
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002400 virtual DeclResult
Mike Stump1eb44332009-09-09 15:08:12 +00002401 ActOnExplicitInstantiation(Scope *S,
Douglas Gregor45f96552009-09-04 06:33:52 +00002402 SourceLocation ExternLoc,
2403 SourceLocation TemplateLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00002404 unsigned TagSpec,
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002405 SourceLocation KWLoc,
2406 const CXXScopeSpec &SS,
2407 IdentifierInfo *Name,
2408 SourceLocation NameLoc,
2409 AttributeList *Attr);
2410
Douglas Gregord5a423b2009-09-25 18:43:00 +00002411 virtual DeclResult ActOnExplicitInstantiation(Scope *S,
2412 SourceLocation ExternLoc,
2413 SourceLocation TemplateLoc,
2414 Declarator &D);
2415
Douglas Gregor51ffb0c2009-11-25 18:55:14 +00002416 TemplateArgumentLoc
2417 SubstDefaultTemplateArgumentIfAvailable(TemplateDecl *Template,
2418 SourceLocation TemplateLoc,
2419 SourceLocation RAngleLoc,
2420 Decl *Param,
2421 TemplateArgumentListBuilder &Converted);
2422
Douglas Gregore7526412009-11-11 19:31:23 +00002423 bool CheckTemplateArgument(NamedDecl *Param,
2424 const TemplateArgumentLoc &Arg,
Douglas Gregore7526412009-11-11 19:31:23 +00002425 TemplateDecl *Template,
2426 SourceLocation TemplateLoc,
Douglas Gregore7526412009-11-11 19:31:23 +00002427 SourceLocation RAngleLoc,
2428 TemplateArgumentListBuilder &Converted);
2429
Douglas Gregorc15cb382009-02-09 23:23:08 +00002430 bool CheckTemplateArgumentList(TemplateDecl *Template,
2431 SourceLocation TemplateLoc,
John McCalld5532b62009-11-23 01:53:49 +00002432 const TemplateArgumentListInfo &TemplateArgs,
Douglas Gregor16134c62009-07-01 00:28:38 +00002433 bool PartialTemplateArgs,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00002434 TemplateArgumentListBuilder &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002435
Mike Stump1eb44332009-09-09 15:08:12 +00002436 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
John McCall833ca992009-10-29 08:12:44 +00002437 const TemplateArgumentLoc &Arg,
Anders Carlsson436b1562009-06-13 00:33:33 +00002438 TemplateArgumentListBuilder &Converted);
2439
John McCall833ca992009-10-29 08:12:44 +00002440 bool CheckTemplateArgument(TemplateTypeParmDecl *Param,
2441 DeclaratorInfo *Arg);
Mike Stump1eb44332009-09-09 15:08:12 +00002442 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002443 NamedDecl *&Entity);
Douglas Gregorcaddba02009-11-12 18:38:13 +00002444 bool CheckTemplateArgumentPointerToMember(Expr *Arg,
2445 TemplateArgument &Converted);
Mike Stump1eb44332009-09-09 15:08:12 +00002446 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002447 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor02cbbd22009-06-11 18:10:32 +00002448 TemplateArgument &Converted);
Douglas Gregor788cd062009-11-11 01:00:40 +00002449 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param,
2450 const TemplateArgumentLoc &Arg);
Douglas Gregorfb898e12009-11-12 16:20:59 +00002451
2452 /// \brief Enumeration describing how template parameter lists are compared
2453 /// for equality.
2454 enum TemplateParameterListEqualKind {
2455 /// \brief We are matching the template parameter lists of two templates
2456 /// that might be redeclarations.
2457 ///
2458 /// \code
2459 /// template<typename T> struct X;
2460 /// template<typename T> struct X;
2461 /// \endcode
2462 TPL_TemplateMatch,
2463
2464 /// \brief We are matching the template parameter lists of two template
2465 /// template parameters as part of matching the template parameter lists
2466 /// of two templates that might be redeclarations.
2467 ///
2468 /// \code
2469 /// template<template<int I> class TT> struct X;
2470 /// template<template<int Value> class Other> struct X;
2471 /// \endcode
2472 TPL_TemplateTemplateParmMatch,
2473
2474 /// \brief We are matching the template parameter lists of a template
2475 /// template argument against the template parameter lists of a template
2476 /// template parameter.
2477 ///
2478 /// \code
2479 /// template<template<int Value> class Metafun> struct X;
2480 /// template<int Value> struct integer_c;
2481 /// X<integer_c> xic;
2482 /// \endcode
2483 TPL_TemplateTemplateArgumentMatch
2484 };
2485
Douglas Gregorddc29e12009-02-06 22:42:48 +00002486 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
2487 TemplateParameterList *Old,
2488 bool Complain,
Douglas Gregorfb898e12009-11-12 16:20:59 +00002489 TemplateParameterListEqualKind Kind,
Douglas Gregordd0574e2009-02-10 00:24:35 +00002490 SourceLocation TemplateArgLoc
Douglas Gregor788cd062009-11-11 01:00:40 +00002491 = SourceLocation());
Mike Stump1eb44332009-09-09 15:08:12 +00002492
Douglas Gregor05396e22009-08-25 17:23:04 +00002493 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002494
Douglas Gregord57959a2009-03-27 23:10:48 +00002495 /// \brief Called when the parser has parsed a C++ typename
2496 /// specifier, e.g., "typename T::type".
2497 ///
2498 /// \param TypenameLoc the location of the 'typename' keyword
2499 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2500 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
2501 /// \param IdLoc the location of the identifier.
2502 virtual TypeResult
2503 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2504 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00002505
2506 /// \brief Called when the parser has parsed a C++ typename
Mike Stump1eb44332009-09-09 15:08:12 +00002507 /// specifier that ends in a template-id, e.g.,
Douglas Gregor17343172009-04-01 00:28:59 +00002508 /// "typename MetaFun::template apply<T1, T2>".
2509 ///
2510 /// \param TypenameLoc the location of the 'typename' keyword
2511 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2512 /// \param TemplateLoc the location of the 'template' keyword, if any.
2513 /// \param Ty the type that the typename specifier refers to.
2514 virtual TypeResult
2515 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2516 SourceLocation TemplateLoc, TypeTy *Ty);
2517
Douglas Gregord57959a2009-03-27 23:10:48 +00002518 QualType CheckTypenameType(NestedNameSpecifier *NNS,
2519 const IdentifierInfo &II,
2520 SourceRange Range);
Douglas Gregorc8ab2562009-05-31 09:31:02 +00002521
Douglas Gregor4a959d82009-08-06 16:20:37 +00002522 QualType RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc,
2523 DeclarationName Name);
2524
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002525 std::string
2526 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
2527 const TemplateArgumentList &Args);
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002528
2529 std::string
2530 getTemplateArgumentBindingsText(const TemplateParameterList *Params,
2531 const TemplateArgument *Args,
2532 unsigned NumArgs);
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002533
Douglas Gregorf67875d2009-06-12 18:26:56 +00002534 /// \brief Describes the result of template argument deduction.
2535 ///
2536 /// The TemplateDeductionResult enumeration describes the result of
2537 /// template argument deduction, as returned from
2538 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
2539 /// structure provides additional information about the results of
2540 /// template argument deduction, e.g., the deduced template argument
2541 /// list (if successful) or the specific template parameters or
2542 /// deduced arguments that were involved in the failure.
2543 enum TemplateDeductionResult {
2544 /// \brief Template argument deduction was successful.
2545 TDK_Success = 0,
2546 /// \brief Template argument deduction exceeded the maximum template
2547 /// instantiation depth (which has already been diagnosed).
2548 TDK_InstantiationDepth,
2549 /// \brief Template argument deduction did not deduce a value
2550 /// for every template parameter.
2551 TDK_Incomplete,
2552 /// \brief Template argument deduction produced inconsistent
2553 /// deduced values for the given template parameter.
2554 TDK_Inconsistent,
2555 /// \brief Template argument deduction failed due to inconsistent
2556 /// cv-qualifiers on a template parameter type that would
2557 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
2558 /// but were given a non-const "X".
2559 TDK_InconsistentQuals,
2560 /// \brief Substitution of the deduced template argument values
2561 /// resulted in an error.
2562 TDK_SubstitutionFailure,
2563 /// \brief Substitution of the deduced template argument values
2564 /// into a non-deduced context produced a type or value that
2565 /// produces a type that does not match the original template
2566 /// arguments provided.
Douglas Gregore53060f2009-06-25 22:08:12 +00002567 TDK_NonDeducedMismatch,
Mike Stump1eb44332009-09-09 15:08:12 +00002568 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002569 /// template, there were too many call arguments.
2570 TDK_TooManyArguments,
Mike Stump1eb44332009-09-09 15:08:12 +00002571 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002572 /// template, there were too few call arguments.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002573 TDK_TooFewArguments,
2574 /// \brief The explicitly-specified template arguments were not valid
2575 /// template arguments for the given template.
2576 TDK_InvalidExplicitArguments
Douglas Gregorf67875d2009-06-12 18:26:56 +00002577 };
2578
2579 /// \brief Provides information about an attempted template argument
2580 /// deduction, whose success or failure was described by a
2581 /// TemplateDeductionResult value.
2582 class TemplateDeductionInfo {
2583 /// \brief The context in which the template arguments are stored.
2584 ASTContext &Context;
2585
2586 /// \brief The deduced template argument list.
2587 ///
2588 TemplateArgumentList *Deduced;
2589
2590 // do not implement these
2591 TemplateDeductionInfo(const TemplateDeductionInfo&);
2592 TemplateDeductionInfo &operator=(const TemplateDeductionInfo&);
2593
2594 public:
2595 TemplateDeductionInfo(ASTContext &Context) : Context(Context), Deduced(0) { }
2596
2597 ~TemplateDeductionInfo() {
2598 // FIXME: if (Deduced) Deduced->Destroy(Context);
2599 }
2600
2601 /// \brief Take ownership of the deduced template argument list.
Mike Stump1eb44332009-09-09 15:08:12 +00002602 TemplateArgumentList *take() {
Douglas Gregorf67875d2009-06-12 18:26:56 +00002603 TemplateArgumentList *Result = Deduced;
2604 Deduced = 0;
2605 return Result;
2606 }
2607
2608 /// \brief Provide a new template argument list that contains the
2609 /// results of template argument deduction.
2610 void reset(TemplateArgumentList *NewDeduced) {
2611 // FIXME: if (Deduced) Deduced->Destroy(Context);
2612 Deduced = NewDeduced;
2613 }
2614
2615 /// \brief The template parameter to which a template argument
2616 /// deduction failure refers.
2617 ///
2618 /// Depending on the result of template argument deduction, this
2619 /// template parameter may have different meanings:
2620 ///
2621 /// TDK_Incomplete: this is the first template parameter whose
2622 /// corresponding template argument was not deduced.
2623 ///
2624 /// TDK_Inconsistent: this is the template parameter for which
2625 /// two different template argument values were deduced.
2626 TemplateParameter Param;
2627
2628 /// \brief The first template argument to which the template
2629 /// argument deduction failure refers.
2630 ///
2631 /// Depending on the result of the template argument deduction,
2632 /// this template argument may have different meanings:
2633 ///
2634 /// TDK_Inconsistent: this argument is the first value deduced
2635 /// for the corresponding template parameter.
2636 ///
2637 /// TDK_SubstitutionFailure: this argument is the template
2638 /// argument we were instantiating when we encountered an error.
2639 ///
2640 /// TDK_NonDeducedMismatch: this is the template argument
2641 /// provided in the source code.
2642 TemplateArgument FirstArg;
2643
2644 /// \brief The second template argument to which the template
2645 /// argument deduction failure refers.
2646 ///
2647 /// FIXME: Finish documenting this.
2648 TemplateArgument SecondArg;
2649 };
2650
2651 TemplateDeductionResult
Douglas Gregor199d9912009-06-05 00:53:49 +00002652 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002653 const TemplateArgumentList &TemplateArgs,
2654 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002655
Douglas Gregor83314aa2009-07-08 20:55:45 +00002656 TemplateDeductionResult
2657 SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002658 const TemplateArgumentListInfo &ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002659 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2660 llvm::SmallVectorImpl<QualType> &ParamTypes,
2661 QualType *FunctionType,
2662 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002663
2664 TemplateDeductionResult
Douglas Gregor83314aa2009-07-08 20:55:45 +00002665 FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
2666 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2667 FunctionDecl *&Specialization,
2668 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002669
Douglas Gregore53060f2009-06-25 22:08:12 +00002670 TemplateDeductionResult
2671 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002672 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +00002673 Expr **Args, unsigned NumArgs,
2674 FunctionDecl *&Specialization,
2675 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002676
2677 TemplateDeductionResult
2678 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
John McCalld5532b62009-11-23 01:53:49 +00002679 const TemplateArgumentListInfo *ExplicitTemplateArgs,
Douglas Gregor83314aa2009-07-08 20:55:45 +00002680 QualType ArgFunctionType,
2681 FunctionDecl *&Specialization,
2682 TemplateDeductionInfo &Info);
Mike Stump1eb44332009-09-09 15:08:12 +00002683
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002684 TemplateDeductionResult
2685 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2686 QualType ToType,
2687 CXXConversionDecl *&Specialization,
2688 TemplateDeductionInfo &Info);
2689
2690 FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
2691 FunctionTemplateDecl *FT2,
Douglas Gregor8a514912009-09-14 18:39:43 +00002692 TemplatePartialOrderingContext TPOC);
Douglas Gregord5a423b2009-09-25 18:43:00 +00002693 FunctionDecl *getMostSpecialized(FunctionDecl **Specializations,
2694 unsigned NumSpecializations,
2695 TemplatePartialOrderingContext TPOC,
2696 SourceLocation Loc,
2697 const PartialDiagnostic &NoneDiag,
2698 const PartialDiagnostic &AmbigDiag,
2699 const PartialDiagnostic &CandidateDiag,
2700 unsigned *Index = 0);
2701
Douglas Gregorbf4ea562009-09-15 16:23:51 +00002702 ClassTemplatePartialSpecializationDecl *
2703 getMoreSpecializedPartialSpecialization(
2704 ClassTemplatePartialSpecializationDecl *PS1,
2705 ClassTemplatePartialSpecializationDecl *PS2);
2706
Douglas Gregore73bb602009-09-14 21:25:05 +00002707 void MarkUsedTemplateParameters(const TemplateArgumentList &TemplateArgs,
2708 bool OnlyDeduced,
Douglas Gregored9c0f92009-10-29 00:04:11 +00002709 unsigned Depth,
Douglas Gregor63f07c52009-09-18 23:21:38 +00002710 llvm::SmallVectorImpl<bool> &Used);
2711 void MarkDeducedTemplateParameters(FunctionTemplateDecl *FunctionTemplate,
2712 llvm::SmallVectorImpl<bool> &Deduced);
2713
Douglas Gregor99ebf652009-02-27 19:31:52 +00002714 //===--------------------------------------------------------------------===//
2715 // C++ Template Instantiation
2716 //
Douglas Gregor26dce442009-03-10 00:06:19 +00002717
Douglas Gregor0f8716b2009-11-09 19:17:50 +00002718 MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D,
2719 const TemplateArgumentList *Innermost = 0);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002720
Douglas Gregor26dce442009-03-10 00:06:19 +00002721 /// \brief A template instantiation that is currently in progress.
2722 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00002723 /// \brief The kind of template instantiation we are performing
Douglas Gregorcca9e962009-07-01 22:01:06 +00002724 enum InstantiationKind {
Douglas Gregordf667e72009-03-10 20:44:00 +00002725 /// We are instantiating a template declaration. The entity is
Douglas Gregorb9f1b8d2009-05-15 00:01:03 +00002726 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00002727 TemplateInstantiation,
2728
2729 /// We are instantiating a default argument for a template
2730 /// parameter. The Entity is the template, and
2731 /// TemplateArgs/NumTemplateArguments provides the template
2732 /// arguments as specified.
Douglas Gregor637a4092009-06-10 23:47:09 +00002733 /// FIXME: Use a TemplateArgumentList
2734 DefaultTemplateArgumentInstantiation,
2735
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002736 /// We are instantiating a default argument for a function.
2737 /// The Entity is the ParmVarDecl, and TemplateArgs/NumTemplateArgs
2738 /// provides the template arguments as specified.
2739 DefaultFunctionArgumentInstantiation,
2740
Mike Stump1eb44332009-09-09 15:08:12 +00002741 /// We are substituting explicit template arguments provided for
Douglas Gregorcca9e962009-07-01 22:01:06 +00002742 /// a function template. The entity is a FunctionTemplateDecl.
2743 ExplicitTemplateArgumentSubstitution,
Mike Stump1eb44332009-09-09 15:08:12 +00002744
Douglas Gregorcca9e962009-07-01 22:01:06 +00002745 /// We are substituting template argument determined as part of
2746 /// template argument deduction for either a class template
2747 /// partial specialization or a function template. The
2748 /// Entity is either a ClassTemplatePartialSpecializationDecl or
2749 /// a FunctionTemplateDecl.
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002750 DeducedTemplateArgumentSubstitution,
2751
2752 /// We are substituting prior template arguments into a new
2753 /// template parameter. The template parameter itself is either a
2754 /// NonTypeTemplateParmDecl or a TemplateTemplateParmDecl.
Douglas Gregorf35f8282009-11-11 21:54:23 +00002755 PriorTemplateArgumentSubstitution,
2756
2757 /// We are checking the validity of a default template argument that
2758 /// has been used when naming a template-id.
2759 DefaultTemplateArgumentChecking
Douglas Gregordf667e72009-03-10 20:44:00 +00002760 } Kind;
2761
Douglas Gregor26dce442009-03-10 00:06:19 +00002762 /// \brief The point of instantiation within the source code.
2763 SourceLocation PointOfInstantiation;
2764
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002765 /// \brief The template in which we are performing the instantiation,
2766 /// for substitutions of prior template arguments.
2767 TemplateDecl *Template;
2768
Douglas Gregor26dce442009-03-10 00:06:19 +00002769 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00002770 uintptr_t Entity;
2771
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002772 /// \brief The list of template arguments we are substituting, if they
2773 /// are not part of the entity.
Douglas Gregordf667e72009-03-10 20:44:00 +00002774 const TemplateArgument *TemplateArgs;
2775
2776 /// \brief The number of template arguments in TemplateArgs.
2777 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002778
2779 /// \brief The source range that covers the construct that cause
2780 /// the instantiation, e.g., the template-id that causes a class
2781 /// template instantiation.
2782 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002783
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002784 ActiveTemplateInstantiation()
2785 : Kind(TemplateInstantiation), Template(0), Entity(0), TemplateArgs(0),
2786 NumTemplateArgs(0) {}
Eli Friedman2ebcc6b2009-08-15 22:50:33 +00002787
Douglas Gregorf35f8282009-11-11 21:54:23 +00002788 /// \brief Determines whether this template is an actual instantiation
2789 /// that should be counted toward the maximum instantiation depth.
2790 bool isInstantiationRecord() const;
2791
Douglas Gregordf667e72009-03-10 20:44:00 +00002792 friend bool operator==(const ActiveTemplateInstantiation &X,
2793 const ActiveTemplateInstantiation &Y) {
2794 if (X.Kind != Y.Kind)
2795 return false;
2796
2797 if (X.Entity != Y.Entity)
2798 return false;
2799
2800 switch (X.Kind) {
2801 case TemplateInstantiation:
2802 return true;
2803
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002804 case PriorTemplateArgumentSubstitution:
Douglas Gregorf35f8282009-11-11 21:54:23 +00002805 case DefaultTemplateArgumentChecking:
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002806 if (X.Template != Y.Template)
2807 return false;
2808
2809 // Fall through
2810
Douglas Gregordf667e72009-03-10 20:44:00 +00002811 case DefaultTemplateArgumentInstantiation:
Douglas Gregorcca9e962009-07-01 22:01:06 +00002812 case ExplicitTemplateArgumentSubstitution:
2813 case DeducedTemplateArgumentSubstitution:
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002814 case DefaultFunctionArgumentInstantiation:
Douglas Gregordf667e72009-03-10 20:44:00 +00002815 return X.TemplateArgs == Y.TemplateArgs;
Mike Stump1eb44332009-09-09 15:08:12 +00002816
Douglas Gregordf667e72009-03-10 20:44:00 +00002817 }
2818
2819 return true;
2820 }
2821
2822 friend bool operator!=(const ActiveTemplateInstantiation &X,
2823 const ActiveTemplateInstantiation &Y) {
2824 return !(X == Y);
2825 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002826 };
2827
2828 /// \brief List of active template instantiations.
2829 ///
2830 /// This vector is treated as a stack. As one template instantiation
2831 /// requires another template instantiation, additional
2832 /// instantiations are pushed onto the stack up to a
2833 /// user-configurable limit LangOptions::InstantiationDepth.
Mike Stump1eb44332009-09-09 15:08:12 +00002834 llvm::SmallVector<ActiveTemplateInstantiation, 16>
Douglas Gregor26dce442009-03-10 00:06:19 +00002835 ActiveTemplateInstantiations;
2836
Douglas Gregorf35f8282009-11-11 21:54:23 +00002837 /// \brief The number of ActiveTemplateInstantiation entries in
2838 /// \c ActiveTemplateInstantiations that are not actual instantiations and,
2839 /// therefore, should not be counted as part of the instantiation depth.
2840 unsigned NonInstantiationEntries;
2841
Douglas Gregor27b152f2009-03-10 18:52:44 +00002842 /// \brief The last template from which a template instantiation
2843 /// error or warning was produced.
2844 ///
2845 /// This value is used to suppress printing of redundant template
2846 /// instantiation backtraces when there are multiple errors in the
2847 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2848 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002849 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002850
Douglas Gregor26dce442009-03-10 00:06:19 +00002851 /// \brief A stack object to be created when performing template
2852 /// instantiation.
2853 ///
2854 /// Construction of an object of type \c InstantiatingTemplate
2855 /// pushes the current instantiation onto the stack of active
2856 /// instantiations. If the size of this stack exceeds the maximum
2857 /// number of recursive template instantiations, construction
2858 /// produces an error and evaluates true.
2859 ///
2860 /// Destruction of this object will pop the named instantiation off
2861 /// the stack.
2862 struct InstantiatingTemplate {
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002863 /// \brief Note that we are instantiating a class template,
2864 /// function template, or a member thereof.
Douglas Gregor26dce442009-03-10 00:06:19 +00002865 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002866 Decl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002867 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002868
2869 /// \brief Note that we are instantiating a default argument in a
2870 /// template-id.
2871 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2872 TemplateDecl *Template,
2873 const TemplateArgument *TemplateArgs,
2874 unsigned NumTemplateArgs,
2875 SourceRange InstantiationRange = SourceRange());
2876
Douglas Gregorcca9e962009-07-01 22:01:06 +00002877 /// \brief Note that we are instantiating a default argument in a
2878 /// template-id.
2879 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2880 FunctionTemplateDecl *FunctionTemplate,
2881 const TemplateArgument *TemplateArgs,
2882 unsigned NumTemplateArgs,
2883 ActiveTemplateInstantiation::InstantiationKind Kind,
2884 SourceRange InstantiationRange = SourceRange());
Mike Stump1eb44332009-09-09 15:08:12 +00002885
Douglas Gregor637a4092009-06-10 23:47:09 +00002886 /// \brief Note that we are instantiating as part of template
2887 /// argument deduction for a class template partial
2888 /// specialization.
2889 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2890 ClassTemplatePartialSpecializationDecl *PartialSpec,
2891 const TemplateArgument *TemplateArgs,
2892 unsigned NumTemplateArgs,
2893 SourceRange InstantiationRange = SourceRange());
2894
Anders Carlsson25cae7f2009-09-05 05:14:19 +00002895 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2896 ParmVarDecl *Param,
2897 const TemplateArgument *TemplateArgs,
2898 unsigned NumTemplateArgs,
2899 SourceRange InstantiationRange = SourceRange());
2900
Douglas Gregor9148c3f2009-11-11 19:13:48 +00002901 /// \brief Note that we are substituting prior template arguments into a
2902 /// non-type or template template parameter.
2903 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2904 TemplateDecl *Template,
2905 NonTypeTemplateParmDecl *Param,
2906 const TemplateArgument *TemplateArgs,
2907 unsigned NumTemplateArgs,
2908 SourceRange InstantiationRange);
2909
2910 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2911 TemplateDecl *Template,
2912 TemplateTemplateParmDecl *Param,
2913 const TemplateArgument *TemplateArgs,
2914 unsigned NumTemplateArgs,
2915 SourceRange InstantiationRange);
2916
Douglas Gregorf35f8282009-11-11 21:54:23 +00002917 /// \brief Note that we are checking the default template argument
2918 /// against the template parameter for a given template-id.
2919 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2920 TemplateDecl *Template,
2921 NamedDecl *Param,
2922 const TemplateArgument *TemplateArgs,
2923 unsigned NumTemplateArgs,
2924 SourceRange InstantiationRange);
2925
2926
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002927 /// \brief Note that we have finished instantiating this template.
2928 void Clear();
2929
2930 ~InstantiatingTemplate() { Clear(); }
Douglas Gregor26dce442009-03-10 00:06:19 +00002931
2932 /// \brief Determines whether we have exceeded the maximum
2933 /// recursive template instantiations.
2934 operator bool() const { return Invalid; }
2935
2936 private:
2937 Sema &SemaRef;
2938 bool Invalid;
2939
Douglas Gregordf667e72009-03-10 20:44:00 +00002940 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2941 SourceRange InstantiationRange);
2942
Douglas Gregor26dce442009-03-10 00:06:19 +00002943 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2944
Mike Stump1eb44332009-09-09 15:08:12 +00002945 InstantiatingTemplate&
Douglas Gregor26dce442009-03-10 00:06:19 +00002946 operator=(const InstantiatingTemplate&); // not implemented
2947 };
2948
Douglas Gregoree1828a2009-03-10 18:03:33 +00002949 void PrintInstantiationStack();
2950
Douglas Gregor5e9f35c2009-06-14 07:33:30 +00002951 /// \brief Determines whether we are currently in a context where
2952 /// template argument substitution failures are not considered
2953 /// errors.
2954 ///
2955 /// When this routine returns true, the emission of most diagnostics
2956 /// will be suppressed and there will be no local error recovery.
2957 bool isSFINAEContext() const;
2958
Douglas Gregorbb260412009-06-14 08:02:22 +00002959 /// \brief RAII class used to determine whether SFINAE has
2960 /// trapped any errors that occur during template argument
2961 /// deduction.
2962 class SFINAETrap {
2963 Sema &SemaRef;
2964 unsigned PrevSFINAEErrors;
2965 public:
2966 explicit SFINAETrap(Sema &SemaRef)
2967 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors) { }
2968
2969 ~SFINAETrap() { SemaRef.NumSFINAEErrors = PrevSFINAEErrors; }
2970
2971 /// \brief Determine whether any SFINAE errors have been trapped.
Mike Stump1eb44332009-09-09 15:08:12 +00002972 bool hasErrorOccurred() const {
2973 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
Douglas Gregorbb260412009-06-14 08:02:22 +00002974 }
2975 };
2976
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002977 /// \brief A stack-allocated class that identifies which local
2978 /// variable declaration instantiations are present in this scope.
2979 ///
2980 /// A new instance of this class type will be created whenever we
2981 /// instantiate a new function declaration, which will have its own
2982 /// set of parameter declarations.
2983 class LocalInstantiationScope {
2984 /// \brief Reference to the semantic analysis that is performing
2985 /// this template instantiation.
2986 Sema &SemaRef;
2987
Douglas Gregor815215d2009-05-27 05:35:12 +00002988 /// \brief A mapping from local declarations that occur
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002989 /// within a template to their instantiations.
2990 ///
2991 /// This mapping is used during instantiation to keep track of,
2992 /// e.g., function parameter and variable declarations. For example,
2993 /// given:
2994 ///
2995 /// \code
2996 /// template<typename T> T add(T x, T y) { return x + y; }
2997 /// \endcode
2998 ///
2999 /// when we instantiate add<int>, we will introduce a mapping from
3000 /// the ParmVarDecl for 'x' that occurs in the template to the
3001 /// instantiated ParmVarDecl for 'x'.
Douglas Gregor815215d2009-05-27 05:35:12 +00003002 llvm::DenseMap<const Decl *, Decl *> LocalDecls;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003003
3004 /// \brief The outer scope, in which contains local variable
Douglas Gregor550d9b22009-10-31 17:21:17 +00003005 /// definitions from some other instantiation (that may not be
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003006 /// relevant to this particular scope).
3007 LocalInstantiationScope *Outer;
3008
3009 // This class is non-copyable
3010 LocalInstantiationScope(const LocalInstantiationScope &);
3011 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
3012
3013 public:
Douglas Gregor550d9b22009-10-31 17:21:17 +00003014 LocalInstantiationScope(Sema &SemaRef, bool CombineWithOuterScope = false)
Mike Stump1eb44332009-09-09 15:08:12 +00003015 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
Douglas Gregor550d9b22009-10-31 17:21:17 +00003016 if (!CombineWithOuterScope)
3017 SemaRef.CurrentInstantiationScope = this;
3018 else
3019 assert(SemaRef.CurrentInstantiationScope &&
3020 "No outer instantiation scope?");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003021 }
3022
3023 ~LocalInstantiationScope() {
3024 SemaRef.CurrentInstantiationScope = Outer;
3025 }
3026
Douglas Gregor815215d2009-05-27 05:35:12 +00003027 Decl *getInstantiationOf(const Decl *D) {
3028 Decl *Result = LocalDecls[D];
3029 assert(Result && "declaration was not instantiated in this scope!");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003030 return Result;
3031 }
3032
Douglas Gregor815215d2009-05-27 05:35:12 +00003033 VarDecl *getInstantiationOf(const VarDecl *Var) {
3034 return cast<VarDecl>(getInstantiationOf(cast<Decl>(Var)));
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003035 }
3036
Douglas Gregor815215d2009-05-27 05:35:12 +00003037 ParmVarDecl *getInstantiationOf(const ParmVarDecl *Var) {
3038 return cast<ParmVarDecl>(getInstantiationOf(cast<Decl>(Var)));
3039 }
3040
Douglas Gregor550d9b22009-10-31 17:21:17 +00003041 NonTypeTemplateParmDecl *getInstantiationOf(
3042 const NonTypeTemplateParmDecl *Var) {
3043 return cast<NonTypeTemplateParmDecl>(getInstantiationOf(cast<Decl>(Var)));
3044 }
3045
Douglas Gregor815215d2009-05-27 05:35:12 +00003046 void InstantiatedLocal(const Decl *D, Decl *Inst) {
3047 Decl *&Stored = LocalDecls[D];
3048 assert(!Stored && "Already instantiated this local");
3049 Stored = Inst;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00003050 }
3051 };
3052
3053 /// \brief The current instantiation scope used to store local
3054 /// variables.
3055 LocalInstantiationScope *CurrentInstantiationScope;
3056
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003057 /// \brief An entity for which implicit template instantiation is required.
3058 ///
Mike Stump1eb44332009-09-09 15:08:12 +00003059 /// The source location associated with the declaration is the first place in
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003060 /// the source code where the declaration was "used". It is not necessarily
Mike Stump1eb44332009-09-09 15:08:12 +00003061 /// the point of instantiation (which will be either before or after the
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003062 /// namespace-scope declaration that triggered this implicit instantiation),
3063 /// However, it is the location that diagnostics should generally refer to,
3064 /// because users will need to know what code triggered the instantiation.
3065 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
Mike Stump1eb44332009-09-09 15:08:12 +00003066
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003067 /// \brief The queue of implicit template instantiations that are required
3068 /// but have not yet been performed.
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00003069 std::deque<PendingImplicitInstantiation> PendingImplicitInstantiations;
Douglas Gregord7f37bf2009-06-22 23:06:13 +00003070
3071 void PerformPendingImplicitInstantiations();
Mike Stump1eb44332009-09-09 15:08:12 +00003072
John McCallcd7ba1c2009-10-21 00:58:09 +00003073 DeclaratorInfo *SubstType(DeclaratorInfo *T,
3074 const MultiLevelTemplateArgumentList &TemplateArgs,
3075 SourceLocation Loc, DeclarationName Entity);
3076
Mike Stump1eb44332009-09-09 15:08:12 +00003077 QualType SubstType(QualType T,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003078 const MultiLevelTemplateArgumentList &TemplateArgs,
John McCallce3ff2b2009-08-25 22:02:44 +00003079 SourceLocation Loc, DeclarationName Entity);
Mike Stump1eb44332009-09-09 15:08:12 +00003080
3081 OwningExprResult SubstExpr(Expr *E,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003082 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00003083
Mike Stump1eb44332009-09-09 15:08:12 +00003084 OwningStmtResult SubstStmt(Stmt *S,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003085 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00003086
John McCallce3ff2b2009-08-25 22:02:44 +00003087 Decl *SubstDecl(Decl *D, DeclContext *Owner,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003088 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00003089
Mike Stump1eb44332009-09-09 15:08:12 +00003090 bool
John McCallce3ff2b2009-08-25 22:02:44 +00003091 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
3092 CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003093 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCalle29ba202009-08-20 01:44:21 +00003094
3095 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00003096 InstantiateClass(SourceLocation PointOfInstantiation,
3097 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003098 const MultiLevelTemplateArgumentList &TemplateArgs,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003099 TemplateSpecializationKind TSK,
Douglas Gregor5842ba92009-08-24 15:23:48 +00003100 bool Complain = true);
Douglas Gregord475b8d2009-03-25 21:17:03 +00003101
Mike Stump1eb44332009-09-09 15:08:12 +00003102 bool
Douglas Gregor972e6ce2009-10-27 06:26:26 +00003103 InstantiateClassTemplateSpecialization(SourceLocation PointOfInstantiation,
Douglas Gregor2943aed2009-03-03 04:44:36 +00003104 ClassTemplateSpecializationDecl *ClassTemplateSpec,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003105 TemplateSpecializationKind TSK,
3106 bool Complain = true);
Douglas Gregor99ebf652009-02-27 19:31:52 +00003107
Douglas Gregora58861f2009-05-13 20:28:22 +00003108 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
3109 CXXRecordDecl *Instantiation,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003110 const MultiLevelTemplateArgumentList &TemplateArgs,
3111 TemplateSpecializationKind TSK);
Douglas Gregora58861f2009-05-13 20:28:22 +00003112
3113 void InstantiateClassTemplateSpecializationMembers(
3114 SourceLocation PointOfInstantiation,
Douglas Gregord0e3daf2009-09-04 22:48:11 +00003115 ClassTemplateSpecializationDecl *ClassTemplateSpec,
3116 TemplateSpecializationKind TSK);
Douglas Gregora58861f2009-05-13 20:28:22 +00003117
Douglas Gregorab452ba2009-03-26 23:50:42 +00003118 NestedNameSpecifier *
John McCallce3ff2b2009-08-25 22:02:44 +00003119 SubstNestedNameSpecifier(NestedNameSpecifier *NNS,
3120 SourceRange Range,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003121 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00003122
Douglas Gregorde650ae2009-03-31 18:38:02 +00003123 TemplateName
John McCallce3ff2b2009-08-25 22:02:44 +00003124 SubstTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregord6350ae2009-08-28 20:31:08 +00003125 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCall833ca992009-10-29 08:12:44 +00003126 bool Subst(const TemplateArgumentLoc &Arg, TemplateArgumentLoc &Result,
3127 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00003128
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00003129 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00003130 FunctionDecl *Function,
Douglas Gregore2d3a3d2009-10-15 14:05:49 +00003131 bool Recursive = false,
3132 bool DefinitionRequired = false);
Douglas Gregor7caa6822009-07-24 20:34:43 +00003133 void InstantiateStaticDataMemberDefinition(
John McCallce3ff2b2009-08-25 22:02:44 +00003134 SourceLocation PointOfInstantiation,
3135 VarDecl *Var,
Douglas Gregore2d3a3d2009-10-15 14:05:49 +00003136 bool Recursive = false,
3137 bool DefinitionRequired = false);
Douglas Gregora58861f2009-05-13 20:28:22 +00003138
Anders Carlsson09025312009-08-29 05:16:22 +00003139 void InstantiateMemInitializers(CXXConstructorDecl *New,
3140 const CXXConstructorDecl *Tmpl,
3141 const MultiLevelTemplateArgumentList &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003142
Douglas Gregore95b4092009-09-16 18:34:49 +00003143 NamedDecl *FindInstantiatedDecl(NamedDecl *D,
3144 const MultiLevelTemplateArgumentList &TemplateArgs);
3145 DeclContext *FindInstantiatedContext(DeclContext *DC,
3146 const MultiLevelTemplateArgumentList &TemplateArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003147
Steve Naroff3536b442007-09-06 21:24:23 +00003148 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00003149 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
3150 IdentifierInfo *ClassName,
3151 SourceLocation ClassLoc,
3152 IdentifierInfo *SuperName,
3153 SourceLocation SuperLoc,
3154 const DeclPtrTy *ProtoRefs,
3155 unsigned NumProtoRefs,
3156 SourceLocation EndProtoLoc,
3157 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003158
Chris Lattnerb28317a2009-03-28 19:18:32 +00003159 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00003160 SourceLocation AtCompatibilityAliasLoc,
3161 IdentifierInfo *AliasName, SourceLocation AliasLocation,
3162 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00003163
3164 void CheckForwardProtocolDeclarationForCircularDependency(
3165 IdentifierInfo *PName,
3166 SourceLocation &PLoc, SourceLocation PrevLoc,
3167 const ObjCList<ObjCProtocolDecl> &PList);
Mike Stump1eb44332009-09-09 15:08:12 +00003168
Chris Lattnerb28317a2009-03-28 19:18:32 +00003169 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00003170 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00003171 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003172 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00003173 SourceLocation EndProtoLoc,
3174 AttributeList *AttrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003175
Chris Lattnerb28317a2009-03-28 19:18:32 +00003176 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
3177 IdentifierInfo *ClassName,
3178 SourceLocation ClassLoc,
3179 IdentifierInfo *CategoryName,
3180 SourceLocation CategoryLoc,
3181 const DeclPtrTy *ProtoRefs,
3182 unsigned NumProtoRefs,
3183 SourceLocation EndProtoLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003184
Chris Lattnerb28317a2009-03-28 19:18:32 +00003185 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00003186 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00003187 IdentifierInfo *ClassName, SourceLocation ClassLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003188 IdentifierInfo *SuperClassname,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00003189 SourceLocation SuperClassLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003190
Chris Lattnerb28317a2009-03-28 19:18:32 +00003191 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00003192 SourceLocation AtCatImplLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003193 IdentifierInfo *ClassName,
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00003194 SourceLocation ClassLoc,
3195 IdentifierInfo *CatName,
3196 SourceLocation CatLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003197
Chris Lattnerb28317a2009-03-28 19:18:32 +00003198 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Ted Kremenekc09cba62009-11-17 23:12:20 +00003199 IdentifierInfo **IdentList,
3200 SourceLocation *IdentLocs,
3201 unsigned NumElts);
Mike Stump1eb44332009-09-09 15:08:12 +00003202
Chris Lattnerb28317a2009-03-28 19:18:32 +00003203 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003204 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00003205 unsigned NumElts,
3206 AttributeList *attrList);
Mike Stump1eb44332009-09-09 15:08:12 +00003207
Chris Lattnere13b9592008-07-26 04:03:38 +00003208 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003209 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00003210 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003211 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Mike Stump1eb44332009-09-09 15:08:12 +00003212
3213 /// Ensure attributes are consistent with type.
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00003214 /// \param [in, out] Attributes The attributes to check; they will
3215 /// be modified to be consistent with \arg PropertyTy.
Mike Stump1eb44332009-09-09 15:08:12 +00003216 void CheckObjCPropertyAttributes(QualType PropertyTy,
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00003217 SourceLocation Loc,
3218 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00003219 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Mike Stump1eb44332009-09-09 15:08:12 +00003220 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003221 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00003222 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003223 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003224
3225 void CompareMethodParamsInBaseAndSuper(Decl *IDecl,
Fariborz Jahaniandbdec8b2009-08-04 01:07:16 +00003226 ObjCMethodDecl *MethodDecl,
3227 bool IsInstance);
Mike Stump1eb44332009-09-09 15:08:12 +00003228
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003229 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003230 DeclPtrTy MergeProtocols);
Mike Stump1eb44332009-09-09 15:08:12 +00003231
3232 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00003233 ObjCInterfaceDecl *ID);
Mike Stump1eb44332009-09-09 15:08:12 +00003234
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003235 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00003236 ObjCProtocolDecl *PDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003237
Chris Lattnerb28317a2009-03-28 19:18:32 +00003238 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
3239 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
3240 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00003241 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Mike Stump1eb44332009-09-09 15:08:12 +00003242
Chris Lattnerb28317a2009-03-28 19:18:32 +00003243 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
3244 FieldDeclarator &FD, ObjCDeclSpec &ODS,
3245 Selector GetterSel, Selector SetterSel,
3246 DeclPtrTy ClassCategory,
3247 bool *OverridingProperty,
3248 tok::ObjCKeywordKind MethodImplKind);
Mike Stump1eb44332009-09-09 15:08:12 +00003249
3250 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003251 SourceLocation PropertyLoc,
3252 bool ImplKind,DeclPtrTy ClassImplDecl,
3253 IdentifierInfo *PropertyId,
3254 IdentifierInfo *PropertyIvar);
Mike Stump1eb44332009-09-09 15:08:12 +00003255
Chris Lattnerb28317a2009-03-28 19:18:32 +00003256 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00003257 SourceLocation BeginLoc, // location of the + or -.
3258 SourceLocation EndLoc, // location of the ; or {.
Mike Stump1eb44332009-09-09 15:08:12 +00003259 tok::TokenKind MethodType,
3260 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00003261 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00003262 // optional arguments. The number of types/arguments is obtained
3263 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00003264 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00003265 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00003266 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
3267 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00003268
Steve Narofff1afaf62009-02-26 15:55:06 +00003269 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
3270 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00003271 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00003272 // Returns 0 if no method is found.
Mike Stump1eb44332009-09-09 15:08:12 +00003273 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
Steve Naroff5609ec02009-03-08 18:56:13 +00003274 ObjCInterfaceDecl *CDecl);
3275 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
3276 ObjCInterfaceDecl *ClassDecl);
Mike Stump1eb44332009-09-09 15:08:12 +00003277
Steve Naroff61f72cb2009-03-09 21:12:44 +00003278 virtual OwningExprResult ActOnClassPropertyRefExpr(
3279 IdentifierInfo &receiverName,
3280 IdentifierInfo &propertyName,
3281 SourceLocation &receiverNameLoc,
3282 SourceLocation &propertyNameLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003283
Steve Naroff68d331a2007-09-27 14:38:14 +00003284 // ActOnClassMessage - used for both unary and keyword messages.
3285 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003286 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003287 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00003288 Scope *S,
Mike Stump1eb44332009-09-09 15:08:12 +00003289 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
3290 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003291 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00003292
3293 // ActOnInstanceMessage - used for both unary and keyword messages.
3294 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003295 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003296 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00003297 ExprTy *receiver, Selector Sel,
Mike Stump1eb44332009-09-09 15:08:12 +00003298 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003299 ExprTy **ArgExprs, unsigned NumArgs);
Mike Stump1eb44332009-09-09 15:08:12 +00003300
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003301 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
3302 virtual void ActOnPragmaPack(PragmaPackKind Kind,
3303 IdentifierInfo *Name,
3304 ExprTy *Alignment,
Mike Stump1eb44332009-09-09 15:08:12 +00003305 SourceLocation PragmaLoc,
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003306 SourceLocation LParenLoc,
3307 SourceLocation RParenLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003308
Ted Kremenek4726d032009-03-23 22:28:25 +00003309 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
Ted Kremenek7a02a372009-08-03 23:24:57 +00003310 virtual void ActOnPragmaUnused(const Token *Identifiers,
3311 unsigned NumIdentifiers, Scope *curScope,
Mike Stump1eb44332009-09-09 15:08:12 +00003312 SourceLocation PragmaLoc,
Ted Kremenek4726d032009-03-23 22:28:25 +00003313 SourceLocation LParenLoc,
3314 SourceLocation RParenLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003315
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00003316 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II);
3317 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
Ryan Flynne25ff832009-07-30 03:15:39 +00003318
Eli Friedmandec7c762009-06-05 06:28:29 +00003319 /// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003320 virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
3321 SourceLocation PragmaLoc,
3322 SourceLocation WeakNameLoc);
3323
Eli Friedmandec7c762009-06-05 06:28:29 +00003324 /// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003325 virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
3326 IdentifierInfo* AliasName,
3327 SourceLocation PragmaLoc,
3328 SourceLocation WeakNameLoc,
3329 SourceLocation AliasNameLoc);
3330
Chris Lattner574aa402009-02-17 01:09:29 +00003331 /// getPragmaPackAlignment() - Return the current alignment as specified by
3332 /// the current #pragma pack directive, or 0 if none is currently active.
3333 unsigned getPragmaPackAlignment() const;
Mike Stump1eb44332009-09-09 15:08:12 +00003334
Chris Lattner574aa402009-02-17 01:09:29 +00003335 /// FreePackedContext - Deallocate and null out PackContext.
3336 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003337
Chris Lattner1e0a3902008-01-16 19:17:22 +00003338 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
3339 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003340 /// If isLvalue, the result of the cast is an lvalue.
Eli Friedman73c39ab2009-10-20 08:27:19 +00003341 void ImpCastExprToType(Expr *&Expr, QualType Type, CastExpr::CastKind Kind,
Anders Carlsson3503d042009-07-31 01:23:52 +00003342 bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00003343
Reid Spencer5f016e22007-07-11 17:01:13 +00003344 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00003345 // functions and arrays to their respective pointers (C99 6.3.2.1).
Mike Stump1eb44332009-09-09 15:08:12 +00003346 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00003347
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003348 // DefaultFunctionArrayConversion - converts functions and arrays
Mike Stump1eb44332009-09-09 15:08:12 +00003349 // to their respective pointers (C99 6.3.2.1).
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003350 void DefaultFunctionArrayConversion(Expr *&expr);
Mike Stump1eb44332009-09-09 15:08:12 +00003351
Steve Naroffb291ab62007-08-28 23:30:39 +00003352 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
Mike Stump1eb44332009-09-09 15:08:12 +00003353 // do not have a prototype. Integer promotions are performed on each
Steve Naroffb291ab62007-08-28 23:30:39 +00003354 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00003355 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003356
3357 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
3358 enum VariadicCallType {
3359 VariadicFunction,
3360 VariadicBlock,
Anders Carlssond74d4142009-09-08 01:48:42 +00003361 VariadicMethod,
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003362 VariadicConstructor,
3363 VariadicDoesNotApply
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003364 };
Mike Stump1eb44332009-09-09 15:08:12 +00003365
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003366 /// GatherArgumentsForCall - Collector argument expressions for various
3367 /// form of call prototypes.
3368 bool GatherArgumentsForCall(SourceLocation CallLoc,
3369 FunctionDecl *FDecl,
3370 const FunctionProtoType *Proto,
3371 unsigned FirstProtoArg,
3372 Expr **Args, unsigned NumArgs,
3373 llvm::SmallVector<Expr *, 8> &AllArgs,
Fariborz Jahanian4cd1c702009-11-24 19:27:49 +00003374 VariadicCallType CallType = VariadicDoesNotApply);
3375
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003376 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
3377 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00003378 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Mike Stump1eb44332009-09-09 15:08:12 +00003379
Reid Spencer5f016e22007-07-11 17:01:13 +00003380 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
3381 // operands and then handles various conversions that are common to binary
3382 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
Mike Stump1eb44332009-09-09 15:08:12 +00003383 // routine returns the first non-arithmetic type found. The client is
Reid Spencer5f016e22007-07-11 17:01:13 +00003384 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003385 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
3386 bool isCompAssign = false);
Mike Stump1eb44332009-09-09 15:08:12 +00003387
Chris Lattnerb7b61152008-01-04 18:22:42 +00003388 /// AssignConvertType - All of the 'assignment' semantic checks return this
3389 /// enum to indicate whether the assignment was allowed. These checks are
3390 /// done for simple assignments, as well as initialization, return from
3391 /// function, argument passing, etc. The query is phrased in terms of a
3392 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003393 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00003394 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00003395 Compatible,
Mike Stump1eb44332009-09-09 15:08:12 +00003396
Chris Lattnerb7b61152008-01-04 18:22:42 +00003397 /// PointerToInt - The assignment converts a pointer to an int, which we
3398 /// accept as an extension.
3399 PointerToInt,
Mike Stump1eb44332009-09-09 15:08:12 +00003400
Chris Lattnerb7b61152008-01-04 18:22:42 +00003401 /// IntToPointer - The assignment converts an int to a pointer, which we
3402 /// accept as an extension.
3403 IntToPointer,
Mike Stump1eb44332009-09-09 15:08:12 +00003404
Chris Lattnerb7b61152008-01-04 18:22:42 +00003405 /// FunctionVoidPointer - The assignment is between a function pointer and
3406 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003407 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003408
3409 /// IncompatiblePointer - The assignment is between two pointers types that
3410 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00003411 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003412
3413 /// IncompatiblePointer - The assignment is between two pointers types which
3414 /// point to integers which have a different sign, but are otherwise identical.
3415 /// This is a subset of the above, but broken out because it's by far the most
3416 /// common case of incompatible pointers.
3417 IncompatiblePointerSign,
3418
Chris Lattnerb7b61152008-01-04 18:22:42 +00003419 /// CompatiblePointerDiscardsQualifiers - The assignment discards
3420 /// c/v/r qualifiers, which we accept as an extension.
3421 CompatiblePointerDiscardsQualifiers,
Fariborz Jahanian36a862f2009-11-07 20:20:40 +00003422
Sean Huntc9132b62009-11-08 07:46:34 +00003423 /// IncompatibleNestedPointerQualifiers - The assignment is between two
3424 /// nested pointer types, and the qualifiers other than the first two
Fariborz Jahaniand288baf2009-11-09 22:28:08 +00003425 /// levels differ e.g. char ** -> const char **, but we accept them as an
3426 /// extension.
Sean Huntc9132b62009-11-08 07:46:34 +00003427 IncompatibleNestedPointerQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003428
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00003429 /// IncompatibleVectors - The assignment is between two vector types that
3430 /// have the same size, which we accept as an extension.
3431 IncompatibleVectors,
Mike Stump1eb44332009-09-09 15:08:12 +00003432
3433 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003434 /// pointer. We disallow this.
3435 IntToBlockPointer,
3436
Mike Stump1eb44332009-09-09 15:08:12 +00003437 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003438 /// pointers types that are not compatible.
3439 IncompatibleBlockPointer,
Mike Stump1eb44332009-09-09 15:08:12 +00003440
Steve Naroff39579072008-10-14 22:18:38 +00003441 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
3442 /// id type and something else (that is incompatible with it). For example,
3443 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
3444 IncompatibleObjCQualifiedId,
Mike Stump1eb44332009-09-09 15:08:12 +00003445
Chris Lattnerb7b61152008-01-04 18:22:42 +00003446 /// Incompatible - We reject this conversion outright, it is invalid to
3447 /// represent it in the AST.
3448 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00003449 };
Mike Stump1eb44332009-09-09 15:08:12 +00003450
Chris Lattner5cf216b2008-01-04 18:04:52 +00003451 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
3452 /// assignment conversion type specified by ConvTy. This returns true if the
3453 /// conversion was invalid or false if the conversion was accepted.
3454 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
3455 SourceLocation Loc,
3456 QualType DstType, QualType SrcType,
3457 Expr *SrcExpr, const char *Flavor);
Mike Stump1eb44332009-09-09 15:08:12 +00003458
3459 /// CheckAssignmentConstraints - Perform type checking for assignment,
3460 /// argument passing, variable initialization, and function return values.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003461 /// This routine is only used by the following two methods. C99 6.5.16.
3462 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Mike Stump1eb44332009-09-09 15:08:12 +00003463
3464 // CheckSingleAssignmentConstraints - Currently used by
3465 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00003466 // this routine performs the default function/array converions.
Mike Stump1eb44332009-09-09 15:08:12 +00003467 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
Chris Lattner5cf216b2008-01-04 18:04:52 +00003468 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003469
3470 // \brief If the lhs type is a transparent union, check whether we
3471 // can initialize the transparent union with the given expression.
Mike Stump1eb44332009-09-09 15:08:12 +00003472 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003473 Expr *&rExpr);
Mike Stump1eb44332009-09-09 15:08:12 +00003474
Reid Spencer5f016e22007-07-11 17:01:13 +00003475 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Mike Stump1eb44332009-09-09 15:08:12 +00003476 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
Chris Lattner5cf216b2008-01-04 18:04:52 +00003477 QualType rhsType);
Mike Stump1eb44332009-09-09 15:08:12 +00003478
Steve Naroff1c7d0672008-09-04 15:10:53 +00003479 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003480 // block pointer types.
Mike Stump1eb44332009-09-09 15:08:12 +00003481 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003482 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00003483
3484 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003485
Sebastian Redl2c7588f2009-10-10 12:04:10 +00003486 bool CheckExceptionSpecCompatibility(Expr *From, QualType ToType);
3487
Mike Stump1eb44332009-09-09 15:08:12 +00003488 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00003489 const char *Flavor,
3490 bool AllowExplicit = false,
3491 bool Elidable = false);
Mike Stump1eb44332009-09-09 15:08:12 +00003492 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Fariborz Jahanian51bebc82009-09-23 20:55:32 +00003493 const char *Flavor,
3494 bool AllowExplicit,
3495 bool Elidable,
3496 ImplicitConversionSequence& ICS);
3497 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003498 const ImplicitConversionSequence& ICS,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003499 const char *Flavor,
3500 bool IgnoreBaseAccess = false);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003501 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00003502 const StandardConversionSequence& SCS,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003503 const char *Flavor, bool IgnoreBaseAccess);
Fariborz Jahanian93034ca2009-10-16 19:20:59 +00003504
3505 bool BuildCXXDerivedToBaseExpr(Expr *&From, CastExpr::CastKind CastKind,
3506 const ImplicitConversionSequence& ICS,
3507 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00003508
Reid Spencer5f016e22007-07-11 17:01:13 +00003509 /// the following "Check" methods will return a valid/converted QualType
3510 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00003511
3512 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00003513 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003514 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003515 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00003516 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003517 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003518 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003519 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003520 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003521 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003522 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003523 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003524 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003525 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003526 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00003527 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00003528 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00003529 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003530 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00003531 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003532 // CheckAssignmentOperands is used for both simple and compound assignment.
3533 // For simple assignment, pass both expressions and a null converted type.
3534 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00003535 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00003536 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00003537 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00003538 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00003539 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00003540 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003541 QualType CXXCheckConditionalOperands( // C++ 5.16
3542 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003543 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00003544
3545 /// type checking for vector binary operators.
3546 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
3547 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
3548 SourceLocation l, bool isRel);
Mike Stump1eb44332009-09-09 15:08:12 +00003549
Steve Narofff69936d2007-09-16 03:34:24 +00003550 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00003551 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00003552 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
3553 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003554 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
3555 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00003556 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Mike Stump1eb44332009-09-09 15:08:12 +00003557
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003558 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00003559 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Mike Stump1eb44332009-09-09 15:08:12 +00003560 const IdentifierInfo *Comp,
Anders Carlsson8f28f992009-08-26 18:25:21 +00003561 SourceLocation CmpLoc);
Mike Stump1eb44332009-09-09 15:08:12 +00003562
Steve Narofff0090632007-09-02 02:04:30 +00003563 /// type checking declaration initializers (C99 6.7.8)
Mike Stump1eb44332009-09-09 15:08:12 +00003564
Douglas Gregorf03d7c72008-11-05 15:29:30 +00003565 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003566 SourceLocation InitLoc,DeclarationName InitEntity,
Anders Carlsson0f5f2c62009-05-30 20:41:30 +00003567 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00003568 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00003569 bool CheckForConstantInitializer(Expr *e, QualType t);
Mike Stump1eb44332009-09-09 15:08:12 +00003570
Douglas Gregor87fd7032009-02-02 17:43:21 +00003571 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003572
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003573 // type checking C++ declaration initializers (C++ [dcl.init]).
3574
3575 /// ReferenceCompareResult - Expresses the result of comparing two
3576 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
3577 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
3578 enum ReferenceCompareResult {
3579 /// Ref_Incompatible - The two types are incompatible, so direct
3580 /// reference binding is not possible.
3581 Ref_Incompatible = 0,
3582 /// Ref_Related - The two types are reference-related, which means
3583 /// that their unqualified forms (T1 and T2) are either the same
3584 /// or T1 is a base class of T2.
3585 Ref_Related,
3586 /// Ref_Compatible_With_Added_Qualification - The two types are
3587 /// reference-compatible with added qualification, meaning that
3588 /// they are reference-compatible and the qualifiers on T1 (cv1)
3589 /// are greater than the qualifiers on T2 (cv2).
3590 Ref_Compatible_With_Added_Qualification,
3591 /// Ref_Compatible - The two types are reference-compatible and
3592 /// have equivalent qualifiers (cv1 == cv2).
3593 Ref_Compatible
3594 };
3595
Douglas Gregor393896f2009-11-05 13:06:35 +00003596 ReferenceCompareResult CompareReferenceRelationship(SourceLocation Loc,
3597 QualType T1, QualType T2,
Douglas Gregor15da57e2008-10-29 02:00:59 +00003598 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003599
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003600 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Douglas Gregor739d8282009-09-23 23:04:10 +00003601 SourceLocation DeclLoc,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00003602 bool SuppressUserConversions,
3603 bool AllowExplicit,
3604 bool ForceRValue,
Sebastian Redla82e4ae2009-11-14 21:15:49 +00003605 ImplicitConversionSequence *ICS = 0,
3606 bool IgnoreBaseAccess = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003607
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003608 /// CheckCastTypes - Check type constraints for casting between types under
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003609 /// C semantics, or forward to CXXCheckCStyleCast in C++.
3610 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr,
Mike Stump1eb44332009-09-09 15:08:12 +00003611 CastExpr::CastKind &Kind,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003612 CXXMethodDecl *& ConversionDecl,
3613 bool FunctionalStyle = false);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003614
Mike Stump1eb44332009-09-09 15:08:12 +00003615 // CheckVectorCast - check type constraints for vectors.
Anders Carlsson584b2472007-11-27 07:16:40 +00003616 // Since vectors are an extension, there are no C standard reference for this.
3617 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00003618 // returns true if the cast is invalid
Anders Carlssonc3516322009-10-16 02:48:28 +00003619 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty,
3620 CastExpr::CastKind &Kind);
Mike Stump1eb44332009-09-09 15:08:12 +00003621
3622 // CheckExtVectorCast - check type constraints for extended vectors.
Nate Begeman58d29a42009-06-26 00:50:28 +00003623 // Since vectors are an extension, there are no C standard reference for this.
3624 // We allow casting between vectors and integer datatypes of the same size,
3625 // or vectors and the element type of that vector.
3626 // returns true if the cast is invalid
Anders Carlsson16a89042009-10-16 05:23:41 +00003627 bool CheckExtVectorCast(SourceRange R, QualType VectorTy, Expr *&CastExpr,
3628 CastExpr::CastKind &Kind);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003629
3630 /// CXXCheckCStyleCast - Check constraints of a C-style or function-style
3631 /// cast under C++ semantics.
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003632 bool CXXCheckCStyleCast(SourceRange R, QualType CastTy, Expr *&CastExpr,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003633 CastExpr::CastKind &Kind, bool FunctionalStyle,
3634 CXXMethodDecl *&ConversionDecl);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003635
Mike Stump1eb44332009-09-09 15:08:12 +00003636 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003637 /// \param Method - May be null.
3638 /// \param [out] ReturnType - The return type of the send.
3639 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00003640 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00003641 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003642 SourceLocation lbrac, SourceLocation rbrac,
Mike Stump1eb44332009-09-09 15:08:12 +00003643 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003644
John McCall5a881bb2009-10-12 21:59:07 +00003645 /// CheckBooleanCondition - Diagnose problems involving the use of
3646 /// the given expression as a boolean condition (e.g. in an if
3647 /// statement). Also performs the standard function and array
3648 /// decays, possibly changing the input variable.
3649 ///
3650 /// \param Loc - A location associated with the condition, e.g. the
3651 /// 'if' keyword.
3652 /// \return true iff there were any errors
3653 bool CheckBooleanCondition(Expr *&CondExpr, SourceLocation Loc);
3654
3655 /// DiagnoseAssignmentAsCondition - Given that an expression is
3656 /// being used as a boolean condition, warn if it's an assignment.
3657 void DiagnoseAssignmentAsCondition(Expr *E);
3658
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003659 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
3660 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003661
Chris Lattnerf4021e72007-08-23 05:46:52 +00003662 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
3663 /// the specified width and sign. If an overflow occurs, detect it and emit
3664 /// the specified diagnostic.
Mike Stump1eb44332009-09-09 15:08:12 +00003665 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
Chris Lattnerf4021e72007-08-23 05:46:52 +00003666 unsigned NewWidth, bool NewSign,
3667 SourceLocation Loc, unsigned DiagID);
Mike Stump1eb44332009-09-09 15:08:12 +00003668
Anders Carlsson15281452008-11-04 16:57:32 +00003669 /// Checks that the Objective-C declaration is declared in the global scope.
3670 /// Emits an error and marks the declaration as invalid if it's not declared
3671 /// in the global scope.
3672 bool CheckObjCDeclScope(Decl *D);
3673
Anders Carlsson7c50aca2007-10-15 20:28:48 +00003674 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00003675
Anders Carlssone21555e2008-11-30 19:50:32 +00003676 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
3677 /// and reports the appropriate diagnostics. Returns false on success.
3678 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003679 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00003680
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003681 /// VerifyBitField - verifies that a bit field expression is an ICE and has
Mike Stump1eb44332009-09-09 15:08:12 +00003682 /// the correct width, and that the field type is valid.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003683 /// Returns false on success.
Eli Friedman1d954f62009-08-15 21:55:26 +00003684 /// Can optionally return whether the bit-field is of width 0
Mike Stump1eb44332009-09-09 15:08:12 +00003685 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
3686 QualType FieldTy, const Expr *BitWidth,
Eli Friedman1d954f62009-08-15 21:55:26 +00003687 bool *ZeroWidth = 0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00003688
Douglas Gregor81b747b2009-09-17 21:32:03 +00003689 /// \name Code completion
3690 //@{
Douglas Gregor791215b2009-09-21 20:51:25 +00003691 virtual void CodeCompleteOrdinaryName(Scope *S);
Douglas Gregor81b747b2009-09-17 21:32:03 +00003692 virtual void CodeCompleteMemberReferenceExpr(Scope *S, ExprTy *Base,
3693 SourceLocation OpLoc,
3694 bool IsArrow);
Douglas Gregor374929f2009-09-18 15:37:17 +00003695 virtual void CodeCompleteTag(Scope *S, unsigned TagSpec);
Douglas Gregor3e1005f2009-09-21 18:10:23 +00003696 virtual void CodeCompleteCase(Scope *S);
Douglas Gregor9c6a0e92009-09-22 15:41:20 +00003697 virtual void CodeCompleteCall(Scope *S, ExprTy *Fn,
3698 ExprTy **Args, unsigned NumArgs);
Douglas Gregor81b747b2009-09-17 21:32:03 +00003699 virtual void CodeCompleteQualifiedId(Scope *S, const CXXScopeSpec &SS,
3700 bool EnteringContext);
Douglas Gregor49f40bd2009-09-18 19:03:04 +00003701 virtual void CodeCompleteUsing(Scope *S);
3702 virtual void CodeCompleteUsingDirective(Scope *S);
3703 virtual void CodeCompleteNamespaceDecl(Scope *S);
3704 virtual void CodeCompleteNamespaceAliasDecl(Scope *S);
Douglas Gregored8d3222009-09-18 20:05:18 +00003705 virtual void CodeCompleteOperatorName(Scope *S);
Steve Naroffece8e712009-10-08 21:55:05 +00003706
Douglas Gregora93b1082009-11-18 23:08:07 +00003707 virtual void CodeCompleteObjCPropertyFlags(Scope *S, ObjCDeclSpec &ODS);
Douglas Gregor4ad96852009-11-19 07:41:15 +00003708 virtual void CodeCompleteObjCPropertyGetter(Scope *S, DeclPtrTy ClassDecl,
3709 DeclPtrTy *Methods,
3710 unsigned NumMethods);
3711 virtual void CodeCompleteObjCPropertySetter(Scope *S, DeclPtrTy ClassDecl,
3712 DeclPtrTy *Methods,
3713 unsigned NumMethods);
3714
Douglas Gregor60b01cc2009-11-17 23:31:36 +00003715 virtual void CodeCompleteObjCClassMessage(Scope *S, IdentifierInfo *FName,
Douglas Gregord3c68542009-11-19 01:08:35 +00003716 SourceLocation FNameLoc,
3717 IdentifierInfo **SelIdents,
3718 unsigned NumSelIdents);
3719 virtual void CodeCompleteObjCInstanceMessage(Scope *S, ExprTy *Receiver,
3720 IdentifierInfo **SelIdents,
3721 unsigned NumSelIdents);
Douglas Gregor55385fe2009-11-18 04:19:12 +00003722 virtual void CodeCompleteObjCProtocolReferences(IdentifierLocPair *Protocols,
3723 unsigned NumProtocols);
Douglas Gregor083128f2009-11-18 04:49:41 +00003724 virtual void CodeCompleteObjCProtocolDecl(Scope *S);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00003725 virtual void CodeCompleteObjCInterfaceDecl(Scope *S);
3726 virtual void CodeCompleteObjCSuperclass(Scope *S,
3727 IdentifierInfo *ClassName);
3728 virtual void CodeCompleteObjCImplementationDecl(Scope *S);
Douglas Gregor33ced0b2009-11-18 19:08:43 +00003729 virtual void CodeCompleteObjCInterfaceCategory(Scope *S,
3730 IdentifierInfo *ClassName);
3731 virtual void CodeCompleteObjCImplementationCategory(Scope *S,
3732 IdentifierInfo *ClassName);
Douglas Gregor424b2a52009-11-18 22:56:13 +00003733 virtual void CodeCompleteObjCPropertyDefinition(Scope *S,
Douglas Gregor322328b2009-11-18 22:32:06 +00003734 DeclPtrTy ObjCImpDecl);
3735 virtual void CodeCompleteObjCPropertySynthesizeIvar(Scope *S,
3736 IdentifierInfo *PropertyName,
3737 DeclPtrTy ObjCImpDecl);
Douglas Gregor3b49aca2009-11-18 16:26:39 +00003738 //@}
Douglas Gregor81b747b2009-09-17 21:32:03 +00003739
Chris Lattner59907c42007-08-10 20:18:51 +00003740 //===--------------------------------------------------------------------===//
3741 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00003742private:
Anders Carlssond406bf02009-08-16 01:56:34 +00003743 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall);
3744 bool CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall);
Mike Stump1eb44332009-09-09 15:08:12 +00003745
Chris Lattner60800082009-02-18 17:49:48 +00003746 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
3747 unsigned ByteNo) const;
Ryan Flynn4403a5e2009-08-06 03:00:50 +00003748 bool CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall);
Chris Lattner69039812009-02-18 06:01:06 +00003749 bool CheckObjCString(Expr *Arg);
Anders Carlssond406bf02009-08-16 01:56:34 +00003750
3751 Action::OwningExprResult CheckBuiltinFunctionCall(unsigned BuiltinID,
3752 CallExpr *TheCall);
Chris Lattner925e60d2007-12-28 05:29:59 +00003753 bool SemaBuiltinVAStart(CallExpr *TheCall);
3754 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman9ac6f622009-08-31 20:06:00 +00003755 bool SemaBuiltinUnaryFP(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00003756 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003757
3758public:
3759 // Used by C++ template instantiation.
Sebastian Redl0eb23302009-01-19 00:08:26 +00003760 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003761
3762private:
Mike Stump1eb44332009-09-09 15:08:12 +00003763 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00003764 bool SemaBuiltinObjectSize(CallExpr *TheCall);
3765 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00003766 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Chris Lattner21fb98e2009-09-23 06:06:36 +00003767 bool SemaBuiltinEHReturnDataRegNo(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003768 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
3769 bool HasVAListArg, unsigned format_idx,
3770 unsigned firstDataArg);
3771 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
3772 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003773 unsigned format_idx, unsigned firstDataArg);
Mike Stump1eb44332009-09-09 15:08:12 +00003774 void CheckNonNullArguments(const NonNullAttr *NonNull,
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +00003775 const CallExpr *TheCall);
Mike Stump1eb44332009-09-09 15:08:12 +00003776 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003777 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00003778 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
3779 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00003780 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00003781};
3782
Ted Kremenek8189cde2009-02-07 01:47:29 +00003783//===--------------------------------------------------------------------===//
3784// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
3785template <typename T>
3786class ExprOwningPtr : public Action::ExprArg {
3787public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00003788 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Mike Stump1eb44332009-09-09 15:08:12 +00003789
Ted Kremenek8189cde2009-02-07 01:47:29 +00003790 void reset(T* p) { Action::ExprArg::operator=(p); }
3791 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
3792 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
3793 T* release() { return take(); }
Mike Stump1eb44332009-09-09 15:08:12 +00003794
Ted Kremenek8189cde2009-02-07 01:47:29 +00003795 T& operator*() const { return *get(); }
3796 T* operator->() const { return get(); }
3797};
Douglas Gregord7e27052009-05-20 22:33:37 +00003798
Reid Spencer5f016e22007-07-11 17:01:13 +00003799} // end namespace clang
3800
3801#endif