blob: f3d202c2ffb6e1b7a16436dcd2a6c15677970f3e [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;
Reid Spencer5f016e22007-07-11 17:01:13 +000045 class Preprocessor;
46 class Decl;
Chris Lattnerb048c982008-04-06 04:47:34 +000047 class DeclContext;
Daniel Dunbar12bc6922008-08-11 03:27:53 +000048 class DeclSpec;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000049 class ExternalSemaSource;
Steve Naroffe8043c32008-04-01 23:04:06 +000050 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000051 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000052 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000053 class InitListExpr;
Nate Begeman2ef13e52009-08-10 23:49:36 +000054 class ParenListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000055 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000056 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000057 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000058 class VarDecl;
59 class ParmVarDecl;
60 class TypedefDecl;
61 class FunctionDecl;
62 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000063 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000064 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000065 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000066 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000067 class ArrayType;
68 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000069 class SwitchStmt;
Sebastian Redl13e88542009-04-27 21:33:24 +000070 class CXXTryStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000071 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000072 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000073 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000074 class TemplateArgument;
Douglas Gregor7e063902009-05-11 23:53:27 +000075 class TemplateArgumentList;
Douglas Gregorddc29e12009-02-06 22:42:48 +000076 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000077 class TemplateTemplateParmDecl;
Douglas Gregorc8ab2562009-05-31 09:31:02 +000078 class ClassTemplatePartialSpecializationDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000079 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000080 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000081 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000082 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000083 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000084 class ObjCImplementationDecl;
85 class ObjCCategoryImplDecl;
86 class ObjCCategoryDecl;
87 class ObjCIvarDecl;
88 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000089 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000090 class ObjCContainerDecl;
Sebastian Redl4994d2d2009-07-04 11:39:00 +000091 class FunctionProtoType;
Douglas Gregor94b1dd22008-10-24 04:54:22 +000092 class BasePaths;
Sebastian Redl43af76e2009-03-07 12:16:37 +000093 struct MemberLookupCriteria;
Anders Carlssonff6b3d62009-05-30 21:05:25 +000094 class CXXTemporary;
Steve Naroffbea0b342007-07-29 16:33:31 +000095
Chris Lattnerea29a3a2009-04-18 20:01:55 +000096/// BlockSemaInfo - When a block is being parsed, this contains information
97/// about the block. It is pointed to from Sema::CurBlock.
98struct BlockSemaInfo {
99 llvm::SmallVector<ParmVarDecl*, 8> Params;
100 bool hasPrototype;
101 bool isVariadic;
102 bool hasBlockDeclRefExprs;
103
104 BlockDecl *TheDecl;
105
106 /// TheScope - This is the scope for the block itself, which contains
107 /// arguments etc.
108 Scope *TheScope;
109
110 /// ReturnType - This will get set to block result type, by looking at
111 /// return types, if any, in the block body.
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +0000112 QualType ReturnType;
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000113
114 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
115 /// it (which acts like the label decl in some ways). Forward referenced
116 /// labels have a LabelStmt created for them with a null location & SubStmt.
117 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
118
Chris Lattnerbcfce662009-04-18 20:10:59 +0000119 /// SwitchStack - This is the current set of active switch statements in the
120 /// block.
121 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
122
Chris Lattner17a78302009-04-19 05:28:12 +0000123 /// SavedFunctionNeedsScopeChecking - This is the value of
124 /// CurFunctionNeedsScopeChecking at the point when the block started.
125 bool SavedFunctionNeedsScopeChecking;
126
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000127 /// PrevBlockInfo - If this is nested inside another block, this points
128 /// to the outer block.
129 BlockSemaInfo *PrevBlockInfo;
130};
131
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000132/// \brief Holds a QualType and a DeclaratorInfo* that came out of a declarator
133/// parsing.
134///
135/// LocInfoType is a "transient" type, only needed for passing to/from Parser
136/// and Sema, when we want to preserve type source info for a parsed type.
137/// It will not participate in the type system semantics in any way.
138class LocInfoType : public Type {
139 enum {
140 // The last number that can fit in Type's TC.
141 // Avoids conflict with an existing Type class.
142 LocInfo = (1 << TypeClassBitSize) - 1
143 };
144
145 DeclaratorInfo *DeclInfo;
146
147 LocInfoType(QualType ty, DeclaratorInfo *DInfo)
148 : Type((TypeClass)LocInfo, ty, ty->isDependentType()), DeclInfo(DInfo) {
149 assert(getTypeClass() == (TypeClass)LocInfo && "LocInfo didn't fit in TC?");
150 }
151 friend class Sema;
152
153public:
154 QualType getType() const { return getCanonicalTypeInternal(); }
155 DeclaratorInfo *getDeclaratorInfo() const { return DeclInfo; }
156
157 virtual void getAsStringInternal(std::string &Str,
158 const PrintingPolicy &Policy) const;
159
160 static bool classof(const Type *T) {
161 return T->getTypeClass() == (TypeClass)LocInfo;
162 }
163 static bool classof(const LocInfoType *) { return true; }
164};
165
Reid Spencer5f016e22007-07-11 17:01:13 +0000166/// Sema - This implements semantic analysis and AST building for C.
167class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +0000168 Sema(const Sema&); // DO NOT IMPLEMENT
169 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +0000170public:
Chris Lattner53ebff32009-01-22 19:21:44 +0000171 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +0000172 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +0000173 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000174 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +0000175 Diagnostic &Diags;
176 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +0000177
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000178 /// \brief Source of additional semantic information.
179 ExternalSemaSource *ExternalSource;
180
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000181 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +0000182 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +0000183
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000184 /// PreDeclaratorDC - Keeps the declaration context before switching to the
185 /// context of a declarator's nested-name-specifier.
186 DeclContext *PreDeclaratorDC;
187
Steve Naroff4eb206b2008-09-03 18:15:37 +0000188 /// CurBlock - If inside of a block definition, this contains a pointer to
189 /// the active block object that represents it.
190 BlockSemaInfo *CurBlock;
191
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000192 /// PackContext - Manages the stack for #pragma pack. An alignment
193 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000194 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000195
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000196 /// FunctionLabelMap - This is a mapping from label identifiers to the
197 /// LabelStmt for it (which acts like the label decl in some ways). Forward
198 /// referenced labels have a LabelStmt created for them with a null location &
199 /// SubStmt.
200 ///
201 /// Note that this should always be accessed through getLabelMap() in order
202 /// to handle blocks properly.
203 llvm::DenseMap<IdentifierInfo*, LabelStmt*> FunctionLabelMap;
Steve Naroffcaaacec2009-03-13 15:38:40 +0000204
Chris Lattnerbcfce662009-04-18 20:10:59 +0000205 /// FunctionSwitchStack - This is the current set of active switch statements
206 /// in the top level function. Clients should always use getSwitchStack() to
207 /// handle the case when they are in a block.
208 llvm::SmallVector<SwitchStmt*, 8> FunctionSwitchStack;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000209
210 /// ExprTemporaries - This is the stack of temporaries that are created by
211 /// the current full expression.
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000212 llvm::SmallVector<CXXTemporary*, 8> ExprTemporaries;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000213
Chris Lattner38c5ebd2009-04-19 05:21:20 +0000214 /// CurFunctionNeedsScopeChecking - This is set to true when a function or
215 /// ObjC method body contains a VLA or an ObjC try block, which introduce
216 /// scopes that need to be checked for goto conditions. If a function does
217 /// not contain this, then it need not have the jump checker run on it.
218 bool CurFunctionNeedsScopeChecking;
219
Nate Begeman213541a2008-04-18 23:10:10 +0000220 /// ExtVectorDecls - This is a list all the extended vector types. This allows
221 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000222 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000223 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Steve Naroffe84a8642008-09-28 14:55:53 +0000224
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000225 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
226 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
227
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000228 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
229
230 /// PureVirtualClassDiagSet - a set of class declarations which we have
231 /// emitted a list of pure virtual functions. Used to prevent emitting the
232 /// same list more than once.
233 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
234
Douglas Gregor63935192009-03-02 00:19:53 +0000235 /// \brief A mapping from external names to the most recent
236 /// locally-scoped external declaration with that name.
237 ///
238 /// This map contains external declarations introduced in local
239 /// scoped, e.g.,
240 ///
241 /// \code
242 /// void f() {
243 /// void foo(int, int);
244 /// }
245 /// \endcode
246 ///
247 /// Here, the name "foo" will be associated with the declaration on
248 /// "foo" within f. This name is not visible outside of
249 /// "f". However, we still find it in two cases:
250 ///
251 /// - If we are declaring another external with the name "foo", we
252 /// can find "foo" as a previous declaration, so that the types
253 /// of this external declaration can be checked for
254 /// compatibility.
255 ///
256 /// - If we would implicitly declare "foo" (e.g., due to a call to
257 /// "foo" in C when no prototype or definition is visible), then
258 /// we find this declaration of "foo" and complain that it is
259 /// not visible.
260 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
261
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000262 /// \brief The set of tentative declarations seen so far in this
263 /// translation unit for which no definition has been seen.
264 ///
265 /// The tentative declarations are indexed by the name of the
266 /// declaration, and only the most recent tentative declaration for
267 /// a given variable will be recorded here.
268 llvm::DenseMap<DeclarationName, VarDecl *> TentativeDefinitions;
269
Ryan Flynne25ff832009-07-30 03:15:39 +0000270 /// WeakUndeclaredIdentifiers - Identifiers contained in
271 /// #pragma weak before declared. rare. may alias another
272 /// identifier, declared or undeclared
273 class WeakInfo {
274 IdentifierInfo *alias; // alias (optional)
275 SourceLocation loc; // for diagnostics
276 bool used; // identifier later declared?
277 public:
278 WeakInfo()
279 : alias(0), loc(SourceLocation()), used(false) {}
280 WeakInfo(IdentifierInfo *Alias, SourceLocation Loc)
281 : alias(Alias), loc(Loc), used(false) {}
282 inline IdentifierInfo * getAlias() const { return alias; }
283 inline SourceLocation getLocation() const { return loc; }
284 void setUsed(bool Used=true) { used = Used; }
285 inline bool getUsed() { return used; }
286 bool operator==(WeakInfo RHS) const {
287 return alias == RHS.getAlias() && loc == RHS.getLocation();
288 }
289 bool operator!=(WeakInfo RHS) const { return !(*this == RHS); }
290 };
291 llvm::DenseMap<IdentifierInfo*,WeakInfo> WeakUndeclaredIdentifiers;
292
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000293 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
294 /// #pragma weak during processing of other Decls.
295 /// I couldn't figure out a clean way to generate these in-line, so
296 /// we store them here and handle separately -- which is a hack.
297 /// It would be best to refactor this.
298 llvm::SmallVector<Decl*,2> WeakTopLevelDecl;
299
Chris Lattner7f925cc2008-04-11 07:00:53 +0000300 IdentifierResolver IdResolver;
301
Steve Naroffe440eb82007-10-10 17:32:04 +0000302 /// Translation Unit Scope - useful to Objective-C actions that need
303 /// to lookup file scope declarations in the "ordinary" C decl namespace.
304 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000305 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000306
307 /// The C++ "std" namespace, where the standard library resides. Cached here
308 /// by GetStdNamespace
309 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000310
311 /// A flag to remember whether the implicit forms of operator new and delete
312 /// have been declared.
313 bool GlobalNewDeleteDeclared;
Douglas Gregorf807fe02009-04-14 16:27:31 +0000314
Douglas Gregorac7610d2009-06-22 20:57:11 +0000315 /// The current expression evaluation context.
316 ExpressionEvaluationContext ExprEvalContext;
317
318 typedef std::vector<std::pair<SourceLocation, Decl *> >
319 PotentiallyReferencedDecls;
320
321 /// A stack of declarations, each element of which is a set of declarations
322 /// that will be marked as referenced if the corresponding potentially
323 /// potentially evaluated expression is potentially evaluated. Each element
324 /// in the stack corresponds to a PotentiallyPotentiallyEvaluated expression
325 /// evaluation context.
326 std::list<PotentiallyReferencedDecls> PotentiallyReferencedDeclStack;
Douglas Gregore0762c92009-06-19 23:52:42 +0000327
Douglas Gregorf807fe02009-04-14 16:27:31 +0000328 /// \brief Whether the code handled by Sema should be considered a
329 /// complete translation unit or not.
330 ///
331 /// When true (which is generally the case), Sema will perform
332 /// end-of-translation-unit semantic tasks (such as creating
333 /// initializers for tentative definitions in C) once parsing has
334 /// completed. This flag will be false when building PCH files,
335 /// since a PCH file is by definition not a complete translation
336 /// unit.
337 bool CompleteTranslationUnit;
338
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000339 llvm::BumpPtrAllocator BumpAlloc;
340
Douglas Gregorbb260412009-06-14 08:02:22 +0000341 /// \brief The number of SFINAE diagnostics that have been trapped.
342 unsigned NumSFINAEErrors;
343
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000344 typedef llvm::DenseMap<Selector, ObjCMethodList> MethodPool;
345
Steve Naroff58ff9e82007-10-14 00:58:41 +0000346 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
347 /// messages to "id". We need to maintain a list, since selectors can have
348 /// differing signatures across classes. In Cocoa, this happens to be
349 /// extremely uncommon (only 1% of selectors are "overloaded").
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000350 MethodPool InstanceMethodPool;
351 MethodPool FactoryMethodPool;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000352
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000353 MethodPool::iterator ReadMethodPool(Selector Sel, bool isInstance);
354
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000355 /// Private Helper predicate to check for 'self'.
356 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000357public:
Douglas Gregorf807fe02009-04-14 16:27:31 +0000358 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
359 bool CompleteTranslationUnit = true);
Chris Lattner574aa402009-02-17 01:09:29 +0000360 ~Sema() {
361 if (PackContext) FreePackedContext();
362 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000363
Chris Lattner53ebff32009-01-22 19:21:44 +0000364 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000365 Diagnostic &getDiagnostics() const { return Diags; }
366 SourceManager &getSourceManager() const { return SourceMgr; }
367
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000368 /// \brief Helper class that creates diagnostics with optional
369 /// template instantiation stacks.
370 ///
371 /// This class provides a wrapper around the basic DiagnosticBuilder
372 /// class that emits diagnostics. SemaDiagnosticBuilder is
373 /// responsible for emitting the diagnostic (as DiagnosticBuilder
374 /// does) and, if the diagnostic comes from inside a template
375 /// instantiation, printing the template instantiation stack as
376 /// well.
377 class SemaDiagnosticBuilder : public DiagnosticBuilder {
378 Sema &SemaRef;
379 unsigned DiagID;
380
381 public:
382 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
383 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
384
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000385 explicit SemaDiagnosticBuilder(Sema &SemaRef)
386 : DiagnosticBuilder(DiagnosticBuilder::Suppress), SemaRef(SemaRef) { }
387
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000388 ~SemaDiagnosticBuilder();
389 };
390
391 /// \brief Emit a diagnostic.
392 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000393 if (isSFINAEContext() && Diagnostic::isBuiltinSFINAEDiag(DiagID)) {
394 // If we encountered an error during template argument
395 // deduction, and that error is one of the SFINAE errors,
Douglas Gregorbb260412009-06-14 08:02:22 +0000396 // suppress the diagnostic.
Douglas Gregor8439fac2009-06-15 16:52:15 +0000397 ++NumSFINAEErrors;
398 return SemaDiagnosticBuilder(*this);
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000399 }
400
Douglas Gregoree1828a2009-03-10 18:03:33 +0000401 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000402 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000403 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000404
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000405 /// \brief Emit a partial diagnostic.
406 SemaDiagnosticBuilder Diag(SourceLocation Loc, const PartialDiagnostic& PD);
407
Chris Lattner394a3fd2007-08-31 04:53:24 +0000408 virtual void DeleteExpr(ExprTy *E);
409 virtual void DeleteStmt(StmtTy *S);
410
Sebastian Redl798d1192008-12-13 16:23:55 +0000411 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000412 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000413 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000414 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000415 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000416 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000417 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
418
Chris Lattner9299f3f2008-08-23 03:19:52 +0000419 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000420
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000421 /// getLabelMap() - Return the current label map. If we're in a block, we
422 /// return it.
423 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
424 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
425 }
426
Chris Lattnerbcfce662009-04-18 20:10:59 +0000427 /// getSwitchStack - This is returns the switch stack for the current block or
428 /// function.
429 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
430 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
431 }
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000432
433 /// WeakTopLevelDeclDecls - access to #pragma weak-generated Decls
434 llvm::SmallVector<Decl*,2> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
Chris Lattnerbcfce662009-04-18 20:10:59 +0000435
Douglas Gregor2e222532009-07-02 17:08:52 +0000436 virtual void ActOnComment(SourceRange Comment);
437
Reid Spencer5f016e22007-07-11 17:01:13 +0000438 //===--------------------------------------------------------------------===//
439 // Type Analysis / Processing: SemaType.cpp.
440 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000441 QualType adjustParameterType(QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000442 QualType ConvertDeclSpecToType(const DeclSpec &DS, SourceLocation DeclLoc,
443 bool &IsInvalid);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000444 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000445 QualType BuildPointerType(QualType T, unsigned Quals,
446 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000447 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000448 SourceLocation Loc, DeclarationName Entity);
449 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
450 Expr *ArraySize, unsigned Quals,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +0000451 SourceRange Brackets, DeclarationName Entity);
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000452 QualType BuildExtVectorType(QualType T, ExprArg ArraySize,
453 SourceLocation AttrLoc);
Douglas Gregor724651c2009-02-28 01:04:19 +0000454 QualType BuildFunctionType(QualType T,
455 QualType *ParamTypes, unsigned NumParamTypes,
456 bool Variadic, unsigned Quals,
457 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor949bf692009-06-09 22:17:39 +0000458 QualType BuildMemberPointerType(QualType T, QualType Class,
459 unsigned Quals, SourceLocation Loc,
460 DeclarationName Entity);
Anders Carlsson9a917e42009-06-12 22:56:54 +0000461 QualType BuildBlockPointerType(QualType T, unsigned Quals,
462 SourceLocation Loc, DeclarationName Entity);
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000463 QualType GetTypeForDeclarator(Declarator &D, Scope *S,
464 DeclaratorInfo **DInfo = 0,
465 unsigned Skip = 0, TagDecl **OwnedDecl = 0);
Argyrios Kyrtzidis4adab7f2009-08-19 01:28:06 +0000466 DeclaratorInfo *GetDeclaratorInfoForDeclarator(Declarator &D, QualType T,
467 unsigned Skip);
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000468 /// \brief Create a LocInfoType to hold the given QualType and DeclaratorInfo.
469 QualType CreateLocInfoType(QualType T, DeclaratorInfo *DInfo);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000470 DeclarationName GetNameForDeclarator(Declarator &D);
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000471 static QualType GetTypeFromParser(TypeTy *Ty, DeclaratorInfo **DInfo = 0);
Sebastian Redlef65f062009-05-29 18:02:33 +0000472 bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
Sebastian Redl6a7330c2009-05-29 15:01:05 +0000473 bool CheckDistantExceptionSpec(QualType T);
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000474 bool CheckEquivalentExceptionSpec(
475 const FunctionProtoType *Old, SourceLocation OldLoc,
476 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl23c7d062009-07-07 20:29:57 +0000477 bool CheckExceptionSpecSubset(unsigned DiagID, unsigned NoteID,
478 const FunctionProtoType *Superset, SourceLocation SuperLoc,
479 const FunctionProtoType *Subset, SourceLocation SubLoc);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000480
Chris Lattnerb28317a2009-03-28 19:18:32 +0000481 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000482
Douglas Gregor57373262008-10-22 14:17:15 +0000483 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
484
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000485 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000486
Anders Carlsson91a0cc92009-08-26 22:33:56 +0000487 bool RequireCompleteType(SourceLocation Loc, QualType T,
488 const PartialDiagnostic &PD);
489
Douglas Gregore6258932009-03-19 00:39:20 +0000490 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
491
Anders Carlssonaf017e62009-06-29 22:58:55 +0000492 QualType BuildTypeofExprType(Expr *E);
493 QualType BuildDecltypeType(Expr *E);
494
Reid Spencer5f016e22007-07-11 17:01:13 +0000495 //===--------------------------------------------------------------------===//
496 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
497 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000498
499 /// getDeclName - Return a pretty name for the specified decl if possible, or
500 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000501 virtual std::string getDeclName(DeclPtrTy D);
Chris Lattner21ff9c92009-03-05 01:25:28 +0000502
Chris Lattner682bf922009-03-29 16:50:03 +0000503 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
504
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000505 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregor42c39f32009-08-26 18:27:52 +0000506 Scope *S, const CXXScopeSpec *SS,
507 bool isClassName = false);
Chris Lattner4c97d762009-04-12 21:49:30 +0000508 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
509
Chris Lattner682bf922009-03-29 16:50:03 +0000510 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregore542c862009-06-23 23:11:28 +0000511 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this), false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000512 }
Douglas Gregore542c862009-06-23 23:11:28 +0000513
514 DeclPtrTy HandleDeclarator(Scope *S, Declarator &D,
515 MultiTemplateParamsArg TemplateParameterLists,
516 bool IsFunctionDefinition);
Douglas Gregor63935192009-03-02 00:19:53 +0000517 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
518 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000519 void DiagnoseFunctionSpecifiers(Declarator& D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000520 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000521 QualType R, DeclaratorInfo *DInfo,
522 Decl* PrevDecl, bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000523 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000524 QualType R, DeclaratorInfo *DInfo,
525 NamedDecl* PrevDecl,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +0000526 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000527 bool &Redeclaration);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000528 void CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000529 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000530 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000531 QualType R, DeclaratorInfo *DInfo,
532 NamedDecl* PrevDecl,
Douglas Gregore542c862009-06-23 23:11:28 +0000533 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregor04495c82009-02-24 01:23:02 +0000534 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000535 bool &Redeclaration);
536 void CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000537 bool &Redeclaration,
538 bool &OverloadableAttrRequired);
John McCall8c4859a2009-07-24 03:03:21 +0000539 void CheckMain(FunctionDecl *FD);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000540 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
541 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000542 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000543 ExprArg defarg);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000544 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000545 SourceLocation EqualLoc,
546 SourceLocation ArgLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000547 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
Anders Carlssoned961f92009-08-25 02:29:20 +0000548 bool SetParamDefaultArgument(ParmVarDecl *Param, ExprArg DefaultArg,
549 SourceLocation EqualLoc);
550
Anders Carlsson5e300d12009-06-12 16:51:40 +0000551
552 // Contains the locations of the beginning of unparsed default
553 // argument locations.
554 llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
555
Anders Carlsson9abf2ae2009-08-16 05:13:48 +0000556 virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000557 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
Anders Carlsson6a75cd92009-07-11 00:34:39 +0000558 void ActOnUninitializedDecl(DeclPtrTy dcl, bool TypeContainsUndeducedAuto);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000559 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000560 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
561 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +0000562 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000563 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
564 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000565 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
566 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
567 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000568
Chris Lattnerb28317a2009-03-28 19:18:32 +0000569 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Douglas Gregore2c31ff2009-05-15 17:59:04 +0000570 DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body,
571 bool IsInstantiation);
Douglas Gregore0762c92009-06-19 23:52:42 +0000572
573 /// \brief Diagnose any unused parameters in the given sequence of
574 /// ParmVarDecl pointers.
575 template<typename InputIterator>
576 void DiagnoseUnusedParameters(InputIterator Param, InputIterator ParamEnd) {
577 for (; Param != ParamEnd; ++Param) {
578 if (!(*Param)->isUsed() && (*Param)->getDeclName() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000579 !(*Param)->template hasAttr<UnusedAttr>())
Douglas Gregore0762c92009-06-19 23:52:42 +0000580 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
581 << (*Param)->getDeclName();
582 }
583 }
584
Chris Lattner5af280c2009-04-19 04:46:21 +0000585 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000586 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000587
Steve Naroffb216c882007-10-09 22:01:59 +0000588 /// Scope actions.
589 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
590 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000591
592 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
593 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000594 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000595
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000596 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
597 RecordDecl *AnonRecord);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000598 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
599 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000600
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000601 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
602 TagDecl::TagKind NewTag,
603 SourceLocation NewTagLoc,
604 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000605
John McCall0f434ec2009-07-31 02:45:11 +0000606 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000607 SourceLocation KWLoc, const CXXScopeSpec &SS,
608 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +0000609 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000610 MultiTemplateParamsArg TemplateParameterLists,
Douglas Gregor402abb52009-05-28 23:31:59 +0000611 bool &OwnedDecl);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000612
Chris Lattnerb28317a2009-03-28 19:18:32 +0000613 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000614 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000615 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
616 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
617 SourceLocation DeclStart,
618 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000619
620 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000621 Declarator &D, Expr *BitfieldWidth,
622 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000623
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000624 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
625 DeclaratorInfo *DInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000626 RecordDecl *Record, SourceLocation Loc,
627 bool Mutable, Expr *BitfieldWidth,
Steve Naroffea218b82009-07-14 14:58:18 +0000628 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000629 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000630 Declarator *D = 0);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000631
632 enum CXXSpecialMember {
633 CXXDefaultConstructor = 0,
634 CXXCopyConstructor = 1,
635 CXXCopyAssignment = 2,
636 CXXDestructor = 3
637 };
638 void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000639
Chris Lattnerb28317a2009-03-28 19:18:32 +0000640 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +0000641 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000642 Declarator &D, ExprTy *BitfieldWidth,
643 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000644
Steve Narofff13271f2007-09-14 23:09:53 +0000645 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000646 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000647 SourceLocation RecLoc, DeclPtrTy TagDecl,
648 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000649 SourceLocation LBrac, SourceLocation RBrac,
650 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000651
652 /// ActOnTagStartDefinition - Invoked when we have entered the
653 /// scope of a tag's definition (e.g., for an enumeration, class,
654 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000655 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000656
657 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
658 /// the definition of a tag (enumeration, class, struct, or union).
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +0000659 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
660 SourceLocation RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +0000661
Douglas Gregor879fd492009-03-17 19:05:46 +0000662 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
663 EnumConstantDecl *LastEnumConst,
664 SourceLocation IdLoc,
665 IdentifierInfo *Id,
666 ExprArg val);
667
Chris Lattnerb28317a2009-03-28 19:18:32 +0000668 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
669 DeclPtrTy LastEnumConstant,
670 SourceLocation IdLoc, IdentifierInfo *Id,
671 SourceLocation EqualLoc, ExprTy *Val);
Mike Stumpc6e35aa2009-05-16 07:06:02 +0000672 virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
673 SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
Edward O'Callaghanfee13812009-08-08 14:36:57 +0000674 DeclPtrTy *Elements, unsigned NumElements,
675 Scope *S, AttributeList *Attr);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000676
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000677 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000678
Chris Lattner0ed844b2008-04-04 06:12:32 +0000679 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000680 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000681 void PopDeclContext();
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000682
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000683 /// EnterDeclaratorContext - Used when we must lookup names in the context
684 /// of a declarator's nested name specifier.
685 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
686 void ExitDeclaratorContext(Scope *S);
687
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000688 DeclContext *getFunctionLevelDeclContext();
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000689
Chris Lattner371f2582008-12-04 23:50:19 +0000690 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
691 /// to the function decl for the function being parsed. If we're currently
692 /// in a 'block', this returns the containing context.
693 FunctionDecl *getCurFunctionDecl();
694
695 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
696 /// the method decl for the method being parsed. If we're currently
697 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000698 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000699
Chris Lattner371f2582008-12-04 23:50:19 +0000700 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
701 /// or C function we're in, otherwise return null. If we're currently
702 /// in a 'block', this returns the containing context.
703 NamedDecl *getCurFunctionOrMethodDecl();
704
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000705 /// Add this decl to the scope shadowed decl chains.
706 void PushOnScopeChains(NamedDecl *D, Scope *S);
707
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000708 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
709 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
710 /// true if 'D' belongs to the given declaration context.
711 bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000712 return IdResolver.isDeclInScope(D, Ctx, Context, S);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000713 }
714
Eli Friedman8f17b662009-02-28 05:41:13 +0000715
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000716 /// Subroutines of ActOnDeclarator().
Chris Lattner682bf922009-03-29 16:50:03 +0000717 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000718 void MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000719 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000720 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000721 void MergeVarDecl(VarDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000722 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000723
724 /// C++ Overloading.
725 bool IsOverload(FunctionDecl *New, Decl* OldD,
726 OverloadedFunctionDecl::function_iterator &MatchedDecl);
Douglas Gregor225c41e2008-11-03 19:09:14 +0000727 ImplicitConversionSequence
Anders Carlsson2974b5c2009-08-27 17:14:02 +0000728 TryImplicitConversion(Expr* From, QualType ToType,
Anders Carlssonda7a18b2009-08-27 17:24:15 +0000729 bool SuppressUserConversions,
730 bool AllowExplicit,
Anders Carlsson08972922009-08-28 15:33:32 +0000731 bool ForceRValue,
732 bool InOverloadResolution);
733 bool IsStandardConversion(Expr *From, QualType ToType,
734 bool InOverloadResolution,
Douglas Gregor60d62c22008-10-31 16:23:19 +0000735 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000736 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
737 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000738 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000739 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Anders Carlsson08972922009-08-28 15:33:32 +0000740 bool InOverloadResolution,
Douglas Gregor45920e82008-12-19 17:40:08 +0000741 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000742 bool isObjCPointerConversion(QualType FromType, QualType ToType,
743 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregor94b1dd22008-10-24 04:54:22 +0000744 bool CheckPointerConversion(Expr *From, QualType ToType);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000745 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
746 QualType &ConvertedType);
Anders Carlsson27a5b9b2009-08-22 23:33:40 +0000747 bool CheckMemberPointerConversion(Expr *From, QualType ToType,
748 CastExpr::CastKind &Kind);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000749 bool IsQualificationConversion(QualType FromType, QualType ToType);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000750 bool IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000751 UserDefinedConversionSequence& User,
Douglas Gregor734d9862009-01-30 23:27:23 +0000752 bool AllowConversionFunctions,
Sebastian Redle2b68332009-04-12 17:16:29 +0000753 bool AllowExplicit, bool ForceRValue);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000754
755 ImplicitConversionSequence::CompareKind
756 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
757 const ImplicitConversionSequence& ICS2);
758
759 ImplicitConversionSequence::CompareKind
760 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
761 const StandardConversionSequence& SCS2);
762
Douglas Gregor57373262008-10-22 14:17:15 +0000763 ImplicitConversionSequence::CompareKind
764 CompareQualificationConversions(const StandardConversionSequence& SCS1,
765 const StandardConversionSequence& SCS2);
766
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000767 ImplicitConversionSequence::CompareKind
768 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
769 const StandardConversionSequence& SCS2);
770
Douglas Gregor225c41e2008-11-03 19:09:14 +0000771 ImplicitConversionSequence
772 TryCopyInitialization(Expr* From, QualType ToType,
Anders Carlsson7b361b52009-08-27 17:37:39 +0000773 bool SuppressUserConversions, bool ForceRValue,
774 bool InOverloadResolution);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000775 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000776 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000777
Douglas Gregor96176b32008-11-18 23:14:02 +0000778 ImplicitConversionSequence
779 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
780 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
781
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000782 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
783 bool PerformContextuallyConvertToBool(Expr *&From);
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000784
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000785 bool PerformObjectMemberConversion(Expr *&From, NamedDecl *Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000786
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000787 /// OverloadingResult - Capture the result of performing overload
788 /// resolution.
789 enum OverloadingResult {
790 OR_Success, ///< Overload resolution succeeded.
791 OR_No_Viable_Function, ///< No viable function found.
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000792 OR_Ambiguous, ///< Ambiguous candidates found.
793 OR_Deleted ///< Overload resoltuion refers to a deleted function.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000794 };
795
John McCall6ff07852009-08-07 22:18:02 +0000796 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
797 // TODO: make this is a typesafe union.
798 typedef llvm::SmallPtrSet<DeclContext *, 16> AssociatedNamespaceSet;
799
Douglas Gregor364e0212009-06-27 21:05:07 +0000800 typedef llvm::SmallPtrSet<AnyFunctionDecl, 16> FunctionSet;
Douglas Gregor063daf62009-03-13 18:40:31 +0000801 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
802
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000803 void AddOverloadCandidate(FunctionDecl *Function,
804 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000805 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000806 bool SuppressUserConversions = false,
807 bool ForceRValue = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000808 void AddFunctionCandidates(const FunctionSet &Functions,
809 Expr **Args, unsigned NumArgs,
810 OverloadCandidateSet& CandidateSet,
811 bool SuppressUserConversions = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000812 void AddMethodCandidate(CXXMethodDecl *Method,
813 Expr *Object, Expr **Args, unsigned NumArgs,
814 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000815 bool SuppressUserConversions = false,
816 bool ForceRValue = false);
Douglas Gregor6b906862009-08-21 00:16:32 +0000817 void AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl,
818 bool HasExplicitTemplateArgs,
819 const TemplateArgument *ExplicitTemplateArgs,
820 unsigned NumExplicitTemplateArgs,
821 Expr *Object, Expr **Args, unsigned NumArgs,
822 OverloadCandidateSet& CandidateSet,
823 bool SuppressUserConversions = false,
824 bool ForceRValue = false);
Douglas Gregore53060f2009-06-25 22:08:12 +0000825 void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor6db8ed42009-06-30 23:57:56 +0000826 bool HasExplicitTemplateArgs,
827 const TemplateArgument *ExplicitTemplateArgs,
828 unsigned NumExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +0000829 Expr **Args, unsigned NumArgs,
830 OverloadCandidateSet& CandidateSet,
831 bool SuppressUserConversions = false,
832 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000833 void AddConversionCandidate(CXXConversionDecl *Conversion,
834 Expr *From, QualType ToType,
835 OverloadCandidateSet& CandidateSet);
Douglas Gregor65ec1fd2009-08-21 23:19:43 +0000836 void AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate,
837 Expr *From, QualType ToType,
838 OverloadCandidateSet &CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000839 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000840 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000841 Expr *Object, Expr **Args, unsigned NumArgs,
842 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000843 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000844 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000845 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000846 OverloadCandidateSet& CandidateSet,
847 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000848 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
849 SourceLocation OpLoc,
850 Expr **Args, unsigned NumArgs,
851 OverloadCandidateSet& CandidateSet,
852 SourceRange OpRange = SourceRange());
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000853 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
854 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000855 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000856 bool IsAssignmentOperator = false,
857 unsigned NumContextualBoolArguments = 0);
Douglas Gregor74253732008-11-19 15:42:04 +0000858 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
859 Expr **Args, unsigned NumArgs,
860 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000861 void AddArgumentDependentLookupCandidates(DeclarationName Name,
862 Expr **Args, unsigned NumArgs,
863 OverloadCandidateSet& CandidateSet);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000864 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
865 const OverloadCandidate& Cand2);
866 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
Douglas Gregore0762c92009-06-19 23:52:42 +0000867 SourceLocation Loc,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000868 OverloadCandidateSet::iterator& Best);
869 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
870 bool OnlyViable);
871
Douglas Gregor904eed32008-11-10 20:40:00 +0000872 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
873 bool Complain);
874 void FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
875
Douglas Gregor17330012009-02-04 15:01:18 +0000876 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn, NamedDecl *Callee,
877 DeclarationName UnqualifiedName,
Douglas Gregor6db8ed42009-06-30 23:57:56 +0000878 bool HasExplicitTemplateArgs,
879 const TemplateArgument *ExplicitTemplateArgs,
880 unsigned NumExplicitTemplateArgs,
Douglas Gregor0a396682008-11-26 06:01:48 +0000881 SourceLocation LParenLoc,
882 Expr **Args, unsigned NumArgs,
883 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +0000884 SourceLocation RParenLoc,
Douglas Gregor17330012009-02-04 15:01:18 +0000885 bool &ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +0000886
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000887 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
888 unsigned Opc,
889 FunctionSet &Functions,
890 ExprArg input);
891
Douglas Gregor063daf62009-03-13 18:40:31 +0000892 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
893 unsigned Opc,
894 FunctionSet &Functions,
895 Expr *LHS, Expr *RHS);
896
Douglas Gregor88a35142008-12-22 05:46:06 +0000897 ExprResult
898 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
899 SourceLocation LParenLoc, Expr **Args,
900 unsigned NumArgs, SourceLocation *CommaLocs,
901 SourceLocation RParenLoc);
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000902 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +0000903 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000904 Expr **Args, unsigned NumArgs,
905 SourceLocation *CommaLocs,
906 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000907
Douglas Gregorfe85ced2009-08-06 03:17:00 +0000908 OwningExprResult BuildOverloadedArrowExpr(Scope *S, ExprArg Base,
909 SourceLocation OpLoc);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000910
Mike Stump56925862009-07-28 22:04:01 +0000911 /// Helpers for dealing with blocks and functions.
Mike Stumpb1682c52009-07-22 23:56:57 +0000912 void CheckFallThroughForFunctionDef(Decl *D, Stmt *Body);
Mike Stump56925862009-07-28 22:04:01 +0000913 void CheckFallThroughForBlock(QualType BlockTy, Stmt *Body);
Chris Lattner04421082008-04-08 04:40:51 +0000914 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +0000915 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000916 void CheckExtraCXXDefaultArguments(Declarator &D);
Mike Stumpb1682c52009-07-22 23:56:57 +0000917 enum ControlFlowKind { NeverFallThrough = 0, MaybeFallThrough = 1,
918 AlwaysFallThrough = 2 };
919 ControlFlowKind CheckFallThrough(Stmt *);
Reid Spencer5f016e22007-07-11 17:01:13 +0000920
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000921 Scope *getNonFieldDeclScope(Scope *S);
922
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000923 /// \name Name lookup
924 ///
925 /// These routines provide name lookup that is used during semantic
926 /// analysis to resolve the various kinds of names (identifiers,
927 /// overloaded operator names, constructor names, etc.) into zero or
928 /// more declarations within a particular scope. The major entry
929 /// points are LookupName, which performs unqualified name lookup,
930 /// and LookupQualifiedName, which performs qualified name lookup.
931 ///
932 /// All name lookup is performed based on some specific criteria,
933 /// which specify what names will be visible to name lookup and how
934 /// far name lookup should work. These criteria are important both
935 /// for capturing language semantics (certain lookups will ignore
936 /// certain names, for example) and for performance, since name
937 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000938 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000939 ///
940 /// The results of name lookup can vary based on the kind of name
941 /// lookup performed, the current language, and the translation
942 /// unit. In C, for example, name lookup will either return nothing
943 /// (no entity found) or a single declaration. In C++, name lookup
944 /// can additionally refer to a set of overloaded functions or
945 /// result in an ambiguity. All of the possible results of name
946 /// lookup are captured by the LookupResult class, which provides
947 /// the ability to distinguish among them.
948 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +0000949
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000950 /// @brief Describes the kind of name lookup to perform.
951 enum LookupNameKind {
952 /// Ordinary name lookup, which finds ordinary names (functions,
953 /// variables, typedefs, etc.) in C and most kinds of names
954 /// (functions, variables, members, types, etc.) in C++.
955 LookupOrdinaryName = 0,
956 /// Tag name lookup, which finds the names of enums, classes,
957 /// structs, and unions.
958 LookupTagName,
959 /// Member name lookup, which finds the names of
960 /// class/struct/union members.
961 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000962 // Look up of an operator name (e.g., operator+) for use with
963 // operator overloading. This lookup is similar to ordinary name
964 // lookup, but will ignore any declarations that are class
965 // members.
966 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000967 /// Look up of a name that precedes the '::' scope resolution
968 /// operator in C++. This lookup completely ignores operator,
969 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
970 LookupNestedNameSpecifierName,
971 /// Look up a namespace name within a C++ using directive or
972 /// namespace alias definition, ignoring non-namespace names (C++
973 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000974 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +0000975 /// Look up an ordinary name that is going to be redeclared as a
976 /// name with linkage. This lookup ignores any declarations that
977 /// are outside of the current scope unless they have linkage. See
978 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
979 LookupRedeclarationWithLinkage,
980 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000981 LookupObjCProtocolName,
982 /// Look up the name of an Objective-C implementation
983 LookupObjCImplementationName,
984 /// Look up the name of an Objective-C category implementation
985 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000986 };
987
988 /// @brief Represents the results of name lookup.
989 ///
990 /// An instance of the LookupResult class captures the results of a
991 /// single name lookup, which can return no result (nothing found),
992 /// a single declaration, a set of overloaded functions, or an
993 /// ambiguity. Use the getKind() method to determine which of these
994 /// results occurred for a given lookup.
995 ///
996 /// Any non-ambiguous lookup can be converted into a single
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000997 /// (possibly NULL) @c NamedDecl* via a conversion function or the
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000998 /// getAsDecl() method. This conversion permits the common-case
999 /// usage in C and Objective-C where name lookup will always return
1000 /// a single declaration.
Douglas Gregor69d993a2009-01-17 01:13:24 +00001001 struct LookupResult {
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001002 /// The kind of entity that is actually stored within the
1003 /// LookupResult object.
Douglas Gregor69d993a2009-01-17 01:13:24 +00001004 enum {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001005 /// First is a single declaration (a NamedDecl*), which may be NULL.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001006 SingleDecl,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001007
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001008 /// First is a single declaration (an OverloadedFunctionDecl*).
1009 OverloadedDeclSingleDecl,
1010
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001011 /// [First, Last) is an iterator range represented as opaque
1012 /// pointers used to reconstruct IdentifierResolver::iterators.
1013 OverloadedDeclFromIdResolver,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001014
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001015 /// [First, Last) is an iterator range represented as opaque
1016 /// pointers used to reconstruct DeclContext::lookup_iterators.
1017 OverloadedDeclFromDeclContext,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001018
1019 /// First is a pointer to a BasePaths structure, which is owned
1020 /// by the LookupResult. Last is non-zero to indicate that the
1021 /// ambiguity is caused by two names found in base class
1022 /// subobjects of different types.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001023 AmbiguousLookupStoresBasePaths,
1024
1025 /// [First, Last) is an iterator range represented as opaque
1026 /// pointers used to reconstruct new'ed Decl*[] array containing
1027 /// found ambiguous decls. LookupResult is owner of this array.
1028 AmbiguousLookupStoresDecls
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001029 } StoredKind;
1030
1031 /// The first lookup result, whose contents depend on the kind of
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001032 /// lookup result. This may be a NamedDecl* (if StoredKind ==
1033 /// SingleDecl), OverloadedFunctionDecl* (if StoredKind ==
1034 /// OverloadedDeclSingleDecl), the opaque pointer from an
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001035 /// IdentifierResolver::iterator (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +00001036 /// OverloadedDeclFromIdResolver), a DeclContext::lookup_iterator
1037 /// (if StoredKind == OverloadedDeclFromDeclContext), or a
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001038 /// BasePaths pointer (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001039 mutable uintptr_t First;
1040
1041 /// The last lookup result, whose contents depend on the kind of
1042 /// lookup result. This may be unused (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +00001043 /// SingleDecl), it may have the same type as First (for
1044 /// overloaded function declarations), or is may be used as a
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001045 /// Boolean value (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001046 mutable uintptr_t Last;
1047
1048 /// Context - The context in which we will build any
1049 /// OverloadedFunctionDecl nodes needed by the conversion to
1050 /// Decl*.
1051 ASTContext *Context;
1052
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001053 /// @brief The kind of entity found by name lookup.
1054 enum LookupKind {
1055 /// @brief No entity found met the criteria.
1056 NotFound = 0,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001057
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001058 /// @brief Name lookup found a single declaration that met the
Douglas Gregor7176fff2009-01-15 00:26:24 +00001059 /// criteria. getAsDecl will return this declaration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001060 Found,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001061
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001062 /// @brief Name lookup found a set of overloaded functions that
Douglas Gregor7176fff2009-01-15 00:26:24 +00001063 /// met the criteria. getAsDecl will turn this set of overloaded
1064 /// functions into an OverloadedFunctionDecl.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001065 FoundOverloaded,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001066
1067 /// Name lookup results in an ambiguity because multiple
1068 /// entities that meet the lookup criteria were found in
1069 /// subobjects of different types. For example:
1070 /// @code
1071 /// struct A { void f(int); }
1072 /// struct B { void f(double); }
1073 /// struct C : A, B { };
1074 /// void test(C c) {
1075 /// c.f(0); // error: A::f and B::f come from subobjects of different
1076 /// // types. overload resolution is not performed.
1077 /// }
1078 /// @endcode
1079 AmbiguousBaseSubobjectTypes,
1080
1081 /// Name lookup results in an ambiguity because multiple
1082 /// nonstatic entities that meet the lookup criteria were found
1083 /// in different subobjects of the same type. For example:
1084 /// @code
1085 /// struct A { int x; };
1086 /// struct B : A { };
1087 /// struct C : A { };
1088 /// struct D : B, C { };
1089 /// int test(D d) {
1090 /// return d.x; // error: 'x' is found in two A subobjects (of B and C)
1091 /// }
1092 /// @endcode
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001093 AmbiguousBaseSubobjects,
1094
1095 /// Name lookup results in an ambiguity because multiple definitions
1096 /// of entity that meet the lookup criteria were found in different
1097 /// declaration contexts.
1098 /// @code
1099 /// namespace A {
1100 /// int i;
1101 /// namespace B { int i; }
1102 /// int test() {
1103 /// using namespace B;
1104 /// return i; // error 'i' is found in namespace A and A::B
1105 /// }
1106 /// }
1107 /// @endcode
1108 AmbiguousReference
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001109 };
1110
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001111 static LookupResult CreateLookupResult(ASTContext &Context, NamedDecl *D);
Douglas Gregor4bb64e72009-01-15 02:19:31 +00001112
Douglas Gregor69d993a2009-01-17 01:13:24 +00001113 static LookupResult CreateLookupResult(ASTContext &Context,
1114 IdentifierResolver::iterator F,
1115 IdentifierResolver::iterator L);
Douglas Gregor7176fff2009-01-15 00:26:24 +00001116
Douglas Gregor69d993a2009-01-17 01:13:24 +00001117 static LookupResult CreateLookupResult(ASTContext &Context,
1118 DeclContext::lookup_iterator F,
1119 DeclContext::lookup_iterator L);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001120
Douglas Gregor69d993a2009-01-17 01:13:24 +00001121 static LookupResult CreateLookupResult(ASTContext &Context, BasePaths *Paths,
1122 bool DifferentSubobjectTypes) {
1123 LookupResult Result;
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001124 Result.StoredKind = AmbiguousLookupStoresBasePaths;
Douglas Gregor69d993a2009-01-17 01:13:24 +00001125 Result.First = reinterpret_cast<uintptr_t>(Paths);
1126 Result.Last = DifferentSubobjectTypes? 1 : 0;
1127 Result.Context = &Context;
1128 return Result;
1129 }
Douglas Gregor4bb64e72009-01-15 02:19:31 +00001130
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001131 template <typename Iterator>
1132 static LookupResult CreateLookupResult(ASTContext &Context,
1133 Iterator B, std::size_t Len) {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001134 NamedDecl ** Array = new NamedDecl*[Len];
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001135 for (std::size_t Idx = 0; Idx < Len; ++Idx, ++B)
1136 Array[Idx] = *B;
1137 LookupResult Result;
1138 Result.StoredKind = AmbiguousLookupStoresDecls;
1139 Result.First = reinterpret_cast<uintptr_t>(Array);
1140 Result.Last = reinterpret_cast<uintptr_t>(Array + Len);
1141 Result.Context = &Context;
1142 return Result;
1143 }
1144
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001145 LookupKind getKind() const;
1146
1147 /// @brief Determine whether name look found something.
1148 operator bool() const { return getKind() != NotFound; }
1149
Douglas Gregor7176fff2009-01-15 00:26:24 +00001150 /// @brief Determines whether the lookup resulted in an ambiguity.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001151 bool isAmbiguous() const {
1152 return StoredKind == AmbiguousLookupStoresBasePaths ||
1153 StoredKind == AmbiguousLookupStoresDecls;
1154 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001155
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001156 /// @brief Allows conversion of a lookup result into a
1157 /// declaration, with the same behavior as getAsDecl.
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001158 operator NamedDecl*() const { return getAsDecl(); }
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001159
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001160 NamedDecl* getAsDecl() const;
Douglas Gregor7176fff2009-01-15 00:26:24 +00001161
1162 BasePaths *getBasePaths() const;
Douglas Gregord8635172009-02-02 21:35:47 +00001163
1164 /// \brief Iterate over the results of name lookup.
1165 ///
1166 /// The @c iterator class provides iteration over the results of a
1167 /// non-ambiguous name lookup.
1168 class iterator {
1169 /// The LookupResult structure we're iterating through.
1170 LookupResult *Result;
1171
1172 /// The current position of this iterator within the sequence of
1173 /// results. This value will have the same representation as the
1174 /// @c First field in the LookupResult structure.
1175 mutable uintptr_t Current;
1176
1177 public:
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001178 typedef NamedDecl * value_type;
1179 typedef NamedDecl * reference;
1180 typedef NamedDecl * pointer;
Douglas Gregord8635172009-02-02 21:35:47 +00001181 typedef std::ptrdiff_t difference_type;
1182 typedef std::forward_iterator_tag iterator_category;
1183
1184 iterator() : Result(0), Current(0) { }
1185
1186 iterator(LookupResult *Res, uintptr_t Cur) : Result(Res), Current(Cur) { }
1187
1188 reference operator*() const;
1189
1190 pointer operator->() const { return **this; }
1191
1192 iterator &operator++();
1193
1194 iterator operator++(int) {
1195 iterator tmp(*this);
1196 ++(*this);
1197 return tmp;
1198 }
1199
1200 friend inline bool operator==(iterator const& x, iterator const& y) {
1201 return x.Current == y.Current;
1202 }
1203
1204 friend inline bool operator!=(iterator const& x, iterator const& y) {
1205 return x.Current != y.Current;
1206 }
1207 };
1208 friend class iterator;
1209
1210 iterator begin();
1211 iterator end();
Douglas Gregor31a19b62009-04-01 21:51:26 +00001212
1213 /// \brief Free the memory associated with this lookup.
1214 void Destroy();
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001215 };
1216
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001217private:
1218 typedef llvm::SmallVector<LookupResult, 3> LookupResultsVecTy;
1219
1220 std::pair<bool, LookupResult> CppLookupName(Scope *S, DeclarationName Name,
1221 LookupNameKind NameKind,
1222 bool RedeclarationOnly);
Fariborz Jahanianef79bc92009-04-07 18:28:06 +00001223 ObjCMethodDecl *FindMethodInNestedImplementations(
1224 const ObjCInterfaceDecl *IFace,
1225 const Selector &Sel);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001226
1227public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001228 /// Determines whether D is a suitable lookup result according to the
1229 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001230 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001231 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001232 switch (NameKind) {
1233 case Sema::LookupOrdinaryName:
1234 case Sema::LookupTagName:
1235 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001236 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001237 case Sema::LookupObjCProtocolName:
1238 case Sema::LookupObjCImplementationName:
1239 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001240 return D->isInIdentifierNamespace(IDNS);
1241
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001242 case Sema::LookupOperatorName:
1243 return D->isInIdentifierNamespace(IDNS) &&
1244 !D->getDeclContext()->isRecord();
1245
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001246 case Sema::LookupNestedNameSpecifierName:
1247 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
1248
1249 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001250 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001251 }
1252
1253 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001254 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001255 return false;
1256 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001257
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001258 LookupResult LookupName(Scope *S, DeclarationName Name,
1259 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001260 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001261 bool AllowBuiltinCreation = false,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001262 SourceLocation Loc = SourceLocation());
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001263 LookupResult LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
1264 LookupNameKind NameKind,
1265 bool RedeclarationOnly = false);
John McCall67d1a672009-08-06 02:15:43 +00001266 Decl *LookupQualifiedNameWithType(DeclContext *LookupCtx,
1267 DeclarationName Name,
1268 QualType T);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001269 LookupResult LookupParsedName(Scope *S, const CXXScopeSpec *SS,
1270 DeclarationName Name,
1271 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001272 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001273 bool AllowBuiltinCreation = false,
Douglas Gregor495c35d2009-08-25 22:51:20 +00001274 SourceLocation Loc = SourceLocation(),
1275 bool EnteringContext = false);
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001276
Douglas Gregor6e378de2009-04-23 23:18:26 +00001277 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001278 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001279
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001280 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
1281 QualType T1, QualType T2,
1282 FunctionSet &Functions);
1283
1284 void ArgumentDependentLookup(DeclarationName Name,
1285 Expr **Args, unsigned NumArgs,
1286 FunctionSet &Functions);
1287
Douglas Gregorfa047642009-02-04 00:32:51 +00001288 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1289 AssociatedNamespaceSet &AssociatedNamespaces,
John McCall6ff07852009-08-07 22:18:02 +00001290 AssociatedClassSet &AssociatedClasses);
Douglas Gregorfa047642009-02-04 00:32:51 +00001291
Douglas Gregor7176fff2009-01-15 00:26:24 +00001292 bool DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
1293 SourceLocation NameLoc,
1294 SourceRange LookupRange = SourceRange());
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001295 //@}
1296
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001297 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001298 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001299 Scope *S, bool ForRedeclaration,
1300 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001301 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1302 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001303 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001304
1305 // More parsing and symbol table subroutines.
1306
Reid Spencer5f016e22007-07-11 17:01:13 +00001307 // Decl attributes - this routine is the top level dispatcher.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001308 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
1309 void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001310
Steve Naroff3c2eb662008-02-10 21:38:56 +00001311 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1312 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001313 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1314 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001315
1316 NamespaceDecl *GetStdNamespace();
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001317
1318 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001319 ObjCInterfaceDecl *IDecl);
Steve Naroff3c2eb662008-02-10 21:38:56 +00001320
Chris Lattner823c44e2009-01-06 07:27:21 +00001321 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001322 /// methods declared in protocol, and those referenced by it.
1323 /// \param IDecl - Used for checking for methods which may have been
1324 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001325 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1326 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001327 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001328 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001329 const llvm::DenseSet<Selector> &ClsMap,
1330 ObjCInterfaceDecl *IDecl);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001331
Steve Naroffa5997c42007-10-02 21:43:37 +00001332 /// CheckImplementationIvars - This routine checks if the instance variables
1333 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001334 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1335 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001336 SourceLocation Loc);
Steve Naroffa5997c42007-10-02 21:43:37 +00001337
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001338 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001339 /// remains unimplemented in the class or category @implementation.
1340 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1341 ObjCContainerDecl* IDecl,
1342 bool IncompleteImpl = false);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001343
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001344 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1345 /// true, or false, accordingly.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001346 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001347 const ObjCMethodDecl *PrevMethod,
1348 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001349
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001350 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1351 /// or protocol against those declared in their implementations.
1352 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1353 const llvm::DenseSet<Selector> &ClsMap,
1354 llvm::DenseSet<Selector> &InsMapSeen,
1355 llvm::DenseSet<Selector> &ClsMapSeen,
1356 ObjCImplDecl* IMPDecl,
1357 ObjCContainerDecl* IDecl,
1358 bool &IncompleteImpl,
1359 bool ImmediateClass);
1360
Steve Naroff58ff9e82007-10-14 00:58:41 +00001361 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1362 /// unit are added to a global pool. This allows us to efficiently associate
1363 /// a selector with a method declaraation for purposes of typechecking
1364 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001365 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff58ff9e82007-10-14 00:58:41 +00001366
Steve Naroff037cda52008-09-30 14:38:43 +00001367 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1368 /// there are multiple signatures.
Fariborz Jahanian835ed7f2009-08-22 21:13:55 +00001369 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R,
1370 bool warn=true);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001371
1372 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1373 /// there are multiple signatures.
1374 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Steve Naroff037cda52008-09-30 14:38:43 +00001375
Steve Naroff58ff9e82007-10-14 00:58:41 +00001376 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001377 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001378 //===--------------------------------------------------------------------===//
1379 // Statement Parsing Callbacks: SemaStmt.cpp.
1380public:
Anders Carlsson6b1d2832009-05-17 21:11:30 +00001381 virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr);
Sebastian Redla60528c2008-12-21 12:04:03 +00001382
1383 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1384 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1385 MultiStmtArg Elts,
1386 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001387 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001388 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001389 SourceLocation EndLoc);
Sebastian Redl117054a2008-12-28 16:13:43 +00001390 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1391 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001392 SourceLocation ColonLoc);
1393 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
1394
Sebastian Redl117054a2008-12-28 16:13:43 +00001395 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1396 SourceLocation ColonLoc,
1397 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001398 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1399 IdentifierInfo *II,
1400 SourceLocation ColonLoc,
1401 StmtArg SubStmt);
Anders Carlssona99fad82009-05-17 18:26:53 +00001402 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
1403 FullExprArg CondVal, StmtArg ThenVal,
1404 SourceLocation ElseLoc, StmtArg ElseVal);
Sebastian Redlde307472009-01-11 00:38:46 +00001405 virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond);
1406 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1407 StmtArg Switch, StmtArg Body);
Anders Carlsson7f537c12009-05-17 21:22:26 +00001408 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
1409 FullExprArg Cond, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001410 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
Chris Lattner98913592009-06-12 23:04:47 +00001411 SourceLocation WhileLoc,
1412 SourceLocation CondLParen, ExprArg Cond,
1413 SourceLocation CondRParen);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001414
1415 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1416 SourceLocation LParenLoc,
1417 StmtArg First, ExprArg Second,
1418 ExprArg Third, SourceLocation RParenLoc,
1419 StmtArg Body);
1420 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1421 SourceLocation LParenLoc,
1422 StmtArg First, ExprArg Second,
1423 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001424
1425 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1426 SourceLocation LabelLoc,
1427 IdentifierInfo *LabelII);
1428 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1429 SourceLocation StarLoc,
1430 ExprArg DestExp);
1431 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1432 Scope *CurScope);
1433 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1434 Scope *CurScope);
1435
1436 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Anders Carlssonf53b4432009-08-18 16:11:00 +00001437 ExprArg RetValExp);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001438 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1439 Expr *RetValExp);
1440
Sebastian Redl3037ed02009-01-18 16:53:17 +00001441 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1442 bool IsSimple,
1443 bool IsVolatile,
1444 unsigned NumOutputs,
1445 unsigned NumInputs,
1446 std::string *Names,
1447 MultiExprArg Constraints,
1448 MultiExprArg Exprs,
1449 ExprArg AsmString,
1450 MultiExprArg Clobbers,
1451 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001452
1453 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1454 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001455 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001456 StmtArg CatchList);
1457
1458 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1459 StmtArg Body);
1460
1461 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1462 StmtArg Try,
1463 StmtArg Catch, StmtArg Finally);
1464
1465 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001466 ExprArg Throw,
1467 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001468 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1469 ExprArg SynchExpr,
1470 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001471
Douglas Gregord308e622009-05-18 20:51:54 +00001472 VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001473 DeclaratorInfo *DInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00001474 IdentifierInfo *Name,
1475 SourceLocation Loc,
1476 SourceRange Range);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001477 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Douglas Gregord308e622009-05-18 20:51:54 +00001478
Sebastian Redl4b07b292008-12-22 19:15:10 +00001479 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001480 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001481 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001482 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1483 StmtArg TryBlock,
1484 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001485 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001486
Anders Carlsson636463e2009-07-30 22:17:18 +00001487 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
1488 /// whose result is unused, warn.
1489 void DiagnoseUnusedExprResult(const Stmt *S);
1490
Reid Spencer5f016e22007-07-11 17:01:13 +00001491 //===--------------------------------------------------------------------===//
1492 // Expression Parsing Callbacks: SemaExpr.cpp.
1493
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001494 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001495 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
1496 ObjCMethodDecl *Getter,
1497 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001498 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1499 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001500
Douglas Gregorac7610d2009-06-22 20:57:11 +00001501 virtual ExpressionEvaluationContext
1502 PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext);
1503
1504 virtual void
1505 PopExpressionEvaluationContext(ExpressionEvaluationContext OldContext,
1506 ExpressionEvaluationContext NewContext);
1507
Douglas Gregore0762c92009-06-19 23:52:42 +00001508 void MarkDeclarationReferenced(SourceLocation Loc, Decl *D);
1509
Reid Spencer5f016e22007-07-11 17:01:13 +00001510 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001511 virtual SourceRange getExprRange(ExprTy *E) const;
1512
Sebastian Redlcd965b92009-01-18 18:53:16 +00001513 virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
1514 IdentifierInfo &II,
1515 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001516 const CXXScopeSpec *SS = 0,
1517 bool isAddressOfOperand = false);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001518 virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001519 SourceLocation OperatorLoc,
1520 OverloadedOperatorKind Op,
1521 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001522 const CXXScopeSpec &SS,
1523 bool isAddressOfOperand);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001524 virtual OwningExprResult ActOnCXXConversionFunctionExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001525 SourceLocation OperatorLoc,
1526 TypeTy *Ty,
1527 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001528 const CXXScopeSpec &SS,
1529 bool isAddressOfOperand);
Anders Carlssone41590d2009-06-24 00:10:43 +00001530 OwningExprResult BuildDeclRefExpr(NamedDecl *D, QualType Ty,
1531 SourceLocation Loc, bool TypeDependent,
1532 bool ValueDependent,
1533 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001534 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1535 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001536 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001537 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1538 FieldDecl *Field,
1539 Expr *BaseObjectExpr = 0,
1540 SourceLocation OpLoc = SourceLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001541 OwningExprResult ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
1542 DeclarationName Name,
1543 bool HasTrailingLParen,
1544 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001545 bool isAddressOfOperand = false);
Douglas Gregor751f9a42009-06-30 15:47:41 +00001546 OwningExprResult BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D,
1547 bool HasTrailingLParen,
1548 const CXXScopeSpec *SS,
1549 bool isAddressOfOperand);
1550
Sebastian Redlcd965b92009-01-18 18:53:16 +00001551 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1552 tok::TokenKind Kind);
1553 virtual OwningExprResult ActOnNumericConstant(const Token &);
1554 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1555 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1556 ExprArg Val);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001557 virtual OwningExprResult ActOnParenListExpr(SourceLocation L,
1558 SourceLocation R,
1559 MultiExprArg Val);
1560
Steve Narofff69936d2007-09-16 03:34:24 +00001561 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001562 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001563 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1564 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001565
Reid Spencer5f016e22007-07-11 17:01:13 +00001566 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001567 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
1568 unsigned OpcIn,
1569 ExprArg InputArg);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001570 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1571 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001572
Douglas Gregorba498172009-03-13 21:01:28 +00001573 OwningExprResult CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1574 bool isSizeOf, SourceRange R);
1575 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1576 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001577 virtual OwningExprResult
1578 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1579 void *TyOrEx, const SourceRange &ArgRange);
Douglas Gregorba498172009-03-13 21:01:28 +00001580
Chris Lattner31e21e02009-01-24 20:17:12 +00001581 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001582 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1583 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001584
1585 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1586 tok::TokenKind Kind,
1587 ExprArg Input);
1588
1589 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1590 SourceLocation LLoc,
1591 ExprArg Idx,
1592 SourceLocation RLoc);
Anders Carlsson8f28f992009-08-26 18:25:21 +00001593
1594 OwningExprResult BuildMemberReferenceExpr(Scope *S, ExprArg Base,
1595 SourceLocation OpLoc,
1596 tok::TokenKind OpKind,
1597 SourceLocation MemberLoc,
1598 DeclarationName MemberName,
1599 DeclPtrTy ImplDecl,
1600 const CXXScopeSpec *SS = 0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001601 virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
1602 SourceLocation OpLoc,
1603 tok::TokenKind OpKind,
1604 SourceLocation MemberLoc,
Fariborz Jahaniana6e3ac52009-03-04 22:30:12 +00001605 IdentifierInfo &Member,
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001606 DeclPtrTy ImplDecl,
1607 const CXXScopeSpec *SS = 0);
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001608 virtual void ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001609 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001610 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001611 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001612 Expr **Args, unsigned NumArgs,
1613 SourceLocation RParenLoc);
Fariborz Jahanian87595e42009-07-23 23:32:59 +00001614 void BuildBaseOrMemberInitializers(ASTContext &C,
1615 CXXConstructorDecl *Constructor,
1616 CXXBaseOrMemberInitializer **Initializers,
1617 unsigned NumInitializers
1618 );
Sebastian Redl0eb23302009-01-19 00:08:26 +00001619
Steve Narofff69936d2007-09-16 03:34:24 +00001620 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001621 /// This provides the location of the left/right parens and a list of comma
1622 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001623 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1624 SourceLocation LParenLoc,
1625 MultiExprArg Args,
1626 SourceLocation *CommaLocs,
1627 SourceLocation RParenLoc);
1628
Nate Begeman2ef13e52009-08-10 23:49:36 +00001629 virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
1630 TypeTy *Ty, SourceLocation RParenLoc,
1631 ExprArg Op);
1632
1633 OwningExprResult MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg ME);
1634 OwningExprResult ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
1635 SourceLocation RParenLoc, ExprArg E,
1636 QualType Ty);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001637
1638 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1639 TypeTy *Ty,
1640 SourceLocation RParenLoc,
1641 ExprArg Op);
1642
1643 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1644 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001645 SourceLocation RParenLoc);
1646
Douglas Gregor05c13a32009-01-22 00:58:24 +00001647 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1648 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001649 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001650 OwningExprResult Init);
1651
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001652 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1653 tok::TokenKind Kind,
1654 ExprArg LHS, ExprArg RHS);
1655 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1656 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001657
Steve Narofff69936d2007-09-16 03:34:24 +00001658 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001659 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001660 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1661 SourceLocation ColonLoc,
1662 ExprArg Cond, ExprArg LHS,
1663 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001664
Steve Naroff1b273c42007-09-16 14:56:35 +00001665 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001666 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1667 SourceLocation LabLoc,
1668 IdentifierInfo *LabelII);
1669
1670 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1671 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001672
1673 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001674 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1675 SourceLocation BuiltinLoc,
1676 SourceLocation TypeLoc,
1677 TypeTy *Arg1,
1678 OffsetOfComponent *CompPtr,
1679 unsigned NumComponents,
1680 SourceLocation RParenLoc);
1681
Steve Naroffd34e9152007-08-01 22:05:33 +00001682 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001683 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1684 TypeTy *arg1, TypeTy *arg2,
1685 SourceLocation RPLoc);
1686
Steve Naroffd04fdd52007-08-03 21:21:27 +00001687 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001688 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1689 ExprArg cond, ExprArg expr1,
1690 ExprArg expr2, SourceLocation RPLoc);
1691
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001692 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001693 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1694 ExprArg expr, TypeTy *type,
1695 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001696
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001697 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001698 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001699
Steve Naroff4eb206b2008-09-03 18:15:37 +00001700 //===------------------------- "Block" Extension ------------------------===//
1701
1702 /// ActOnBlockStart - This callback is invoked when a block literal is
1703 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001704 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001705
Steve Naroff090276f2008-10-10 01:28:17 +00001706 /// ActOnBlockArguments - This callback allows processing of block arguments.
1707 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001708 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001709
Steve Naroff4eb206b2008-09-03 18:15:37 +00001710 /// ActOnBlockError - If there is an error parsing a block, this callback
1711 /// is invoked to pop the information about the block from the action impl.
1712 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001713
Steve Naroff4eb206b2008-09-03 18:15:37 +00001714 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1715 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001716 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1717 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001718
Chris Lattner76a642f2009-02-15 22:43:40 +00001719 //===---------------------------- C++ Features --------------------------===//
1720
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001721 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001722 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1723 IdentifierInfo *Ident,
1724 SourceLocation LBrace);
1725 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001726
Chris Lattnerb28317a2009-03-28 19:18:32 +00001727 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1728 SourceLocation UsingLoc,
1729 SourceLocation NamespcLoc,
1730 const CXXScopeSpec &SS,
1731 SourceLocation IdentLoc,
1732 IdentifierInfo *NamespcName,
1733 AttributeList *AttrList);
Anders Carlssondbb00942009-03-28 05:27:17 +00001734
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001735 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1736
Chris Lattnerb28317a2009-03-28 19:18:32 +00001737 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001738 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001739 SourceLocation AliasLoc,
1740 IdentifierInfo *Alias,
1741 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001742 SourceLocation IdentLoc,
1743 IdentifierInfo *Ident);
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001744
Anders Carlssonc72160b2009-08-28 05:40:36 +00001745 NamedDecl *BuildUsingDeclaration(SourceLocation UsingLoc,
1746 const CXXScopeSpec &SS,
1747 SourceLocation IdentLoc,
1748 DeclarationName Name,
1749 AttributeList *AttrList,
1750 bool IsTypeName);
1751
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001752 virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope,
Anders Carlsson595adc12009-08-29 19:54:19 +00001753 AccessSpecifier AS,
Anders Carlssonc72160b2009-08-28 05:40:36 +00001754 SourceLocation UsingLoc,
1755 const CXXScopeSpec &SS,
1756 SourceLocation IdentLoc,
1757 IdentifierInfo *TargetName,
1758 OverloadedOperatorKind Op,
1759 AttributeList *AttrList,
1760 bool IsTypeName);
Anders Carlssondbb00942009-03-28 05:27:17 +00001761
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001762 /// AddCXXDirectInitializerToDecl - This action is called immediately after
1763 /// ActOnDeclarator, when a C++ direct initializer is present.
1764 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001765 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001766 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001767 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001768 SourceLocation *CommaLocs,
1769 SourceLocation RParenLoc);
1770
Anders Carlsson49d44012009-04-24 05:16:06 +00001771 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1772 /// and sets it as the initializer for the the passed in VarDecl.
Anders Carlssonfe2de492009-08-25 05:18:00 +00001773 bool InitializeVarWithConstructor(VarDecl *VD,
Anders Carlsson930e8d02009-04-16 23:50:50 +00001774 CXXConstructorDecl *Constructor,
1775 QualType DeclInitType,
1776 Expr **Exprs, unsigned NumExprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001777
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001778 OwningExprResult BuildCXXConstructExpr(QualType DeclInitType,
1779 CXXConstructorDecl *Constructor,
1780 Expr **Exprs, unsigned NumExprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001781
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00001782 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
1783 /// including handling of its default argument expressions.
Anders Carlssonda3f4e22009-08-25 05:12:04 +00001784 OwningExprResult BuildCXXConstructExpr(QualType DeclInitType,
1785 CXXConstructorDecl *Constructor,
1786 bool Elidable,
1787 Expr **Exprs, unsigned NumExprs);
Anders Carlsson089c2602009-08-15 23:41:35 +00001788
Anders Carlssone7624a72009-08-27 05:08:22 +00001789 OwningExprResult BuildCXXTemporaryObjectExpr(CXXConstructorDecl *Cons,
1790 QualType writtenTy,
1791 SourceLocation tyBeginLoc,
1792 MultiExprArg Args,
1793 SourceLocation rParenLoc);
1794
Anders Carlsson56c5e332009-08-25 03:49:14 +00001795 /// BuildCXXDefaultArgExpr - Creates a CXXDefaultArgExpr, instantiating
1796 /// the default expr if needed.
1797 OwningExprResult BuildCXXDefaultArgExpr(SourceLocation CallLoc,
1798 FunctionDecl *FD,
1799 ParmVarDecl *Param);
1800
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00001801 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
1802 /// constructed variable.
1803 void FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001804
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001805 /// DefineImplicitDefaultConstructor - Checks for feasibility of
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001806 /// defining this constructor as the default constructor.
1807 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1808 CXXConstructorDecl *Constructor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001809
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00001810 /// DefineImplicitDestructor - Checks for feasibility of
1811 /// defining this destructor as the default destructor.
1812 void DefineImplicitDestructor(SourceLocation CurrentLocation,
1813 CXXDestructorDecl *Destructor);
1814
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001815 /// DefineImplicitCopyConstructor - Checks for feasibility of
1816 /// defining this constructor as the copy constructor.
1817 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
1818 CXXConstructorDecl *Constructor,
1819 unsigned TypeQuals);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001820
1821 /// DefineImplicitOverloadedAssign - Checks for feasibility of
1822 /// defining implicit this overloaded assignment operator.
1823 void DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
1824 CXXMethodDecl *MethodDecl);
1825
1826 /// getAssignOperatorMethod - Returns the default copy assignmment operator
1827 /// for the class.
1828 CXXMethodDecl *getAssignOperatorMethod(ParmVarDecl *Decl,
1829 CXXRecordDecl *ClassDecl);
Anders Carlssondef11992009-05-30 20:36:53 +00001830
1831 /// MaybeBindToTemporary - If the passed in expression has a record type with
1832 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
1833 /// it simply returns the passed in expression.
1834 OwningExprResult MaybeBindToTemporary(Expr *E);
Anders Carlssonb27615a2009-05-30 22:47:03 +00001835
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001836 /// InitializationKind - Represents which kind of C++ initialization
1837 /// [dcl.init] a routine is to perform.
1838 enum InitializationKind {
1839 IK_Direct, ///< Direct initialization
1840 IK_Copy, ///< Copy initialization
1841 IK_Default ///< Default initialization
1842 };
1843
Douglas Gregor18fe5682008-11-03 20:45:27 +00001844 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001845 PerformInitializationByConstructor(QualType ClassType,
1846 Expr **Args, unsigned NumArgs,
1847 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001848 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001849 InitializationKind Kind);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001850
Douglas Gregor49badde2008-10-27 19:41:14 +00001851 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001852 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1853 tok::TokenKind Kind,
1854 SourceLocation LAngleBracketLoc,
1855 TypeTy *Ty,
1856 SourceLocation RAngleBracketLoc,
1857 SourceLocation LParenLoc,
1858 ExprArg E,
1859 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001860
Sebastian Redlf53597f2009-03-15 17:47:39 +00001861 /// ActOnCXXTypeid - Parse typeid( something ).
1862 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1863 SourceLocation LParenLoc, bool isType,
1864 void *TyOrExpr,
1865 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001866
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001867 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001868 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001869
Steve Naroff1b273c42007-09-16 14:56:35 +00001870 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001871 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1872 tok::TokenKind Kind);
1873
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001874 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1875 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1876
Chris Lattner50dd2892008-02-26 00:51:44 +00001877 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001878 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1879 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001880 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001881
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001882 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1883 /// Can be interpreted either as function-style casting ("int(x)")
1884 /// or class type construction ("ClassType(x,y,z)")
1885 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001886 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1887 TypeTy *TypeRep,
1888 SourceLocation LParenLoc,
1889 MultiExprArg Exprs,
1890 SourceLocation *CommaLocs,
1891 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001892
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001893 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001894 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1895 SourceLocation PlacementLParen,
1896 MultiExprArg PlacementArgs,
1897 SourceLocation PlacementRParen,
1898 bool ParenTypeId, Declarator &D,
1899 SourceLocation ConstructorLParen,
1900 MultiExprArg ConstructorArgs,
1901 SourceLocation ConstructorRParen);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001902 OwningExprResult BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
1903 SourceLocation PlacementLParen,
1904 MultiExprArg PlacementArgs,
1905 SourceLocation PlacementRParen,
1906 bool ParenTypeId,
1907 QualType AllocType,
1908 SourceLocation TypeLoc,
1909 SourceRange TypeRange,
1910 ExprArg ArraySize,
1911 SourceLocation ConstructorLParen,
1912 MultiExprArg ConstructorArgs,
1913 SourceLocation ConstructorRParen);
1914
1915 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1916 SourceRange R);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001917 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1918 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001919 Expr **PlaceArgs, unsigned NumPlaceArgs,
1920 FunctionDecl *&OperatorNew,
1921 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001922 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1923 DeclarationName Name, Expr** Args,
1924 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001925 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001926 void DeclareGlobalNewDelete();
1927 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1928 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001929
1930 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001931 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1932 bool UseGlobal, bool ArrayForm,
1933 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001934
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001935 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
1936 /// C++ if/switch/while/for statement.
1937 /// e.g: "if (int x = f()) {...}"
Sebastian Redlf53597f2009-03-15 17:47:39 +00001938 virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001939 SourceLocation StartLoc,
1940 Declarator &D,
1941 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001942 ExprArg AssignExprVal);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001943
Sebastian Redl64b45f72009-01-05 20:52:13 +00001944 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1945 /// pseudo-functions.
1946 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1947 SourceLocation KWLoc,
1948 SourceLocation LParen,
1949 TypeTy *Ty,
1950 SourceLocation RParen);
Anders Carlsson3aa4ca42009-08-26 17:36:19 +00001951
Anders Carlssonec773872009-08-25 23:46:41 +00001952 virtual OwningExprResult
Anders Carlsson3aa4ca42009-08-26 17:36:19 +00001953 ActOnDestructorReferenceExpr(Scope *S, ExprArg Base,
Anders Carlssonec773872009-08-25 23:46:41 +00001954 SourceLocation OpLoc,
1955 tok::TokenKind OpKind,
1956 SourceLocation ClassNameLoc,
1957 IdentifierInfo *ClassName,
1958 const CXXScopeSpec *SS = 0);
1959
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001960 /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is
1961 /// non-empty, will create a new CXXExprWithTemporaries expression.
1962 /// Otherwise, just returs the passed in expression.
Anders Carlssonf54741e2009-06-16 03:37:31 +00001963 Expr *MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1964 bool ShouldDestroyTemporaries);
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001965
Anders Carlsson165a0a02009-05-17 18:41:29 +00001966 virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr);
1967
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001968 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001969
Douglas Gregorf59a56e2009-07-21 23:53:31 +00001970 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
1971 bool EnteringContext = false);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001972 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001973 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1974 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001975
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001976 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1977 /// global scope ('::').
1978 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1979 SourceLocation CCLoc);
1980
1981 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1982 /// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
1983 /// we want to resolve "bar::". 'SS' is empty or the previously parsed
1984 /// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
1985 /// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
1986 /// Returns a CXXScopeTy* object representing the C++ scope.
1987 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1988 const CXXScopeSpec &SS,
1989 SourceLocation IdLoc,
1990 SourceLocation CCLoc,
Douglas Gregor495c35d2009-08-25 22:51:20 +00001991 IdentifierInfo &II,
1992 bool EnteringContext);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001993
Douglas Gregor39a8de12009-02-25 19:37:18 +00001994 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1995 /// nested-name-specifier that involves a template-id, e.g.,
1996 /// "foo::bar<int, float>::", and now we need to build a scope
1997 /// specifier. \p SS is empty or the previously parsed nested-name
1998 /// part ("foo::"), \p Type is the already-parsed class template
1999 /// specialization (or other template-id that names a type), \p
2000 /// TypeRange is the source range where the type is located, and \p
2001 /// CCLoc is the location of the trailing '::'.
2002 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
2003 const CXXScopeSpec &SS,
2004 TypeTy *Type,
2005 SourceRange TypeRange,
2006 SourceLocation CCLoc);
2007
Douglas Gregorfe85ced2009-08-06 03:17:00 +00002008 /// ActOnCXXEnterMemberScope - Called when a C++ class member accessor ('.'
2009 /// or '->') is parsed. After this method is called, according to
2010 /// [C++ 3.4.5p4], qualified-ids should be looked up in the contexts of both
2011 /// the entire postfix-expression and the scope of the class of the object
2012 /// expression.
2013 /// 'SS' should be an empty CXXScopeSpec to be filled with the class's scope.
2014 virtual OwningExprResult ActOnCXXEnterMemberScope(Scope *S, CXXScopeSpec &SS,
2015 ExprArg Base,
2016 tok::TokenKind OpKind);
2017
2018 /// ActOnCXXExitMemberScope - Called when a postfix-expression that previously
2019 /// invoked ActOnCXXEnterMemberScope() is finished. 'SS' is the same
2020 /// CXXScopeSpec that was passed to ActOnCXXEnterMemberScope. Used to
2021 /// indicate that names should revert to being looked up in the defining
2022 /// scope.
2023 virtual void ActOnCXXExitMemberScope(Scope *S, const CXXScopeSpec &SS);
2024
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002025 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
2026 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
2027 /// After this method is called, according to [C++ 3.4.3p3], names should be
2028 /// looked up in the declarator-id's scope, until the declarator is parsed and
2029 /// ActOnCXXExitDeclaratorScope is called.
2030 /// The 'SS' should be a non-empty valid CXXScopeSpec.
2031 virtual void ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
2032
2033 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
2034 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
2035 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
2036 /// Used to indicate that names should revert to being looked up in the
2037 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00002038 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00002039
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00002040 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
2041 /// initializer for the declaration 'Dcl'.
2042 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
2043 /// static data member of class X, names should be looked up in the scope of
2044 /// class X.
2045 virtual void ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl);
2046
2047 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
2048 /// initializer for the declaration 'Dcl'.
2049 virtual void ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl);
2050
Anders Carlsson55085182007-08-21 17:43:55 +00002051 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00002052 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
2053 ExprTy **Strings,
2054 unsigned NumStrings);
Anders Carlssonfc0f0212009-06-07 18:45:35 +00002055
2056 Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
2057 QualType EncodedType,
2058 SourceLocation RParenLoc);
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002059 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00002060 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002061 SourceLocation LParenLoc,
2062 TypeTy *Ty,
2063 SourceLocation RParenLoc);
2064
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002065 // ParseObjCSelectorExpression - Build selector expression for @selector
2066 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
2067 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00002068 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002069 SourceLocation LParenLoc,
2070 SourceLocation RParenLoc);
2071
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00002072 // ParseObjCProtocolExpression - Build protocol expression for @protocol
2073 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
2074 SourceLocation AtLoc,
2075 SourceLocation ProtoLoc,
2076 SourceLocation LParenLoc,
2077 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002078
2079 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00002080 // C++ Declarations
2081 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00002082 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
2083 SourceLocation ExternLoc,
2084 SourceLocation LangLoc,
2085 const char *Lang,
2086 unsigned StrSize,
2087 SourceLocation LBraceLoc);
2088 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
2089 DeclPtrTy LinkageSpec,
2090 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00002091
2092
2093 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002094 // C++ Classes
2095 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002096 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
2097 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00002098
Chris Lattnerb28317a2009-03-28 19:18:32 +00002099 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
2100 Declarator &D,
Douglas Gregor37b372b2009-08-20 22:52:58 +00002101 MultiTemplateParamsArg TemplateParameterLists,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002102 ExprTy *BitfieldWidth,
Sebastian Redle2b68332009-04-12 17:16:29 +00002103 ExprTy *Init,
2104 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002105
Chris Lattnerb28317a2009-03-28 19:18:32 +00002106 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002107 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002108 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002109 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +00002110 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002111 SourceLocation IdLoc,
2112 SourceLocation LParenLoc,
2113 ExprTy **Args, unsigned NumArgs,
2114 SourceLocation *CommaLocs,
2115 SourceLocation RParenLoc);
2116
Eli Friedman59c04372009-07-29 19:44:27 +00002117 MemInitResult BuildMemberInitializer(FieldDecl *Member, Expr **Args,
2118 unsigned NumArgs, SourceLocation IdLoc,
2119 SourceLocation RParenLoc);
2120
2121 MemInitResult BuildBaseInitializer(QualType BaseType, Expr **Args,
2122 unsigned NumArgs, SourceLocation IdLoc,
2123 SourceLocation RParenLoc,
2124 CXXRecordDecl *ClassDecl);
2125
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002126 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
2127
Chris Lattnerb28317a2009-03-28 19:18:32 +00002128 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00002129 SourceLocation ColonLoc,
2130 MemInitTy **MemInits, unsigned NumMemInits);
2131
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002132 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002133 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002134 SourceLocation LBrac,
2135 SourceLocation RBrac);
2136
Douglas Gregor6569d682009-05-27 23:11:45 +00002137 virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002138 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
2139 DeclPtrTy Method);
2140 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
2141 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
2142 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002143
Chris Lattnerb28317a2009-03-28 19:18:32 +00002144 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
2145 ExprArg AssertExpr,
2146 ExprArg AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00002147
John McCall67d1a672009-08-06 02:15:43 +00002148 virtual DeclPtrTy ActOnFriendDecl(Scope *S,
John McCall3f9a8a62009-08-11 06:59:38 +00002149 llvm::PointerUnion<const DeclSpec*,Declarator*> D,
2150 bool IsDefinition);
John McCall02cace72009-08-28 07:59:38 +00002151 DeclPtrTy ActOnFriendTypeDecl(Scope *S, const DeclSpec& DS,
2152 bool IsDefinition);
2153 DeclPtrTy ActOnFriendFunctionDecl(Scope *S, Declarator& D, bool IsDefinition);
Anders Carlsson00338362009-05-11 22:55:49 +00002154
Chris Lattner65401802009-04-25 08:28:21 +00002155 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
2156 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002157 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00002158 QualType CheckDestructorDeclarator(Declarator &D,
2159 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002160 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002161 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002162 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002163
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002164 //===--------------------------------------------------------------------===//
2165 // C++ Derived Classes
2166 //
2167
2168 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00002169 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
2170 SourceRange SpecifierRange,
2171 bool Virtual, AccessSpecifier Access,
2172 QualType BaseType,
2173 SourceLocation BaseLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002174 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002175 SourceRange SpecifierRange,
2176 bool Virtual, AccessSpecifier Access,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002177 TypeTy *basetype, SourceLocation
2178 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002179
Douglas Gregor2943aed2009-03-03 04:44:36 +00002180 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
2181 unsigned NumBases);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002182 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002183 unsigned NumBases);
2184
2185 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002186 bool IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths);
Douglas Gregor7176fff2009-01-15 00:26:24 +00002187 bool LookupInBases(CXXRecordDecl *Class, const MemberLookupCriteria& Criteria,
2188 BasePaths &Paths);
Douglas Gregor0575d4a2008-10-24 16:17:19 +00002189 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2190 SourceLocation Loc, SourceRange Range);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002191 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2192 unsigned InaccessibleBaseID,
2193 unsigned AmbigiousBaseConvID,
2194 SourceLocation Loc, SourceRange Range,
2195 DeclarationName Name);
2196
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +00002197 std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002198
Sebastian Redl23c7d062009-07-07 20:29:57 +00002199 /// CheckOverridingFunctionReturnType - Checks whether the return types are
2200 /// covariant, according to C++ [class.virtual]p5.
2201 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002202 const CXXMethodDecl *Old);
Sebastian Redl23c7d062009-07-07 20:29:57 +00002203
2204 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
2205 /// spec is a subset of base spec.
2206 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
2207 const CXXMethodDecl *Old);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002208
Anders Carlsson29f006b2009-03-27 05:05:05 +00002209 //===--------------------------------------------------------------------===//
2210 // C++ Access Control
2211 //
Sebastian Redl726212f2009-07-18 14:32:15 +00002212
Anders Carlsson29f006b2009-03-27 05:05:05 +00002213 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
2214 NamedDecl *PrevMemberDecl,
2215 AccessSpecifier LexicalAS);
Sebastian Redl726212f2009-07-18 14:32:15 +00002216
2217 const CXXBaseSpecifier *FindInaccessibleBase(QualType Derived, QualType Base,
2218 BasePaths &Paths,
2219 bool NoPrivileges = false);
2220
2221 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002222 unsigned InaccessibleBaseID,
2223 BasePaths& Paths, SourceLocation AccessLoc,
2224 DeclarationName Name);
Sebastian Redl726212f2009-07-18 14:32:15 +00002225
2226
Anders Carlsson8211eff2009-03-24 01:19:16 +00002227 enum AbstractDiagSelID {
2228 AbstractNone = -1,
2229 AbstractReturnType,
2230 AbstractParamType,
2231 AbstractVariableType,
2232 AbstractFieldType
2233 };
2234
Anders Carlssona6ec7ad2009-08-27 00:13:57 +00002235 bool RequireNonAbstractType(SourceLocation Loc, QualType T,
2236 const PartialDiagnostic &PD,
2237 const CXXRecordDecl *CurrentRD = 0);
2238
Anders Carlsson8211eff2009-03-24 01:19:16 +00002239 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00002240 AbstractDiagSelID SelID = AbstractNone,
2241 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002242
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002243 //===--------------------------------------------------------------------===//
2244 // C++ Overloaded Operators [C++ 13.5]
2245 //
2246
2247 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
2248
Douglas Gregor72c3f312008-12-05 18:15:24 +00002249 //===--------------------------------------------------------------------===//
2250 // C++ Templates [C++ 14]
2251 //
Douglas Gregorc45c2322009-03-31 00:43:58 +00002252 virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
Douglas Gregor495c35d2009-08-25 22:51:20 +00002253 const CXXScopeSpec *SS,
2254 bool EnteringContext,
2255 TemplateTy &Template);
Douglas Gregor72c3f312008-12-05 18:15:24 +00002256 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002257 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002258
Anders Carlsson941df7d2009-06-12 19:58:00 +00002259 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
2260 SourceLocation EllipsisLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002261 SourceLocation KeyLoc,
2262 IdentifierInfo *ParamName,
2263 SourceLocation ParamNameLoc,
2264 unsigned Depth, unsigned Position);
2265 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002266 SourceLocation EqualLoc,
2267 SourceLocation DefaultLoc,
2268 TypeTy *Default);
2269
Douglas Gregor2943aed2009-03-03 04:44:36 +00002270 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002271 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
2272 unsigned Depth,
2273 unsigned Position);
2274 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002275 SourceLocation EqualLoc,
2276 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002277 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
2278 SourceLocation TmpLoc,
2279 TemplateParamsTy *Params,
2280 IdentifierInfo *ParamName,
2281 SourceLocation ParamNameLoc,
2282 unsigned Depth,
2283 unsigned Position);
2284 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002285 SourceLocation EqualLoc,
2286 ExprArg Default);
2287
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002288 virtual TemplateParamsTy *
2289 ActOnTemplateParameterList(unsigned Depth,
2290 SourceLocation ExportLoc,
2291 SourceLocation TemplateLoc,
2292 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002293 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002294 SourceLocation RAngleLoc);
Douglas Gregord684b002009-02-10 19:49:53 +00002295 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
2296 TemplateParameterList *OldParams);
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002297 TemplateParameterList *
2298 MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
2299 const CXXScopeSpec &SS,
2300 TemplateParameterList **ParamLists,
2301 unsigned NumParamLists);
2302
John McCall0f434ec2009-07-31 02:45:11 +00002303 DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002304 SourceLocation KWLoc, const CXXScopeSpec &SS,
2305 IdentifierInfo *Name, SourceLocation NameLoc,
2306 AttributeList *Attr,
Douglas Gregor05396e22009-08-25 17:23:04 +00002307 TemplateParameterList *TemplateParams,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002308 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002309
Douglas Gregor7532dc62009-03-30 22:58:21 +00002310 QualType CheckTemplateIdType(TemplateName Template,
2311 SourceLocation TemplateLoc,
2312 SourceLocation LAngleLoc,
2313 const TemplateArgument *TemplateArgs,
2314 unsigned NumTemplateArgs,
2315 SourceLocation RAngleLoc);
Douglas Gregor40808ce2009-03-09 23:48:35 +00002316
Douglas Gregorcc636682009-02-17 23:15:12 +00002317 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00002318 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
2319 SourceLocation LAngleLoc,
2320 ASTTemplateArgsPtr TemplateArgs,
2321 SourceLocation *TemplateArgLocs,
2322 SourceLocation RAngleLoc);
Douglas Gregorcc636682009-02-17 23:15:12 +00002323
Douglas Gregoredce4dd2009-06-30 22:34:41 +00002324 OwningExprResult BuildTemplateIdExpr(TemplateName Template,
2325 SourceLocation TemplateNameLoc,
2326 SourceLocation LAngleLoc,
2327 const TemplateArgument *TemplateArgs,
2328 unsigned NumTemplateArgs,
2329 SourceLocation RAngleLoc);
2330
2331 virtual OwningExprResult ActOnTemplateIdExpr(TemplateTy Template,
2332 SourceLocation TemplateNameLoc,
2333 SourceLocation LAngleLoc,
2334 ASTTemplateArgsPtr TemplateArgs,
2335 SourceLocation *TemplateArgLocs,
2336 SourceLocation RAngleLoc);
2337
Douglas Gregorc45c2322009-03-31 00:43:58 +00002338 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
2339 const IdentifierInfo &Name,
2340 SourceLocation NameLoc,
2341 const CXXScopeSpec &SS);
2342
Douglas Gregor88b70942009-02-25 22:02:03 +00002343 bool CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
2344 ClassTemplateSpecializationDecl *PrevDecl,
2345 SourceLocation TemplateNameLoc,
Douglas Gregorff668032009-05-13 18:28:20 +00002346 SourceRange ScopeSpecifierRange,
Douglas Gregor16df8502009-06-12 22:21:45 +00002347 bool PartialSpecialization,
Douglas Gregorff668032009-05-13 18:28:20 +00002348 bool ExplicitInstantiation);
Douglas Gregor88b70942009-02-25 22:02:03 +00002349
Douglas Gregore94866f2009-06-12 21:21:02 +00002350 bool CheckClassTemplatePartialSpecializationArgs(
2351 TemplateParameterList *TemplateParams,
Anders Carlsson6360be72009-06-13 18:20:51 +00002352 const TemplateArgumentListBuilder &TemplateArgs,
Douglas Gregor6aa75cf2009-06-12 22:08:06 +00002353 bool &MirrorsPrimaryTemplate);
Douglas Gregore94866f2009-06-12 21:21:02 +00002354
Douglas Gregor212e81c2009-03-25 00:13:59 +00002355 virtual DeclResult
John McCall0f434ec2009-07-31 02:45:11 +00002356 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorcc636682009-02-17 23:15:12 +00002357 SourceLocation KWLoc,
2358 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00002359 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00002360 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002361 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00002362 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregorc15cb382009-02-09 23:23:08 +00002363 SourceLocation *TemplateArgLocs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002364 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002365 AttributeList *Attr,
2366 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002367
Douglas Gregore542c862009-06-23 23:11:28 +00002368 virtual DeclPtrTy ActOnTemplateDeclarator(Scope *S,
2369 MultiTemplateParamsArg TemplateParameterLists,
2370 Declarator &D);
2371
Douglas Gregor52591bf2009-06-24 00:54:41 +00002372 virtual DeclPtrTy ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
2373 MultiTemplateParamsArg TemplateParameterLists,
2374 Declarator &D);
2375
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002376 virtual DeclResult
2377 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
2378 unsigned TagSpec,
2379 SourceLocation KWLoc,
2380 const CXXScopeSpec &SS,
2381 TemplateTy Template,
2382 SourceLocation TemplateNameLoc,
2383 SourceLocation LAngleLoc,
2384 ASTTemplateArgsPtr TemplateArgs,
2385 SourceLocation *TemplateArgLocs,
2386 SourceLocation RAngleLoc,
2387 AttributeList *Attr);
2388
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002389 virtual DeclResult
2390 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
2391 unsigned TagSpec,
2392 SourceLocation KWLoc,
2393 const CXXScopeSpec &SS,
2394 IdentifierInfo *Name,
2395 SourceLocation NameLoc,
2396 AttributeList *Attr);
2397
Douglas Gregorc15cb382009-02-09 23:23:08 +00002398 bool CheckTemplateArgumentList(TemplateDecl *Template,
2399 SourceLocation TemplateLoc,
2400 SourceLocation LAngleLoc,
Douglas Gregor40808ce2009-03-09 23:48:35 +00002401 const TemplateArgument *TemplateArgs,
2402 unsigned NumTemplateArgs,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002403 SourceLocation RAngleLoc,
Douglas Gregor16134c62009-07-01 00:28:38 +00002404 bool PartialTemplateArgs,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00002405 TemplateArgumentListBuilder &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002406
Anders Carlsson436b1562009-06-13 00:33:33 +00002407 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
2408 const TemplateArgument &Arg,
2409 TemplateArgumentListBuilder &Converted);
2410
Douglas Gregorc15cb382009-02-09 23:23:08 +00002411 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg,
2412 SourceLocation ArgLoc);
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002413 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
2414 NamedDecl *&Entity);
2415 bool CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member);
Douglas Gregor2943aed2009-03-03 04:44:36 +00002416 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
2417 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor02cbbd22009-06-11 18:10:32 +00002418 TemplateArgument &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002419 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param, DeclRefExpr *Arg);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002420 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
2421 TemplateParameterList *Old,
2422 bool Complain,
Douglas Gregordd0574e2009-02-10 00:24:35 +00002423 bool IsTemplateTemplateParm = false,
2424 SourceLocation TemplateArgLoc
2425 = SourceLocation());
Douglas Gregorddc29e12009-02-06 22:42:48 +00002426
Douglas Gregor05396e22009-08-25 17:23:04 +00002427 bool CheckTemplateDeclScope(Scope *S, TemplateParameterList *TemplateParams);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002428
Douglas Gregord57959a2009-03-27 23:10:48 +00002429 /// \brief Called when the parser has parsed a C++ typename
2430 /// specifier, e.g., "typename T::type".
2431 ///
2432 /// \param TypenameLoc the location of the 'typename' keyword
2433 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2434 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
2435 /// \param IdLoc the location of the identifier.
2436 virtual TypeResult
2437 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2438 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00002439
2440 /// \brief Called when the parser has parsed a C++ typename
2441 /// specifier that ends in a template-id, e.g.,
2442 /// "typename MetaFun::template apply<T1, T2>".
2443 ///
2444 /// \param TypenameLoc the location of the 'typename' keyword
2445 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2446 /// \param TemplateLoc the location of the 'template' keyword, if any.
2447 /// \param Ty the type that the typename specifier refers to.
2448 virtual TypeResult
2449 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2450 SourceLocation TemplateLoc, TypeTy *Ty);
2451
Douglas Gregord57959a2009-03-27 23:10:48 +00002452 QualType CheckTypenameType(NestedNameSpecifier *NNS,
2453 const IdentifierInfo &II,
2454 SourceRange Range);
Douglas Gregorc8ab2562009-05-31 09:31:02 +00002455
Douglas Gregor4a959d82009-08-06 16:20:37 +00002456 QualType RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc,
2457 DeclarationName Name);
2458
Douglas Gregorf67875d2009-06-12 18:26:56 +00002459 /// \brief Describes the result of template argument deduction.
2460 ///
2461 /// The TemplateDeductionResult enumeration describes the result of
2462 /// template argument deduction, as returned from
2463 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
2464 /// structure provides additional information about the results of
2465 /// template argument deduction, e.g., the deduced template argument
2466 /// list (if successful) or the specific template parameters or
2467 /// deduced arguments that were involved in the failure.
2468 enum TemplateDeductionResult {
2469 /// \brief Template argument deduction was successful.
2470 TDK_Success = 0,
2471 /// \brief Template argument deduction exceeded the maximum template
2472 /// instantiation depth (which has already been diagnosed).
2473 TDK_InstantiationDepth,
2474 /// \brief Template argument deduction did not deduce a value
2475 /// for every template parameter.
2476 TDK_Incomplete,
2477 /// \brief Template argument deduction produced inconsistent
2478 /// deduced values for the given template parameter.
2479 TDK_Inconsistent,
2480 /// \brief Template argument deduction failed due to inconsistent
2481 /// cv-qualifiers on a template parameter type that would
2482 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
2483 /// but were given a non-const "X".
2484 TDK_InconsistentQuals,
2485 /// \brief Substitution of the deduced template argument values
2486 /// resulted in an error.
2487 TDK_SubstitutionFailure,
2488 /// \brief Substitution of the deduced template argument values
2489 /// into a non-deduced context produced a type or value that
2490 /// produces a type that does not match the original template
2491 /// arguments provided.
Douglas Gregore53060f2009-06-25 22:08:12 +00002492 TDK_NonDeducedMismatch,
2493 /// \brief When performing template argument deduction for a function
2494 /// template, there were too many call arguments.
2495 TDK_TooManyArguments,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00002496 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002497 /// template, there were too few call arguments.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002498 TDK_TooFewArguments,
2499 /// \brief The explicitly-specified template arguments were not valid
2500 /// template arguments for the given template.
2501 TDK_InvalidExplicitArguments
Douglas Gregorf67875d2009-06-12 18:26:56 +00002502 };
2503
2504 /// \brief Provides information about an attempted template argument
2505 /// deduction, whose success or failure was described by a
2506 /// TemplateDeductionResult value.
2507 class TemplateDeductionInfo {
2508 /// \brief The context in which the template arguments are stored.
2509 ASTContext &Context;
2510
2511 /// \brief The deduced template argument list.
2512 ///
2513 TemplateArgumentList *Deduced;
2514
2515 // do not implement these
2516 TemplateDeductionInfo(const TemplateDeductionInfo&);
2517 TemplateDeductionInfo &operator=(const TemplateDeductionInfo&);
2518
2519 public:
2520 TemplateDeductionInfo(ASTContext &Context) : Context(Context), Deduced(0) { }
2521
2522 ~TemplateDeductionInfo() {
2523 // FIXME: if (Deduced) Deduced->Destroy(Context);
2524 }
2525
2526 /// \brief Take ownership of the deduced template argument list.
2527 TemplateArgumentList *take() {
2528 TemplateArgumentList *Result = Deduced;
2529 Deduced = 0;
2530 return Result;
2531 }
2532
2533 /// \brief Provide a new template argument list that contains the
2534 /// results of template argument deduction.
2535 void reset(TemplateArgumentList *NewDeduced) {
2536 // FIXME: if (Deduced) Deduced->Destroy(Context);
2537 Deduced = NewDeduced;
2538 }
2539
2540 /// \brief The template parameter to which a template argument
2541 /// deduction failure refers.
2542 ///
2543 /// Depending on the result of template argument deduction, this
2544 /// template parameter may have different meanings:
2545 ///
2546 /// TDK_Incomplete: this is the first template parameter whose
2547 /// corresponding template argument was not deduced.
2548 ///
2549 /// TDK_Inconsistent: this is the template parameter for which
2550 /// two different template argument values were deduced.
2551 TemplateParameter Param;
2552
2553 /// \brief The first template argument to which the template
2554 /// argument deduction failure refers.
2555 ///
2556 /// Depending on the result of the template argument deduction,
2557 /// this template argument may have different meanings:
2558 ///
2559 /// TDK_Inconsistent: this argument is the first value deduced
2560 /// for the corresponding template parameter.
2561 ///
2562 /// TDK_SubstitutionFailure: this argument is the template
2563 /// argument we were instantiating when we encountered an error.
2564 ///
2565 /// TDK_NonDeducedMismatch: this is the template argument
2566 /// provided in the source code.
2567 TemplateArgument FirstArg;
2568
2569 /// \brief The second template argument to which the template
2570 /// argument deduction failure refers.
2571 ///
2572 /// FIXME: Finish documenting this.
2573 TemplateArgument SecondArg;
2574 };
2575
2576 TemplateDeductionResult
Douglas Gregor199d9912009-06-05 00:53:49 +00002577 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002578 const TemplateArgumentList &TemplateArgs,
2579 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002580
2581 TemplateDeductionResult
2582 SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2583 const TemplateArgument *ExplicitTemplateArgs,
2584 unsigned NumExplicitTemplateArgs,
2585 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2586 llvm::SmallVectorImpl<QualType> &ParamTypes,
2587 QualType *FunctionType,
2588 TemplateDeductionInfo &Info);
2589
2590 TemplateDeductionResult
2591 FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
2592 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2593 FunctionDecl *&Specialization,
2594 TemplateDeductionInfo &Info);
2595
Douglas Gregore53060f2009-06-25 22:08:12 +00002596 TemplateDeductionResult
2597 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002598 bool HasExplicitTemplateArgs,
2599 const TemplateArgument *ExplicitTemplateArgs,
2600 unsigned NumExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +00002601 Expr **Args, unsigned NumArgs,
2602 FunctionDecl *&Specialization,
2603 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002604
2605 TemplateDeductionResult
2606 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2607 bool HasExplicitTemplateArgs,
2608 const TemplateArgument *ExplicitTemplateArgs,
2609 unsigned NumExplicitTemplateArgs,
2610 QualType ArgFunctionType,
2611 FunctionDecl *&Specialization,
2612 TemplateDeductionInfo &Info);
Douglas Gregore53060f2009-06-25 22:08:12 +00002613
Douglas Gregor65ec1fd2009-08-21 23:19:43 +00002614 TemplateDeductionResult
2615 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2616 QualType ToType,
2617 CXXConversionDecl *&Specialization,
2618 TemplateDeductionInfo &Info);
2619
2620 FunctionTemplateDecl *getMoreSpecializedTemplate(FunctionTemplateDecl *FT1,
2621 FunctionTemplateDecl *FT2,
2622 bool isCallContext);
2623
Douglas Gregor031a5882009-06-13 00:26:55 +00002624 void MarkDeducedTemplateParameters(const TemplateArgumentList &TemplateArgs,
2625 llvm::SmallVectorImpl<bool> &Deduced);
2626
Douglas Gregor99ebf652009-02-27 19:31:52 +00002627 //===--------------------------------------------------------------------===//
2628 // C++ Template Instantiation
2629 //
Douglas Gregor26dce442009-03-10 00:06:19 +00002630
Douglas Gregord1102432009-08-28 17:37:35 +00002631 MultiLevelTemplateArgumentList getTemplateInstantiationArgs(NamedDecl *D);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002632
Douglas Gregor26dce442009-03-10 00:06:19 +00002633 /// \brief A template instantiation that is currently in progress.
2634 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00002635 /// \brief The kind of template instantiation we are performing
Douglas Gregorcca9e962009-07-01 22:01:06 +00002636 enum InstantiationKind {
Douglas Gregordf667e72009-03-10 20:44:00 +00002637 /// We are instantiating a template declaration. The entity is
Douglas Gregorb9f1b8d2009-05-15 00:01:03 +00002638 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00002639 TemplateInstantiation,
2640
2641 /// We are instantiating a default argument for a template
2642 /// parameter. The Entity is the template, and
2643 /// TemplateArgs/NumTemplateArguments provides the template
2644 /// arguments as specified.
Douglas Gregor637a4092009-06-10 23:47:09 +00002645 /// FIXME: Use a TemplateArgumentList
2646 DefaultTemplateArgumentInstantiation,
2647
Douglas Gregorcca9e962009-07-01 22:01:06 +00002648 /// We are substituting explicit template arguments provided for
2649 /// a function template. The entity is a FunctionTemplateDecl.
2650 ExplicitTemplateArgumentSubstitution,
2651
2652 /// We are substituting template argument determined as part of
2653 /// template argument deduction for either a class template
2654 /// partial specialization or a function template. The
2655 /// Entity is either a ClassTemplatePartialSpecializationDecl or
2656 /// a FunctionTemplateDecl.
2657 DeducedTemplateArgumentSubstitution
Douglas Gregordf667e72009-03-10 20:44:00 +00002658 } Kind;
2659
Douglas Gregor26dce442009-03-10 00:06:19 +00002660 /// \brief The point of instantiation within the source code.
2661 SourceLocation PointOfInstantiation;
2662
2663 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00002664 uintptr_t Entity;
2665
2666 // \brief If this the instantiation of a default template
Douglas Gregor7e063902009-05-11 23:53:27 +00002667 // argument, the list of template arguments.
Douglas Gregordf667e72009-03-10 20:44:00 +00002668 const TemplateArgument *TemplateArgs;
2669
2670 /// \brief The number of template arguments in TemplateArgs.
2671 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002672
2673 /// \brief The source range that covers the construct that cause
2674 /// the instantiation, e.g., the template-id that causes a class
2675 /// template instantiation.
2676 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002677
Eli Friedman2ebcc6b2009-08-15 22:50:33 +00002678 ActiveTemplateInstantiation() : Kind(TemplateInstantiation), Entity(0),
2679 TemplateArgs(0), NumTemplateArgs(0) {}
2680
Douglas Gregordf667e72009-03-10 20:44:00 +00002681 friend bool operator==(const ActiveTemplateInstantiation &X,
2682 const ActiveTemplateInstantiation &Y) {
2683 if (X.Kind != Y.Kind)
2684 return false;
2685
2686 if (X.Entity != Y.Entity)
2687 return false;
2688
2689 switch (X.Kind) {
2690 case TemplateInstantiation:
2691 return true;
2692
2693 case DefaultTemplateArgumentInstantiation:
Douglas Gregorcca9e962009-07-01 22:01:06 +00002694 case ExplicitTemplateArgumentSubstitution:
2695 case DeducedTemplateArgumentSubstitution:
Douglas Gregordf667e72009-03-10 20:44:00 +00002696 return X.TemplateArgs == Y.TemplateArgs;
2697 }
2698
2699 return true;
2700 }
2701
2702 friend bool operator!=(const ActiveTemplateInstantiation &X,
2703 const ActiveTemplateInstantiation &Y) {
2704 return !(X == Y);
2705 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002706 };
2707
2708 /// \brief List of active template instantiations.
2709 ///
2710 /// This vector is treated as a stack. As one template instantiation
2711 /// requires another template instantiation, additional
2712 /// instantiations are pushed onto the stack up to a
2713 /// user-configurable limit LangOptions::InstantiationDepth.
2714 llvm::SmallVector<ActiveTemplateInstantiation, 16>
2715 ActiveTemplateInstantiations;
2716
Douglas Gregor27b152f2009-03-10 18:52:44 +00002717 /// \brief The last template from which a template instantiation
2718 /// error or warning was produced.
2719 ///
2720 /// This value is used to suppress printing of redundant template
2721 /// instantiation backtraces when there are multiple errors in the
2722 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2723 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002724 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002725
Douglas Gregor26dce442009-03-10 00:06:19 +00002726 /// \brief A stack object to be created when performing template
2727 /// instantiation.
2728 ///
2729 /// Construction of an object of type \c InstantiatingTemplate
2730 /// pushes the current instantiation onto the stack of active
2731 /// instantiations. If the size of this stack exceeds the maximum
2732 /// number of recursive template instantiations, construction
2733 /// produces an error and evaluates true.
2734 ///
2735 /// Destruction of this object will pop the named instantiation off
2736 /// the stack.
2737 struct InstantiatingTemplate {
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002738 /// \brief Note that we are instantiating a class template,
2739 /// function template, or a member thereof.
Douglas Gregor26dce442009-03-10 00:06:19 +00002740 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002741 Decl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002742 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002743
2744 /// \brief Note that we are instantiating a default argument in a
2745 /// template-id.
2746 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2747 TemplateDecl *Template,
2748 const TemplateArgument *TemplateArgs,
2749 unsigned NumTemplateArgs,
2750 SourceRange InstantiationRange = SourceRange());
2751
Douglas Gregorcca9e962009-07-01 22:01:06 +00002752 /// \brief Note that we are instantiating a default argument in a
2753 /// template-id.
2754 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2755 FunctionTemplateDecl *FunctionTemplate,
2756 const TemplateArgument *TemplateArgs,
2757 unsigned NumTemplateArgs,
2758 ActiveTemplateInstantiation::InstantiationKind Kind,
2759 SourceRange InstantiationRange = SourceRange());
2760
Douglas Gregor637a4092009-06-10 23:47:09 +00002761 /// \brief Note that we are instantiating as part of template
2762 /// argument deduction for a class template partial
2763 /// specialization.
2764 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2765 ClassTemplatePartialSpecializationDecl *PartialSpec,
2766 const TemplateArgument *TemplateArgs,
2767 unsigned NumTemplateArgs,
2768 SourceRange InstantiationRange = SourceRange());
2769
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002770 /// \brief Note that we have finished instantiating this template.
2771 void Clear();
2772
2773 ~InstantiatingTemplate() { Clear(); }
Douglas Gregor26dce442009-03-10 00:06:19 +00002774
2775 /// \brief Determines whether we have exceeded the maximum
2776 /// recursive template instantiations.
2777 operator bool() const { return Invalid; }
2778
2779 private:
2780 Sema &SemaRef;
2781 bool Invalid;
2782
Douglas Gregordf667e72009-03-10 20:44:00 +00002783 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2784 SourceRange InstantiationRange);
2785
Douglas Gregor26dce442009-03-10 00:06:19 +00002786 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2787
2788 InstantiatingTemplate&
2789 operator=(const InstantiatingTemplate&); // not implemented
2790 };
2791
Douglas Gregoree1828a2009-03-10 18:03:33 +00002792 void PrintInstantiationStack();
2793
Douglas Gregor5e9f35c2009-06-14 07:33:30 +00002794 /// \brief Determines whether we are currently in a context where
2795 /// template argument substitution failures are not considered
2796 /// errors.
2797 ///
2798 /// When this routine returns true, the emission of most diagnostics
2799 /// will be suppressed and there will be no local error recovery.
2800 bool isSFINAEContext() const;
2801
Douglas Gregorbb260412009-06-14 08:02:22 +00002802 /// \brief RAII class used to determine whether SFINAE has
2803 /// trapped any errors that occur during template argument
2804 /// deduction.
2805 class SFINAETrap {
2806 Sema &SemaRef;
2807 unsigned PrevSFINAEErrors;
2808 public:
2809 explicit SFINAETrap(Sema &SemaRef)
2810 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors) { }
2811
2812 ~SFINAETrap() { SemaRef.NumSFINAEErrors = PrevSFINAEErrors; }
2813
2814 /// \brief Determine whether any SFINAE errors have been trapped.
2815 bool hasErrorOccurred() const {
2816 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
2817 }
2818 };
2819
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002820 /// \brief A stack-allocated class that identifies which local
2821 /// variable declaration instantiations are present in this scope.
2822 ///
2823 /// A new instance of this class type will be created whenever we
2824 /// instantiate a new function declaration, which will have its own
2825 /// set of parameter declarations.
2826 class LocalInstantiationScope {
2827 /// \brief Reference to the semantic analysis that is performing
2828 /// this template instantiation.
2829 Sema &SemaRef;
2830
Douglas Gregor815215d2009-05-27 05:35:12 +00002831 /// \brief A mapping from local declarations that occur
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002832 /// within a template to their instantiations.
2833 ///
2834 /// This mapping is used during instantiation to keep track of,
2835 /// e.g., function parameter and variable declarations. For example,
2836 /// given:
2837 ///
2838 /// \code
2839 /// template<typename T> T add(T x, T y) { return x + y; }
2840 /// \endcode
2841 ///
2842 /// when we instantiate add<int>, we will introduce a mapping from
2843 /// the ParmVarDecl for 'x' that occurs in the template to the
2844 /// instantiated ParmVarDecl for 'x'.
Douglas Gregor815215d2009-05-27 05:35:12 +00002845 llvm::DenseMap<const Decl *, Decl *> LocalDecls;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002846
2847 /// \brief The outer scope, in which contains local variable
2848 /// definitions from some other instantiation (that is not
2849 /// relevant to this particular scope).
2850 LocalInstantiationScope *Outer;
2851
2852 // This class is non-copyable
2853 LocalInstantiationScope(const LocalInstantiationScope &);
2854 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
2855
2856 public:
2857 LocalInstantiationScope(Sema &SemaRef)
2858 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
2859 SemaRef.CurrentInstantiationScope = this;
2860 }
2861
2862 ~LocalInstantiationScope() {
2863 SemaRef.CurrentInstantiationScope = Outer;
2864 }
2865
Douglas Gregor815215d2009-05-27 05:35:12 +00002866 Decl *getInstantiationOf(const Decl *D) {
2867 Decl *Result = LocalDecls[D];
2868 assert(Result && "declaration was not instantiated in this scope!");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002869 return Result;
2870 }
2871
Douglas Gregor815215d2009-05-27 05:35:12 +00002872 VarDecl *getInstantiationOf(const VarDecl *Var) {
2873 return cast<VarDecl>(getInstantiationOf(cast<Decl>(Var)));
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002874 }
2875
Douglas Gregor815215d2009-05-27 05:35:12 +00002876 ParmVarDecl *getInstantiationOf(const ParmVarDecl *Var) {
2877 return cast<ParmVarDecl>(getInstantiationOf(cast<Decl>(Var)));
2878 }
2879
2880 void InstantiatedLocal(const Decl *D, Decl *Inst) {
2881 Decl *&Stored = LocalDecls[D];
2882 assert(!Stored && "Already instantiated this local");
2883 Stored = Inst;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002884 }
2885 };
2886
2887 /// \brief The current instantiation scope used to store local
2888 /// variables.
2889 LocalInstantiationScope *CurrentInstantiationScope;
2890
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002891 /// \brief An entity for which implicit template instantiation is required.
2892 ///
2893 /// The source location associated with the declaration is the first place in
2894 /// the source code where the declaration was "used". It is not necessarily
2895 /// the point of instantiation (which will be either before or after the
2896 /// namespace-scope declaration that triggered this implicit instantiation),
2897 /// However, it is the location that diagnostics should generally refer to,
2898 /// because users will need to know what code triggered the instantiation.
2899 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
2900
2901 /// \brief The queue of implicit template instantiations that are required
2902 /// but have not yet been performed.
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00002903 std::deque<PendingImplicitInstantiation> PendingImplicitInstantiations;
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002904
2905 void PerformPendingImplicitInstantiations();
2906
Douglas Gregord6350ae2009-08-28 20:31:08 +00002907 QualType SubstType(QualType T,
2908 const MultiLevelTemplateArgumentList &TemplateArgs,
John McCallce3ff2b2009-08-25 22:02:44 +00002909 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor199d9912009-06-05 00:53:49 +00002910
Douglas Gregord6350ae2009-08-28 20:31:08 +00002911 OwningExprResult SubstExpr(Expr *E,
2912 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00002913
Douglas Gregord6350ae2009-08-28 20:31:08 +00002914 OwningStmtResult SubstStmt(Stmt *S,
2915 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002916
John McCallce3ff2b2009-08-25 22:02:44 +00002917 Decl *SubstDecl(Decl *D, DeclContext *Owner,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002918 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002919
Douglas Gregor2943aed2009-03-03 04:44:36 +00002920 bool
John McCallce3ff2b2009-08-25 22:02:44 +00002921 SubstBaseSpecifiers(CXXRecordDecl *Instantiation,
2922 CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002923 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCalle29ba202009-08-20 01:44:21 +00002924
2925 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00002926 InstantiateClass(SourceLocation PointOfInstantiation,
2927 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002928 const MultiLevelTemplateArgumentList &TemplateArgs,
Douglas Gregor5842ba92009-08-24 15:23:48 +00002929 bool ExplicitInstantiation,
2930 bool Complain = true);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002931
Douglas Gregor2943aed2009-03-03 04:44:36 +00002932 bool
2933 InstantiateClassTemplateSpecialization(
2934 ClassTemplateSpecializationDecl *ClassTemplateSpec,
Douglas Gregor5842ba92009-08-24 15:23:48 +00002935 bool ExplicitInstantiation, bool Complain = true);
Douglas Gregor99ebf652009-02-27 19:31:52 +00002936
Douglas Gregora58861f2009-05-13 20:28:22 +00002937 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
2938 CXXRecordDecl *Instantiation,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002939 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregora58861f2009-05-13 20:28:22 +00002940
2941 void InstantiateClassTemplateSpecializationMembers(
2942 SourceLocation PointOfInstantiation,
2943 ClassTemplateSpecializationDecl *ClassTemplateSpec);
2944
Douglas Gregorab452ba2009-03-26 23:50:42 +00002945 NestedNameSpecifier *
John McCallce3ff2b2009-08-25 22:02:44 +00002946 SubstNestedNameSpecifier(NestedNameSpecifier *NNS,
2947 SourceRange Range,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002948 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00002949
Douglas Gregorde650ae2009-03-31 18:38:02 +00002950 TemplateName
John McCallce3ff2b2009-08-25 22:02:44 +00002951 SubstTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002952 const MultiLevelTemplateArgumentList &TemplateArgs);
John McCallce3ff2b2009-08-25 22:02:44 +00002953 TemplateArgument Subst(TemplateArgument Arg,
Douglas Gregord6350ae2009-08-28 20:31:08 +00002954 const MultiLevelTemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00002955
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002956 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00002957 FunctionDecl *Function,
2958 bool Recursive = false);
Douglas Gregor7caa6822009-07-24 20:34:43 +00002959 void InstantiateStaticDataMemberDefinition(
John McCallce3ff2b2009-08-25 22:02:44 +00002960 SourceLocation PointOfInstantiation,
2961 VarDecl *Var,
2962 bool Recursive = false);
Douglas Gregora58861f2009-05-13 20:28:22 +00002963
Anders Carlsson09025312009-08-29 05:16:22 +00002964 void InstantiateMemInitializers(CXXConstructorDecl *New,
2965 const CXXConstructorDecl *Tmpl,
2966 const MultiLevelTemplateArgumentList &TemplateArgs);
2967
John McCallce3ff2b2009-08-25 22:02:44 +00002968 NamedDecl *FindInstantiatedDecl(NamedDecl *D);
John McCall02cace72009-08-28 07:59:38 +00002969 DeclContext *FindInstantiatedContext(DeclContext *DC);
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002970
Steve Naroff3536b442007-09-06 21:24:23 +00002971 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002972 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
2973 IdentifierInfo *ClassName,
2974 SourceLocation ClassLoc,
2975 IdentifierInfo *SuperName,
2976 SourceLocation SuperLoc,
2977 const DeclPtrTy *ProtoRefs,
2978 unsigned NumProtoRefs,
2979 SourceLocation EndProtoLoc,
2980 AttributeList *AttrList);
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002981
Chris Lattnerb28317a2009-03-28 19:18:32 +00002982 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002983 SourceLocation AtCompatibilityAliasLoc,
2984 IdentifierInfo *AliasName, SourceLocation AliasLocation,
2985 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00002986
2987 void CheckForwardProtocolDeclarationForCircularDependency(
2988 IdentifierInfo *PName,
2989 SourceLocation &PLoc, SourceLocation PrevLoc,
2990 const ObjCList<ObjCProtocolDecl> &PList);
Steve Naroff3536b442007-09-06 21:24:23 +00002991
Chris Lattnerb28317a2009-03-28 19:18:32 +00002992 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002993 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002994 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002995 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00002996 SourceLocation EndProtoLoc,
2997 AttributeList *AttrList);
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002998
Chris Lattnerb28317a2009-03-28 19:18:32 +00002999 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
3000 IdentifierInfo *ClassName,
3001 SourceLocation ClassLoc,
3002 IdentifierInfo *CategoryName,
3003 SourceLocation CategoryLoc,
3004 const DeclPtrTy *ProtoRefs,
3005 unsigned NumProtoRefs,
3006 SourceLocation EndProtoLoc);
Fariborz Jahanianfd225cc2007-09-18 20:26:58 +00003007
Chris Lattnerb28317a2009-03-28 19:18:32 +00003008 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00003009 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00003010 IdentifierInfo *ClassName, SourceLocation ClassLoc,
3011 IdentifierInfo *SuperClassname,
3012 SourceLocation SuperClassLoc);
3013
Chris Lattnerb28317a2009-03-28 19:18:32 +00003014 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00003015 SourceLocation AtCatImplLoc,
3016 IdentifierInfo *ClassName,
3017 SourceLocation ClassLoc,
3018 IdentifierInfo *CatName,
3019 SourceLocation CatLoc);
3020
Chris Lattnerb28317a2009-03-28 19:18:32 +00003021 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroff37e58d12007-10-02 22:39:18 +00003022 IdentifierInfo **IdentList,
3023 unsigned NumElts);
Fariborz Jahanian894c57f2007-09-21 15:40:54 +00003024
Chris Lattnerb28317a2009-03-28 19:18:32 +00003025 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003026 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00003027 unsigned NumElts,
3028 AttributeList *attrList);
Fariborz Jahanian245f92a2007-10-05 21:01:53 +00003029
Chris Lattnere13b9592008-07-26 04:03:38 +00003030 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00003031 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00003032 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003033 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003034
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00003035 /// Ensure attributes are consistent with type.
3036 /// \param [in, out] Attributes The attributes to check; they will
3037 /// be modified to be consistent with \arg PropertyTy.
3038 void CheckObjCPropertyAttributes(QualType PropertyTy,
3039 SourceLocation Loc,
3040 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00003041 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003042 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
3043 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00003044 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00003045 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Fariborz Jahanianb5e02242008-04-24 19:58:34 +00003046
Fariborz Jahaniandbdec8b2009-08-04 01:07:16 +00003047 void CompareMethodParamsInBaseAndSuper(Decl *IDecl,
3048 ObjCMethodDecl *MethodDecl,
3049 bool IsInstance);
3050
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003051 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003052 DeclPtrTy MergeProtocols);
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00003053
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00003054 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
3055 ObjCInterfaceDecl *ID);
3056
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00003057 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00003058 ObjCProtocolDecl *PDecl);
3059
Chris Lattnerb28317a2009-03-28 19:18:32 +00003060 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
3061 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
3062 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00003063 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00003064
Chris Lattnerb28317a2009-03-28 19:18:32 +00003065 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
3066 FieldDeclarator &FD, ObjCDeclSpec &ODS,
3067 Selector GetterSel, Selector SetterSel,
3068 DeclPtrTy ClassCategory,
3069 bool *OverridingProperty,
3070 tok::ObjCKeywordKind MethodImplKind);
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00003071
Chris Lattnerb28317a2009-03-28 19:18:32 +00003072 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
3073 SourceLocation PropertyLoc,
3074 bool ImplKind,DeclPtrTy ClassImplDecl,
3075 IdentifierInfo *PropertyId,
3076 IdentifierInfo *PropertyIvar);
Fariborz Jahanianf624f812008-04-18 00:19:30 +00003077
Chris Lattnerb28317a2009-03-28 19:18:32 +00003078 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00003079 SourceLocation BeginLoc, // location of the + or -.
3080 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +00003081 tok::TokenKind MethodType,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003082 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00003083 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00003084 // optional arguments. The number of types/arguments is obtained
3085 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00003086 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00003087 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00003088 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
3089 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00003090
Steve Narofff1afaf62009-02-26 15:55:06 +00003091 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
3092 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00003093 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00003094 // Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +00003095 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
3096 ObjCInterfaceDecl *CDecl);
3097 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
3098 ObjCInterfaceDecl *ClassDecl);
Steve Narofff1afaf62009-02-26 15:55:06 +00003099
Steve Naroff61f72cb2009-03-09 21:12:44 +00003100 virtual OwningExprResult ActOnClassPropertyRefExpr(
3101 IdentifierInfo &receiverName,
3102 IdentifierInfo &propertyName,
3103 SourceLocation &receiverNameLoc,
3104 SourceLocation &propertyNameLoc);
3105
Steve Naroff68d331a2007-09-27 14:38:14 +00003106 // ActOnClassMessage - used for both unary and keyword messages.
3107 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003108 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003109 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00003110 Scope *S,
Anders Carlssonff975cf2009-02-14 18:21:46 +00003111 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
3112 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003113 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00003114
3115 // ActOnInstanceMessage - used for both unary and keyword messages.
3116 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003117 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003118 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00003119 ExprTy *receiver, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +00003120 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003121 ExprTy **ArgExprs, unsigned NumArgs);
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003122
3123 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
3124 virtual void ActOnPragmaPack(PragmaPackKind Kind,
3125 IdentifierInfo *Name,
3126 ExprTy *Alignment,
3127 SourceLocation PragmaLoc,
3128 SourceLocation LParenLoc,
3129 SourceLocation RParenLoc);
Chris Lattner574aa402009-02-17 01:09:29 +00003130
Ted Kremenek4726d032009-03-23 22:28:25 +00003131 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
Ted Kremenek7a02a372009-08-03 23:24:57 +00003132 virtual void ActOnPragmaUnused(const Token *Identifiers,
3133 unsigned NumIdentifiers, Scope *curScope,
Ted Kremenek4726d032009-03-23 22:28:25 +00003134 SourceLocation PragmaLoc,
3135 SourceLocation LParenLoc,
3136 SourceLocation RParenLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003137
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00003138 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II);
3139 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
Ryan Flynne25ff832009-07-30 03:15:39 +00003140
Eli Friedmandec7c762009-06-05 06:28:29 +00003141 /// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003142 virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
3143 SourceLocation PragmaLoc,
3144 SourceLocation WeakNameLoc);
3145
Eli Friedmandec7c762009-06-05 06:28:29 +00003146 /// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003147 virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
3148 IdentifierInfo* AliasName,
3149 SourceLocation PragmaLoc,
3150 SourceLocation WeakNameLoc,
3151 SourceLocation AliasNameLoc);
3152
Chris Lattner574aa402009-02-17 01:09:29 +00003153 /// getPragmaPackAlignment() - Return the current alignment as specified by
3154 /// the current #pragma pack directive, or 0 if none is currently active.
3155 unsigned getPragmaPackAlignment() const;
3156
3157 /// FreePackedContext - Deallocate and null out PackContext.
3158 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003159
Chris Lattner1e0a3902008-01-16 19:17:22 +00003160 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
3161 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003162 /// If isLvalue, the result of the cast is an lvalue.
Anders Carlsson3503d042009-07-31 01:23:52 +00003163 void ImpCastExprToType(Expr *&Expr, QualType Type,
Anders Carlssonbd0fb302009-08-10 21:30:22 +00003164 const CastExpr::CastInfo &Info =
3165 CastExpr::CastInfo(CastExpr::CK_Unknown),
Anders Carlsson3503d042009-07-31 01:23:52 +00003166 bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00003167
Reid Spencer5f016e22007-07-11 17:01:13 +00003168 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00003169 // functions and arrays to their respective pointers (C99 6.3.2.1).
3170 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00003171
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003172 // DefaultFunctionArrayConversion - converts functions and arrays
3173 // to their respective pointers (C99 6.3.2.1).
3174 void DefaultFunctionArrayConversion(Expr *&expr);
Steve Naroff90045e82007-07-13 23:32:42 +00003175
Steve Naroffb291ab62007-08-28 23:30:39 +00003176 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
3177 // do not have a prototype. Integer promotions are performed on each
3178 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00003179 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003180
3181 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
3182 enum VariadicCallType {
3183 VariadicFunction,
3184 VariadicBlock,
3185 VariadicMethod
3186 };
3187
3188 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
3189 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00003190 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Steve Naroffb291ab62007-08-28 23:30:39 +00003191
Reid Spencer5f016e22007-07-11 17:01:13 +00003192 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
3193 // operands and then handles various conversions that are common to binary
3194 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
3195 // routine returns the first non-arithmetic type found. The client is
3196 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003197 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
3198 bool isCompAssign = false);
Chris Lattnerb7b61152008-01-04 18:22:42 +00003199
3200 /// AssignConvertType - All of the 'assignment' semantic checks return this
3201 /// enum to indicate whether the assignment was allowed. These checks are
3202 /// done for simple assignments, as well as initialization, return from
3203 /// function, argument passing, etc. The query is phrased in terms of a
3204 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003205 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00003206 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00003207 Compatible,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003208
3209 /// PointerToInt - The assignment converts a pointer to an int, which we
3210 /// accept as an extension.
3211 PointerToInt,
3212
3213 /// IntToPointer - The assignment converts an int to a pointer, which we
3214 /// accept as an extension.
3215 IntToPointer,
3216
3217 /// FunctionVoidPointer - The assignment is between a function pointer and
3218 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003219 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003220
3221 /// IncompatiblePointer - The assignment is between two pointers types that
3222 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00003223 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003224
3225 /// IncompatiblePointer - The assignment is between two pointers types which
3226 /// point to integers which have a different sign, but are otherwise identical.
3227 /// This is a subset of the above, but broken out because it's by far the most
3228 /// common case of incompatible pointers.
3229 IncompatiblePointerSign,
3230
Chris Lattnerb7b61152008-01-04 18:22:42 +00003231 /// CompatiblePointerDiscardsQualifiers - The assignment discards
3232 /// c/v/r qualifiers, which we accept as an extension.
3233 CompatiblePointerDiscardsQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003234
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00003235 /// IncompatibleVectors - The assignment is between two vector types that
3236 /// have the same size, which we accept as an extension.
3237 IncompatibleVectors,
3238
Steve Naroffbfdcae62008-09-04 15:31:07 +00003239 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003240 /// pointer. We disallow this.
3241 IntToBlockPointer,
3242
Steve Naroffbfdcae62008-09-04 15:31:07 +00003243 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003244 /// pointers types that are not compatible.
3245 IncompatibleBlockPointer,
3246
Steve Naroff39579072008-10-14 22:18:38 +00003247 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
3248 /// id type and something else (that is incompatible with it). For example,
3249 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
3250 IncompatibleObjCQualifiedId,
3251
Chris Lattnerb7b61152008-01-04 18:22:42 +00003252 /// Incompatible - We reject this conversion outright, it is invalid to
3253 /// represent it in the AST.
3254 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00003255 };
Chris Lattner5cf216b2008-01-04 18:04:52 +00003256
3257 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
3258 /// assignment conversion type specified by ConvTy. This returns true if the
3259 /// conversion was invalid or false if the conversion was accepted.
3260 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
3261 SourceLocation Loc,
3262 QualType DstType, QualType SrcType,
3263 Expr *SrcExpr, const char *Flavor);
3264
3265 /// CheckAssignmentConstraints - Perform type checking for assignment,
3266 /// argument passing, variable initialization, and function return values.
3267 /// This routine is only used by the following two methods. C99 6.5.16.
3268 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00003269
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003270 // CheckSingleAssignmentConstraints - Currently used by
Steve Naroff1b273c42007-09-16 14:56:35 +00003271 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00003272 // this routine performs the default function/array converions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003273 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
3274 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003275
3276 // \brief If the lhs type is a transparent union, check whether we
3277 // can initialize the transparent union with the given expression.
3278 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
3279 Expr *&rExpr);
Steve Naroff90045e82007-07-13 23:32:42 +00003280
Reid Spencer5f016e22007-07-11 17:01:13 +00003281 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner5cf216b2008-01-04 18:04:52 +00003282 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
3283 QualType rhsType);
Steve Naroff1c7d0672008-09-04 15:10:53 +00003284
3285 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003286 // block pointer types.
Steve Naroff1c7d0672008-09-04 15:10:53 +00003287 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
3288 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00003289
3290 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003291
Douglas Gregor45920e82008-12-19 17:40:08 +00003292 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00003293 const char *Flavor,
3294 bool AllowExplicit = false,
3295 bool Elidable = false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003296 bool PerformImplicitConversion(Expr *&From, QualType ToType,
3297 const ImplicitConversionSequence& ICS,
Douglas Gregor45920e82008-12-19 17:40:08 +00003298 const char *Flavor);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003299 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00003300 const StandardConversionSequence& SCS,
3301 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00003302
Reid Spencer5f016e22007-07-11 17:01:13 +00003303 /// the following "Check" methods will return a valid/converted QualType
3304 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00003305
3306 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00003307 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003308 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003309 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00003310 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003311 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003312 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003313 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003314 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003315 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003316 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003317 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003318 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003319 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003320 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00003321 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00003322 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00003323 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003324 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00003325 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003326 // CheckAssignmentOperands is used for both simple and compound assignment.
3327 // For simple assignment, pass both expressions and a null converted type.
3328 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00003329 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00003330 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00003331 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00003332 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00003333 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00003334 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003335 QualType CXXCheckConditionalOperands( // C++ 5.16
3336 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003337 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00003338
3339 /// type checking for vector binary operators.
3340 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
3341 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
3342 SourceLocation l, bool isRel);
Reid Spencer5f016e22007-07-11 17:01:13 +00003343
Steve Narofff69936d2007-09-16 03:34:24 +00003344 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00003345 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00003346 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
3347 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003348 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
3349 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00003350 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003351
3352 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00003353 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Anders Carlsson8f28f992009-08-26 18:25:21 +00003354 const IdentifierInfo *Comp,
3355 SourceLocation CmpLoc);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003356
Steve Narofff0090632007-09-02 02:04:30 +00003357 /// type checking declaration initializers (C99 6.7.8)
Anders Carlsson2078bb92009-05-27 16:10:08 +00003358
Douglas Gregorf03d7c72008-11-05 15:29:30 +00003359 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003360 SourceLocation InitLoc,DeclarationName InitEntity,
Anders Carlsson0f5f2c62009-05-30 20:41:30 +00003361 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00003362 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00003363 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroff2fdc3742007-12-10 22:44:33 +00003364
Douglas Gregor87fd7032009-02-02 17:43:21 +00003365 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003366
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003367 // type checking C++ declaration initializers (C++ [dcl.init]).
3368
3369 /// ReferenceCompareResult - Expresses the result of comparing two
3370 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
3371 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
3372 enum ReferenceCompareResult {
3373 /// Ref_Incompatible - The two types are incompatible, so direct
3374 /// reference binding is not possible.
3375 Ref_Incompatible = 0,
3376 /// Ref_Related - The two types are reference-related, which means
3377 /// that their unqualified forms (T1 and T2) are either the same
3378 /// or T1 is a base class of T2.
3379 Ref_Related,
3380 /// Ref_Compatible_With_Added_Qualification - The two types are
3381 /// reference-compatible with added qualification, meaning that
3382 /// they are reference-compatible and the qualifiers on T1 (cv1)
3383 /// are greater than the qualifiers on T2 (cv2).
3384 Ref_Compatible_With_Added_Qualification,
3385 /// Ref_Compatible - The two types are reference-compatible and
3386 /// have equivalent qualifiers (cv1 == cv2).
3387 Ref_Compatible
3388 };
3389
Douglas Gregor15da57e2008-10-29 02:00:59 +00003390 ReferenceCompareResult CompareReferenceRelationship(QualType T1, QualType T2,
3391 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003392
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003393 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Anders Carlsson2de3ace2009-08-27 17:30:43 +00003394 bool SuppressUserConversions,
3395 bool AllowExplicit,
3396 bool ForceRValue,
3397 ImplicitConversionSequence *ICS = 0);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003398
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003399 /// CheckCastTypes - Check type constraints for casting between types under
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003400 /// C semantics, or forward to CXXCheckCStyleCast in C++.
3401 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003402 CastExpr::CastKind &Kind,
3403 CXXMethodDecl *& ConversionDecl,
3404 bool FunctionalStyle = false);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003405
Anders Carlsson584b2472007-11-27 07:16:40 +00003406 // CheckVectorCast - check type constraints for vectors.
3407 // Since vectors are an extension, there are no C standard reference for this.
3408 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00003409 // returns true if the cast is invalid
3410 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
3411
Nate Begeman58d29a42009-06-26 00:50:28 +00003412 // CheckExtVectorCast - check type constraints for extended vectors.
3413 // Since vectors are an extension, there are no C standard reference for this.
3414 // We allow casting between vectors and integer datatypes of the same size,
3415 // or vectors and the element type of that vector.
3416 // returns true if the cast is invalid
3417 bool CheckExtVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003418
3419 /// CXXCheckCStyleCast - Check constraints of a C-style or function-style
3420 /// cast under C++ semantics.
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003421 bool CXXCheckCStyleCast(SourceRange R, QualType CastTy, Expr *&CastExpr,
Fariborz Jahaniane9f42082009-08-26 18:55:36 +00003422 CastExpr::CastKind &Kind, bool FunctionalStyle,
3423 CXXMethodDecl *&ConversionDecl);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003424
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003425 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
3426 /// \param Method - May be null.
3427 /// \param [out] ReturnType - The return type of the send.
3428 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00003429 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00003430 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003431 SourceLocation lbrac, SourceLocation rbrac,
3432 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003433
3434 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
3435 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003436
Chris Lattnerf4021e72007-08-23 05:46:52 +00003437 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
3438 /// the specified width and sign. If an overflow occurs, detect it and emit
3439 /// the specified diagnostic.
3440 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
3441 unsigned NewWidth, bool NewSign,
3442 SourceLocation Loc, unsigned DiagID);
3443
Anders Carlsson15281452008-11-04 16:57:32 +00003444 /// Checks that the Objective-C declaration is declared in the global scope.
3445 /// Emits an error and marks the declaration as invalid if it's not declared
3446 /// in the global scope.
3447 bool CheckObjCDeclScope(Decl *D);
3448
Anders Carlsson7c50aca2007-10-15 20:28:48 +00003449 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00003450
Anders Carlssone21555e2008-11-30 19:50:32 +00003451 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
3452 /// and reports the appropriate diagnostics. Returns false on success.
3453 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003454 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00003455
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003456 /// VerifyBitField - verifies that a bit field expression is an ICE and has
3457 /// the correct width, and that the field type is valid.
3458 /// Returns false on success.
Eli Friedman1d954f62009-08-15 21:55:26 +00003459 /// Can optionally return whether the bit-field is of width 0
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003460 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
Eli Friedman1d954f62009-08-15 21:55:26 +00003461 QualType FieldTy, const Expr *BitWidth,
3462 bool *ZeroWidth = 0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00003463
Chris Lattner59907c42007-08-10 20:18:51 +00003464 //===--------------------------------------------------------------------===//
3465 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00003466private:
Anders Carlssond406bf02009-08-16 01:56:34 +00003467 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall);
3468 bool CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall);
Fariborz Jahanian725165f2009-05-18 21:05:18 +00003469
Chris Lattner60800082009-02-18 17:49:48 +00003470 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
3471 unsigned ByteNo) const;
Ryan Flynn4403a5e2009-08-06 03:00:50 +00003472 bool CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall);
Chris Lattner69039812009-02-18 06:01:06 +00003473 bool CheckObjCString(Expr *Arg);
Anders Carlssond406bf02009-08-16 01:56:34 +00003474
3475 Action::OwningExprResult CheckBuiltinFunctionCall(unsigned BuiltinID,
3476 CallExpr *TheCall);
Chris Lattner925e60d2007-12-28 05:29:59 +00003477 bool SemaBuiltinVAStart(CallExpr *TheCall);
3478 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00003479 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003480
3481public:
3482 // Used by C++ template instantiation.
Sebastian Redl0eb23302009-01-19 00:08:26 +00003483 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003484
3485private:
Daniel Dunbar4493f792008-07-21 22:59:13 +00003486 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00003487 bool SemaBuiltinObjectSize(CallExpr *TheCall);
3488 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00003489 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003490 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
3491 bool HasVAListArg, unsigned format_idx,
3492 unsigned firstDataArg);
3493 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
3494 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003495 unsigned format_idx, unsigned firstDataArg);
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +00003496 void CheckNonNullArguments(const NonNullAttr *NonNull,
3497 const CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003498 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003499 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00003500 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
3501 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00003502 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00003503};
3504
Mike Stumpb83d2872009-02-19 22:01:56 +00003505
Ted Kremenek8189cde2009-02-07 01:47:29 +00003506//===--------------------------------------------------------------------===//
3507// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
3508template <typename T>
3509class ExprOwningPtr : public Action::ExprArg {
3510public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00003511 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Ted Kremenek8189cde2009-02-07 01:47:29 +00003512
3513 void reset(T* p) { Action::ExprArg::operator=(p); }
3514 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
3515 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
3516 T* release() { return take(); }
3517
3518 T& operator*() const { return *get(); }
3519 T* operator->() const { return get(); }
3520};
Douglas Gregord7e27052009-05-20 22:33:37 +00003521
Reid Spencer5f016e22007-07-11 17:01:13 +00003522} // end namespace clang
3523
3524#endif