blob: 12ab47c81aa7be0cccdeda3f44fbdb52bd89a8ec [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 Gregore0762c92009-06-19 23:52:42 +000021#include "clang/AST/Attr.h"
Douglas Gregoreb11cd02009-01-14 22:20:51 +000022#include "clang/AST/DeclBase.h"
Douglas Gregore0762c92009-06-19 23:52:42 +000023#include "clang/AST/Decl.h"
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000024#include "clang/AST/DeclObjC.h"
Anders Carlsson1c5976e2009-06-05 03:43:12 +000025#include "clang/AST/DeclTemplate.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000026#include "clang/Parse/Action.h"
Chris Lattner500d3292009-01-29 05:15:15 +000027#include "clang/Sema/SemaDiagnostic.h"
Anders Carlssonc1fcb772007-07-22 07:07:56 +000028#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian85ff2642007-10-05 18:00:57 +000029#include "llvm/ADT/DenseSet.h"
Chris Lattnerf3876682007-10-07 01:13:46 +000030#include "llvm/ADT/SmallPtrSet.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000031#include "llvm/ADT/OwningPtr.h"
Douglas Gregorb33fe2f2009-06-30 17:20:14 +000032#include <deque>
Douglas Gregorac7610d2009-06-22 20:57:11 +000033#include <list>
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +000034#include <string>
Douglas Gregor94b1dd22008-10-24 04:54:22 +000035#include <vector>
Reid Spencer5f016e22007-07-11 17:01:13 +000036
Chris Lattnerf4021e72007-08-23 05:46:52 +000037namespace llvm {
38 class APSInt;
39}
40
Reid Spencer5f016e22007-07-11 17:01:13 +000041namespace clang {
42 class ASTContext;
Chris Lattner2ae34ed2008-02-06 00:46:58 +000043 class ASTConsumer;
Reid Spencer5f016e22007-07-11 17:01:13 +000044 class Preprocessor;
45 class Decl;
Chris Lattnerb048c982008-04-06 04:47:34 +000046 class DeclContext;
Daniel Dunbar12bc6922008-08-11 03:27:53 +000047 class DeclSpec;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000048 class ExternalSemaSource;
Steve Naroffe8043c32008-04-01 23:04:06 +000049 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000050 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000051 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000052 class InitListExpr;
Nate Begeman2ef13e52009-08-10 23:49:36 +000053 class ParenListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000054 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000055 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000056 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000057 class VarDecl;
58 class ParmVarDecl;
59 class TypedefDecl;
60 class FunctionDecl;
61 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000062 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000063 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000064 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000065 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000066 class ArrayType;
67 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000068 class SwitchStmt;
Sebastian Redl13e88542009-04-27 21:33:24 +000069 class CXXTryStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000070 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000071 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000072 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000073 class TemplateArgument;
Douglas Gregor7e063902009-05-11 23:53:27 +000074 class TemplateArgumentList;
Douglas Gregorddc29e12009-02-06 22:42:48 +000075 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000076 class TemplateTemplateParmDecl;
Douglas Gregorc8ab2562009-05-31 09:31:02 +000077 class ClassTemplatePartialSpecializationDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000078 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000079 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000080 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000081 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000082 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000083 class ObjCImplementationDecl;
84 class ObjCCategoryImplDecl;
85 class ObjCCategoryDecl;
86 class ObjCIvarDecl;
87 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000088 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000089 class ObjCContainerDecl;
Sebastian Redl4994d2d2009-07-04 11:39:00 +000090 class FunctionProtoType;
Douglas Gregor94b1dd22008-10-24 04:54:22 +000091 class BasePaths;
Sebastian Redl43af76e2009-03-07 12:16:37 +000092 struct MemberLookupCriteria;
Anders Carlssonff6b3d62009-05-30 21:05:25 +000093 class CXXTemporary;
Steve Naroffbea0b342007-07-29 16:33:31 +000094
Chris Lattnerea29a3a2009-04-18 20:01:55 +000095/// BlockSemaInfo - When a block is being parsed, this contains information
96/// about the block. It is pointed to from Sema::CurBlock.
97struct BlockSemaInfo {
98 llvm::SmallVector<ParmVarDecl*, 8> Params;
99 bool hasPrototype;
100 bool isVariadic;
101 bool hasBlockDeclRefExprs;
102
103 BlockDecl *TheDecl;
104
105 /// TheScope - This is the scope for the block itself, which contains
106 /// arguments etc.
107 Scope *TheScope;
108
109 /// ReturnType - This will get set to block result type, by looking at
110 /// return types, if any, in the block body.
Fariborz Jahanian7d5c74e2009-06-19 23:37:08 +0000111 QualType ReturnType;
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000112
113 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
114 /// it (which acts like the label decl in some ways). Forward referenced
115 /// labels have a LabelStmt created for them with a null location & SubStmt.
116 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
117
Chris Lattnerbcfce662009-04-18 20:10:59 +0000118 /// SwitchStack - This is the current set of active switch statements in the
119 /// block.
120 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
121
Chris Lattner17a78302009-04-19 05:28:12 +0000122 /// SavedFunctionNeedsScopeChecking - This is the value of
123 /// CurFunctionNeedsScopeChecking at the point when the block started.
124 bool SavedFunctionNeedsScopeChecking;
125
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000126 /// PrevBlockInfo - If this is nested inside another block, this points
127 /// to the outer block.
128 BlockSemaInfo *PrevBlockInfo;
129};
130
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000131/// \brief Holds a QualType and a DeclaratorInfo* that came out of a declarator
132/// parsing.
133///
134/// LocInfoType is a "transient" type, only needed for passing to/from Parser
135/// and Sema, when we want to preserve type source info for a parsed type.
136/// It will not participate in the type system semantics in any way.
137class LocInfoType : public Type {
138 enum {
139 // The last number that can fit in Type's TC.
140 // Avoids conflict with an existing Type class.
141 LocInfo = (1 << TypeClassBitSize) - 1
142 };
143
144 DeclaratorInfo *DeclInfo;
145
146 LocInfoType(QualType ty, DeclaratorInfo *DInfo)
147 : Type((TypeClass)LocInfo, ty, ty->isDependentType()), DeclInfo(DInfo) {
148 assert(getTypeClass() == (TypeClass)LocInfo && "LocInfo didn't fit in TC?");
149 }
150 friend class Sema;
151
152public:
153 QualType getType() const { return getCanonicalTypeInternal(); }
154 DeclaratorInfo *getDeclaratorInfo() const { return DeclInfo; }
155
156 virtual void getAsStringInternal(std::string &Str,
157 const PrintingPolicy &Policy) const;
158
159 static bool classof(const Type *T) {
160 return T->getTypeClass() == (TypeClass)LocInfo;
161 }
162 static bool classof(const LocInfoType *) { return true; }
163};
164
Reid Spencer5f016e22007-07-11 17:01:13 +0000165/// Sema - This implements semantic analysis and AST building for C.
166class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +0000167 Sema(const Sema&); // DO NOT IMPLEMENT
168 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +0000169public:
Chris Lattner53ebff32009-01-22 19:21:44 +0000170 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +0000171 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +0000172 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000173 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +0000174 Diagnostic &Diags;
175 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +0000176
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000177 /// \brief Source of additional semantic information.
178 ExternalSemaSource *ExternalSource;
179
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000180 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +0000181 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +0000182
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000183 /// PreDeclaratorDC - Keeps the declaration context before switching to the
184 /// context of a declarator's nested-name-specifier.
185 DeclContext *PreDeclaratorDC;
186
Steve Naroff4eb206b2008-09-03 18:15:37 +0000187 /// CurBlock - If inside of a block definition, this contains a pointer to
188 /// the active block object that represents it.
189 BlockSemaInfo *CurBlock;
190
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000191 /// PackContext - Manages the stack for #pragma pack. An alignment
192 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000193 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000194
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000195 /// FunctionLabelMap - This is a mapping from label identifiers to the
196 /// LabelStmt for it (which acts like the label decl in some ways). Forward
197 /// referenced labels have a LabelStmt created for them with a null location &
198 /// SubStmt.
199 ///
200 /// Note that this should always be accessed through getLabelMap() in order
201 /// to handle blocks properly.
202 llvm::DenseMap<IdentifierInfo*, LabelStmt*> FunctionLabelMap;
Steve Naroffcaaacec2009-03-13 15:38:40 +0000203
Chris Lattnerbcfce662009-04-18 20:10:59 +0000204 /// FunctionSwitchStack - This is the current set of active switch statements
205 /// in the top level function. Clients should always use getSwitchStack() to
206 /// handle the case when they are in a block.
207 llvm::SmallVector<SwitchStmt*, 8> FunctionSwitchStack;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000208
209 /// ExprTemporaries - This is the stack of temporaries that are created by
210 /// the current full expression.
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000211 llvm::SmallVector<CXXTemporary*, 8> ExprTemporaries;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000212
Chris Lattner38c5ebd2009-04-19 05:21:20 +0000213 /// CurFunctionNeedsScopeChecking - This is set to true when a function or
214 /// ObjC method body contains a VLA or an ObjC try block, which introduce
215 /// scopes that need to be checked for goto conditions. If a function does
216 /// not contain this, then it need not have the jump checker run on it.
217 bool CurFunctionNeedsScopeChecking;
218
Nate Begeman213541a2008-04-18 23:10:10 +0000219 /// ExtVectorDecls - This is a list all the extended vector types. This allows
220 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000221 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000222 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Steve Naroffe84a8642008-09-28 14:55:53 +0000223
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000224 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
225 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
226
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000227 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
228
229 /// PureVirtualClassDiagSet - a set of class declarations which we have
230 /// emitted a list of pure virtual functions. Used to prevent emitting the
231 /// same list more than once.
232 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
233
Douglas Gregor63935192009-03-02 00:19:53 +0000234 /// \brief A mapping from external names to the most recent
235 /// locally-scoped external declaration with that name.
236 ///
237 /// This map contains external declarations introduced in local
238 /// scoped, e.g.,
239 ///
240 /// \code
241 /// void f() {
242 /// void foo(int, int);
243 /// }
244 /// \endcode
245 ///
246 /// Here, the name "foo" will be associated with the declaration on
247 /// "foo" within f. This name is not visible outside of
248 /// "f". However, we still find it in two cases:
249 ///
250 /// - If we are declaring another external with the name "foo", we
251 /// can find "foo" as a previous declaration, so that the types
252 /// of this external declaration can be checked for
253 /// compatibility.
254 ///
255 /// - If we would implicitly declare "foo" (e.g., due to a call to
256 /// "foo" in C when no prototype or definition is visible), then
257 /// we find this declaration of "foo" and complain that it is
258 /// not visible.
259 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
260
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000261 /// \brief The set of tentative declarations seen so far in this
262 /// translation unit for which no definition has been seen.
263 ///
264 /// The tentative declarations are indexed by the name of the
265 /// declaration, and only the most recent tentative declaration for
266 /// a given variable will be recorded here.
267 llvm::DenseMap<DeclarationName, VarDecl *> TentativeDefinitions;
268
Ryan Flynne25ff832009-07-30 03:15:39 +0000269 /// WeakUndeclaredIdentifiers - Identifiers contained in
270 /// #pragma weak before declared. rare. may alias another
271 /// identifier, declared or undeclared
272 class WeakInfo {
273 IdentifierInfo *alias; // alias (optional)
274 SourceLocation loc; // for diagnostics
275 bool used; // identifier later declared?
276 public:
277 WeakInfo()
278 : alias(0), loc(SourceLocation()), used(false) {}
279 WeakInfo(IdentifierInfo *Alias, SourceLocation Loc)
280 : alias(Alias), loc(Loc), used(false) {}
281 inline IdentifierInfo * getAlias() const { return alias; }
282 inline SourceLocation getLocation() const { return loc; }
283 void setUsed(bool Used=true) { used = Used; }
284 inline bool getUsed() { return used; }
285 bool operator==(WeakInfo RHS) const {
286 return alias == RHS.getAlias() && loc == RHS.getLocation();
287 }
288 bool operator!=(WeakInfo RHS) const { return !(*this == RHS); }
289 };
290 llvm::DenseMap<IdentifierInfo*,WeakInfo> WeakUndeclaredIdentifiers;
291
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000292 /// WeakTopLevelDecl - Translation-unit scoped declarations generated by
293 /// #pragma weak during processing of other Decls.
294 /// I couldn't figure out a clean way to generate these in-line, so
295 /// we store them here and handle separately -- which is a hack.
296 /// It would be best to refactor this.
297 llvm::SmallVector<Decl*,2> WeakTopLevelDecl;
298
Chris Lattner7f925cc2008-04-11 07:00:53 +0000299 IdentifierResolver IdResolver;
300
Steve Naroffe440eb82007-10-10 17:32:04 +0000301 /// Translation Unit Scope - useful to Objective-C actions that need
302 /// to lookup file scope declarations in the "ordinary" C decl namespace.
303 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000304 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000305
306 /// The C++ "std" namespace, where the standard library resides. Cached here
307 /// by GetStdNamespace
308 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000309
310 /// A flag to remember whether the implicit forms of operator new and delete
311 /// have been declared.
312 bool GlobalNewDeleteDeclared;
Douglas Gregorf807fe02009-04-14 16:27:31 +0000313
Douglas Gregorac7610d2009-06-22 20:57:11 +0000314 /// The current expression evaluation context.
315 ExpressionEvaluationContext ExprEvalContext;
316
317 typedef std::vector<std::pair<SourceLocation, Decl *> >
318 PotentiallyReferencedDecls;
319
320 /// A stack of declarations, each element of which is a set of declarations
321 /// that will be marked as referenced if the corresponding potentially
322 /// potentially evaluated expression is potentially evaluated. Each element
323 /// in the stack corresponds to a PotentiallyPotentiallyEvaluated expression
324 /// evaluation context.
325 std::list<PotentiallyReferencedDecls> PotentiallyReferencedDeclStack;
Douglas Gregore0762c92009-06-19 23:52:42 +0000326
Douglas Gregorf807fe02009-04-14 16:27:31 +0000327 /// \brief Whether the code handled by Sema should be considered a
328 /// complete translation unit or not.
329 ///
330 /// When true (which is generally the case), Sema will perform
331 /// end-of-translation-unit semantic tasks (such as creating
332 /// initializers for tentative definitions in C) once parsing has
333 /// completed. This flag will be false when building PCH files,
334 /// since a PCH file is by definition not a complete translation
335 /// unit.
336 bool CompleteTranslationUnit;
337
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000338 llvm::BumpPtrAllocator BumpAlloc;
339
Douglas Gregorbb260412009-06-14 08:02:22 +0000340 /// \brief The number of SFINAE diagnostics that have been trapped.
341 unsigned NumSFINAEErrors;
342
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000343 typedef llvm::DenseMap<Selector, ObjCMethodList> MethodPool;
344
Steve Naroff58ff9e82007-10-14 00:58:41 +0000345 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
346 /// messages to "id". We need to maintain a list, since selectors can have
347 /// differing signatures across classes. In Cocoa, this happens to be
348 /// extremely uncommon (only 1% of selectors are "overloaded").
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000349 MethodPool InstanceMethodPool;
350 MethodPool FactoryMethodPool;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000351
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000352 MethodPool::iterator ReadMethodPool(Selector Sel, bool isInstance);
353
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000354 /// Private Helper predicate to check for 'self'.
355 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000356public:
Douglas Gregorf807fe02009-04-14 16:27:31 +0000357 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
358 bool CompleteTranslationUnit = true);
Chris Lattner574aa402009-02-17 01:09:29 +0000359 ~Sema() {
360 if (PackContext) FreePackedContext();
361 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000362
Chris Lattner53ebff32009-01-22 19:21:44 +0000363 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000364 Diagnostic &getDiagnostics() const { return Diags; }
365 SourceManager &getSourceManager() const { return SourceMgr; }
366
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000367 /// \brief Helper class that creates diagnostics with optional
368 /// template instantiation stacks.
369 ///
370 /// This class provides a wrapper around the basic DiagnosticBuilder
371 /// class that emits diagnostics. SemaDiagnosticBuilder is
372 /// responsible for emitting the diagnostic (as DiagnosticBuilder
373 /// does) and, if the diagnostic comes from inside a template
374 /// instantiation, printing the template instantiation stack as
375 /// well.
376 class SemaDiagnosticBuilder : public DiagnosticBuilder {
377 Sema &SemaRef;
378 unsigned DiagID;
379
380 public:
381 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
382 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
383
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000384 explicit SemaDiagnosticBuilder(Sema &SemaRef)
385 : DiagnosticBuilder(DiagnosticBuilder::Suppress), SemaRef(SemaRef) { }
386
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000387 ~SemaDiagnosticBuilder();
388 };
389
390 /// \brief Emit a diagnostic.
391 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000392 if (isSFINAEContext() && Diagnostic::isBuiltinSFINAEDiag(DiagID)) {
393 // If we encountered an error during template argument
394 // deduction, and that error is one of the SFINAE errors,
Douglas Gregorbb260412009-06-14 08:02:22 +0000395 // suppress the diagnostic.
Douglas Gregor8439fac2009-06-15 16:52:15 +0000396 ++NumSFINAEErrors;
397 return SemaDiagnosticBuilder(*this);
Douglas Gregor5e9f35c2009-06-14 07:33:30 +0000398 }
399
Douglas Gregoree1828a2009-03-10 18:03:33 +0000400 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000401 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000402 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000403
Chris Lattner394a3fd2007-08-31 04:53:24 +0000404 virtual void DeleteExpr(ExprTy *E);
405 virtual void DeleteStmt(StmtTy *S);
406
Sebastian Redl798d1192008-12-13 16:23:55 +0000407 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000408 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000409 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000410 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000411 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000412 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000413 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
414
Chris Lattner9299f3f2008-08-23 03:19:52 +0000415 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000416
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000417 /// getLabelMap() - Return the current label map. If we're in a block, we
418 /// return it.
419 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
420 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
421 }
422
Chris Lattnerbcfce662009-04-18 20:10:59 +0000423 /// getSwitchStack - This is returns the switch stack for the current block or
424 /// function.
425 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
426 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
427 }
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +0000428
429 /// WeakTopLevelDeclDecls - access to #pragma weak-generated Decls
430 llvm::SmallVector<Decl*,2> &WeakTopLevelDecls() { return WeakTopLevelDecl; }
Chris Lattnerbcfce662009-04-18 20:10:59 +0000431
Douglas Gregor2e222532009-07-02 17:08:52 +0000432 virtual void ActOnComment(SourceRange Comment);
433
Reid Spencer5f016e22007-07-11 17:01:13 +0000434 //===--------------------------------------------------------------------===//
435 // Type Analysis / Processing: SemaType.cpp.
436 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000437 QualType adjustParameterType(QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000438 QualType ConvertDeclSpecToType(const DeclSpec &DS, SourceLocation DeclLoc,
439 bool &IsInvalid);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000440 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000441 QualType BuildPointerType(QualType T, unsigned Quals,
442 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000443 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000444 SourceLocation Loc, DeclarationName Entity);
445 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
446 Expr *ArraySize, unsigned Quals,
Douglas Gregor7e7eb3d2009-07-06 15:59:29 +0000447 SourceRange Brackets, DeclarationName Entity);
Douglas Gregor9cdda0c2009-06-17 21:51:59 +0000448 QualType BuildExtVectorType(QualType T, ExprArg ArraySize,
449 SourceLocation AttrLoc);
Douglas Gregor724651c2009-02-28 01:04:19 +0000450 QualType BuildFunctionType(QualType T,
451 QualType *ParamTypes, unsigned NumParamTypes,
452 bool Variadic, unsigned Quals,
453 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor949bf692009-06-09 22:17:39 +0000454 QualType BuildMemberPointerType(QualType T, QualType Class,
455 unsigned Quals, SourceLocation Loc,
456 DeclarationName Entity);
Anders Carlsson9a917e42009-06-12 22:56:54 +0000457 QualType BuildBlockPointerType(QualType T, unsigned Quals,
458 SourceLocation Loc, DeclarationName Entity);
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000459 QualType GetTypeForDeclarator(Declarator &D, Scope *S,
460 DeclaratorInfo **DInfo = 0,
461 unsigned Skip = 0, TagDecl **OwnedDecl = 0);
Argyrios Kyrtzidis4adab7f2009-08-19 01:28:06 +0000462 DeclaratorInfo *GetDeclaratorInfoForDeclarator(Declarator &D, QualType T,
463 unsigned Skip);
Argyrios Kyrtzidis1bb8a452009-08-19 01:28:17 +0000464 /// \brief Create a LocInfoType to hold the given QualType and DeclaratorInfo.
465 QualType CreateLocInfoType(QualType T, DeclaratorInfo *DInfo);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000466 DeclarationName GetNameForDeclarator(Declarator &D);
Argyrios Kyrtzidise8661902009-08-19 01:28:28 +0000467 static QualType GetTypeFromParser(TypeTy *Ty, DeclaratorInfo **DInfo = 0);
Sebastian Redlef65f062009-05-29 18:02:33 +0000468 bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
Sebastian Redl6a7330c2009-05-29 15:01:05 +0000469 bool CheckDistantExceptionSpec(QualType T);
Sebastian Redl4994d2d2009-07-04 11:39:00 +0000470 bool CheckEquivalentExceptionSpec(
471 const FunctionProtoType *Old, SourceLocation OldLoc,
472 const FunctionProtoType *New, SourceLocation NewLoc);
Sebastian Redl23c7d062009-07-07 20:29:57 +0000473 bool CheckExceptionSpecSubset(unsigned DiagID, unsigned NoteID,
474 const FunctionProtoType *Superset, SourceLocation SuperLoc,
475 const FunctionProtoType *Subset, SourceLocation SubLoc);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000476
Chris Lattnerb28317a2009-03-28 19:18:32 +0000477 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000478
Douglas Gregor57373262008-10-22 14:17:15 +0000479 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
480
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000481 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000482
Douglas Gregor86447ec2009-03-09 16:13:40 +0000483 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Douglas Gregor4ec339f2009-01-19 19:26:10 +0000484 SourceRange Range1 = SourceRange(),
485 SourceRange Range2 = SourceRange(),
486 QualType PrintType = QualType());
487
Douglas Gregore6258932009-03-19 00:39:20 +0000488 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
489
Anders Carlssonaf017e62009-06-29 22:58:55 +0000490 QualType BuildTypeofExprType(Expr *E);
491 QualType BuildDecltypeType(Expr *E);
492
Reid Spencer5f016e22007-07-11 17:01:13 +0000493 //===--------------------------------------------------------------------===//
494 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
495 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000496
497 /// getDeclName - Return a pretty name for the specified decl if possible, or
498 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000499 virtual std::string getDeclName(DeclPtrTy D);
Chris Lattner21ff9c92009-03-05 01:25:28 +0000500
Chris Lattner682bf922009-03-29 16:50:03 +0000501 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
502
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000503 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregorb696ea32009-02-04 17:00:24 +0000504 Scope *S, const CXXScopeSpec *SS);
Chris Lattner4c97d762009-04-12 21:49:30 +0000505 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
506
Chris Lattner682bf922009-03-29 16:50:03 +0000507 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
Douglas Gregore542c862009-06-23 23:11:28 +0000508 return HandleDeclarator(S, D, MultiTemplateParamsArg(*this), false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000509 }
Douglas Gregore542c862009-06-23 23:11:28 +0000510
511 DeclPtrTy HandleDeclarator(Scope *S, Declarator &D,
512 MultiTemplateParamsArg TemplateParameterLists,
513 bool IsFunctionDefinition);
Douglas Gregor63935192009-03-02 00:19:53 +0000514 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
515 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000516 void DiagnoseFunctionSpecifiers(Declarator& D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000517 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000518 QualType R, DeclaratorInfo *DInfo,
519 Decl* PrevDecl, bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000520 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000521 QualType R, DeclaratorInfo *DInfo,
522 NamedDecl* PrevDecl,
Douglas Gregordfe3f2d2009-07-22 17:18:37 +0000523 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000524 bool &Redeclaration);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000525 void CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000526 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000527 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000528 QualType R, DeclaratorInfo *DInfo,
529 NamedDecl* PrevDecl,
Douglas Gregore542c862009-06-23 23:11:28 +0000530 MultiTemplateParamsArg TemplateParamLists,
Douglas Gregor04495c82009-02-24 01:23:02 +0000531 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000532 bool &Redeclaration);
533 void CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000534 bool &Redeclaration,
535 bool &OverloadableAttrRequired);
John McCall8c4859a2009-07-24 03:03:21 +0000536 void CheckMain(FunctionDecl *FD);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000537 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
538 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000539 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000540 ExprArg defarg);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000541 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Anders Carlsson5e300d12009-06-12 16:51:40 +0000542 SourceLocation EqualLoc,
543 SourceLocation ArgLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000544 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
Anders Carlsson5e300d12009-06-12 16:51:40 +0000545
546 // Contains the locations of the beginning of unparsed default
547 // argument locations.
548 llvm::DenseMap<ParmVarDecl *,SourceLocation> UnparsedDefaultArgLocs;
549
Anders Carlsson9abf2ae2009-08-16 05:13:48 +0000550 virtual void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000551 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
Anders Carlsson6a75cd92009-07-11 00:34:39 +0000552 void ActOnUninitializedDecl(DeclPtrTy dcl, bool TypeContainsUndeducedAuto);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000553 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000554 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
555 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +0000556 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000557 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
558 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000559 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
560 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
561 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000562
Chris Lattnerb28317a2009-03-28 19:18:32 +0000563 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Douglas Gregore2c31ff2009-05-15 17:59:04 +0000564 DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body,
565 bool IsInstantiation);
Douglas Gregore0762c92009-06-19 23:52:42 +0000566
567 /// \brief Diagnose any unused parameters in the given sequence of
568 /// ParmVarDecl pointers.
569 template<typename InputIterator>
570 void DiagnoseUnusedParameters(InputIterator Param, InputIterator ParamEnd) {
571 for (; Param != ParamEnd; ++Param) {
572 if (!(*Param)->isUsed() && (*Param)->getDeclName() &&
Argyrios Kyrtzidis40b598e2009-06-30 02:34:44 +0000573 !(*Param)->template hasAttr<UnusedAttr>())
Douglas Gregore0762c92009-06-19 23:52:42 +0000574 Diag((*Param)->getLocation(), diag::warn_unused_parameter)
575 << (*Param)->getDeclName();
576 }
577 }
578
Chris Lattner5af280c2009-04-19 04:46:21 +0000579 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000580 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000581
Steve Naroffb216c882007-10-09 22:01:59 +0000582 /// Scope actions.
583 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
584 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000585
586 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
587 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000588 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000589
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000590 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
591 RecordDecl *AnonRecord);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000592 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
593 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000594
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000595 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
596 TagDecl::TagKind NewTag,
597 SourceLocation NewTagLoc,
598 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000599
John McCall0f434ec2009-07-31 02:45:11 +0000600 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000601 SourceLocation KWLoc, const CXXScopeSpec &SS,
602 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +0000603 AttributeList *Attr, AccessSpecifier AS,
Douglas Gregor7cdbc582009-07-22 23:48:44 +0000604 MultiTemplateParamsArg TemplateParameterLists,
Douglas Gregor402abb52009-05-28 23:31:59 +0000605 bool &OwnedDecl);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000606
Chris Lattnerb28317a2009-03-28 19:18:32 +0000607 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000608 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000609 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
610 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
611 SourceLocation DeclStart,
612 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000613
614 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000615 Declarator &D, Expr *BitfieldWidth,
616 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000617
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +0000618 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
619 DeclaratorInfo *DInfo,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000620 RecordDecl *Record, SourceLocation Loc,
621 bool Mutable, Expr *BitfieldWidth,
Steve Naroffea218b82009-07-14 14:58:18 +0000622 SourceLocation TSSL,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000623 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000624 Declarator *D = 0);
Douglas Gregor1f2023a2009-07-22 18:25:24 +0000625
626 enum CXXSpecialMember {
627 CXXDefaultConstructor = 0,
628 CXXCopyConstructor = 1,
629 CXXCopyAssignment = 2,
630 CXXDestructor = 3
631 };
632 void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000633
Chris Lattnerb28317a2009-03-28 19:18:32 +0000634 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +0000635 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000636 Declarator &D, ExprTy *BitfieldWidth,
637 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000638
Steve Narofff13271f2007-09-14 23:09:53 +0000639 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000640 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000641 SourceLocation RecLoc, DeclPtrTy TagDecl,
642 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000643 SourceLocation LBrac, SourceLocation RBrac,
644 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000645
646 /// ActOnTagStartDefinition - Invoked when we have entered the
647 /// scope of a tag's definition (e.g., for an enumeration, class,
648 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000649 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000650
651 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
652 /// the definition of a tag (enumeration, class, struct, or union).
Argyrios Kyrtzidis07a5b282009-07-14 03:17:52 +0000653 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl,
654 SourceLocation RBraceLoc);
Douglas Gregor72de6672009-01-08 20:45:30 +0000655
Douglas Gregor879fd492009-03-17 19:05:46 +0000656 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
657 EnumConstantDecl *LastEnumConst,
658 SourceLocation IdLoc,
659 IdentifierInfo *Id,
660 ExprArg val);
661
Chris Lattnerb28317a2009-03-28 19:18:32 +0000662 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
663 DeclPtrTy LastEnumConstant,
664 SourceLocation IdLoc, IdentifierInfo *Id,
665 SourceLocation EqualLoc, ExprTy *Val);
Mike Stumpc6e35aa2009-05-16 07:06:02 +0000666 virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
667 SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
Edward O'Callaghanfee13812009-08-08 14:36:57 +0000668 DeclPtrTy *Elements, unsigned NumElements,
669 Scope *S, AttributeList *Attr);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000670
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000671 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000672
Chris Lattner0ed844b2008-04-04 06:12:32 +0000673 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000674 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000675 void PopDeclContext();
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000676
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000677 /// EnterDeclaratorContext - Used when we must lookup names in the context
678 /// of a declarator's nested name specifier.
679 void EnterDeclaratorContext(Scope *S, DeclContext *DC);
680 void ExitDeclaratorContext(Scope *S);
681
Anders Carlsson8517d9b2009-08-08 17:45:02 +0000682 DeclContext *getFunctionLevelDeclContext();
Argyrios Kyrtzidis1d175532009-06-17 23:15:40 +0000683
Chris Lattner371f2582008-12-04 23:50:19 +0000684 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
685 /// to the function decl for the function being parsed. If we're currently
686 /// in a 'block', this returns the containing context.
687 FunctionDecl *getCurFunctionDecl();
688
689 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
690 /// the method decl for the method being parsed. If we're currently
691 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000692 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000693
Chris Lattner371f2582008-12-04 23:50:19 +0000694 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
695 /// or C function we're in, otherwise return null. If we're currently
696 /// in a 'block', this returns the containing context.
697 NamedDecl *getCurFunctionOrMethodDecl();
698
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000699 /// Add this decl to the scope shadowed decl chains.
700 void PushOnScopeChains(NamedDecl *D, Scope *S);
701
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000702 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
703 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
704 /// true if 'D' belongs to the given declaration context.
705 bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000706 return IdResolver.isDeclInScope(D, Ctx, Context, S);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000707 }
708
Eli Friedman8f17b662009-02-28 05:41:13 +0000709
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000710 /// Subroutines of ActOnDeclarator().
Chris Lattner682bf922009-03-29 16:50:03 +0000711 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000712 void MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000713 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000714 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000715 void MergeVarDecl(VarDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000716 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000717
718 /// C++ Overloading.
719 bool IsOverload(FunctionDecl *New, Decl* OldD,
720 OverloadedFunctionDecl::function_iterator &MatchedDecl);
Douglas Gregor225c41e2008-11-03 19:09:14 +0000721 ImplicitConversionSequence
722 TryImplicitConversion(Expr* From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000723 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +0000724 bool AllowExplicit = false,
725 bool ForceRValue = false);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000726 bool IsStandardConversion(Expr *From, QualType ToType,
727 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000728 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
729 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000730 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000731 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +0000732 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000733 bool isObjCPointerConversion(QualType FromType, QualType ToType,
734 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregor94b1dd22008-10-24 04:54:22 +0000735 bool CheckPointerConversion(Expr *From, QualType ToType);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000736 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
737 QualType &ConvertedType);
738 bool CheckMemberPointerConversion(Expr *From, QualType ToType);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000739 bool IsQualificationConversion(QualType FromType, QualType ToType);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000740 bool IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000741 UserDefinedConversionSequence& User,
Douglas Gregor734d9862009-01-30 23:27:23 +0000742 bool AllowConversionFunctions,
Sebastian Redle2b68332009-04-12 17:16:29 +0000743 bool AllowExplicit, bool ForceRValue);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000744
745 ImplicitConversionSequence::CompareKind
746 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
747 const ImplicitConversionSequence& ICS2);
748
749 ImplicitConversionSequence::CompareKind
750 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
751 const StandardConversionSequence& SCS2);
752
Douglas Gregor57373262008-10-22 14:17:15 +0000753 ImplicitConversionSequence::CompareKind
754 CompareQualificationConversions(const StandardConversionSequence& SCS1,
755 const StandardConversionSequence& SCS2);
756
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000757 ImplicitConversionSequence::CompareKind
758 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
759 const StandardConversionSequence& SCS2);
760
Douglas Gregor225c41e2008-11-03 19:09:14 +0000761 ImplicitConversionSequence
762 TryCopyInitialization(Expr* From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000763 bool SuppressUserConversions = false,
764 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000765 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000766 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000767
Douglas Gregor96176b32008-11-18 23:14:02 +0000768 ImplicitConversionSequence
769 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
770 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
771
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000772 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
773 bool PerformContextuallyConvertToBool(Expr *&From);
Fariborz Jahanian98a541e2009-07-29 18:40:24 +0000774
Fariborz Jahanianf3e53d32009-07-29 19:40:11 +0000775 bool PerformObjectMemberConversion(Expr *&From, NamedDecl *Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000776
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000777 /// OverloadingResult - Capture the result of performing overload
778 /// resolution.
779 enum OverloadingResult {
780 OR_Success, ///< Overload resolution succeeded.
781 OR_No_Viable_Function, ///< No viable function found.
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000782 OR_Ambiguous, ///< Ambiguous candidates found.
783 OR_Deleted ///< Overload resoltuion refers to a deleted function.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000784 };
785
John McCall6ff07852009-08-07 22:18:02 +0000786 // Members have to be NamespaceDecl* or TranslationUnitDecl*.
787 // TODO: make this is a typesafe union.
788 typedef llvm::SmallPtrSet<DeclContext *, 16> AssociatedNamespaceSet;
789
Douglas Gregor364e0212009-06-27 21:05:07 +0000790 typedef llvm::SmallPtrSet<AnyFunctionDecl, 16> FunctionSet;
Douglas Gregor063daf62009-03-13 18:40:31 +0000791 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
792
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000793 void AddOverloadCandidate(FunctionDecl *Function,
794 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000795 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000796 bool SuppressUserConversions = false,
797 bool ForceRValue = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000798 void AddFunctionCandidates(const FunctionSet &Functions,
799 Expr **Args, unsigned NumArgs,
800 OverloadCandidateSet& CandidateSet,
801 bool SuppressUserConversions = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000802 void AddMethodCandidate(CXXMethodDecl *Method,
803 Expr *Object, Expr **Args, unsigned NumArgs,
804 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000805 bool SuppressUserConversions = false,
806 bool ForceRValue = false);
Douglas Gregore53060f2009-06-25 22:08:12 +0000807 void AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor6db8ed42009-06-30 23:57:56 +0000808 bool HasExplicitTemplateArgs,
809 const TemplateArgument *ExplicitTemplateArgs,
810 unsigned NumExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +0000811 Expr **Args, unsigned NumArgs,
812 OverloadCandidateSet& CandidateSet,
813 bool SuppressUserConversions = false,
814 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000815 void AddConversionCandidate(CXXConversionDecl *Conversion,
816 Expr *From, QualType ToType,
817 OverloadCandidateSet& CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000818 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000819 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000820 Expr *Object, Expr **Args, unsigned NumArgs,
821 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000822 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000823 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000824 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000825 OverloadCandidateSet& CandidateSet,
826 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000827 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
828 SourceLocation OpLoc,
829 Expr **Args, unsigned NumArgs,
830 OverloadCandidateSet& CandidateSet,
831 SourceRange OpRange = SourceRange());
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000832 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
833 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000834 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000835 bool IsAssignmentOperator = false,
836 unsigned NumContextualBoolArguments = 0);
Douglas Gregor74253732008-11-19 15:42:04 +0000837 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
838 Expr **Args, unsigned NumArgs,
839 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000840 void AddArgumentDependentLookupCandidates(DeclarationName Name,
841 Expr **Args, unsigned NumArgs,
842 OverloadCandidateSet& CandidateSet);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000843 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
844 const OverloadCandidate& Cand2);
845 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
Douglas Gregore0762c92009-06-19 23:52:42 +0000846 SourceLocation Loc,
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000847 OverloadCandidateSet::iterator& Best);
848 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
849 bool OnlyViable);
850
Douglas Gregor904eed32008-11-10 20:40:00 +0000851 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
852 bool Complain);
853 void FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
854
Douglas Gregor17330012009-02-04 15:01:18 +0000855 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn, NamedDecl *Callee,
856 DeclarationName UnqualifiedName,
Douglas Gregor6db8ed42009-06-30 23:57:56 +0000857 bool HasExplicitTemplateArgs,
858 const TemplateArgument *ExplicitTemplateArgs,
859 unsigned NumExplicitTemplateArgs,
Douglas Gregor0a396682008-11-26 06:01:48 +0000860 SourceLocation LParenLoc,
861 Expr **Args, unsigned NumArgs,
862 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +0000863 SourceLocation RParenLoc,
Douglas Gregor17330012009-02-04 15:01:18 +0000864 bool &ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +0000865
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000866 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
867 unsigned Opc,
868 FunctionSet &Functions,
869 ExprArg input);
870
Douglas Gregor063daf62009-03-13 18:40:31 +0000871 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
872 unsigned Opc,
873 FunctionSet &Functions,
874 Expr *LHS, Expr *RHS);
875
Douglas Gregor88a35142008-12-22 05:46:06 +0000876 ExprResult
877 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
878 SourceLocation LParenLoc, Expr **Args,
879 unsigned NumArgs, SourceLocation *CommaLocs,
880 SourceLocation RParenLoc);
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000881 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +0000882 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000883 Expr **Args, unsigned NumArgs,
884 SourceLocation *CommaLocs,
885 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000886
Douglas Gregorfe85ced2009-08-06 03:17:00 +0000887 OwningExprResult BuildOverloadedArrowExpr(Scope *S, ExprArg Base,
888 SourceLocation OpLoc);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000889
Mike Stump56925862009-07-28 22:04:01 +0000890 /// Helpers for dealing with blocks and functions.
Mike Stumpb1682c52009-07-22 23:56:57 +0000891 void CheckFallThroughForFunctionDef(Decl *D, Stmt *Body);
Mike Stump56925862009-07-28 22:04:01 +0000892 void CheckFallThroughForBlock(QualType BlockTy, Stmt *Body);
Chris Lattner04421082008-04-08 04:40:51 +0000893 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +0000894 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000895 void CheckExtraCXXDefaultArguments(Declarator &D);
Mike Stumpb1682c52009-07-22 23:56:57 +0000896 enum ControlFlowKind { NeverFallThrough = 0, MaybeFallThrough = 1,
897 AlwaysFallThrough = 2 };
898 ControlFlowKind CheckFallThrough(Stmt *);
Reid Spencer5f016e22007-07-11 17:01:13 +0000899
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000900 Scope *getNonFieldDeclScope(Scope *S);
901
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000902 /// \name Name lookup
903 ///
904 /// These routines provide name lookup that is used during semantic
905 /// analysis to resolve the various kinds of names (identifiers,
906 /// overloaded operator names, constructor names, etc.) into zero or
907 /// more declarations within a particular scope. The major entry
908 /// points are LookupName, which performs unqualified name lookup,
909 /// and LookupQualifiedName, which performs qualified name lookup.
910 ///
911 /// All name lookup is performed based on some specific criteria,
912 /// which specify what names will be visible to name lookup and how
913 /// far name lookup should work. These criteria are important both
914 /// for capturing language semantics (certain lookups will ignore
915 /// certain names, for example) and for performance, since name
916 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000917 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000918 ///
919 /// The results of name lookup can vary based on the kind of name
920 /// lookup performed, the current language, and the translation
921 /// unit. In C, for example, name lookup will either return nothing
922 /// (no entity found) or a single declaration. In C++, name lookup
923 /// can additionally refer to a set of overloaded functions or
924 /// result in an ambiguity. All of the possible results of name
925 /// lookup are captured by the LookupResult class, which provides
926 /// the ability to distinguish among them.
927 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +0000928
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000929 /// @brief Describes the kind of name lookup to perform.
930 enum LookupNameKind {
931 /// Ordinary name lookup, which finds ordinary names (functions,
932 /// variables, typedefs, etc.) in C and most kinds of names
933 /// (functions, variables, members, types, etc.) in C++.
934 LookupOrdinaryName = 0,
935 /// Tag name lookup, which finds the names of enums, classes,
936 /// structs, and unions.
937 LookupTagName,
938 /// Member name lookup, which finds the names of
939 /// class/struct/union members.
940 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000941 // Look up of an operator name (e.g., operator+) for use with
942 // operator overloading. This lookup is similar to ordinary name
943 // lookup, but will ignore any declarations that are class
944 // members.
945 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000946 /// Look up of a name that precedes the '::' scope resolution
947 /// operator in C++. This lookup completely ignores operator,
948 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
949 LookupNestedNameSpecifierName,
950 /// Look up a namespace name within a C++ using directive or
951 /// namespace alias definition, ignoring non-namespace names (C++
952 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000953 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +0000954 /// Look up an ordinary name that is going to be redeclared as a
955 /// name with linkage. This lookup ignores any declarations that
956 /// are outside of the current scope unless they have linkage. See
957 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
958 LookupRedeclarationWithLinkage,
959 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000960 LookupObjCProtocolName,
961 /// Look up the name of an Objective-C implementation
962 LookupObjCImplementationName,
963 /// Look up the name of an Objective-C category implementation
964 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000965 };
966
967 /// @brief Represents the results of name lookup.
968 ///
969 /// An instance of the LookupResult class captures the results of a
970 /// single name lookup, which can return no result (nothing found),
971 /// a single declaration, a set of overloaded functions, or an
972 /// ambiguity. Use the getKind() method to determine which of these
973 /// results occurred for a given lookup.
974 ///
975 /// Any non-ambiguous lookup can be converted into a single
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000976 /// (possibly NULL) @c NamedDecl* via a conversion function or the
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000977 /// getAsDecl() method. This conversion permits the common-case
978 /// usage in C and Objective-C where name lookup will always return
979 /// a single declaration.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000980 struct LookupResult {
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000981 /// The kind of entity that is actually stored within the
982 /// LookupResult object.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000983 enum {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000984 /// First is a single declaration (a NamedDecl*), which may be NULL.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000985 SingleDecl,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000986
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000987 /// First is a single declaration (an OverloadedFunctionDecl*).
988 OverloadedDeclSingleDecl,
989
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000990 /// [First, Last) is an iterator range represented as opaque
991 /// pointers used to reconstruct IdentifierResolver::iterators.
992 OverloadedDeclFromIdResolver,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000993
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000994 /// [First, Last) is an iterator range represented as opaque
995 /// pointers used to reconstruct DeclContext::lookup_iterators.
996 OverloadedDeclFromDeclContext,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000997
998 /// First is a pointer to a BasePaths structure, which is owned
999 /// by the LookupResult. Last is non-zero to indicate that the
1000 /// ambiguity is caused by two names found in base class
1001 /// subobjects of different types.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001002 AmbiguousLookupStoresBasePaths,
1003
1004 /// [First, Last) is an iterator range represented as opaque
1005 /// pointers used to reconstruct new'ed Decl*[] array containing
1006 /// found ambiguous decls. LookupResult is owner of this array.
1007 AmbiguousLookupStoresDecls
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001008 } StoredKind;
1009
1010 /// The first lookup result, whose contents depend on the kind of
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001011 /// lookup result. This may be a NamedDecl* (if StoredKind ==
1012 /// SingleDecl), OverloadedFunctionDecl* (if StoredKind ==
1013 /// OverloadedDeclSingleDecl), the opaque pointer from an
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001014 /// IdentifierResolver::iterator (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +00001015 /// OverloadedDeclFromIdResolver), a DeclContext::lookup_iterator
1016 /// (if StoredKind == OverloadedDeclFromDeclContext), or a
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001017 /// BasePaths pointer (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001018 mutable uintptr_t First;
1019
1020 /// The last lookup result, whose contents depend on the kind of
1021 /// lookup result. This may be unused (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +00001022 /// SingleDecl), it may have the same type as First (for
1023 /// overloaded function declarations), or is may be used as a
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001024 /// Boolean value (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001025 mutable uintptr_t Last;
1026
1027 /// Context - The context in which we will build any
1028 /// OverloadedFunctionDecl nodes needed by the conversion to
1029 /// Decl*.
1030 ASTContext *Context;
1031
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001032 /// @brief The kind of entity found by name lookup.
1033 enum LookupKind {
1034 /// @brief No entity found met the criteria.
1035 NotFound = 0,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001036
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001037 /// @brief Name lookup found a single declaration that met the
Douglas Gregor7176fff2009-01-15 00:26:24 +00001038 /// criteria. getAsDecl will return this declaration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001039 Found,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001040
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001041 /// @brief Name lookup found a set of overloaded functions that
Douglas Gregor7176fff2009-01-15 00:26:24 +00001042 /// met the criteria. getAsDecl will turn this set of overloaded
1043 /// functions into an OverloadedFunctionDecl.
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001044 FoundOverloaded,
Douglas Gregor7176fff2009-01-15 00:26:24 +00001045
1046 /// Name lookup results in an ambiguity because multiple
1047 /// entities that meet the lookup criteria were found in
1048 /// subobjects of different types. For example:
1049 /// @code
1050 /// struct A { void f(int); }
1051 /// struct B { void f(double); }
1052 /// struct C : A, B { };
1053 /// void test(C c) {
1054 /// c.f(0); // error: A::f and B::f come from subobjects of different
1055 /// // types. overload resolution is not performed.
1056 /// }
1057 /// @endcode
1058 AmbiguousBaseSubobjectTypes,
1059
1060 /// Name lookup results in an ambiguity because multiple
1061 /// nonstatic entities that meet the lookup criteria were found
1062 /// in different subobjects of the same type. For example:
1063 /// @code
1064 /// struct A { int x; };
1065 /// struct B : A { };
1066 /// struct C : A { };
1067 /// struct D : B, C { };
1068 /// int test(D d) {
1069 /// return d.x; // error: 'x' is found in two A subobjects (of B and C)
1070 /// }
1071 /// @endcode
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001072 AmbiguousBaseSubobjects,
1073
1074 /// Name lookup results in an ambiguity because multiple definitions
1075 /// of entity that meet the lookup criteria were found in different
1076 /// declaration contexts.
1077 /// @code
1078 /// namespace A {
1079 /// int i;
1080 /// namespace B { int i; }
1081 /// int test() {
1082 /// using namespace B;
1083 /// return i; // error 'i' is found in namespace A and A::B
1084 /// }
1085 /// }
1086 /// @endcode
1087 AmbiguousReference
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001088 };
1089
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001090 static LookupResult CreateLookupResult(ASTContext &Context, NamedDecl *D);
Douglas Gregor4bb64e72009-01-15 02:19:31 +00001091
Douglas Gregor69d993a2009-01-17 01:13:24 +00001092 static LookupResult CreateLookupResult(ASTContext &Context,
1093 IdentifierResolver::iterator F,
1094 IdentifierResolver::iterator L);
Douglas Gregor7176fff2009-01-15 00:26:24 +00001095
Douglas Gregor69d993a2009-01-17 01:13:24 +00001096 static LookupResult CreateLookupResult(ASTContext &Context,
1097 DeclContext::lookup_iterator F,
1098 DeclContext::lookup_iterator L);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001099
Douglas Gregor69d993a2009-01-17 01:13:24 +00001100 static LookupResult CreateLookupResult(ASTContext &Context, BasePaths *Paths,
1101 bool DifferentSubobjectTypes) {
1102 LookupResult Result;
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001103 Result.StoredKind = AmbiguousLookupStoresBasePaths;
Douglas Gregor69d993a2009-01-17 01:13:24 +00001104 Result.First = reinterpret_cast<uintptr_t>(Paths);
1105 Result.Last = DifferentSubobjectTypes? 1 : 0;
1106 Result.Context = &Context;
1107 return Result;
1108 }
Douglas Gregor4bb64e72009-01-15 02:19:31 +00001109
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001110 template <typename Iterator>
1111 static LookupResult CreateLookupResult(ASTContext &Context,
1112 Iterator B, std::size_t Len) {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001113 NamedDecl ** Array = new NamedDecl*[Len];
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001114 for (std::size_t Idx = 0; Idx < Len; ++Idx, ++B)
1115 Array[Idx] = *B;
1116 LookupResult Result;
1117 Result.StoredKind = AmbiguousLookupStoresDecls;
1118 Result.First = reinterpret_cast<uintptr_t>(Array);
1119 Result.Last = reinterpret_cast<uintptr_t>(Array + Len);
1120 Result.Context = &Context;
1121 return Result;
1122 }
1123
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001124 LookupKind getKind() const;
1125
1126 /// @brief Determine whether name look found something.
1127 operator bool() const { return getKind() != NotFound; }
1128
Douglas Gregor7176fff2009-01-15 00:26:24 +00001129 /// @brief Determines whether the lookup resulted in an ambiguity.
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001130 bool isAmbiguous() const {
1131 return StoredKind == AmbiguousLookupStoresBasePaths ||
1132 StoredKind == AmbiguousLookupStoresDecls;
1133 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001134
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001135 /// @brief Allows conversion of a lookup result into a
1136 /// declaration, with the same behavior as getAsDecl.
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001137 operator NamedDecl*() const { return getAsDecl(); }
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001138
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001139 NamedDecl* getAsDecl() const;
Douglas Gregor7176fff2009-01-15 00:26:24 +00001140
1141 BasePaths *getBasePaths() const;
Douglas Gregord8635172009-02-02 21:35:47 +00001142
1143 /// \brief Iterate over the results of name lookup.
1144 ///
1145 /// The @c iterator class provides iteration over the results of a
1146 /// non-ambiguous name lookup.
1147 class iterator {
1148 /// The LookupResult structure we're iterating through.
1149 LookupResult *Result;
1150
1151 /// The current position of this iterator within the sequence of
1152 /// results. This value will have the same representation as the
1153 /// @c First field in the LookupResult structure.
1154 mutable uintptr_t Current;
1155
1156 public:
Douglas Gregor47b9a1c2009-02-04 17:27:36 +00001157 typedef NamedDecl * value_type;
1158 typedef NamedDecl * reference;
1159 typedef NamedDecl * pointer;
Douglas Gregord8635172009-02-02 21:35:47 +00001160 typedef std::ptrdiff_t difference_type;
1161 typedef std::forward_iterator_tag iterator_category;
1162
1163 iterator() : Result(0), Current(0) { }
1164
1165 iterator(LookupResult *Res, uintptr_t Cur) : Result(Res), Current(Cur) { }
1166
1167 reference operator*() const;
1168
1169 pointer operator->() const { return **this; }
1170
1171 iterator &operator++();
1172
1173 iterator operator++(int) {
1174 iterator tmp(*this);
1175 ++(*this);
1176 return tmp;
1177 }
1178
1179 friend inline bool operator==(iterator const& x, iterator const& y) {
1180 return x.Current == y.Current;
1181 }
1182
1183 friend inline bool operator!=(iterator const& x, iterator const& y) {
1184 return x.Current != y.Current;
1185 }
1186 };
1187 friend class iterator;
1188
1189 iterator begin();
1190 iterator end();
Douglas Gregor31a19b62009-04-01 21:51:26 +00001191
1192 /// \brief Free the memory associated with this lookup.
1193 void Destroy();
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001194 };
1195
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001196private:
1197 typedef llvm::SmallVector<LookupResult, 3> LookupResultsVecTy;
1198
1199 std::pair<bool, LookupResult> CppLookupName(Scope *S, DeclarationName Name,
1200 LookupNameKind NameKind,
1201 bool RedeclarationOnly);
Fariborz Jahanianef79bc92009-04-07 18:28:06 +00001202 ObjCMethodDecl *FindMethodInNestedImplementations(
1203 const ObjCInterfaceDecl *IFace,
1204 const Selector &Sel);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001205
1206public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001207 /// Determines whether D is a suitable lookup result according to the
1208 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001209 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001210 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001211 switch (NameKind) {
1212 case Sema::LookupOrdinaryName:
1213 case Sema::LookupTagName:
1214 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001215 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001216 case Sema::LookupObjCProtocolName:
1217 case Sema::LookupObjCImplementationName:
1218 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001219 return D->isInIdentifierNamespace(IDNS);
1220
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001221 case Sema::LookupOperatorName:
1222 return D->isInIdentifierNamespace(IDNS) &&
1223 !D->getDeclContext()->isRecord();
1224
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001225 case Sema::LookupNestedNameSpecifierName:
1226 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
1227
1228 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001229 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001230 }
1231
1232 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001233 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001234 return false;
1235 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001236
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001237 LookupResult LookupName(Scope *S, DeclarationName Name,
1238 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001239 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001240 bool AllowBuiltinCreation = false,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001241 SourceLocation Loc = SourceLocation());
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001242 LookupResult LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
1243 LookupNameKind NameKind,
1244 bool RedeclarationOnly = false);
John McCall67d1a672009-08-06 02:15:43 +00001245 Decl *LookupQualifiedNameWithType(DeclContext *LookupCtx,
1246 DeclarationName Name,
1247 QualType T);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001248 LookupResult LookupParsedName(Scope *S, const CXXScopeSpec *SS,
1249 DeclarationName Name,
1250 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001251 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001252 bool AllowBuiltinCreation = false,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001253 SourceLocation Loc = SourceLocation());
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001254
Douglas Gregor6e378de2009-04-23 23:18:26 +00001255 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001256 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001257
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001258 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
1259 QualType T1, QualType T2,
1260 FunctionSet &Functions);
1261
1262 void ArgumentDependentLookup(DeclarationName Name,
1263 Expr **Args, unsigned NumArgs,
1264 FunctionSet &Functions);
1265
Douglas Gregorfa047642009-02-04 00:32:51 +00001266 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1267 AssociatedNamespaceSet &AssociatedNamespaces,
John McCall6ff07852009-08-07 22:18:02 +00001268 AssociatedClassSet &AssociatedClasses);
Douglas Gregorfa047642009-02-04 00:32:51 +00001269
Douglas Gregor7176fff2009-01-15 00:26:24 +00001270 bool DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
1271 SourceLocation NameLoc,
1272 SourceRange LookupRange = SourceRange());
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001273 //@}
1274
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001275 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001276 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001277 Scope *S, bool ForRedeclaration,
1278 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001279 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1280 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001281 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001282
1283 // More parsing and symbol table subroutines.
1284
Reid Spencer5f016e22007-07-11 17:01:13 +00001285 // Decl attributes - this routine is the top level dispatcher.
Douglas Gregor9cdda0c2009-06-17 21:51:59 +00001286 void ProcessDeclAttributes(Scope *S, Decl *D, const Declarator &PD);
1287 void ProcessDeclAttributeList(Scope *S, Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001288
Steve Naroff3c2eb662008-02-10 21:38:56 +00001289 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1290 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001291 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1292 ObjCMethodDecl *IntfMethod);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001293
1294 NamespaceDecl *GetStdNamespace();
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001295
1296 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001297 ObjCInterfaceDecl *IDecl);
Steve Naroff3c2eb662008-02-10 21:38:56 +00001298
Chris Lattner823c44e2009-01-06 07:27:21 +00001299 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001300 /// methods declared in protocol, and those referenced by it.
1301 /// \param IDecl - Used for checking for methods which may have been
1302 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001303 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1304 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001305 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001306 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001307 const llvm::DenseSet<Selector> &ClsMap,
1308 ObjCInterfaceDecl *IDecl);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001309
Steve Naroffa5997c42007-10-02 21:43:37 +00001310 /// CheckImplementationIvars - This routine checks if the instance variables
1311 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001312 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1313 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001314 SourceLocation Loc);
Steve Naroffa5997c42007-10-02 21:43:37 +00001315
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001316 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001317 /// remains unimplemented in the class or category @implementation.
1318 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1319 ObjCContainerDecl* IDecl,
1320 bool IncompleteImpl = false);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001321
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001322 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1323 /// true, or false, accordingly.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001324 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001325 const ObjCMethodDecl *PrevMethod,
1326 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001327
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001328 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1329 /// or protocol against those declared in their implementations.
1330 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1331 const llvm::DenseSet<Selector> &ClsMap,
1332 llvm::DenseSet<Selector> &InsMapSeen,
1333 llvm::DenseSet<Selector> &ClsMapSeen,
1334 ObjCImplDecl* IMPDecl,
1335 ObjCContainerDecl* IDecl,
1336 bool &IncompleteImpl,
1337 bool ImmediateClass);
1338
Steve Naroff58ff9e82007-10-14 00:58:41 +00001339 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1340 /// unit are added to a global pool. This allows us to efficiently associate
1341 /// a selector with a method declaraation for purposes of typechecking
1342 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001343 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff58ff9e82007-10-14 00:58:41 +00001344
Steve Naroff037cda52008-09-30 14:38:43 +00001345 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1346 /// there are multiple signatures.
1347 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001348
1349 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1350 /// there are multiple signatures.
1351 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Steve Naroff037cda52008-09-30 14:38:43 +00001352
Steve Naroff58ff9e82007-10-14 00:58:41 +00001353 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001354 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001355 //===--------------------------------------------------------------------===//
1356 // Statement Parsing Callbacks: SemaStmt.cpp.
1357public:
Anders Carlsson6b1d2832009-05-17 21:11:30 +00001358 virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr);
Sebastian Redla60528c2008-12-21 12:04:03 +00001359
1360 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1361 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1362 MultiStmtArg Elts,
1363 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001364 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001365 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001366 SourceLocation EndLoc);
Sebastian Redl117054a2008-12-28 16:13:43 +00001367 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1368 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001369 SourceLocation ColonLoc);
1370 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
1371
Sebastian Redl117054a2008-12-28 16:13:43 +00001372 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1373 SourceLocation ColonLoc,
1374 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001375 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1376 IdentifierInfo *II,
1377 SourceLocation ColonLoc,
1378 StmtArg SubStmt);
Anders Carlssona99fad82009-05-17 18:26:53 +00001379 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
1380 FullExprArg CondVal, StmtArg ThenVal,
1381 SourceLocation ElseLoc, StmtArg ElseVal);
Sebastian Redlde307472009-01-11 00:38:46 +00001382 virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond);
1383 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1384 StmtArg Switch, StmtArg Body);
Anders Carlsson7f537c12009-05-17 21:22:26 +00001385 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
1386 FullExprArg Cond, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001387 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
Chris Lattner98913592009-06-12 23:04:47 +00001388 SourceLocation WhileLoc,
1389 SourceLocation CondLParen, ExprArg Cond,
1390 SourceLocation CondRParen);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001391
1392 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1393 SourceLocation LParenLoc,
1394 StmtArg First, ExprArg Second,
1395 ExprArg Third, SourceLocation RParenLoc,
1396 StmtArg Body);
1397 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1398 SourceLocation LParenLoc,
1399 StmtArg First, ExprArg Second,
1400 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001401
1402 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1403 SourceLocation LabelLoc,
1404 IdentifierInfo *LabelII);
1405 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1406 SourceLocation StarLoc,
1407 ExprArg DestExp);
1408 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1409 Scope *CurScope);
1410 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1411 Scope *CurScope);
1412
1413 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Anders Carlssonf53b4432009-08-18 16:11:00 +00001414 ExprArg RetValExp);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001415 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1416 Expr *RetValExp);
1417
Sebastian Redl3037ed02009-01-18 16:53:17 +00001418 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1419 bool IsSimple,
1420 bool IsVolatile,
1421 unsigned NumOutputs,
1422 unsigned NumInputs,
1423 std::string *Names,
1424 MultiExprArg Constraints,
1425 MultiExprArg Exprs,
1426 ExprArg AsmString,
1427 MultiExprArg Clobbers,
1428 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001429
1430 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1431 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001432 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001433 StmtArg CatchList);
1434
1435 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1436 StmtArg Body);
1437
1438 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1439 StmtArg Try,
1440 StmtArg Catch, StmtArg Finally);
1441
1442 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001443 ExprArg Throw,
1444 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001445 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1446 ExprArg SynchExpr,
1447 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001448
Douglas Gregord308e622009-05-18 20:51:54 +00001449 VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
Argyrios Kyrtzidisa1d56622009-08-19 01:27:57 +00001450 DeclaratorInfo *DInfo,
Douglas Gregord308e622009-05-18 20:51:54 +00001451 IdentifierInfo *Name,
1452 SourceLocation Loc,
1453 SourceRange Range);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001454 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Douglas Gregord308e622009-05-18 20:51:54 +00001455
Sebastian Redl4b07b292008-12-22 19:15:10 +00001456 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001457 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001458 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001459 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1460 StmtArg TryBlock,
1461 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001462 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001463
Anders Carlsson636463e2009-07-30 22:17:18 +00001464 /// DiagnoseUnusedExprResult - If the statement passed in is an expression
1465 /// whose result is unused, warn.
1466 void DiagnoseUnusedExprResult(const Stmt *S);
1467
Reid Spencer5f016e22007-07-11 17:01:13 +00001468 //===--------------------------------------------------------------------===//
1469 // Expression Parsing Callbacks: SemaExpr.cpp.
1470
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001471 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001472 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
1473 ObjCMethodDecl *Getter,
1474 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001475 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1476 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001477
Douglas Gregorac7610d2009-06-22 20:57:11 +00001478 virtual ExpressionEvaluationContext
1479 PushExpressionEvaluationContext(ExpressionEvaluationContext NewContext);
1480
1481 virtual void
1482 PopExpressionEvaluationContext(ExpressionEvaluationContext OldContext,
1483 ExpressionEvaluationContext NewContext);
1484
Douglas Gregore0762c92009-06-19 23:52:42 +00001485 void MarkDeclarationReferenced(SourceLocation Loc, Decl *D);
1486
Reid Spencer5f016e22007-07-11 17:01:13 +00001487 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001488 virtual SourceRange getExprRange(ExprTy *E) const;
1489
Sebastian Redlcd965b92009-01-18 18:53:16 +00001490 virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
1491 IdentifierInfo &II,
1492 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001493 const CXXScopeSpec *SS = 0,
1494 bool isAddressOfOperand = false);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001495 virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001496 SourceLocation OperatorLoc,
1497 OverloadedOperatorKind Op,
1498 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001499 const CXXScopeSpec &SS,
1500 bool isAddressOfOperand);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001501 virtual OwningExprResult ActOnCXXConversionFunctionExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001502 SourceLocation OperatorLoc,
1503 TypeTy *Ty,
1504 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001505 const CXXScopeSpec &SS,
1506 bool isAddressOfOperand);
Anders Carlssone41590d2009-06-24 00:10:43 +00001507 OwningExprResult BuildDeclRefExpr(NamedDecl *D, QualType Ty,
1508 SourceLocation Loc, bool TypeDependent,
1509 bool ValueDependent,
1510 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001511 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1512 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001513 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001514 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1515 FieldDecl *Field,
1516 Expr *BaseObjectExpr = 0,
1517 SourceLocation OpLoc = SourceLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001518 OwningExprResult ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
1519 DeclarationName Name,
1520 bool HasTrailingLParen,
1521 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001522 bool isAddressOfOperand = false);
Douglas Gregor751f9a42009-06-30 15:47:41 +00001523 OwningExprResult BuildDeclarationNameExpr(SourceLocation Loc, NamedDecl *D,
1524 bool HasTrailingLParen,
1525 const CXXScopeSpec *SS,
1526 bool isAddressOfOperand);
1527
Sebastian Redlcd965b92009-01-18 18:53:16 +00001528 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1529 tok::TokenKind Kind);
1530 virtual OwningExprResult ActOnNumericConstant(const Token &);
1531 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1532 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1533 ExprArg Val);
Nate Begeman2ef13e52009-08-10 23:49:36 +00001534 virtual OwningExprResult ActOnParenListExpr(SourceLocation L,
1535 SourceLocation R,
1536 MultiExprArg Val);
1537
Steve Narofff69936d2007-09-16 03:34:24 +00001538 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001539 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001540 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1541 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001542
Reid Spencer5f016e22007-07-11 17:01:13 +00001543 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001544 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
1545 unsigned OpcIn,
1546 ExprArg InputArg);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001547 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1548 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001549
Douglas Gregorba498172009-03-13 21:01:28 +00001550 OwningExprResult CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1551 bool isSizeOf, SourceRange R);
1552 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1553 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001554 virtual OwningExprResult
1555 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1556 void *TyOrEx, const SourceRange &ArgRange);
Douglas Gregorba498172009-03-13 21:01:28 +00001557
Chris Lattner31e21e02009-01-24 20:17:12 +00001558 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001559 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1560 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001561
1562 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1563 tok::TokenKind Kind,
1564 ExprArg Input);
1565
1566 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1567 SourceLocation LLoc,
1568 ExprArg Idx,
1569 SourceLocation RLoc);
1570 virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
1571 SourceLocation OpLoc,
1572 tok::TokenKind OpKind,
1573 SourceLocation MemberLoc,
Fariborz Jahaniana6e3ac52009-03-04 22:30:12 +00001574 IdentifierInfo &Member,
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001575 DeclPtrTy ImplDecl,
1576 const CXXScopeSpec *SS = 0);
Fariborz Jahanian393612e2009-07-21 22:36:06 +00001577 virtual void ActOnDefaultCtorInitializers(DeclPtrTy CDtorDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001578 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001579 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001580 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001581 Expr **Args, unsigned NumArgs,
1582 SourceLocation RParenLoc);
Fariborz Jahanian87595e42009-07-23 23:32:59 +00001583 void BuildBaseOrMemberInitializers(ASTContext &C,
1584 CXXConstructorDecl *Constructor,
1585 CXXBaseOrMemberInitializer **Initializers,
1586 unsigned NumInitializers
1587 );
Sebastian Redl0eb23302009-01-19 00:08:26 +00001588
Steve Narofff69936d2007-09-16 03:34:24 +00001589 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001590 /// This provides the location of the left/right parens and a list of comma
1591 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001592 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1593 SourceLocation LParenLoc,
1594 MultiExprArg Args,
1595 SourceLocation *CommaLocs,
1596 SourceLocation RParenLoc);
1597
Nate Begeman2ef13e52009-08-10 23:49:36 +00001598 virtual OwningExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
1599 TypeTy *Ty, SourceLocation RParenLoc,
1600 ExprArg Op);
1601
1602 OwningExprResult MaybeConvertParenListExprToParenExpr(Scope *S, ExprArg ME);
1603 OwningExprResult ActOnCastOfParenListExpr(Scope *S, SourceLocation LParenLoc,
1604 SourceLocation RParenLoc, ExprArg E,
1605 QualType Ty);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001606
1607 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1608 TypeTy *Ty,
1609 SourceLocation RParenLoc,
1610 ExprArg Op);
1611
1612 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1613 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001614 SourceLocation RParenLoc);
1615
Douglas Gregor05c13a32009-01-22 00:58:24 +00001616 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1617 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001618 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001619 OwningExprResult Init);
1620
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001621 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1622 tok::TokenKind Kind,
1623 ExprArg LHS, ExprArg RHS);
1624 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1625 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001626
Steve Narofff69936d2007-09-16 03:34:24 +00001627 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001628 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001629 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1630 SourceLocation ColonLoc,
1631 ExprArg Cond, ExprArg LHS,
1632 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001633
Steve Naroff1b273c42007-09-16 14:56:35 +00001634 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001635 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1636 SourceLocation LabLoc,
1637 IdentifierInfo *LabelII);
1638
1639 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1640 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001641
1642 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001643 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1644 SourceLocation BuiltinLoc,
1645 SourceLocation TypeLoc,
1646 TypeTy *Arg1,
1647 OffsetOfComponent *CompPtr,
1648 unsigned NumComponents,
1649 SourceLocation RParenLoc);
1650
Steve Naroffd34e9152007-08-01 22:05:33 +00001651 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001652 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1653 TypeTy *arg1, TypeTy *arg2,
1654 SourceLocation RPLoc);
1655
Steve Naroffd04fdd52007-08-03 21:21:27 +00001656 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001657 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1658 ExprArg cond, ExprArg expr1,
1659 ExprArg expr2, SourceLocation RPLoc);
1660
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001661 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001662 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1663 ExprArg expr, TypeTy *type,
1664 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001665
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001666 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001667 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001668
Steve Naroff4eb206b2008-09-03 18:15:37 +00001669 //===------------------------- "Block" Extension ------------------------===//
1670
1671 /// ActOnBlockStart - This callback is invoked when a block literal is
1672 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001673 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001674
Steve Naroff090276f2008-10-10 01:28:17 +00001675 /// ActOnBlockArguments - This callback allows processing of block arguments.
1676 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001677 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001678
Steve Naroff4eb206b2008-09-03 18:15:37 +00001679 /// ActOnBlockError - If there is an error parsing a block, this callback
1680 /// is invoked to pop the information about the block from the action impl.
1681 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001682
Steve Naroff4eb206b2008-09-03 18:15:37 +00001683 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1684 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001685 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1686 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001687
Chris Lattner76a642f2009-02-15 22:43:40 +00001688 //===---------------------------- C++ Features --------------------------===//
1689
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001690 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001691 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1692 IdentifierInfo *Ident,
1693 SourceLocation LBrace);
1694 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001695
Chris Lattnerb28317a2009-03-28 19:18:32 +00001696 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1697 SourceLocation UsingLoc,
1698 SourceLocation NamespcLoc,
1699 const CXXScopeSpec &SS,
1700 SourceLocation IdentLoc,
1701 IdentifierInfo *NamespcName,
1702 AttributeList *AttrList);
Anders Carlssondbb00942009-03-28 05:27:17 +00001703
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001704 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1705
Chris Lattnerb28317a2009-03-28 19:18:32 +00001706 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001707 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001708 SourceLocation AliasLoc,
1709 IdentifierInfo *Alias,
1710 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001711 SourceLocation IdentLoc,
1712 IdentifierInfo *Ident);
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001713
1714 virtual DeclPtrTy ActOnUsingDeclaration(Scope *CurScope,
1715 SourceLocation UsingLoc,
1716 const CXXScopeSpec &SS,
1717 SourceLocation IdentLoc,
1718 IdentifierInfo *TargetName,
Anders Carlsson0c6139d2009-06-27 00:27:47 +00001719 OverloadedOperatorKind Op,
Douglas Gregor9cfbe482009-06-20 00:51:54 +00001720 AttributeList *AttrList,
1721 bool IsTypeName);
Anders Carlssondbb00942009-03-28 05:27:17 +00001722
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001723 /// AddCXXDirectInitializerToDecl - This action is called immediately after
1724 /// ActOnDeclarator, when a C++ direct initializer is present.
1725 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001726 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001727 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001728 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001729 SourceLocation *CommaLocs,
1730 SourceLocation RParenLoc);
1731
Anders Carlsson49d44012009-04-24 05:16:06 +00001732 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1733 /// and sets it as the initializer for the the passed in VarDecl.
Anders Carlsson930e8d02009-04-16 23:50:50 +00001734 void InitializeVarWithConstructor(VarDecl *VD,
1735 CXXConstructorDecl *Constructor,
1736 QualType DeclInitType,
1737 Expr **Exprs, unsigned NumExprs);
Anders Carlsson9abf2ae2009-08-16 05:13:48 +00001738
1739 Expr *BuildCXXConstructExpr(QualType DeclInitType,
1740 CXXConstructorDecl *Constructor,
1741 Expr **Exprs, unsigned NumExprs);
1742
Fariborz Jahanianb2c352e2009-08-05 17:03:54 +00001743 /// BuildCXXConstructExpr - Creates a complete call to a constructor,
1744 /// including handling of its default argument expressions.
Anders Carlsson089c2602009-08-15 23:41:35 +00001745 Expr *BuildCXXConstructExpr(QualType DeclInitType,
1746 CXXConstructorDecl *Constructor,
1747 bool Elidable,
1748 Expr **Exprs, unsigned NumExprs);
Anders Carlsson089c2602009-08-15 23:41:35 +00001749
Fariborz Jahaniana83f7ed2009-08-03 19:13:25 +00001750 /// FinalizeVarWithDestructor - Prepare for calling destructor on the
1751 /// constructed variable.
1752 void FinalizeVarWithDestructor(VarDecl *VD, QualType DeclInitType);
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001753
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001754 /// DefineImplicitDefaultConstructor - Checks for feasibility of
Fariborz Jahanianf8dcb862009-06-19 19:55:27 +00001755 /// defining this constructor as the default constructor.
1756 void DefineImplicitDefaultConstructor(SourceLocation CurrentLocation,
1757 CXXConstructorDecl *Constructor);
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001758
Fariborz Jahanian8d2b3562009-06-26 23:49:16 +00001759 /// DefineImplicitDestructor - Checks for feasibility of
1760 /// defining this destructor as the default destructor.
1761 void DefineImplicitDestructor(SourceLocation CurrentLocation,
1762 CXXDestructorDecl *Destructor);
1763
Fariborz Jahanian485f0872009-06-22 23:34:40 +00001764 /// DefineImplicitCopyConstructor - Checks for feasibility of
1765 /// defining this constructor as the copy constructor.
1766 void DefineImplicitCopyConstructor(SourceLocation CurrentLocation,
1767 CXXConstructorDecl *Constructor,
1768 unsigned TypeQuals);
Fariborz Jahanianc75bc2d2009-06-25 21:45:19 +00001769
1770 /// DefineImplicitOverloadedAssign - Checks for feasibility of
1771 /// defining implicit this overloaded assignment operator.
1772 void DefineImplicitOverloadedAssign(SourceLocation CurrentLocation,
1773 CXXMethodDecl *MethodDecl);
1774
1775 /// getAssignOperatorMethod - Returns the default copy assignmment operator
1776 /// for the class.
1777 CXXMethodDecl *getAssignOperatorMethod(ParmVarDecl *Decl,
1778 CXXRecordDecl *ClassDecl);
Anders Carlssondef11992009-05-30 20:36:53 +00001779
1780 /// MaybeBindToTemporary - If the passed in expression has a record type with
1781 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
1782 /// it simply returns the passed in expression.
1783 OwningExprResult MaybeBindToTemporary(Expr *E);
Anders Carlssonb27615a2009-05-30 22:47:03 +00001784
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001785 /// InitializationKind - Represents which kind of C++ initialization
1786 /// [dcl.init] a routine is to perform.
1787 enum InitializationKind {
1788 IK_Direct, ///< Direct initialization
1789 IK_Copy, ///< Copy initialization
1790 IK_Default ///< Default initialization
1791 };
1792
Douglas Gregor18fe5682008-11-03 20:45:27 +00001793 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001794 PerformInitializationByConstructor(QualType ClassType,
1795 Expr **Args, unsigned NumArgs,
1796 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001797 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001798 InitializationKind Kind);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001799
Douglas Gregor49badde2008-10-27 19:41:14 +00001800 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001801 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1802 tok::TokenKind Kind,
1803 SourceLocation LAngleBracketLoc,
1804 TypeTy *Ty,
1805 SourceLocation RAngleBracketLoc,
1806 SourceLocation LParenLoc,
1807 ExprArg E,
1808 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001809
Sebastian Redlf53597f2009-03-15 17:47:39 +00001810 /// ActOnCXXTypeid - Parse typeid( something ).
1811 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1812 SourceLocation LParenLoc, bool isType,
1813 void *TyOrExpr,
1814 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001815
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001816 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001817 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001818
Steve Naroff1b273c42007-09-16 14:56:35 +00001819 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001820 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1821 tok::TokenKind Kind);
1822
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001823 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1824 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1825
Chris Lattner50dd2892008-02-26 00:51:44 +00001826 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001827 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1828 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001829 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001830
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001831 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1832 /// Can be interpreted either as function-style casting ("int(x)")
1833 /// or class type construction ("ClassType(x,y,z)")
1834 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001835 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1836 TypeTy *TypeRep,
1837 SourceLocation LParenLoc,
1838 MultiExprArg Exprs,
1839 SourceLocation *CommaLocs,
1840 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001841
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001842 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001843 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1844 SourceLocation PlacementLParen,
1845 MultiExprArg PlacementArgs,
1846 SourceLocation PlacementRParen,
1847 bool ParenTypeId, Declarator &D,
1848 SourceLocation ConstructorLParen,
1849 MultiExprArg ConstructorArgs,
1850 SourceLocation ConstructorRParen);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001851 OwningExprResult BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
1852 SourceLocation PlacementLParen,
1853 MultiExprArg PlacementArgs,
1854 SourceLocation PlacementRParen,
1855 bool ParenTypeId,
1856 QualType AllocType,
1857 SourceLocation TypeLoc,
1858 SourceRange TypeRange,
1859 ExprArg ArraySize,
1860 SourceLocation ConstructorLParen,
1861 MultiExprArg ConstructorArgs,
1862 SourceLocation ConstructorRParen);
1863
1864 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1865 SourceRange R);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001866 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1867 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001868 Expr **PlaceArgs, unsigned NumPlaceArgs,
1869 FunctionDecl *&OperatorNew,
1870 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001871 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1872 DeclarationName Name, Expr** Args,
1873 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001874 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001875 void DeclareGlobalNewDelete();
1876 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1877 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001878
1879 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001880 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1881 bool UseGlobal, bool ArrayForm,
1882 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001883
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001884 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
1885 /// C++ if/switch/while/for statement.
1886 /// e.g: "if (int x = f()) {...}"
Sebastian Redlf53597f2009-03-15 17:47:39 +00001887 virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001888 SourceLocation StartLoc,
1889 Declarator &D,
1890 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001891 ExprArg AssignExprVal);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001892
Sebastian Redl64b45f72009-01-05 20:52:13 +00001893 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1894 /// pseudo-functions.
1895 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1896 SourceLocation KWLoc,
1897 SourceLocation LParen,
1898 TypeTy *Ty,
1899 SourceLocation RParen);
1900
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001901 /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is
1902 /// non-empty, will create a new CXXExprWithTemporaries expression.
1903 /// Otherwise, just returs the passed in expression.
Anders Carlssonf54741e2009-06-16 03:37:31 +00001904 Expr *MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1905 bool ShouldDestroyTemporaries);
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001906
Anders Carlsson165a0a02009-05-17 18:41:29 +00001907 virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr);
1908
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001909 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001910
Douglas Gregorf59a56e2009-07-21 23:53:31 +00001911 DeclContext *computeDeclContext(const CXXScopeSpec &SS,
1912 bool EnteringContext = false);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001913 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001914 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1915 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001916
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001917 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1918 /// global scope ('::').
1919 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1920 SourceLocation CCLoc);
1921
1922 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1923 /// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
1924 /// we want to resolve "bar::". 'SS' is empty or the previously parsed
1925 /// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
1926 /// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
1927 /// Returns a CXXScopeTy* object representing the C++ scope.
1928 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1929 const CXXScopeSpec &SS,
1930 SourceLocation IdLoc,
1931 SourceLocation CCLoc,
Douglas Gregor2def4832008-11-17 20:34:05 +00001932 IdentifierInfo &II);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001933
Douglas Gregor39a8de12009-02-25 19:37:18 +00001934 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1935 /// nested-name-specifier that involves a template-id, e.g.,
1936 /// "foo::bar<int, float>::", and now we need to build a scope
1937 /// specifier. \p SS is empty or the previously parsed nested-name
1938 /// part ("foo::"), \p Type is the already-parsed class template
1939 /// specialization (or other template-id that names a type), \p
1940 /// TypeRange is the source range where the type is located, and \p
1941 /// CCLoc is the location of the trailing '::'.
1942 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1943 const CXXScopeSpec &SS,
1944 TypeTy *Type,
1945 SourceRange TypeRange,
1946 SourceLocation CCLoc);
1947
Douglas Gregorfe85ced2009-08-06 03:17:00 +00001948 /// ActOnCXXEnterMemberScope - Called when a C++ class member accessor ('.'
1949 /// or '->') is parsed. After this method is called, according to
1950 /// [C++ 3.4.5p4], qualified-ids should be looked up in the contexts of both
1951 /// the entire postfix-expression and the scope of the class of the object
1952 /// expression.
1953 /// 'SS' should be an empty CXXScopeSpec to be filled with the class's scope.
1954 virtual OwningExprResult ActOnCXXEnterMemberScope(Scope *S, CXXScopeSpec &SS,
1955 ExprArg Base,
1956 tok::TokenKind OpKind);
1957
1958 /// ActOnCXXExitMemberScope - Called when a postfix-expression that previously
1959 /// invoked ActOnCXXEnterMemberScope() is finished. 'SS' is the same
1960 /// CXXScopeSpec that was passed to ActOnCXXEnterMemberScope. Used to
1961 /// indicate that names should revert to being looked up in the defining
1962 /// scope.
1963 virtual void ActOnCXXExitMemberScope(Scope *S, const CXXScopeSpec &SS);
1964
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001965 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1966 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1967 /// After this method is called, according to [C++ 3.4.3p3], names should be
1968 /// looked up in the declarator-id's scope, until the declarator is parsed and
1969 /// ActOnCXXExitDeclaratorScope is called.
1970 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1971 virtual void ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
1972
1973 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1974 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1975 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1976 /// Used to indicate that names should revert to being looked up in the
1977 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00001978 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001979
Argyrios Kyrtzidis0ffd9ff2009-06-17 22:50:06 +00001980 /// ActOnCXXEnterDeclInitializer - Invoked when we are about to parse an
1981 /// initializer for the declaration 'Dcl'.
1982 /// After this method is called, according to [C++ 3.4.1p13], if 'Dcl' is a
1983 /// static data member of class X, names should be looked up in the scope of
1984 /// class X.
1985 virtual void ActOnCXXEnterDeclInitializer(Scope *S, DeclPtrTy Dcl);
1986
1987 /// ActOnCXXExitDeclInitializer - Invoked after we are finished parsing an
1988 /// initializer for the declaration 'Dcl'.
1989 virtual void ActOnCXXExitDeclInitializer(Scope *S, DeclPtrTy Dcl);
1990
Anders Carlsson55085182007-08-21 17:43:55 +00001991 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00001992 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
1993 ExprTy **Strings,
1994 unsigned NumStrings);
Anders Carlssonfc0f0212009-06-07 18:45:35 +00001995
1996 Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
1997 QualType EncodedType,
1998 SourceLocation RParenLoc);
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001999 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00002000 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00002001 SourceLocation LParenLoc,
2002 TypeTy *Ty,
2003 SourceLocation RParenLoc);
2004
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002005 // ParseObjCSelectorExpression - Build selector expression for @selector
2006 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
2007 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00002008 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00002009 SourceLocation LParenLoc,
2010 SourceLocation RParenLoc);
2011
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00002012 // ParseObjCProtocolExpression - Build protocol expression for @protocol
2013 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
2014 SourceLocation AtLoc,
2015 SourceLocation ProtoLoc,
2016 SourceLocation LParenLoc,
2017 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002018
2019 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00002020 // C++ Declarations
2021 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00002022 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
2023 SourceLocation ExternLoc,
2024 SourceLocation LangLoc,
2025 const char *Lang,
2026 unsigned StrSize,
2027 SourceLocation LBraceLoc);
2028 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
2029 DeclPtrTy LinkageSpec,
2030 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00002031
2032
2033 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002034 // C++ Classes
2035 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00002036 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
2037 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00002038
Chris Lattnerb28317a2009-03-28 19:18:32 +00002039 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
2040 Declarator &D,
2041 ExprTy *BitfieldWidth,
Sebastian Redle2b68332009-04-12 17:16:29 +00002042 ExprTy *Init,
2043 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002044
Chris Lattnerb28317a2009-03-28 19:18:32 +00002045 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002046 Scope *S,
Fariborz Jahanianbcfad542009-06-30 23:26:25 +00002047 const CXXScopeSpec &SS,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002048 IdentifierInfo *MemberOrBase,
Fariborz Jahanian96174332009-07-01 19:21:19 +00002049 TypeTy *TemplateTypeTy,
Douglas Gregor7ad83902008-11-05 04:29:56 +00002050 SourceLocation IdLoc,
2051 SourceLocation LParenLoc,
2052 ExprTy **Args, unsigned NumArgs,
2053 SourceLocation *CommaLocs,
2054 SourceLocation RParenLoc);
2055
Eli Friedman59c04372009-07-29 19:44:27 +00002056 MemInitResult BuildMemberInitializer(FieldDecl *Member, Expr **Args,
2057 unsigned NumArgs, SourceLocation IdLoc,
2058 SourceLocation RParenLoc);
2059
2060 MemInitResult BuildBaseInitializer(QualType BaseType, Expr **Args,
2061 unsigned NumArgs, SourceLocation IdLoc,
2062 SourceLocation RParenLoc,
2063 CXXRecordDecl *ClassDecl);
2064
Douglas Gregor396b7cd2008-11-03 17:51:48 +00002065 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
2066
Chris Lattnerb28317a2009-03-28 19:18:32 +00002067 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00002068 SourceLocation ColonLoc,
2069 MemInitTy **MemInits, unsigned NumMemInits);
2070
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002071 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002072 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00002073 SourceLocation LBrac,
2074 SourceLocation RBrac);
2075
Douglas Gregor6569d682009-05-27 23:11:45 +00002076 virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002077 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
2078 DeclPtrTy Method);
2079 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
2080 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
2081 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00002082
Chris Lattnerb28317a2009-03-28 19:18:32 +00002083 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
2084 ExprArg AssertExpr,
2085 ExprArg AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00002086
John McCall67d1a672009-08-06 02:15:43 +00002087 virtual DeclPtrTy ActOnFriendDecl(Scope *S,
John McCall3f9a8a62009-08-11 06:59:38 +00002088 llvm::PointerUnion<const DeclSpec*,Declarator*> D,
2089 bool IsDefinition);
Anders Carlsson00338362009-05-11 22:55:49 +00002090
Chris Lattner65401802009-04-25 08:28:21 +00002091 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
2092 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002093 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00002094 QualType CheckDestructorDeclarator(Declarator &D,
2095 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00002096 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00002097 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002098 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00002099
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002100 //===--------------------------------------------------------------------===//
2101 // C++ Derived Classes
2102 //
2103
2104 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00002105 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
2106 SourceRange SpecifierRange,
2107 bool Virtual, AccessSpecifier Access,
2108 QualType BaseType,
2109 SourceLocation BaseLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002110 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002111 SourceRange SpecifierRange,
2112 bool Virtual, AccessSpecifier Access,
Douglas Gregor2943aed2009-03-03 04:44:36 +00002113 TypeTy *basetype, SourceLocation
2114 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002115
Douglas Gregor2943aed2009-03-03 04:44:36 +00002116 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
2117 unsigned NumBases);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002118 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00002119 unsigned NumBases);
2120
2121 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002122 bool IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths);
Douglas Gregor7176fff2009-01-15 00:26:24 +00002123 bool LookupInBases(CXXRecordDecl *Class, const MemberLookupCriteria& Criteria,
2124 BasePaths &Paths);
Douglas Gregor0575d4a2008-10-24 16:17:19 +00002125 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2126 SourceLocation Loc, SourceRange Range);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002127 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2128 unsigned InaccessibleBaseID,
2129 unsigned AmbigiousBaseConvID,
2130 SourceLocation Loc, SourceRange Range,
2131 DeclarationName Name);
2132
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +00002133 std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002134
Sebastian Redl23c7d062009-07-07 20:29:57 +00002135 /// CheckOverridingFunctionReturnType - Checks whether the return types are
2136 /// covariant, according to C++ [class.virtual]p5.
2137 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
Anders Carlssond7ba27d2009-05-14 01:09:04 +00002138 const CXXMethodDecl *Old);
Sebastian Redl23c7d062009-07-07 20:29:57 +00002139
2140 /// CheckOverridingFunctionExceptionSpec - Checks whether the exception
2141 /// spec is a subset of base spec.
2142 bool CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New,
2143 const CXXMethodDecl *Old);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00002144
Anders Carlsson29f006b2009-03-27 05:05:05 +00002145 //===--------------------------------------------------------------------===//
2146 // C++ Access Control
2147 //
Sebastian Redl726212f2009-07-18 14:32:15 +00002148
Anders Carlsson29f006b2009-03-27 05:05:05 +00002149 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
2150 NamedDecl *PrevMemberDecl,
2151 AccessSpecifier LexicalAS);
Sebastian Redl726212f2009-07-18 14:32:15 +00002152
2153 const CXXBaseSpecifier *FindInaccessibleBase(QualType Derived, QualType Base,
2154 BasePaths &Paths,
2155 bool NoPrivileges = false);
2156
2157 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00002158 unsigned InaccessibleBaseID,
2159 BasePaths& Paths, SourceLocation AccessLoc,
2160 DeclarationName Name);
Sebastian Redl726212f2009-07-18 14:32:15 +00002161
2162
Anders Carlsson8211eff2009-03-24 01:19:16 +00002163 enum AbstractDiagSelID {
2164 AbstractNone = -1,
2165 AbstractReturnType,
2166 AbstractParamType,
2167 AbstractVariableType,
2168 AbstractFieldType
2169 };
2170
2171 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00002172 AbstractDiagSelID SelID = AbstractNone,
2173 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00002174
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00002175 //===--------------------------------------------------------------------===//
2176 // C++ Overloaded Operators [C++ 13.5]
2177 //
2178
2179 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
2180
Douglas Gregor72c3f312008-12-05 18:15:24 +00002181 //===--------------------------------------------------------------------===//
2182 // C++ Templates [C++ 14]
2183 //
Douglas Gregorc45c2322009-03-31 00:43:58 +00002184 virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
Douglas Gregor7532dc62009-03-30 22:58:21 +00002185 TemplateTy &Template,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002186 const CXXScopeSpec *SS = 0);
Douglas Gregor72c3f312008-12-05 18:15:24 +00002187 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002188 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002189
Anders Carlsson941df7d2009-06-12 19:58:00 +00002190 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename, bool Ellipsis,
2191 SourceLocation EllipsisLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002192 SourceLocation KeyLoc,
2193 IdentifierInfo *ParamName,
2194 SourceLocation ParamNameLoc,
2195 unsigned Depth, unsigned Position);
2196 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002197 SourceLocation EqualLoc,
2198 SourceLocation DefaultLoc,
2199 TypeTy *Default);
2200
Douglas Gregor2943aed2009-03-03 04:44:36 +00002201 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002202 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
2203 unsigned Depth,
2204 unsigned Position);
2205 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002206 SourceLocation EqualLoc,
2207 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00002208 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
2209 SourceLocation TmpLoc,
2210 TemplateParamsTy *Params,
2211 IdentifierInfo *ParamName,
2212 SourceLocation ParamNameLoc,
2213 unsigned Depth,
2214 unsigned Position);
2215 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00002216 SourceLocation EqualLoc,
2217 ExprArg Default);
2218
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002219 virtual TemplateParamsTy *
2220 ActOnTemplateParameterList(unsigned Depth,
2221 SourceLocation ExportLoc,
2222 SourceLocation TemplateLoc,
2223 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002224 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00002225 SourceLocation RAngleLoc);
Douglas Gregord684b002009-02-10 19:49:53 +00002226 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
2227 TemplateParameterList *OldParams);
Douglas Gregorf59a56e2009-07-21 23:53:31 +00002228 TemplateParameterList *
2229 MatchTemplateParametersToScopeSpecifier(SourceLocation DeclStartLoc,
2230 const CXXScopeSpec &SS,
2231 TemplateParameterList **ParamLists,
2232 unsigned NumParamLists);
2233
John McCall0f434ec2009-07-31 02:45:11 +00002234 DeclResult CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorbd1099e2009-07-23 16:36:45 +00002235 SourceLocation KWLoc, const CXXScopeSpec &SS,
2236 IdentifierInfo *Name, SourceLocation NameLoc,
2237 AttributeList *Attr,
2238 MultiTemplateParamsArg TemplateParameterLists,
2239 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002240
Douglas Gregor7532dc62009-03-30 22:58:21 +00002241 QualType CheckTemplateIdType(TemplateName Template,
2242 SourceLocation TemplateLoc,
2243 SourceLocation LAngleLoc,
2244 const TemplateArgument *TemplateArgs,
2245 unsigned NumTemplateArgs,
2246 SourceLocation RAngleLoc);
Douglas Gregor40808ce2009-03-09 23:48:35 +00002247
Douglas Gregorcc636682009-02-17 23:15:12 +00002248 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00002249 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
2250 SourceLocation LAngleLoc,
2251 ASTTemplateArgsPtr TemplateArgs,
2252 SourceLocation *TemplateArgLocs,
2253 SourceLocation RAngleLoc);
Douglas Gregorcc636682009-02-17 23:15:12 +00002254
Douglas Gregoredce4dd2009-06-30 22:34:41 +00002255 OwningExprResult BuildTemplateIdExpr(TemplateName Template,
2256 SourceLocation TemplateNameLoc,
2257 SourceLocation LAngleLoc,
2258 const TemplateArgument *TemplateArgs,
2259 unsigned NumTemplateArgs,
2260 SourceLocation RAngleLoc);
2261
2262 virtual OwningExprResult ActOnTemplateIdExpr(TemplateTy Template,
2263 SourceLocation TemplateNameLoc,
2264 SourceLocation LAngleLoc,
2265 ASTTemplateArgsPtr TemplateArgs,
2266 SourceLocation *TemplateArgLocs,
2267 SourceLocation RAngleLoc);
2268
Douglas Gregorc45c2322009-03-31 00:43:58 +00002269 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
2270 const IdentifierInfo &Name,
2271 SourceLocation NameLoc,
2272 const CXXScopeSpec &SS);
2273
Douglas Gregor88b70942009-02-25 22:02:03 +00002274 bool CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
2275 ClassTemplateSpecializationDecl *PrevDecl,
2276 SourceLocation TemplateNameLoc,
Douglas Gregorff668032009-05-13 18:28:20 +00002277 SourceRange ScopeSpecifierRange,
Douglas Gregor16df8502009-06-12 22:21:45 +00002278 bool PartialSpecialization,
Douglas Gregorff668032009-05-13 18:28:20 +00002279 bool ExplicitInstantiation);
Douglas Gregor88b70942009-02-25 22:02:03 +00002280
Douglas Gregore94866f2009-06-12 21:21:02 +00002281 bool CheckClassTemplatePartialSpecializationArgs(
2282 TemplateParameterList *TemplateParams,
Anders Carlsson6360be72009-06-13 18:20:51 +00002283 const TemplateArgumentListBuilder &TemplateArgs,
Douglas Gregor6aa75cf2009-06-12 22:08:06 +00002284 bool &MirrorsPrimaryTemplate);
Douglas Gregore94866f2009-06-12 21:21:02 +00002285
Douglas Gregor212e81c2009-03-25 00:13:59 +00002286 virtual DeclResult
John McCall0f434ec2009-07-31 02:45:11 +00002287 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK,
Douglas Gregorcc636682009-02-17 23:15:12 +00002288 SourceLocation KWLoc,
2289 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00002290 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00002291 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002292 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00002293 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregorc15cb382009-02-09 23:23:08 +00002294 SourceLocation *TemplateArgLocs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00002295 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00002296 AttributeList *Attr,
2297 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00002298
Douglas Gregore542c862009-06-23 23:11:28 +00002299 virtual DeclPtrTy ActOnTemplateDeclarator(Scope *S,
2300 MultiTemplateParamsArg TemplateParameterLists,
2301 Declarator &D);
2302
Douglas Gregor52591bf2009-06-24 00:54:41 +00002303 virtual DeclPtrTy ActOnStartOfFunctionTemplateDef(Scope *FnBodyScope,
2304 MultiTemplateParamsArg TemplateParameterLists,
2305 Declarator &D);
2306
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002307 virtual DeclResult
2308 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
2309 unsigned TagSpec,
2310 SourceLocation KWLoc,
2311 const CXXScopeSpec &SS,
2312 TemplateTy Template,
2313 SourceLocation TemplateNameLoc,
2314 SourceLocation LAngleLoc,
2315 ASTTemplateArgsPtr TemplateArgs,
2316 SourceLocation *TemplateArgLocs,
2317 SourceLocation RAngleLoc,
2318 AttributeList *Attr);
2319
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00002320 virtual DeclResult
2321 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
2322 unsigned TagSpec,
2323 SourceLocation KWLoc,
2324 const CXXScopeSpec &SS,
2325 IdentifierInfo *Name,
2326 SourceLocation NameLoc,
2327 AttributeList *Attr);
2328
Douglas Gregorc15cb382009-02-09 23:23:08 +00002329 bool CheckTemplateArgumentList(TemplateDecl *Template,
2330 SourceLocation TemplateLoc,
2331 SourceLocation LAngleLoc,
Douglas Gregor40808ce2009-03-09 23:48:35 +00002332 const TemplateArgument *TemplateArgs,
2333 unsigned NumTemplateArgs,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002334 SourceLocation RAngleLoc,
Douglas Gregor16134c62009-07-01 00:28:38 +00002335 bool PartialTemplateArgs,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00002336 TemplateArgumentListBuilder &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002337
Anders Carlsson436b1562009-06-13 00:33:33 +00002338 bool CheckTemplateTypeArgument(TemplateTypeParmDecl *Param,
2339 const TemplateArgument &Arg,
2340 TemplateArgumentListBuilder &Converted);
2341
Douglas Gregorc15cb382009-02-09 23:23:08 +00002342 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg,
2343 SourceLocation ArgLoc);
Douglas Gregor3e00bad2009-02-17 01:05:43 +00002344 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
2345 NamedDecl *&Entity);
2346 bool CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member);
Douglas Gregor2943aed2009-03-03 04:44:36 +00002347 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
2348 QualType InstantiatedParamType, Expr *&Arg,
Douglas Gregor02cbbd22009-06-11 18:10:32 +00002349 TemplateArgument &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00002350 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param, DeclRefExpr *Arg);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002351 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
2352 TemplateParameterList *Old,
2353 bool Complain,
Douglas Gregordd0574e2009-02-10 00:24:35 +00002354 bool IsTemplateTemplateParm = false,
2355 SourceLocation TemplateArgLoc
2356 = SourceLocation());
Douglas Gregorddc29e12009-02-06 22:42:48 +00002357
2358 bool CheckTemplateDeclScope(Scope *S,
2359 MultiTemplateParamsArg &TemplateParameterLists);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002360
Douglas Gregord57959a2009-03-27 23:10:48 +00002361 /// \brief Called when the parser has parsed a C++ typename
2362 /// specifier, e.g., "typename T::type".
2363 ///
2364 /// \param TypenameLoc the location of the 'typename' keyword
2365 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2366 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
2367 /// \param IdLoc the location of the identifier.
2368 virtual TypeResult
2369 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2370 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00002371
2372 /// \brief Called when the parser has parsed a C++ typename
2373 /// specifier that ends in a template-id, e.g.,
2374 /// "typename MetaFun::template apply<T1, T2>".
2375 ///
2376 /// \param TypenameLoc the location of the 'typename' keyword
2377 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2378 /// \param TemplateLoc the location of the 'template' keyword, if any.
2379 /// \param Ty the type that the typename specifier refers to.
2380 virtual TypeResult
2381 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2382 SourceLocation TemplateLoc, TypeTy *Ty);
2383
Douglas Gregord57959a2009-03-27 23:10:48 +00002384 QualType CheckTypenameType(NestedNameSpecifier *NNS,
2385 const IdentifierInfo &II,
2386 SourceRange Range);
Douglas Gregorc8ab2562009-05-31 09:31:02 +00002387
Douglas Gregor4a959d82009-08-06 16:20:37 +00002388 QualType RebuildTypeInCurrentInstantiation(QualType T, SourceLocation Loc,
2389 DeclarationName Name);
2390
Douglas Gregorf67875d2009-06-12 18:26:56 +00002391 /// \brief Describes the result of template argument deduction.
2392 ///
2393 /// The TemplateDeductionResult enumeration describes the result of
2394 /// template argument deduction, as returned from
2395 /// DeduceTemplateArguments(). The separate TemplateDeductionInfo
2396 /// structure provides additional information about the results of
2397 /// template argument deduction, e.g., the deduced template argument
2398 /// list (if successful) or the specific template parameters or
2399 /// deduced arguments that were involved in the failure.
2400 enum TemplateDeductionResult {
2401 /// \brief Template argument deduction was successful.
2402 TDK_Success = 0,
2403 /// \brief Template argument deduction exceeded the maximum template
2404 /// instantiation depth (which has already been diagnosed).
2405 TDK_InstantiationDepth,
2406 /// \brief Template argument deduction did not deduce a value
2407 /// for every template parameter.
2408 TDK_Incomplete,
2409 /// \brief Template argument deduction produced inconsistent
2410 /// deduced values for the given template parameter.
2411 TDK_Inconsistent,
2412 /// \brief Template argument deduction failed due to inconsistent
2413 /// cv-qualifiers on a template parameter type that would
2414 /// otherwise be deduced, e.g., we tried to deduce T in "const T"
2415 /// but were given a non-const "X".
2416 TDK_InconsistentQuals,
2417 /// \brief Substitution of the deduced template argument values
2418 /// resulted in an error.
2419 TDK_SubstitutionFailure,
2420 /// \brief Substitution of the deduced template argument values
2421 /// into a non-deduced context produced a type or value that
2422 /// produces a type that does not match the original template
2423 /// arguments provided.
Douglas Gregore53060f2009-06-25 22:08:12 +00002424 TDK_NonDeducedMismatch,
2425 /// \brief When performing template argument deduction for a function
2426 /// template, there were too many call arguments.
2427 TDK_TooManyArguments,
Douglas Gregorde0cb8b2009-07-07 23:09:34 +00002428 /// \brief When performing template argument deduction for a function
Douglas Gregore53060f2009-06-25 22:08:12 +00002429 /// template, there were too few call arguments.
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002430 TDK_TooFewArguments,
2431 /// \brief The explicitly-specified template arguments were not valid
2432 /// template arguments for the given template.
2433 TDK_InvalidExplicitArguments
Douglas Gregorf67875d2009-06-12 18:26:56 +00002434 };
2435
2436 /// \brief Provides information about an attempted template argument
2437 /// deduction, whose success or failure was described by a
2438 /// TemplateDeductionResult value.
2439 class TemplateDeductionInfo {
2440 /// \brief The context in which the template arguments are stored.
2441 ASTContext &Context;
2442
2443 /// \brief The deduced template argument list.
2444 ///
2445 TemplateArgumentList *Deduced;
2446
2447 // do not implement these
2448 TemplateDeductionInfo(const TemplateDeductionInfo&);
2449 TemplateDeductionInfo &operator=(const TemplateDeductionInfo&);
2450
2451 public:
2452 TemplateDeductionInfo(ASTContext &Context) : Context(Context), Deduced(0) { }
2453
2454 ~TemplateDeductionInfo() {
2455 // FIXME: if (Deduced) Deduced->Destroy(Context);
2456 }
2457
2458 /// \brief Take ownership of the deduced template argument list.
2459 TemplateArgumentList *take() {
2460 TemplateArgumentList *Result = Deduced;
2461 Deduced = 0;
2462 return Result;
2463 }
2464
2465 /// \brief Provide a new template argument list that contains the
2466 /// results of template argument deduction.
2467 void reset(TemplateArgumentList *NewDeduced) {
2468 // FIXME: if (Deduced) Deduced->Destroy(Context);
2469 Deduced = NewDeduced;
2470 }
2471
2472 /// \brief The template parameter to which a template argument
2473 /// deduction failure refers.
2474 ///
2475 /// Depending on the result of template argument deduction, this
2476 /// template parameter may have different meanings:
2477 ///
2478 /// TDK_Incomplete: this is the first template parameter whose
2479 /// corresponding template argument was not deduced.
2480 ///
2481 /// TDK_Inconsistent: this is the template parameter for which
2482 /// two different template argument values were deduced.
2483 TemplateParameter Param;
2484
2485 /// \brief The first template argument to which the template
2486 /// argument deduction failure refers.
2487 ///
2488 /// Depending on the result of the template argument deduction,
2489 /// this template argument may have different meanings:
2490 ///
2491 /// TDK_Inconsistent: this argument is the first value deduced
2492 /// for the corresponding template parameter.
2493 ///
2494 /// TDK_SubstitutionFailure: this argument is the template
2495 /// argument we were instantiating when we encountered an error.
2496 ///
2497 /// TDK_NonDeducedMismatch: this is the template argument
2498 /// provided in the source code.
2499 TemplateArgument FirstArg;
2500
2501 /// \brief The second template argument to which the template
2502 /// argument deduction failure refers.
2503 ///
2504 /// FIXME: Finish documenting this.
2505 TemplateArgument SecondArg;
2506 };
2507
2508 TemplateDeductionResult
Douglas Gregor199d9912009-06-05 00:53:49 +00002509 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
Douglas Gregorf67875d2009-06-12 18:26:56 +00002510 const TemplateArgumentList &TemplateArgs,
2511 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002512
2513 TemplateDeductionResult
2514 SubstituteExplicitTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2515 const TemplateArgument *ExplicitTemplateArgs,
2516 unsigned NumExplicitTemplateArgs,
2517 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2518 llvm::SmallVectorImpl<QualType> &ParamTypes,
2519 QualType *FunctionType,
2520 TemplateDeductionInfo &Info);
2521
2522 TemplateDeductionResult
2523 FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
2524 llvm::SmallVectorImpl<TemplateArgument> &Deduced,
2525 FunctionDecl *&Specialization,
2526 TemplateDeductionInfo &Info);
2527
Douglas Gregore53060f2009-06-25 22:08:12 +00002528 TemplateDeductionResult
2529 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
Douglas Gregor6db8ed42009-06-30 23:57:56 +00002530 bool HasExplicitTemplateArgs,
2531 const TemplateArgument *ExplicitTemplateArgs,
2532 unsigned NumExplicitTemplateArgs,
Douglas Gregore53060f2009-06-25 22:08:12 +00002533 Expr **Args, unsigned NumArgs,
2534 FunctionDecl *&Specialization,
2535 TemplateDeductionInfo &Info);
Douglas Gregor83314aa2009-07-08 20:55:45 +00002536
2537 TemplateDeductionResult
2538 DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
2539 bool HasExplicitTemplateArgs,
2540 const TemplateArgument *ExplicitTemplateArgs,
2541 unsigned NumExplicitTemplateArgs,
2542 QualType ArgFunctionType,
2543 FunctionDecl *&Specialization,
2544 TemplateDeductionInfo &Info);
Douglas Gregore53060f2009-06-25 22:08:12 +00002545
Douglas Gregor031a5882009-06-13 00:26:55 +00002546 void MarkDeducedTemplateParameters(const TemplateArgumentList &TemplateArgs,
2547 llvm::SmallVectorImpl<bool> &Deduced);
2548
Douglas Gregor99ebf652009-02-27 19:31:52 +00002549 //===--------------------------------------------------------------------===//
2550 // C++ Template Instantiation
2551 //
Douglas Gregor26dce442009-03-10 00:06:19 +00002552
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002553 const TemplateArgumentList &getTemplateInstantiationArgs(NamedDecl *D);
2554
Douglas Gregor26dce442009-03-10 00:06:19 +00002555 /// \brief A template instantiation that is currently in progress.
2556 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00002557 /// \brief The kind of template instantiation we are performing
Douglas Gregorcca9e962009-07-01 22:01:06 +00002558 enum InstantiationKind {
Douglas Gregordf667e72009-03-10 20:44:00 +00002559 /// We are instantiating a template declaration. The entity is
Douglas Gregorb9f1b8d2009-05-15 00:01:03 +00002560 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00002561 TemplateInstantiation,
2562
2563 /// We are instantiating a default argument for a template
2564 /// parameter. The Entity is the template, and
2565 /// TemplateArgs/NumTemplateArguments provides the template
2566 /// arguments as specified.
Douglas Gregor637a4092009-06-10 23:47:09 +00002567 /// FIXME: Use a TemplateArgumentList
2568 DefaultTemplateArgumentInstantiation,
2569
Douglas Gregorcca9e962009-07-01 22:01:06 +00002570 /// We are substituting explicit template arguments provided for
2571 /// a function template. The entity is a FunctionTemplateDecl.
2572 ExplicitTemplateArgumentSubstitution,
2573
2574 /// We are substituting template argument determined as part of
2575 /// template argument deduction for either a class template
2576 /// partial specialization or a function template. The
2577 /// Entity is either a ClassTemplatePartialSpecializationDecl or
2578 /// a FunctionTemplateDecl.
2579 DeducedTemplateArgumentSubstitution
Douglas Gregordf667e72009-03-10 20:44:00 +00002580 } Kind;
2581
Douglas Gregor26dce442009-03-10 00:06:19 +00002582 /// \brief The point of instantiation within the source code.
2583 SourceLocation PointOfInstantiation;
2584
2585 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00002586 uintptr_t Entity;
2587
2588 // \brief If this the instantiation of a default template
Douglas Gregor7e063902009-05-11 23:53:27 +00002589 // argument, the list of template arguments.
Douglas Gregordf667e72009-03-10 20:44:00 +00002590 const TemplateArgument *TemplateArgs;
2591
2592 /// \brief The number of template arguments in TemplateArgs.
2593 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002594
2595 /// \brief The source range that covers the construct that cause
2596 /// the instantiation, e.g., the template-id that causes a class
2597 /// template instantiation.
2598 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002599
Eli Friedman2ebcc6b2009-08-15 22:50:33 +00002600 ActiveTemplateInstantiation() : Kind(TemplateInstantiation), Entity(0),
2601 TemplateArgs(0), NumTemplateArgs(0) {}
2602
Douglas Gregordf667e72009-03-10 20:44:00 +00002603 friend bool operator==(const ActiveTemplateInstantiation &X,
2604 const ActiveTemplateInstantiation &Y) {
2605 if (X.Kind != Y.Kind)
2606 return false;
2607
2608 if (X.Entity != Y.Entity)
2609 return false;
2610
2611 switch (X.Kind) {
2612 case TemplateInstantiation:
2613 return true;
2614
2615 case DefaultTemplateArgumentInstantiation:
Douglas Gregorcca9e962009-07-01 22:01:06 +00002616 case ExplicitTemplateArgumentSubstitution:
2617 case DeducedTemplateArgumentSubstitution:
Douglas Gregordf667e72009-03-10 20:44:00 +00002618 return X.TemplateArgs == Y.TemplateArgs;
2619 }
2620
2621 return true;
2622 }
2623
2624 friend bool operator!=(const ActiveTemplateInstantiation &X,
2625 const ActiveTemplateInstantiation &Y) {
2626 return !(X == Y);
2627 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002628 };
2629
2630 /// \brief List of active template instantiations.
2631 ///
2632 /// This vector is treated as a stack. As one template instantiation
2633 /// requires another template instantiation, additional
2634 /// instantiations are pushed onto the stack up to a
2635 /// user-configurable limit LangOptions::InstantiationDepth.
2636 llvm::SmallVector<ActiveTemplateInstantiation, 16>
2637 ActiveTemplateInstantiations;
2638
Douglas Gregor27b152f2009-03-10 18:52:44 +00002639 /// \brief The last template from which a template instantiation
2640 /// error or warning was produced.
2641 ///
2642 /// This value is used to suppress printing of redundant template
2643 /// instantiation backtraces when there are multiple errors in the
2644 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2645 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002646 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002647
Douglas Gregor26dce442009-03-10 00:06:19 +00002648 /// \brief A stack object to be created when performing template
2649 /// instantiation.
2650 ///
2651 /// Construction of an object of type \c InstantiatingTemplate
2652 /// pushes the current instantiation onto the stack of active
2653 /// instantiations. If the size of this stack exceeds the maximum
2654 /// number of recursive template instantiations, construction
2655 /// produces an error and evaluates true.
2656 ///
2657 /// Destruction of this object will pop the named instantiation off
2658 /// the stack.
2659 struct InstantiatingTemplate {
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002660 /// \brief Note that we are instantiating a class template,
2661 /// function template, or a member thereof.
Douglas Gregor26dce442009-03-10 00:06:19 +00002662 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002663 Decl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002664 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002665
2666 /// \brief Note that we are instantiating a default argument in a
2667 /// template-id.
2668 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2669 TemplateDecl *Template,
2670 const TemplateArgument *TemplateArgs,
2671 unsigned NumTemplateArgs,
2672 SourceRange InstantiationRange = SourceRange());
2673
Douglas Gregorcca9e962009-07-01 22:01:06 +00002674 /// \brief Note that we are instantiating a default argument in a
2675 /// template-id.
2676 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2677 FunctionTemplateDecl *FunctionTemplate,
2678 const TemplateArgument *TemplateArgs,
2679 unsigned NumTemplateArgs,
2680 ActiveTemplateInstantiation::InstantiationKind Kind,
2681 SourceRange InstantiationRange = SourceRange());
2682
Douglas Gregor637a4092009-06-10 23:47:09 +00002683 /// \brief Note that we are instantiating as part of template
2684 /// argument deduction for a class template partial
2685 /// specialization.
2686 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2687 ClassTemplatePartialSpecializationDecl *PartialSpec,
2688 const TemplateArgument *TemplateArgs,
2689 unsigned NumTemplateArgs,
2690 SourceRange InstantiationRange = SourceRange());
2691
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002692 /// \brief Note that we have finished instantiating this template.
2693 void Clear();
2694
2695 ~InstantiatingTemplate() { Clear(); }
Douglas Gregor26dce442009-03-10 00:06:19 +00002696
2697 /// \brief Determines whether we have exceeded the maximum
2698 /// recursive template instantiations.
2699 operator bool() const { return Invalid; }
2700
2701 private:
2702 Sema &SemaRef;
2703 bool Invalid;
2704
Douglas Gregordf667e72009-03-10 20:44:00 +00002705 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2706 SourceRange InstantiationRange);
2707
Douglas Gregor26dce442009-03-10 00:06:19 +00002708 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2709
2710 InstantiatingTemplate&
2711 operator=(const InstantiatingTemplate&); // not implemented
2712 };
2713
Douglas Gregoree1828a2009-03-10 18:03:33 +00002714 void PrintInstantiationStack();
2715
Douglas Gregor5e9f35c2009-06-14 07:33:30 +00002716 /// \brief Determines whether we are currently in a context where
2717 /// template argument substitution failures are not considered
2718 /// errors.
2719 ///
2720 /// When this routine returns true, the emission of most diagnostics
2721 /// will be suppressed and there will be no local error recovery.
2722 bool isSFINAEContext() const;
2723
Douglas Gregorbb260412009-06-14 08:02:22 +00002724 /// \brief RAII class used to determine whether SFINAE has
2725 /// trapped any errors that occur during template argument
2726 /// deduction.
2727 class SFINAETrap {
2728 Sema &SemaRef;
2729 unsigned PrevSFINAEErrors;
2730 public:
2731 explicit SFINAETrap(Sema &SemaRef)
2732 : SemaRef(SemaRef), PrevSFINAEErrors(SemaRef.NumSFINAEErrors) { }
2733
2734 ~SFINAETrap() { SemaRef.NumSFINAEErrors = PrevSFINAEErrors; }
2735
2736 /// \brief Determine whether any SFINAE errors have been trapped.
2737 bool hasErrorOccurred() const {
2738 return SemaRef.NumSFINAEErrors > PrevSFINAEErrors;
2739 }
2740 };
2741
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002742 /// \brief A stack-allocated class that identifies which local
2743 /// variable declaration instantiations are present in this scope.
2744 ///
2745 /// A new instance of this class type will be created whenever we
2746 /// instantiate a new function declaration, which will have its own
2747 /// set of parameter declarations.
2748 class LocalInstantiationScope {
2749 /// \brief Reference to the semantic analysis that is performing
2750 /// this template instantiation.
2751 Sema &SemaRef;
2752
Douglas Gregor815215d2009-05-27 05:35:12 +00002753 /// \brief A mapping from local declarations that occur
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002754 /// within a template to their instantiations.
2755 ///
2756 /// This mapping is used during instantiation to keep track of,
2757 /// e.g., function parameter and variable declarations. For example,
2758 /// given:
2759 ///
2760 /// \code
2761 /// template<typename T> T add(T x, T y) { return x + y; }
2762 /// \endcode
2763 ///
2764 /// when we instantiate add<int>, we will introduce a mapping from
2765 /// the ParmVarDecl for 'x' that occurs in the template to the
2766 /// instantiated ParmVarDecl for 'x'.
Douglas Gregor815215d2009-05-27 05:35:12 +00002767 llvm::DenseMap<const Decl *, Decl *> LocalDecls;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002768
2769 /// \brief The outer scope, in which contains local variable
2770 /// definitions from some other instantiation (that is not
2771 /// relevant to this particular scope).
2772 LocalInstantiationScope *Outer;
2773
2774 // This class is non-copyable
2775 LocalInstantiationScope(const LocalInstantiationScope &);
2776 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
2777
2778 public:
2779 LocalInstantiationScope(Sema &SemaRef)
2780 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
2781 SemaRef.CurrentInstantiationScope = this;
2782 }
2783
2784 ~LocalInstantiationScope() {
2785 SemaRef.CurrentInstantiationScope = Outer;
2786 }
2787
Douglas Gregor815215d2009-05-27 05:35:12 +00002788 Decl *getInstantiationOf(const Decl *D) {
2789 Decl *Result = LocalDecls[D];
2790 assert(Result && "declaration was not instantiated in this scope!");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002791 return Result;
2792 }
2793
Douglas Gregor815215d2009-05-27 05:35:12 +00002794 VarDecl *getInstantiationOf(const VarDecl *Var) {
2795 return cast<VarDecl>(getInstantiationOf(cast<Decl>(Var)));
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002796 }
2797
Douglas Gregor815215d2009-05-27 05:35:12 +00002798 ParmVarDecl *getInstantiationOf(const ParmVarDecl *Var) {
2799 return cast<ParmVarDecl>(getInstantiationOf(cast<Decl>(Var)));
2800 }
2801
2802 void InstantiatedLocal(const Decl *D, Decl *Inst) {
2803 Decl *&Stored = LocalDecls[D];
2804 assert(!Stored && "Already instantiated this local");
2805 Stored = Inst;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002806 }
2807 };
2808
2809 /// \brief The current instantiation scope used to store local
2810 /// variables.
2811 LocalInstantiationScope *CurrentInstantiationScope;
2812
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002813 /// \brief An entity for which implicit template instantiation is required.
2814 ///
2815 /// The source location associated with the declaration is the first place in
2816 /// the source code where the declaration was "used". It is not necessarily
2817 /// the point of instantiation (which will be either before or after the
2818 /// namespace-scope declaration that triggered this implicit instantiation),
2819 /// However, it is the location that diagnostics should generally refer to,
2820 /// because users will need to know what code triggered the instantiation.
2821 typedef std::pair<ValueDecl *, SourceLocation> PendingImplicitInstantiation;
2822
2823 /// \brief The queue of implicit template instantiations that are required
2824 /// but have not yet been performed.
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00002825 std::deque<PendingImplicitInstantiation> PendingImplicitInstantiations;
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002826
2827 void PerformPendingImplicitInstantiations();
2828
Douglas Gregor7e063902009-05-11 23:53:27 +00002829 QualType InstantiateType(QualType T, const TemplateArgumentList &TemplateArgs,
Douglas Gregor99ebf652009-02-27 19:31:52 +00002830 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor199d9912009-06-05 00:53:49 +00002831
Douglas Gregora0e500d2009-03-12 16:53:44 +00002832 OwningExprResult InstantiateExpr(Expr *E,
Douglas Gregor7e063902009-05-11 23:53:27 +00002833 const TemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00002834
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002835 OwningStmtResult InstantiateStmt(Stmt *S,
2836 const TemplateArgumentList &TemplateArgs);
Douglas Gregor66b46be2009-05-20 22:57:03 +00002837 OwningStmtResult InstantiateCompoundStmt(CompoundStmt *S,
2838 const TemplateArgumentList &TemplateArgs,
2839 bool isStmtExpr);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002840
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002841 Decl *InstantiateDecl(Decl *D, DeclContext *Owner,
Douglas Gregor7e063902009-05-11 23:53:27 +00002842 const TemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002843
Douglas Gregor2943aed2009-03-03 04:44:36 +00002844 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00002845 InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
2846 CXXRecordDecl *Pattern,
Douglas Gregor7e063902009-05-11 23:53:27 +00002847 const TemplateArgumentList &TemplateArgs);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002848
2849 bool
John McCalle29ba202009-08-20 01:44:21 +00002850 InstantiateTemplatePattern(SourceLocation PointOfInstantiation,
2851 CXXRecordDecl *Pattern);
2852
2853 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00002854 InstantiateClass(SourceLocation PointOfInstantiation,
2855 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002856 const TemplateArgumentList &TemplateArgs,
2857 bool ExplicitInstantiation);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002858
Douglas Gregor2943aed2009-03-03 04:44:36 +00002859 bool
2860 InstantiateClassTemplateSpecialization(
2861 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2862 bool ExplicitInstantiation);
Douglas Gregor99ebf652009-02-27 19:31:52 +00002863
Douglas Gregora58861f2009-05-13 20:28:22 +00002864 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
2865 CXXRecordDecl *Instantiation,
2866 const TemplateArgumentList &TemplateArgs);
2867
2868 void InstantiateClassTemplateSpecializationMembers(
2869 SourceLocation PointOfInstantiation,
2870 ClassTemplateSpecializationDecl *ClassTemplateSpec);
2871
Douglas Gregorab452ba2009-03-26 23:50:42 +00002872 NestedNameSpecifier *
2873 InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
2874 SourceRange Range,
Douglas Gregor7e063902009-05-11 23:53:27 +00002875 const TemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00002876
Douglas Gregorde650ae2009-03-31 18:38:02 +00002877 TemplateName
2878 InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregor7e063902009-05-11 23:53:27 +00002879 const TemplateArgumentList &TemplateArgs);
Douglas Gregor91333002009-06-11 00:06:24 +00002880 TemplateArgument Instantiate(TemplateArgument Arg,
2881 const TemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00002882
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002883 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
Douglas Gregorb33fe2f2009-06-30 17:20:14 +00002884 FunctionDecl *Function,
2885 bool Recursive = false);
Douglas Gregor7caa6822009-07-24 20:34:43 +00002886 void InstantiateStaticDataMemberDefinition(
2887 SourceLocation PointOfInstantiation,
2888 VarDecl *Var,
2889 bool Recursive = false);
Douglas Gregora58861f2009-05-13 20:28:22 +00002890
Douglas Gregored961e72009-05-27 17:54:46 +00002891 NamedDecl *InstantiateCurrentDeclRef(NamedDecl *D);
Douglas Gregord7f37bf2009-06-22 23:06:13 +00002892
Steve Naroff3536b442007-09-06 21:24:23 +00002893 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002894 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
2895 IdentifierInfo *ClassName,
2896 SourceLocation ClassLoc,
2897 IdentifierInfo *SuperName,
2898 SourceLocation SuperLoc,
2899 const DeclPtrTy *ProtoRefs,
2900 unsigned NumProtoRefs,
2901 SourceLocation EndProtoLoc,
2902 AttributeList *AttrList);
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002903
Chris Lattnerb28317a2009-03-28 19:18:32 +00002904 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002905 SourceLocation AtCompatibilityAliasLoc,
2906 IdentifierInfo *AliasName, SourceLocation AliasLocation,
2907 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00002908
2909 void CheckForwardProtocolDeclarationForCircularDependency(
2910 IdentifierInfo *PName,
2911 SourceLocation &PLoc, SourceLocation PrevLoc,
2912 const ObjCList<ObjCProtocolDecl> &PList);
Steve Naroff3536b442007-09-06 21:24:23 +00002913
Chris Lattnerb28317a2009-03-28 19:18:32 +00002914 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002915 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002916 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002917 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00002918 SourceLocation EndProtoLoc,
2919 AttributeList *AttrList);
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002920
Chris Lattnerb28317a2009-03-28 19:18:32 +00002921 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
2922 IdentifierInfo *ClassName,
2923 SourceLocation ClassLoc,
2924 IdentifierInfo *CategoryName,
2925 SourceLocation CategoryLoc,
2926 const DeclPtrTy *ProtoRefs,
2927 unsigned NumProtoRefs,
2928 SourceLocation EndProtoLoc);
Fariborz Jahanianfd225cc2007-09-18 20:26:58 +00002929
Chris Lattnerb28317a2009-03-28 19:18:32 +00002930 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002931 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00002932 IdentifierInfo *ClassName, SourceLocation ClassLoc,
2933 IdentifierInfo *SuperClassname,
2934 SourceLocation SuperClassLoc);
2935
Chris Lattnerb28317a2009-03-28 19:18:32 +00002936 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00002937 SourceLocation AtCatImplLoc,
2938 IdentifierInfo *ClassName,
2939 SourceLocation ClassLoc,
2940 IdentifierInfo *CatName,
2941 SourceLocation CatLoc);
2942
Chris Lattnerb28317a2009-03-28 19:18:32 +00002943 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroff37e58d12007-10-02 22:39:18 +00002944 IdentifierInfo **IdentList,
2945 unsigned NumElts);
Fariborz Jahanian894c57f2007-09-21 15:40:54 +00002946
Chris Lattnerb28317a2009-03-28 19:18:32 +00002947 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002948 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00002949 unsigned NumElts,
2950 AttributeList *attrList);
Fariborz Jahanian245f92a2007-10-05 21:01:53 +00002951
Chris Lattnere13b9592008-07-26 04:03:38 +00002952 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002953 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002954 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002955 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002956
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00002957 /// Ensure attributes are consistent with type.
2958 /// \param [in, out] Attributes The attributes to check; they will
2959 /// be modified to be consistent with \arg PropertyTy.
2960 void CheckObjCPropertyAttributes(QualType PropertyTy,
2961 SourceLocation Loc,
2962 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00002963 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002964 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
2965 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00002966 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002967 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Fariborz Jahanianb5e02242008-04-24 19:58:34 +00002968
Fariborz Jahaniandbdec8b2009-08-04 01:07:16 +00002969 void CompareMethodParamsInBaseAndSuper(Decl *IDecl,
2970 ObjCMethodDecl *MethodDecl,
2971 bool IsInstance);
2972
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002973 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002974 DeclPtrTy MergeProtocols);
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002975
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00002976 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
2977 ObjCInterfaceDecl *ID);
2978
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002979 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002980 ObjCProtocolDecl *PDecl);
2981
Chris Lattnerb28317a2009-03-28 19:18:32 +00002982 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
2983 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
2984 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00002985 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002986
Chris Lattnerb28317a2009-03-28 19:18:32 +00002987 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
2988 FieldDeclarator &FD, ObjCDeclSpec &ODS,
2989 Selector GetterSel, Selector SetterSel,
2990 DeclPtrTy ClassCategory,
2991 bool *OverridingProperty,
2992 tok::ObjCKeywordKind MethodImplKind);
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00002993
Chris Lattnerb28317a2009-03-28 19:18:32 +00002994 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
2995 SourceLocation PropertyLoc,
2996 bool ImplKind,DeclPtrTy ClassImplDecl,
2997 IdentifierInfo *PropertyId,
2998 IdentifierInfo *PropertyIvar);
Fariborz Jahanianf624f812008-04-18 00:19:30 +00002999
Chris Lattnerb28317a2009-03-28 19:18:32 +00003000 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00003001 SourceLocation BeginLoc, // location of the + or -.
3002 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +00003003 tok::TokenKind MethodType,
Chris Lattnerb28317a2009-03-28 19:18:32 +00003004 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00003005 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00003006 // optional arguments. The number of types/arguments is obtained
3007 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00003008 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00003009 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00003010 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
3011 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00003012
Steve Narofff1afaf62009-02-26 15:55:06 +00003013 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
3014 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00003015 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00003016 // Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +00003017 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
3018 ObjCInterfaceDecl *CDecl);
3019 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
3020 ObjCInterfaceDecl *ClassDecl);
Steve Narofff1afaf62009-02-26 15:55:06 +00003021
Steve Naroff61f72cb2009-03-09 21:12:44 +00003022 virtual OwningExprResult ActOnClassPropertyRefExpr(
3023 IdentifierInfo &receiverName,
3024 IdentifierInfo &propertyName,
3025 SourceLocation &receiverNameLoc,
3026 SourceLocation &propertyNameLoc);
3027
Steve Naroff68d331a2007-09-27 14:38:14 +00003028 // ActOnClassMessage - used for both unary and keyword messages.
3029 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003030 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003031 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00003032 Scope *S,
Anders Carlssonff975cf2009-02-14 18:21:46 +00003033 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
3034 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003035 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00003036
3037 // ActOnInstanceMessage - used for both unary and keyword messages.
3038 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00003039 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00003040 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00003041 ExprTy *receiver, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +00003042 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00003043 ExprTy **ArgExprs, unsigned NumArgs);
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003044
3045 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
3046 virtual void ActOnPragmaPack(PragmaPackKind Kind,
3047 IdentifierInfo *Name,
3048 ExprTy *Alignment,
3049 SourceLocation PragmaLoc,
3050 SourceLocation LParenLoc,
3051 SourceLocation RParenLoc);
Chris Lattner574aa402009-02-17 01:09:29 +00003052
Ted Kremenek4726d032009-03-23 22:28:25 +00003053 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
Ted Kremenek7a02a372009-08-03 23:24:57 +00003054 virtual void ActOnPragmaUnused(const Token *Identifiers,
3055 unsigned NumIdentifiers, Scope *curScope,
Ted Kremenek4726d032009-03-23 22:28:25 +00003056 SourceLocation PragmaLoc,
3057 SourceLocation LParenLoc,
3058 SourceLocation RParenLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003059
Ryan Flynn7b1fdbd2009-07-31 02:52:19 +00003060 NamedDecl *DeclClonePragmaWeak(NamedDecl *ND, IdentifierInfo *II);
3061 void DeclApplyPragmaWeak(Scope *S, NamedDecl *ND, WeakInfo &W);
Ryan Flynne25ff832009-07-30 03:15:39 +00003062
Eli Friedmandec7c762009-06-05 06:28:29 +00003063 /// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003064 virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
3065 SourceLocation PragmaLoc,
3066 SourceLocation WeakNameLoc);
3067
Eli Friedmandec7c762009-06-05 06:28:29 +00003068 /// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00003069 virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
3070 IdentifierInfo* AliasName,
3071 SourceLocation PragmaLoc,
3072 SourceLocation WeakNameLoc,
3073 SourceLocation AliasNameLoc);
3074
Chris Lattner574aa402009-02-17 01:09:29 +00003075 /// getPragmaPackAlignment() - Return the current alignment as specified by
3076 /// the current #pragma pack directive, or 0 if none is currently active.
3077 unsigned getPragmaPackAlignment() const;
3078
3079 /// FreePackedContext - Deallocate and null out PackContext.
3080 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00003081
Chris Lattner1e0a3902008-01-16 19:17:22 +00003082 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
3083 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00003084 /// If isLvalue, the result of the cast is an lvalue.
Anders Carlsson3503d042009-07-31 01:23:52 +00003085 void ImpCastExprToType(Expr *&Expr, QualType Type,
Anders Carlssonbd0fb302009-08-10 21:30:22 +00003086 const CastExpr::CastInfo &Info =
3087 CastExpr::CastInfo(CastExpr::CK_Unknown),
Anders Carlsson3503d042009-07-31 01:23:52 +00003088 bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00003089
Reid Spencer5f016e22007-07-11 17:01:13 +00003090 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00003091 // functions and arrays to their respective pointers (C99 6.3.2.1).
3092 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00003093
Steve Naroffc80b4ee2007-07-16 21:54:35 +00003094 // DefaultFunctionArrayConversion - converts functions and arrays
3095 // to their respective pointers (C99 6.3.2.1).
3096 void DefaultFunctionArrayConversion(Expr *&expr);
Steve Naroff90045e82007-07-13 23:32:42 +00003097
Steve Naroffb291ab62007-08-28 23:30:39 +00003098 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
3099 // do not have a prototype. Integer promotions are performed on each
3100 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00003101 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00003102
3103 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
3104 enum VariadicCallType {
3105 VariadicFunction,
3106 VariadicBlock,
3107 VariadicMethod
3108 };
3109
3110 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
3111 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00003112 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Steve Naroffb291ab62007-08-28 23:30:39 +00003113
Reid Spencer5f016e22007-07-11 17:01:13 +00003114 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
3115 // operands and then handles various conversions that are common to binary
3116 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
3117 // routine returns the first non-arithmetic type found. The client is
3118 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003119 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
3120 bool isCompAssign = false);
Chris Lattnerb7b61152008-01-04 18:22:42 +00003121
3122 /// AssignConvertType - All of the 'assignment' semantic checks return this
3123 /// enum to indicate whether the assignment was allowed. These checks are
3124 /// done for simple assignments, as well as initialization, return from
3125 /// function, argument passing, etc. The query is phrased in terms of a
3126 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003127 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00003128 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00003129 Compatible,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003130
3131 /// PointerToInt - The assignment converts a pointer to an int, which we
3132 /// accept as an extension.
3133 PointerToInt,
3134
3135 /// IntToPointer - The assignment converts an int to a pointer, which we
3136 /// accept as an extension.
3137 IntToPointer,
3138
3139 /// FunctionVoidPointer - The assignment is between a function pointer and
3140 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00003141 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00003142
3143 /// IncompatiblePointer - The assignment is between two pointers types that
3144 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00003145 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00003146
3147 /// IncompatiblePointer - The assignment is between two pointers types which
3148 /// point to integers which have a different sign, but are otherwise identical.
3149 /// This is a subset of the above, but broken out because it's by far the most
3150 /// common case of incompatible pointers.
3151 IncompatiblePointerSign,
3152
Chris Lattnerb7b61152008-01-04 18:22:42 +00003153 /// CompatiblePointerDiscardsQualifiers - The assignment discards
3154 /// c/v/r qualifiers, which we accept as an extension.
3155 CompatiblePointerDiscardsQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00003156
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00003157 /// IncompatibleVectors - The assignment is between two vector types that
3158 /// have the same size, which we accept as an extension.
3159 IncompatibleVectors,
3160
Steve Naroffbfdcae62008-09-04 15:31:07 +00003161 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003162 /// pointer. We disallow this.
3163 IntToBlockPointer,
3164
Steve Naroffbfdcae62008-09-04 15:31:07 +00003165 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00003166 /// pointers types that are not compatible.
3167 IncompatibleBlockPointer,
3168
Steve Naroff39579072008-10-14 22:18:38 +00003169 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
3170 /// id type and something else (that is incompatible with it). For example,
3171 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
3172 IncompatibleObjCQualifiedId,
3173
Chris Lattnerb7b61152008-01-04 18:22:42 +00003174 /// Incompatible - We reject this conversion outright, it is invalid to
3175 /// represent it in the AST.
3176 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00003177 };
Chris Lattner5cf216b2008-01-04 18:04:52 +00003178
3179 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
3180 /// assignment conversion type specified by ConvTy. This returns true if the
3181 /// conversion was invalid or false if the conversion was accepted.
3182 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
3183 SourceLocation Loc,
3184 QualType DstType, QualType SrcType,
3185 Expr *SrcExpr, const char *Flavor);
3186
3187 /// CheckAssignmentConstraints - Perform type checking for assignment,
3188 /// argument passing, variable initialization, and function return values.
3189 /// This routine is only used by the following two methods. C99 6.5.16.
3190 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00003191
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003192 // CheckSingleAssignmentConstraints - Currently used by
Steve Naroff1b273c42007-09-16 14:56:35 +00003193 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00003194 // this routine performs the default function/array converions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00003195 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
3196 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00003197
3198 // \brief If the lhs type is a transparent union, check whether we
3199 // can initialize the transparent union with the given expression.
3200 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
3201 Expr *&rExpr);
Steve Naroff90045e82007-07-13 23:32:42 +00003202
Reid Spencer5f016e22007-07-11 17:01:13 +00003203 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner5cf216b2008-01-04 18:04:52 +00003204 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
3205 QualType rhsType);
Steve Naroff1c7d0672008-09-04 15:10:53 +00003206
3207 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003208 // block pointer types.
Steve Naroff1c7d0672008-09-04 15:10:53 +00003209 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
3210 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00003211
3212 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003213
Douglas Gregor45920e82008-12-19 17:40:08 +00003214 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00003215 const char *Flavor,
3216 bool AllowExplicit = false,
3217 bool Elidable = false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003218 bool PerformImplicitConversion(Expr *&From, QualType ToType,
3219 const ImplicitConversionSequence& ICS,
Douglas Gregor45920e82008-12-19 17:40:08 +00003220 const char *Flavor);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00003221 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00003222 const StandardConversionSequence& SCS,
3223 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00003224
Reid Spencer5f016e22007-07-11 17:01:13 +00003225 /// the following "Check" methods will return a valid/converted QualType
3226 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00003227
3228 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00003229 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00003230 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003231 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00003232 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003233 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003234 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00003235 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003236 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003237 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003238 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00003239 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00003240 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00003241 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003242 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00003243 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00003244 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00003245 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00003246 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00003247 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003248 // CheckAssignmentOperands is used for both simple and compound assignment.
3249 // For simple assignment, pass both expressions and a null converted type.
3250 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00003251 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00003252 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00003253 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00003254 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00003255 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00003256 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003257 QualType CXXCheckConditionalOperands( // C++ 5.16
3258 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00003259 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00003260
3261 /// type checking for vector binary operators.
3262 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
3263 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
3264 SourceLocation l, bool isRel);
Reid Spencer5f016e22007-07-11 17:01:13 +00003265
Steve Narofff69936d2007-09-16 03:34:24 +00003266 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00003267 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00003268 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
3269 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00003270 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
3271 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00003272 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003273
3274 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00003275 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Steve Naroffe1b31fe2007-07-27 22:15:19 +00003276 IdentifierInfo &Comp, SourceLocation CmpLoc);
3277
Steve Narofff0090632007-09-02 02:04:30 +00003278 /// type checking declaration initializers (C99 6.7.8)
Anders Carlsson2078bb92009-05-27 16:10:08 +00003279
Douglas Gregorf03d7c72008-11-05 15:29:30 +00003280 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003281 SourceLocation InitLoc,DeclarationName InitEntity,
Anders Carlsson0f5f2c62009-05-30 20:41:30 +00003282 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00003283 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00003284 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroff2fdc3742007-12-10 22:44:33 +00003285
Douglas Gregor87fd7032009-02-02 17:43:21 +00003286 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00003287
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003288 // type checking C++ declaration initializers (C++ [dcl.init]).
3289
3290 /// ReferenceCompareResult - Expresses the result of comparing two
3291 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
3292 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
3293 enum ReferenceCompareResult {
3294 /// Ref_Incompatible - The two types are incompatible, so direct
3295 /// reference binding is not possible.
3296 Ref_Incompatible = 0,
3297 /// Ref_Related - The two types are reference-related, which means
3298 /// that their unqualified forms (T1 and T2) are either the same
3299 /// or T1 is a base class of T2.
3300 Ref_Related,
3301 /// Ref_Compatible_With_Added_Qualification - The two types are
3302 /// reference-compatible with added qualification, meaning that
3303 /// they are reference-compatible and the qualifiers on T1 (cv1)
3304 /// are greater than the qualifiers on T2 (cv2).
3305 Ref_Compatible_With_Added_Qualification,
3306 /// Ref_Compatible - The two types are reference-compatible and
3307 /// have equivalent qualifiers (cv1 == cv2).
3308 Ref_Compatible
3309 };
3310
Douglas Gregor15da57e2008-10-29 02:00:59 +00003311 ReferenceCompareResult CompareReferenceRelationship(QualType T1, QualType T2,
3312 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003313
Sebastian Redl3201f6b2009-04-16 17:51:27 +00003314 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00003315 ImplicitConversionSequence *ICS = 0,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00003316 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +00003317 bool AllowExplicit = false,
3318 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00003319
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003320 /// CheckCastTypes - Check type constraints for casting between types under
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003321 /// C semantics, or forward to CXXCheckCStyleCast in C++.
3322 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr,
Anders Carlssoncdb61972009-08-07 22:21:05 +00003323 CastExpr::CastKind &Kind, bool FunctionalStyle = false);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003324
Anders Carlsson584b2472007-11-27 07:16:40 +00003325 // CheckVectorCast - check type constraints for vectors.
3326 // Since vectors are an extension, there are no C standard reference for this.
3327 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00003328 // returns true if the cast is invalid
3329 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
3330
Nate Begeman58d29a42009-06-26 00:50:28 +00003331 // CheckExtVectorCast - check type constraints for extended vectors.
3332 // Since vectors are an extension, there are no C standard reference for this.
3333 // We allow casting between vectors and integer datatypes of the same size,
3334 // or vectors and the element type of that vector.
3335 // returns true if the cast is invalid
3336 bool CheckExtVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003337
3338 /// CXXCheckCStyleCast - Check constraints of a C-style or function-style
3339 /// cast under C++ semantics.
Sebastian Redlef0cb8e2009-07-29 13:50:23 +00003340 bool CXXCheckCStyleCast(SourceRange R, QualType CastTy, Expr *&CastExpr,
Anders Carlssoncdb61972009-08-07 22:21:05 +00003341 CastExpr::CastKind &Kind, bool FunctionalStyle);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003342
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003343 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
3344 /// \param Method - May be null.
3345 /// \param [out] ReturnType - The return type of the send.
3346 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00003347 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00003348 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00003349 SourceLocation lbrac, SourceLocation rbrac,
3350 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00003351
3352 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
3353 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Sebastian Redl9cc11e72009-07-25 15:41:38 +00003354
Chris Lattnerf4021e72007-08-23 05:46:52 +00003355 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
3356 /// the specified width and sign. If an overflow occurs, detect it and emit
3357 /// the specified diagnostic.
3358 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
3359 unsigned NewWidth, bool NewSign,
3360 SourceLocation Loc, unsigned DiagID);
3361
Anders Carlsson15281452008-11-04 16:57:32 +00003362 /// Checks that the Objective-C declaration is declared in the global scope.
3363 /// Emits an error and marks the declaration as invalid if it's not declared
3364 /// in the global scope.
3365 bool CheckObjCDeclScope(Decl *D);
3366
Anders Carlsson7c50aca2007-10-15 20:28:48 +00003367 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00003368
Anders Carlssone21555e2008-11-30 19:50:32 +00003369 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
3370 /// and reports the appropriate diagnostics. Returns false on success.
3371 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003372 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00003373
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003374 /// VerifyBitField - verifies that a bit field expression is an ICE and has
3375 /// the correct width, and that the field type is valid.
3376 /// Returns false on success.
Eli Friedman1d954f62009-08-15 21:55:26 +00003377 /// Can optionally return whether the bit-field is of width 0
Anders Carlsson9f1e5722008-12-06 20:33:04 +00003378 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
Eli Friedman1d954f62009-08-15 21:55:26 +00003379 QualType FieldTy, const Expr *BitWidth,
3380 bool *ZeroWidth = 0);
Sebastian Redl0eb23302009-01-19 00:08:26 +00003381
Chris Lattner59907c42007-08-10 20:18:51 +00003382 //===--------------------------------------------------------------------===//
3383 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00003384private:
Anders Carlssond406bf02009-08-16 01:56:34 +00003385 bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall);
3386 bool CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall);
Fariborz Jahanian725165f2009-05-18 21:05:18 +00003387
Chris Lattner60800082009-02-18 17:49:48 +00003388 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
3389 unsigned ByteNo) const;
Ryan Flynn4403a5e2009-08-06 03:00:50 +00003390 bool CheckablePrintfAttr(const FormatAttr *Format, CallExpr *TheCall);
Chris Lattner69039812009-02-18 06:01:06 +00003391 bool CheckObjCString(Expr *Arg);
Anders Carlssond406bf02009-08-16 01:56:34 +00003392
3393 Action::OwningExprResult CheckBuiltinFunctionCall(unsigned BuiltinID,
3394 CallExpr *TheCall);
Chris Lattner925e60d2007-12-28 05:29:59 +00003395 bool SemaBuiltinVAStart(CallExpr *TheCall);
3396 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00003397 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003398
3399public:
3400 // Used by C++ template instantiation.
Sebastian Redl0eb23302009-01-19 00:08:26 +00003401 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00003402
3403private:
Daniel Dunbar4493f792008-07-21 22:59:13 +00003404 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00003405 bool SemaBuiltinObjectSize(CallExpr *TheCall);
3406 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00003407 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003408 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
3409 bool HasVAListArg, unsigned format_idx,
3410 unsigned firstDataArg);
3411 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
3412 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003413 unsigned format_idx, unsigned firstDataArg);
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +00003414 void CheckNonNullArguments(const NonNullAttr *NonNull,
3415 const CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00003416 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00003417 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00003418 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
3419 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00003420 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00003421};
3422
Mike Stumpb83d2872009-02-19 22:01:56 +00003423
Ted Kremenek8189cde2009-02-07 01:47:29 +00003424//===--------------------------------------------------------------------===//
3425// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
3426template <typename T>
3427class ExprOwningPtr : public Action::ExprArg {
3428public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00003429 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Ted Kremenek8189cde2009-02-07 01:47:29 +00003430
3431 void reset(T* p) { Action::ExprArg::operator=(p); }
3432 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
3433 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
3434 T* release() { return take(); }
3435
3436 T& operator*() const { return *get(); }
3437 T* operator->() const { return get(); }
3438};
Douglas Gregord7e27052009-05-20 22:33:37 +00003439
Reid Spencer5f016e22007-07-11 17:01:13 +00003440} // end namespace clang
3441
3442#endif