blob: ac8997d3b30d2e2485370bbdeae9cee311248963 [file] [log] [blame]
Reid Spencer5f016e22007-07-11 17:01:13 +00001//===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner0bc735f2007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Reid Spencer5f016e22007-07-11 17:01:13 +00007//
8//===----------------------------------------------------------------------===//
9//
10// This file defines the Sema class, which performs semantic analysis and
11// builds ASTs.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_SEMA_H
16#define LLVM_CLANG_AST_SEMA_H
17
Chris Lattner7f925cc2008-04-11 07:00:53 +000018#include "IdentifierResolver.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000019#include "CXXFieldCollector.h"
Douglas Gregor8e9bebd2008-10-21 16:13:35 +000020#include "SemaOverload.h"
Douglas Gregoreb11cd02009-01-14 22:20:51 +000021#include "clang/AST/DeclBase.h"
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000022#include "clang/AST/DeclObjC.h"
Anders Carlsson1c5976e2009-06-05 03:43:12 +000023#include "clang/AST/DeclTemplate.h"
Reid Spencer5f016e22007-07-11 17:01:13 +000024#include "clang/Parse/Action.h"
Chris Lattner500d3292009-01-29 05:15:15 +000025#include "clang/Sema/SemaDiagnostic.h"
Anders Carlssonc1fcb772007-07-22 07:07:56 +000026#include "llvm/ADT/SmallVector.h"
Fariborz Jahanian85ff2642007-10-05 18:00:57 +000027#include "llvm/ADT/DenseSet.h"
Chris Lattnerf3876682007-10-07 01:13:46 +000028#include "llvm/ADT/SmallPtrSet.h"
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +000029#include "llvm/ADT/OwningPtr.h"
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +000030#include <string>
Douglas Gregor94b1dd22008-10-24 04:54:22 +000031#include <vector>
Reid Spencer5f016e22007-07-11 17:01:13 +000032
Chris Lattnerf4021e72007-08-23 05:46:52 +000033namespace llvm {
34 class APSInt;
35}
36
Reid Spencer5f016e22007-07-11 17:01:13 +000037namespace clang {
38 class ASTContext;
Chris Lattner2ae34ed2008-02-06 00:46:58 +000039 class ASTConsumer;
Reid Spencer5f016e22007-07-11 17:01:13 +000040 class Preprocessor;
41 class Decl;
Chris Lattnerb048c982008-04-06 04:47:34 +000042 class DeclContext;
Daniel Dunbar12bc6922008-08-11 03:27:53 +000043 class DeclSpec;
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +000044 class ExternalSemaSource;
Steve Naroffe8043c32008-04-01 23:04:06 +000045 class NamedDecl;
Sebastian Redl798d1192008-12-13 16:23:55 +000046 class Stmt;
Reid Spencer5f016e22007-07-11 17:01:13 +000047 class Expr;
Steve Naroff6f9f3072007-09-02 15:34:30 +000048 class InitListExpr;
Douglas Gregor05c13a32009-01-22 00:58:24 +000049 class DesignatedInitExpr;
Chris Lattner925e60d2007-12-28 05:29:59 +000050 class CallExpr;
Douglas Gregor1a49af92009-01-06 05:10:23 +000051 class DeclRefExpr;
Reid Spencer5f016e22007-07-11 17:01:13 +000052 class VarDecl;
53 class ParmVarDecl;
54 class TypedefDecl;
55 class FunctionDecl;
56 class QualType;
Sebastian Redl43af76e2009-03-07 12:16:37 +000057 class LangOptions;
Chris Lattnerd2177732007-07-20 16:59:19 +000058 class Token;
Reid Spencer5f016e22007-07-11 17:01:13 +000059 class IntegerLiteral;
Steve Naroffa49e1fa2008-01-22 00:55:40 +000060 class StringLiteral;
Reid Spencer5f016e22007-07-11 17:01:13 +000061 class ArrayType;
62 class LabelStmt;
Anders Carlssonc1fcb772007-07-22 07:07:56 +000063 class SwitchStmt;
Sebastian Redl13e88542009-04-27 21:33:24 +000064 class CXXTryStmt;
Nate Begeman213541a2008-04-18 23:10:10 +000065 class ExtVectorType;
Steve Naroffbea0b342007-07-29 16:33:31 +000066 class TypedefDecl;
Douglas Gregoraaba5e32009-02-04 19:02:06 +000067 class TemplateDecl;
Douglas Gregor3e00bad2009-02-17 01:05:43 +000068 class TemplateArgument;
Douglas Gregor7e063902009-05-11 23:53:27 +000069 class TemplateArgumentList;
Douglas Gregorddc29e12009-02-06 22:42:48 +000070 class TemplateParameterList;
Douglas Gregorc15cb382009-02-09 23:23:08 +000071 class TemplateTemplateParmDecl;
Douglas Gregorc8ab2562009-05-31 09:31:02 +000072 class ClassTemplatePartialSpecializationDecl;
Douglas Gregor88b70942009-02-25 22:02:03 +000073 class ClassTemplateDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000074 class ObjCInterfaceDecl;
Steve Naroffe8043c32008-04-01 23:04:06 +000075 class ObjCCompatibleAliasDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000076 class ObjCProtocolDecl;
Chris Lattnercddc8882009-03-01 00:56:52 +000077 class ObjCImplDecl;
Ted Kremeneka526c5c2008-01-07 19:49:32 +000078 class ObjCImplementationDecl;
79 class ObjCCategoryImplDecl;
80 class ObjCCategoryDecl;
81 class ObjCIvarDecl;
82 class ObjCMethodDecl;
Fariborz Jahanian02edb982008-05-01 00:03:38 +000083 class ObjCPropertyDecl;
Steve Naroff0701bbb2009-01-08 17:28:14 +000084 class ObjCContainerDecl;
Douglas Gregor94b1dd22008-10-24 04:54:22 +000085 class BasePaths;
Sebastian Redl43af76e2009-03-07 12:16:37 +000086 struct MemberLookupCriteria;
Anders Carlssonff6b3d62009-05-30 21:05:25 +000087 class CXXTemporary;
Steve Naroffbea0b342007-07-29 16:33:31 +000088
Chris Lattnerea29a3a2009-04-18 20:01:55 +000089/// BlockSemaInfo - When a block is being parsed, this contains information
90/// about the block. It is pointed to from Sema::CurBlock.
91struct BlockSemaInfo {
92 llvm::SmallVector<ParmVarDecl*, 8> Params;
93 bool hasPrototype;
94 bool isVariadic;
95 bool hasBlockDeclRefExprs;
96
97 BlockDecl *TheDecl;
98
99 /// TheScope - This is the scope for the block itself, which contains
100 /// arguments etc.
101 Scope *TheScope;
102
103 /// ReturnType - This will get set to block result type, by looking at
104 /// return types, if any, in the block body.
105 Type *ReturnType;
106
107 /// LabelMap - This is a mapping from label identifiers to the LabelStmt for
108 /// it (which acts like the label decl in some ways). Forward referenced
109 /// labels have a LabelStmt created for them with a null location & SubStmt.
110 llvm::DenseMap<IdentifierInfo*, LabelStmt*> LabelMap;
111
Chris Lattnerbcfce662009-04-18 20:10:59 +0000112 /// SwitchStack - This is the current set of active switch statements in the
113 /// block.
114 llvm::SmallVector<SwitchStmt*, 8> SwitchStack;
115
Chris Lattner17a78302009-04-19 05:28:12 +0000116 /// SavedFunctionNeedsScopeChecking - This is the value of
117 /// CurFunctionNeedsScopeChecking at the point when the block started.
118 bool SavedFunctionNeedsScopeChecking;
119
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000120 /// PrevBlockInfo - If this is nested inside another block, this points
121 /// to the outer block.
122 BlockSemaInfo *PrevBlockInfo;
123};
124
Reid Spencer5f016e22007-07-11 17:01:13 +0000125/// Sema - This implements semantic analysis and AST building for C.
126class Sema : public Action {
Chris Lattnerf50adff2009-02-17 00:58:30 +0000127 Sema(const Sema&); // DO NOT IMPLEMENT
128 void operator=(const Sema&); // DO NOT IMPLEMENT
Chris Lattner0b2f4da2008-06-29 00:28:59 +0000129public:
Chris Lattner53ebff32009-01-22 19:21:44 +0000130 const LangOptions &LangOpts;
Reid Spencer5f016e22007-07-11 17:01:13 +0000131 Preprocessor &PP;
Reid Spencer5f016e22007-07-11 17:01:13 +0000132 ASTContext &Context;
Chris Lattner2ae34ed2008-02-06 00:46:58 +0000133 ASTConsumer &Consumer;
Chris Lattner3cfa9282008-11-22 08:28:49 +0000134 Diagnostic &Diags;
135 SourceManager &SourceMgr;
Steve Naroff03300712007-11-12 13:56:41 +0000136
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000137 /// \brief Source of additional semantic information.
138 ExternalSemaSource *ExternalSource;
139
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000140 /// CurContext - This is the current declaration context of parsing.
Chris Lattnerb048c982008-04-06 04:47:34 +0000141 DeclContext *CurContext;
Chris Lattner0ed844b2008-04-04 06:12:32 +0000142
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000143 /// PreDeclaratorDC - Keeps the declaration context before switching to the
144 /// context of a declarator's nested-name-specifier.
145 DeclContext *PreDeclaratorDC;
146
Steve Naroff4eb206b2008-09-03 18:15:37 +0000147 /// CurBlock - If inside of a block definition, this contains a pointer to
148 /// the active block object that represents it.
149 BlockSemaInfo *CurBlock;
150
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000151 /// PackContext - Manages the stack for #pragma pack. An alignment
152 /// of 0 indicates default alignment.
Chris Lattner574aa402009-02-17 01:09:29 +0000153 void *PackContext; // Really a "PragmaPackStack*"
Daniel Dunbar4cde9272008-10-14 05:35:18 +0000154
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000155 /// FunctionLabelMap - This is a mapping from label identifiers to the
156 /// LabelStmt for it (which acts like the label decl in some ways). Forward
157 /// referenced labels have a LabelStmt created for them with a null location &
158 /// SubStmt.
159 ///
160 /// Note that this should always be accessed through getLabelMap() in order
161 /// to handle blocks properly.
162 llvm::DenseMap<IdentifierInfo*, LabelStmt*> FunctionLabelMap;
Steve Naroffcaaacec2009-03-13 15:38:40 +0000163
Chris Lattnerbcfce662009-04-18 20:10:59 +0000164 /// FunctionSwitchStack - This is the current set of active switch statements
165 /// in the top level function. Clients should always use getSwitchStack() to
166 /// handle the case when they are in a block.
167 llvm::SmallVector<SwitchStmt*, 8> FunctionSwitchStack;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000168
169 /// ExprTemporaries - This is the stack of temporaries that are created by
170 /// the current full expression.
Anders Carlssonff6b3d62009-05-30 21:05:25 +0000171 llvm::SmallVector<CXXTemporary*, 8> ExprTemporaries;
Anders Carlsson165a0a02009-05-17 18:41:29 +0000172
Chris Lattner38c5ebd2009-04-19 05:21:20 +0000173 /// CurFunctionNeedsScopeChecking - This is set to true when a function or
174 /// ObjC method body contains a VLA or an ObjC try block, which introduce
175 /// scopes that need to be checked for goto conditions. If a function does
176 /// not contain this, then it need not have the jump checker run on it.
177 bool CurFunctionNeedsScopeChecking;
178
Nate Begeman213541a2008-04-18 23:10:10 +0000179 /// ExtVectorDecls - This is a list all the extended vector types. This allows
180 /// us to associate a raw vector type with one of the ext_vector type names.
Steve Naroffbea0b342007-07-29 16:33:31 +0000181 /// This is only necessary for issuing pretty diagnostics.
Nate Begeman213541a2008-04-18 23:10:10 +0000182 llvm::SmallVector<TypedefDecl*, 24> ExtVectorDecls;
Chris Lattner59907c42007-08-10 20:18:51 +0000183
Steve Naroffe84a8642008-09-28 14:55:53 +0000184 /// ObjCCategoryImpls - Maintain a list of category implementations so
185 /// we can check for duplicates and find local method declarations.
186 llvm::SmallVector<ObjCCategoryImplDecl*, 8> ObjCCategoryImpls;
187
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000188 /// FieldCollector - Collects CXXFieldDecls during parsing of C++ classes.
189 llvm::OwningPtr<CXXFieldCollector> FieldCollector;
190
Anders Carlsson4681ebd2009-03-22 20:18:17 +0000191 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 8> RecordDeclSetTy;
192
193 /// PureVirtualClassDiagSet - a set of class declarations which we have
194 /// emitted a list of pure virtual functions. Used to prevent emitting the
195 /// same list more than once.
196 llvm::OwningPtr<RecordDeclSetTy> PureVirtualClassDiagSet;
197
Douglas Gregor63935192009-03-02 00:19:53 +0000198 /// \brief A mapping from external names to the most recent
199 /// locally-scoped external declaration with that name.
200 ///
201 /// This map contains external declarations introduced in local
202 /// scoped, e.g.,
203 ///
204 /// \code
205 /// void f() {
206 /// void foo(int, int);
207 /// }
208 /// \endcode
209 ///
210 /// Here, the name "foo" will be associated with the declaration on
211 /// "foo" within f. This name is not visible outside of
212 /// "f". However, we still find it in two cases:
213 ///
214 /// - If we are declaring another external with the name "foo", we
215 /// can find "foo" as a previous declaration, so that the types
216 /// of this external declaration can be checked for
217 /// compatibility.
218 ///
219 /// - If we would implicitly declare "foo" (e.g., due to a call to
220 /// "foo" in C when no prototype or definition is visible), then
221 /// we find this declaration of "foo" and complain that it is
222 /// not visible.
223 llvm::DenseMap<DeclarationName, NamedDecl *> LocallyScopedExternalDecls;
224
Douglas Gregorb6c8c8b2009-04-21 17:11:58 +0000225 /// \brief The set of tentative declarations seen so far in this
226 /// translation unit for which no definition has been seen.
227 ///
228 /// The tentative declarations are indexed by the name of the
229 /// declaration, and only the most recent tentative declaration for
230 /// a given variable will be recorded here.
231 llvm::DenseMap<DeclarationName, VarDecl *> TentativeDefinitions;
232
Chris Lattner7f925cc2008-04-11 07:00:53 +0000233 IdentifierResolver IdResolver;
234
Steve Naroffe440eb82007-10-10 17:32:04 +0000235 /// Translation Unit Scope - useful to Objective-C actions that need
236 /// to lookup file scope declarations in the "ordinary" C decl namespace.
237 /// For example, user-defined classes, built-in "id" type, etc.
Steve Naroffb216c882007-10-09 22:01:59 +0000238 Scope *TUScope;
Sebastian Redlc42e1182008-11-11 11:37:55 +0000239
240 /// The C++ "std" namespace, where the standard library resides. Cached here
241 /// by GetStdNamespace
242 NamespaceDecl *StdNamespace;
Sebastian Redlb5a57a62008-12-03 20:26:15 +0000243
244 /// A flag to remember whether the implicit forms of operator new and delete
245 /// have been declared.
246 bool GlobalNewDeleteDeclared;
Douglas Gregorf807fe02009-04-14 16:27:31 +0000247
248 /// \brief Whether the code handled by Sema should be considered a
249 /// complete translation unit or not.
250 ///
251 /// When true (which is generally the case), Sema will perform
252 /// end-of-translation-unit semantic tasks (such as creating
253 /// initializers for tentative definitions in C) once parsing has
254 /// completed. This flag will be false when building PCH files,
255 /// since a PCH file is by definition not a complete translation
256 /// unit.
257 bool CompleteTranslationUnit;
258
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000259 typedef llvm::DenseMap<Selector, ObjCMethodList> MethodPool;
260
Steve Naroff58ff9e82007-10-14 00:58:41 +0000261 /// Instance/Factory Method Pools - allows efficient lookup when typechecking
262 /// messages to "id". We need to maintain a list, since selectors can have
263 /// differing signatures across classes. In Cocoa, this happens to be
264 /// extremely uncommon (only 1% of selectors are "overloaded").
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000265 MethodPool InstanceMethodPool;
266 MethodPool FactoryMethodPool;
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000267
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +0000268 MethodPool::iterator ReadMethodPool(Selector Sel, bool isInstance);
269
Steve Naroff6b9dfd42009-03-04 15:11:40 +0000270 /// Private Helper predicate to check for 'self'.
271 bool isSelfExpr(Expr *RExpr);
Reid Spencer5f016e22007-07-11 17:01:13 +0000272public:
Douglas Gregorf807fe02009-04-14 16:27:31 +0000273 Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
274 bool CompleteTranslationUnit = true);
Chris Lattner574aa402009-02-17 01:09:29 +0000275 ~Sema() {
276 if (PackContext) FreePackedContext();
277 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000278
Chris Lattner53ebff32009-01-22 19:21:44 +0000279 const LangOptions &getLangOptions() const { return LangOpts; }
Chris Lattner3cfa9282008-11-22 08:28:49 +0000280 Diagnostic &getDiagnostics() const { return Diags; }
281 SourceManager &getSourceManager() const { return SourceMgr; }
282
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000283 /// \brief Helper class that creates diagnostics with optional
284 /// template instantiation stacks.
285 ///
286 /// This class provides a wrapper around the basic DiagnosticBuilder
287 /// class that emits diagnostics. SemaDiagnosticBuilder is
288 /// responsible for emitting the diagnostic (as DiagnosticBuilder
289 /// does) and, if the diagnostic comes from inside a template
290 /// instantiation, printing the template instantiation stack as
291 /// well.
292 class SemaDiagnosticBuilder : public DiagnosticBuilder {
293 Sema &SemaRef;
294 unsigned DiagID;
295
296 public:
297 SemaDiagnosticBuilder(DiagnosticBuilder &DB, Sema &SemaRef, unsigned DiagID)
298 : DiagnosticBuilder(DB), SemaRef(SemaRef), DiagID(DiagID) { }
299
300 ~SemaDiagnosticBuilder();
301 };
302
303 /// \brief Emit a diagnostic.
304 SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) {
Douglas Gregoree1828a2009-03-10 18:03:33 +0000305 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID);
Douglas Gregor25a88bb2009-03-20 22:48:49 +0000306 return SemaDiagnosticBuilder(DB, *this, DiagID);
Chris Lattner3cfa9282008-11-22 08:28:49 +0000307 }
Reid Spencer5f016e22007-07-11 17:01:13 +0000308
Chris Lattner394a3fd2007-08-31 04:53:24 +0000309 virtual void DeleteExpr(ExprTy *E);
310 virtual void DeleteStmt(StmtTy *S);
311
Sebastian Redl798d1192008-12-13 16:23:55 +0000312 OwningExprResult Owned(Expr* E) { return OwningExprResult(*this, E); }
Sebastian Redl0eb23302009-01-19 00:08:26 +0000313 OwningExprResult Owned(ExprResult R) {
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000314 if (R.isInvalid())
Steve Naroff872b9ac2009-01-21 22:32:33 +0000315 return ExprError();
Douglas Gregor5ac8aff2009-01-26 22:44:13 +0000316 return OwningExprResult(*this, R.get());
Sebastian Redl0eb23302009-01-19 00:08:26 +0000317 }
Sebastian Redl798d1192008-12-13 16:23:55 +0000318 OwningStmtResult Owned(Stmt* S) { return OwningStmtResult(*this, S); }
319
Chris Lattner9299f3f2008-08-23 03:19:52 +0000320 virtual void ActOnEndOfTranslationUnit();
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000321
Chris Lattnerea29a3a2009-04-18 20:01:55 +0000322 /// getLabelMap() - Return the current label map. If we're in a block, we
323 /// return it.
324 llvm::DenseMap<IdentifierInfo*, LabelStmt*> &getLabelMap() {
325 return CurBlock ? CurBlock->LabelMap : FunctionLabelMap;
326 }
327
Chris Lattnerbcfce662009-04-18 20:10:59 +0000328 /// getSwitchStack - This is returns the switch stack for the current block or
329 /// function.
330 llvm::SmallVector<SwitchStmt*,8> &getSwitchStack() {
331 return CurBlock ? CurBlock->SwitchStack : FunctionSwitchStack;
332 }
333
Reid Spencer5f016e22007-07-11 17:01:13 +0000334 //===--------------------------------------------------------------------===//
335 // Type Analysis / Processing: SemaType.cpp.
336 //
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000337 QualType adjustParameterType(QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000338 QualType ConvertDeclSpecToType(const DeclSpec &DS, SourceLocation DeclLoc,
339 bool &IsInvalid);
Chris Lattnerc9b346d2008-06-29 00:50:08 +0000340 void ProcessTypeAttributeList(QualType &Result, const AttributeList *AL);
Douglas Gregorcd281c32009-02-28 00:25:32 +0000341 QualType BuildPointerType(QualType T, unsigned Quals,
342 SourceLocation Loc, DeclarationName Entity);
Sebastian Redl7c80bd62009-03-16 23:22:08 +0000343 QualType BuildReferenceType(QualType T, bool LValueRef, unsigned Quals,
Douglas Gregorcd281c32009-02-28 00:25:32 +0000344 SourceLocation Loc, DeclarationName Entity);
345 QualType BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
346 Expr *ArraySize, unsigned Quals,
347 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor724651c2009-02-28 01:04:19 +0000348 QualType BuildFunctionType(QualType T,
349 QualType *ParamTypes, unsigned NumParamTypes,
350 bool Variadic, unsigned Quals,
351 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor949bf692009-06-09 22:17:39 +0000352 QualType BuildMemberPointerType(QualType T, QualType Class,
353 unsigned Quals, SourceLocation Loc,
354 DeclarationName Entity);
Douglas Gregor402abb52009-05-28 23:31:59 +0000355 QualType GetTypeForDeclarator(Declarator &D, Scope *S, unsigned Skip = 0,
356 TagDecl **OwnedDecl = 0);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000357 DeclarationName GetNameForDeclarator(Declarator &D);
Sebastian Redlef65f062009-05-29 18:02:33 +0000358 bool CheckSpecifiedExceptionType(QualType T, const SourceRange &Range);
Sebastian Redl6a7330c2009-05-29 15:01:05 +0000359 bool CheckDistantExceptionSpec(QualType T);
Douglas Gregor10bd3682008-11-17 22:58:34 +0000360
Chris Lattnerb28317a2009-03-28 19:18:32 +0000361 QualType ObjCGetTypeForMethodDefinition(DeclPtrTy D);
Fariborz Jahanian306d68f2007-11-08 23:49:49 +0000362
Douglas Gregor57373262008-10-22 14:17:15 +0000363 bool UnwrapSimilarPointerTypes(QualType& T1, QualType& T2);
364
Sebastian Redlcee63fb2008-12-02 14:43:59 +0000365 virtual TypeResult ActOnTypeName(Scope *S, Declarator &D);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000366
Douglas Gregor86447ec2009-03-09 16:13:40 +0000367 bool RequireCompleteType(SourceLocation Loc, QualType T, unsigned diag,
Douglas Gregor4ec339f2009-01-19 19:26:10 +0000368 SourceRange Range1 = SourceRange(),
369 SourceRange Range2 = SourceRange(),
370 QualType PrintType = QualType());
371
Douglas Gregore6258932009-03-19 00:39:20 +0000372 QualType getQualifiedNameType(const CXXScopeSpec &SS, QualType T);
373
Reid Spencer5f016e22007-07-11 17:01:13 +0000374 //===--------------------------------------------------------------------===//
375 // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
376 //
Chris Lattner21ff9c92009-03-05 01:25:28 +0000377
378 /// getDeclName - Return a pretty name for the specified decl if possible, or
379 /// an empty string if not. This is used for pretty crash reporting.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000380 virtual std::string getDeclName(DeclPtrTy D);
Chris Lattner21ff9c92009-03-05 01:25:28 +0000381
Chris Lattner682bf922009-03-29 16:50:03 +0000382 DeclGroupPtrTy ConvertDeclToDeclGroup(DeclPtrTy Ptr);
383
Douglas Gregor1a51b4a2009-02-09 15:09:02 +0000384 virtual TypeTy *getTypeName(IdentifierInfo &II, SourceLocation NameLoc,
Douglas Gregorb696ea32009-02-04 17:00:24 +0000385 Scope *S, const CXXScopeSpec *SS);
Chris Lattner4c97d762009-04-12 21:49:30 +0000386 virtual DeclSpec::TST isTagName(IdentifierInfo &II, Scope *S);
387
Chris Lattner682bf922009-03-29 16:50:03 +0000388 virtual DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D) {
389 return ActOnDeclarator(S, D, false);
Douglas Gregor584049d2008-12-15 23:53:10 +0000390 }
Chris Lattner682bf922009-03-29 16:50:03 +0000391 DeclPtrTy ActOnDeclarator(Scope *S, Declarator &D, bool IsFunctionDefinition);
Douglas Gregor63935192009-03-02 00:19:53 +0000392 void RegisterLocallyScopedExternCDecl(NamedDecl *ND, NamedDecl *PrevDecl,
393 Scope *S);
Eli Friedman85a53192009-04-07 19:37:57 +0000394 void DiagnoseFunctionSpecifiers(Declarator& D);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000395 NamedDecl* ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000396 QualType R, Decl* PrevDecl,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000397 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000398 NamedDecl* ActOnVariableDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000399 QualType R, NamedDecl* PrevDecl,
Douglas Gregorcda9c672009-02-16 17:45:42 +0000400 bool &Redeclaration);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000401 void CheckVariableDeclaration(VarDecl *NewVD, NamedDecl *PrevDecl,
Douglas Gregor3d7a12a2009-03-25 23:32:15 +0000402 bool &Redeclaration);
Douglas Gregor4afa39d2009-01-20 01:17:11 +0000403 NamedDecl* ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
Chris Lattner682bf922009-03-29 16:50:03 +0000404 QualType R, NamedDecl* PrevDecl,
Douglas Gregor04495c82009-02-24 01:23:02 +0000405 bool IsFunctionDefinition,
Chris Lattnereaaebc72009-04-25 08:06:05 +0000406 bool &Redeclaration);
407 void CheckFunctionDeclaration(FunctionDecl *NewFD, NamedDecl *&PrevDecl,
Douglas Gregor2dc0e642009-03-23 23:06:20 +0000408 bool &Redeclaration,
409 bool &OverloadableAttrRequired);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000410 virtual DeclPtrTy ActOnParamDeclarator(Scope *S, Declarator &D);
411 virtual void ActOnParamDefaultArgument(DeclPtrTy param,
Chris Lattner04421082008-04-08 04:40:51 +0000412 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +0000413 ExprArg defarg);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000414 virtual void ActOnParamUnparsedDefaultArgument(DeclPtrTy param,
Douglas Gregor61366e92008-12-24 00:01:03 +0000415 SourceLocation EqualLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000416 virtual void ActOnParamDefaultArgumentError(DeclPtrTy param);
Anders Carlssonf5dcd382009-05-30 21:37:25 +0000417 virtual void AddInitializerToDecl(DeclPtrTy dcl, FullExprArg init);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000418 void AddInitializerToDecl(DeclPtrTy dcl, ExprArg init, bool DirectInit);
419 void ActOnUninitializedDecl(DeclPtrTy dcl);
420 virtual void SetDeclDeleted(DeclPtrTy dcl, SourceLocation DelLoc);
Eli Friedmanc1dc6532009-05-29 01:49:24 +0000421 virtual DeclGroupPtrTy FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
422 DeclPtrTy *Group,
Chris Lattner682bf922009-03-29 16:50:03 +0000423 unsigned NumDecls);
Douglas Gregora3a83512009-04-01 23:51:29 +0000424 virtual void ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
425 SourceLocation LocAfterDecls);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000426 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, Declarator &D);
427 virtual DeclPtrTy ActOnStartOfFunctionDef(Scope *S, DeclPtrTy D);
428 virtual void ActOnStartOfObjCMethodDef(Scope *S, DeclPtrTy D);
Sebastian Redlb8a6aca2009-01-19 22:31:54 +0000429
Chris Lattnerb28317a2009-03-28 19:18:32 +0000430 virtual DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body);
Douglas Gregore2c31ff2009-05-15 17:59:04 +0000431 DeclPtrTy ActOnFinishFunctionBody(DeclPtrTy Decl, StmtArg Body,
432 bool IsInstantiation);
Chris Lattner5af280c2009-04-19 04:46:21 +0000433 void DiagnoseInvalidJumps(Stmt *Body);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000434 virtual DeclPtrTy ActOnFileScopeAsmDecl(SourceLocation Loc, ExprArg expr);
Anders Carlssondfab6cb2008-02-08 00:33:21 +0000435
Steve Naroffb216c882007-10-09 22:01:59 +0000436 /// Scope actions.
437 virtual void ActOnPopScope(SourceLocation Loc, Scope *S);
438 virtual void ActOnTranslationUnitScope(SourceLocation Loc, Scope *S);
Reid Spencer5f016e22007-07-11 17:01:13 +0000439
440 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
441 /// no declarator (e.g. "struct foo;") is parsed.
Chris Lattnerb28317a2009-03-28 19:18:32 +0000442 virtual DeclPtrTy ParsedFreeStandingDeclSpec(Scope *S, DeclSpec &DS);
Reid Spencer5f016e22007-07-11 17:01:13 +0000443
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000444 bool InjectAnonymousStructOrUnionMembers(Scope *S, DeclContext *Owner,
445 RecordDecl *AnonRecord);
Chris Lattnerb28317a2009-03-28 19:18:32 +0000446 virtual DeclPtrTy BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
447 RecordDecl *Record);
Douglas Gregorbcbffc42009-01-07 00:43:41 +0000448
Douglas Gregor501c5ce2009-05-14 16:41:31 +0000449 bool isAcceptableTagRedeclaration(const TagDecl *Previous,
450 TagDecl::TagKind NewTag,
451 SourceLocation NewTagLoc,
452 const IdentifierInfo &Name);
Douglas Gregored4ec8f2009-05-03 17:18:57 +0000453
Chris Lattnerb28317a2009-03-28 19:18:32 +0000454 virtual DeclPtrTy ActOnTag(Scope *S, unsigned TagSpec, TagKind TK,
455 SourceLocation KWLoc, const CXXScopeSpec &SS,
456 IdentifierInfo *Name, SourceLocation NameLoc,
Douglas Gregor402abb52009-05-28 23:31:59 +0000457 AttributeList *Attr, AccessSpecifier AS,
458 bool &OwnedDecl);
Ted Kremenek4b7c9832008-09-05 17:16:31 +0000459
Chris Lattnerb28317a2009-03-28 19:18:32 +0000460 virtual void ActOnDefs(Scope *S, DeclPtrTy TagD, SourceLocation DeclStart,
Chris Lattner06f54852008-08-23 02:00:52 +0000461 IdentifierInfo *ClassName,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000462 llvm::SmallVectorImpl<DeclPtrTy> &Decls);
463 virtual DeclPtrTy ActOnField(Scope *S, DeclPtrTy TagD,
464 SourceLocation DeclStart,
465 Declarator &D, ExprTy *BitfieldWidth);
Chris Lattner24793662009-03-05 22:45:59 +0000466
467 FieldDecl *HandleField(Scope *S, RecordDecl *TagD, SourceLocation DeclStart,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000468 Declarator &D, Expr *BitfieldWidth,
469 AccessSpecifier AS);
Chris Lattner24793662009-03-05 22:45:59 +0000470
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000471 FieldDecl *CheckFieldDecl(DeclarationName Name, QualType T,
472 RecordDecl *Record, SourceLocation Loc,
473 bool Mutable, Expr *BitfieldWidth,
Douglas Gregor4dd55f52009-03-11 20:50:30 +0000474 AccessSpecifier AS, NamedDecl *PrevDecl,
Douglas Gregor3cf538d2009-03-11 18:59:21 +0000475 Declarator *D = 0);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000476
Chris Lattnerb28317a2009-03-28 19:18:32 +0000477 virtual DeclPtrTy ActOnIvar(Scope *S, SourceLocation DeclStart,
Fariborz Jahanian496b5a82009-06-05 18:16:35 +0000478 DeclPtrTy IntfDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000479 Declarator &D, ExprTy *BitfieldWidth,
480 tok::ObjCKeywordKind visibility);
Fariborz Jahanian1d78cc42008-04-10 23:32:45 +0000481
Steve Narofff13271f2007-09-14 23:09:53 +0000482 // This is used for both record definitions and ObjC interface declarations.
Fariborz Jahanian9d048ff2007-09-29 00:54:24 +0000483 virtual void ActOnFields(Scope* S,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000484 SourceLocation RecLoc, DeclPtrTy TagDecl,
485 DeclPtrTy *Fields, unsigned NumFields,
Daniel Dunbar1bfe1c22008-10-03 02:03:53 +0000486 SourceLocation LBrac, SourceLocation RBrac,
487 AttributeList *AttrList);
Douglas Gregor72de6672009-01-08 20:45:30 +0000488
489 /// ActOnTagStartDefinition - Invoked when we have entered the
490 /// scope of a tag's definition (e.g., for an enumeration, class,
491 /// struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000492 virtual void ActOnTagStartDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000493
494 /// ActOnTagFinishDefinition - Invoked once we have finished parsing
495 /// the definition of a tag (enumeration, class, struct, or union).
Chris Lattnerb28317a2009-03-28 19:18:32 +0000496 virtual void ActOnTagFinishDefinition(Scope *S, DeclPtrTy TagDecl);
Douglas Gregor72de6672009-01-08 20:45:30 +0000497
Douglas Gregor879fd492009-03-17 19:05:46 +0000498 EnumConstantDecl *CheckEnumConstant(EnumDecl *Enum,
499 EnumConstantDecl *LastEnumConst,
500 SourceLocation IdLoc,
501 IdentifierInfo *Id,
502 ExprArg val);
503
Chris Lattnerb28317a2009-03-28 19:18:32 +0000504 virtual DeclPtrTy ActOnEnumConstant(Scope *S, DeclPtrTy EnumDecl,
505 DeclPtrTy LastEnumConstant,
506 SourceLocation IdLoc, IdentifierInfo *Id,
507 SourceLocation EqualLoc, ExprTy *Val);
Mike Stumpc6e35aa2009-05-16 07:06:02 +0000508 virtual void ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
509 SourceLocation RBraceLoc, DeclPtrTy EnumDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +0000510 DeclPtrTy *Elements, unsigned NumElements);
Sebastian Redl37d6de32008-11-08 13:00:26 +0000511
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +0000512 DeclContext *getContainingDC(DeclContext *DC);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +0000513
Chris Lattner0ed844b2008-04-04 06:12:32 +0000514 /// Set the current declaration context until it gets popped.
Douglas Gregor44b43212008-12-11 16:49:14 +0000515 void PushDeclContext(Scope *S, DeclContext *DC);
Chris Lattnerb048c982008-04-06 04:47:34 +0000516 void PopDeclContext();
Argyrios Kyrtzidis53d0ea52008-06-28 06:07:14 +0000517
Chris Lattner371f2582008-12-04 23:50:19 +0000518 /// getCurFunctionDecl - If inside of a function body, this returns a pointer
519 /// to the function decl for the function being parsed. If we're currently
520 /// in a 'block', this returns the containing context.
521 FunctionDecl *getCurFunctionDecl();
522
523 /// getCurMethodDecl - If inside of a method body, this returns a pointer to
524 /// the method decl for the method being parsed. If we're currently
525 /// in a 'block', this returns the containing context.
Daniel Dunbarc4a1dea2008-08-11 05:35:13 +0000526 ObjCMethodDecl *getCurMethodDecl();
Chris Lattner0ed844b2008-04-04 06:12:32 +0000527
Chris Lattner371f2582008-12-04 23:50:19 +0000528 /// getCurFunctionOrMethodDecl - Return the Decl for the current ObjC method
529 /// or C function we're in, otherwise return null. If we're currently
530 /// in a 'block', this returns the containing context.
531 NamedDecl *getCurFunctionOrMethodDecl();
532
Argyrios Kyrtzidis87f3ff02008-04-12 00:47:19 +0000533 /// Add this decl to the scope shadowed decl chains.
534 void PushOnScopeChains(NamedDecl *D, Scope *S);
535
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000536 /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
537 /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
538 /// true if 'D' belongs to the given declaration context.
539 bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0) {
Douglas Gregor44b43212008-12-11 16:49:14 +0000540 return IdResolver.isDeclInScope(D, Ctx, Context, S);
Argyrios Kyrtzidis15a12d02008-09-09 21:18:04 +0000541 }
542
Eli Friedman8f17b662009-02-28 05:41:13 +0000543
Chris Lattnerf1d705c2008-02-21 01:07:18 +0000544 /// Subroutines of ActOnDeclarator().
Chris Lattner682bf922009-03-29 16:50:03 +0000545 TypedefDecl *ParseTypedefDecl(Scope *S, Declarator &D, QualType T);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000546 void MergeTypeDefDecl(TypedefDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000547 bool MergeFunctionDecl(FunctionDecl *New, Decl *Old);
Douglas Gregor04495c82009-02-24 01:23:02 +0000548 bool MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old);
Chris Lattnereaaebc72009-04-25 08:06:05 +0000549 void MergeVarDecl(VarDecl *New, Decl *Old);
Douglas Gregorcda9c672009-02-16 17:45:42 +0000550 bool MergeCXXFunctionDecl(FunctionDecl *New, FunctionDecl *Old);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000551
552 /// C++ Overloading.
553 bool IsOverload(FunctionDecl *New, Decl* OldD,
554 OverloadedFunctionDecl::function_iterator &MatchedDecl);
Douglas Gregor225c41e2008-11-03 19:09:14 +0000555 ImplicitConversionSequence
556 TryImplicitConversion(Expr* From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000557 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +0000558 bool AllowExplicit = false,
559 bool ForceRValue = false);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000560 bool IsStandardConversion(Expr *From, QualType ToType,
561 StandardConversionSequence& SCS);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000562 bool IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType);
563 bool IsFloatingPointPromotion(QualType FromType, QualType ToType);
Douglas Gregor5cdf8212009-02-12 00:15:05 +0000564 bool IsComplexPromotion(QualType FromType, QualType ToType);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000565 bool IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +0000566 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregorc7887512008-12-19 19:13:09 +0000567 bool isObjCPointerConversion(QualType FromType, QualType ToType,
568 QualType& ConvertedType, bool &IncompatibleObjC);
Douglas Gregor94b1dd22008-10-24 04:54:22 +0000569 bool CheckPointerConversion(Expr *From, QualType ToType);
Sebastian Redl4433aaf2009-01-25 19:43:20 +0000570 bool IsMemberPointerConversion(Expr *From, QualType FromType, QualType ToType,
571 QualType &ConvertedType);
572 bool CheckMemberPointerConversion(Expr *From, QualType ToType);
Douglas Gregor98cd5992008-10-21 23:43:52 +0000573 bool IsQualificationConversion(QualType FromType, QualType ToType);
Douglas Gregor60d62c22008-10-31 16:23:19 +0000574 bool IsUserDefinedConversion(Expr *From, QualType ToType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000575 UserDefinedConversionSequence& User,
Douglas Gregor734d9862009-01-30 23:27:23 +0000576 bool AllowConversionFunctions,
Sebastian Redle2b68332009-04-12 17:16:29 +0000577 bool AllowExplicit, bool ForceRValue);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000578
579 ImplicitConversionSequence::CompareKind
580 CompareImplicitConversionSequences(const ImplicitConversionSequence& ICS1,
581 const ImplicitConversionSequence& ICS2);
582
583 ImplicitConversionSequence::CompareKind
584 CompareStandardConversionSequences(const StandardConversionSequence& SCS1,
585 const StandardConversionSequence& SCS2);
586
Douglas Gregor57373262008-10-22 14:17:15 +0000587 ImplicitConversionSequence::CompareKind
588 CompareQualificationConversions(const StandardConversionSequence& SCS1,
589 const StandardConversionSequence& SCS2);
590
Douglas Gregorbc0805a2008-10-23 00:40:37 +0000591 ImplicitConversionSequence::CompareKind
592 CompareDerivedToBaseConversions(const StandardConversionSequence& SCS1,
593 const StandardConversionSequence& SCS2);
594
Douglas Gregor225c41e2008-11-03 19:09:14 +0000595 ImplicitConversionSequence
596 TryCopyInitialization(Expr* From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000597 bool SuppressUserConversions = false,
598 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000599 bool PerformCopyInitialization(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +0000600 const char *Flavor, bool Elidable = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +0000601
Douglas Gregor96176b32008-11-18 23:14:02 +0000602 ImplicitConversionSequence
603 TryObjectArgumentInitialization(Expr *From, CXXMethodDecl *Method);
604 bool PerformObjectArgumentInitialization(Expr *&From, CXXMethodDecl *Method);
605
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000606 ImplicitConversionSequence TryContextuallyConvertToBool(Expr *From);
607 bool PerformContextuallyConvertToBool(Expr *&From);
608
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000609 /// OverloadingResult - Capture the result of performing overload
610 /// resolution.
611 enum OverloadingResult {
612 OR_Success, ///< Overload resolution succeeded.
613 OR_No_Viable_Function, ///< No viable function found.
Douglas Gregor48f3bb92009-02-18 21:56:37 +0000614 OR_Ambiguous, ///< Ambiguous candidates found.
615 OR_Deleted ///< Overload resoltuion refers to a deleted function.
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000616 };
617
Douglas Gregor063daf62009-03-13 18:40:31 +0000618 typedef llvm::SmallPtrSet<FunctionDecl *, 16> FunctionSet;
619 typedef llvm::SmallPtrSet<NamespaceDecl *, 16> AssociatedNamespaceSet;
620 typedef llvm::SmallPtrSet<CXXRecordDecl *, 16> AssociatedClassSet;
621
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000622 void AddOverloadCandidate(FunctionDecl *Function,
623 Expr **Args, unsigned NumArgs,
Douglas Gregor225c41e2008-11-03 19:09:14 +0000624 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000625 bool SuppressUserConversions = false,
626 bool ForceRValue = false);
Douglas Gregor063daf62009-03-13 18:40:31 +0000627 void AddFunctionCandidates(const FunctionSet &Functions,
628 Expr **Args, unsigned NumArgs,
629 OverloadCandidateSet& CandidateSet,
630 bool SuppressUserConversions = false);
Douglas Gregor96176b32008-11-18 23:14:02 +0000631 void AddMethodCandidate(CXXMethodDecl *Method,
632 Expr *Object, Expr **Args, unsigned NumArgs,
633 OverloadCandidateSet& CandidateSet,
Sebastian Redle2b68332009-04-12 17:16:29 +0000634 bool SuppressUserConversions = false,
635 bool ForceRValue = false);
Douglas Gregorf1991ea2008-11-07 22:36:19 +0000636 void AddConversionCandidate(CXXConversionDecl *Conversion,
637 Expr *From, QualType ToType,
638 OverloadCandidateSet& CandidateSet);
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000639 void AddSurrogateCandidate(CXXConversionDecl *Conversion,
Douglas Gregor72564e72009-02-26 23:50:07 +0000640 const FunctionProtoType *Proto,
Douglas Gregor106c6eb2008-11-19 22:57:39 +0000641 Expr *Object, Expr **Args, unsigned NumArgs,
642 OverloadCandidateSet& CandidateSet);
Douglas Gregor063daf62009-03-13 18:40:31 +0000643 void AddOperatorCandidates(OverloadedOperatorKind Op, Scope *S,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000644 SourceLocation OpLoc,
Douglas Gregor96176b32008-11-18 23:14:02 +0000645 Expr **Args, unsigned NumArgs,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000646 OverloadCandidateSet& CandidateSet,
647 SourceRange OpRange = SourceRange());
Douglas Gregor063daf62009-03-13 18:40:31 +0000648 void AddMemberOperatorCandidates(OverloadedOperatorKind Op,
649 SourceLocation OpLoc,
650 Expr **Args, unsigned NumArgs,
651 OverloadCandidateSet& CandidateSet,
652 SourceRange OpRange = SourceRange());
Douglas Gregoreb8f3062008-11-12 17:17:38 +0000653 void AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys,
654 Expr **Args, unsigned NumArgs,
Douglas Gregor88b4bf22009-01-13 00:52:54 +0000655 OverloadCandidateSet& CandidateSet,
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000656 bool IsAssignmentOperator = false,
657 unsigned NumContextualBoolArguments = 0);
Douglas Gregor74253732008-11-19 15:42:04 +0000658 void AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
659 Expr **Args, unsigned NumArgs,
660 OverloadCandidateSet& CandidateSet);
Douglas Gregorfa047642009-02-04 00:32:51 +0000661 void AddArgumentDependentLookupCandidates(DeclarationName Name,
662 Expr **Args, unsigned NumArgs,
663 OverloadCandidateSet& CandidateSet);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000664 bool isBetterOverloadCandidate(const OverloadCandidate& Cand1,
665 const OverloadCandidate& Cand2);
666 OverloadingResult BestViableFunction(OverloadCandidateSet& CandidateSet,
667 OverloadCandidateSet::iterator& Best);
668 void PrintOverloadCandidates(OverloadCandidateSet& CandidateSet,
669 bool OnlyViable);
670
Douglas Gregor904eed32008-11-10 20:40:00 +0000671 FunctionDecl *ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType,
672 bool Complain);
673 void FixOverloadedFunctionReference(Expr *E, FunctionDecl *Fn);
674
Douglas Gregor17330012009-02-04 15:01:18 +0000675 FunctionDecl *ResolveOverloadedCallFn(Expr *Fn, NamedDecl *Callee,
676 DeclarationName UnqualifiedName,
Douglas Gregor0a396682008-11-26 06:01:48 +0000677 SourceLocation LParenLoc,
678 Expr **Args, unsigned NumArgs,
679 SourceLocation *CommaLocs,
Douglas Gregorfa047642009-02-04 00:32:51 +0000680 SourceLocation RParenLoc,
Douglas Gregor17330012009-02-04 15:01:18 +0000681 bool &ArgumentDependentLookup);
Douglas Gregor063daf62009-03-13 18:40:31 +0000682
Douglas Gregorbc736fc2009-03-13 23:49:33 +0000683 OwningExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
684 unsigned Opc,
685 FunctionSet &Functions,
686 ExprArg input);
687
Douglas Gregor063daf62009-03-13 18:40:31 +0000688 OwningExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
689 unsigned Opc,
690 FunctionSet &Functions,
691 Expr *LHS, Expr *RHS);
692
Douglas Gregor88a35142008-12-22 05:46:06 +0000693 ExprResult
694 BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
695 SourceLocation LParenLoc, Expr **Args,
696 unsigned NumArgs, SourceLocation *CommaLocs,
697 SourceLocation RParenLoc);
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000698 ExprResult
Douglas Gregor5c37de72008-12-06 00:22:45 +0000699 BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
Douglas Gregorf9eb9052008-11-19 21:05:33 +0000700 Expr **Args, unsigned NumArgs,
701 SourceLocation *CommaLocs,
702 SourceLocation RParenLoc);
Douglas Gregor8e9bebd2008-10-21 16:13:35 +0000703
Douglas Gregor3fc749d2008-12-23 00:26:44 +0000704 ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
Douglas Gregor8ba10742008-11-20 16:27:02 +0000705 SourceLocation MemberLoc,
706 IdentifierInfo &Member);
Douglas Gregor09f41cf2009-01-14 15:45:31 +0000707
Chris Lattner823c44e2009-01-06 07:27:21 +0000708 /// Helpers for dealing with function parameters.
Chris Lattner04421082008-04-08 04:40:51 +0000709 bool CheckParmsForFunctionDef(FunctionDecl *FD);
Chris Lattner04421082008-04-08 04:40:51 +0000710 void CheckCXXDefaultArguments(FunctionDecl *FD);
Douglas Gregor6d6eb572008-05-07 04:49:29 +0000711 void CheckExtraCXXDefaultArguments(Declarator &D);
Reid Spencer5f016e22007-07-11 17:01:13 +0000712
Douglas Gregor1a0d31a2009-01-12 18:45:55 +0000713 Scope *getNonFieldDeclScope(Scope *S);
714
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000715 /// \name Name lookup
716 ///
717 /// These routines provide name lookup that is used during semantic
718 /// analysis to resolve the various kinds of names (identifiers,
719 /// overloaded operator names, constructor names, etc.) into zero or
720 /// more declarations within a particular scope. The major entry
721 /// points are LookupName, which performs unqualified name lookup,
722 /// and LookupQualifiedName, which performs qualified name lookup.
723 ///
724 /// All name lookup is performed based on some specific criteria,
725 /// which specify what names will be visible to name lookup and how
726 /// far name lookup should work. These criteria are important both
727 /// for capturing language semantics (certain lookups will ignore
728 /// certain names, for example) and for performance, since name
729 /// lookup is often a bottleneck in the compilation of C++. Name
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000730 /// lookup criteria is specified via the LookupCriteria enumeration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000731 ///
732 /// The results of name lookup can vary based on the kind of name
733 /// lookup performed, the current language, and the translation
734 /// unit. In C, for example, name lookup will either return nothing
735 /// (no entity found) or a single declaration. In C++, name lookup
736 /// can additionally refer to a set of overloaded functions or
737 /// result in an ambiguity. All of the possible results of name
738 /// lookup are captured by the LookupResult class, which provides
739 /// the ability to distinguish among them.
740 //@{
Douglas Gregorf780abc2008-12-30 03:27:21 +0000741
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000742 /// @brief Describes the kind of name lookup to perform.
743 enum LookupNameKind {
744 /// Ordinary name lookup, which finds ordinary names (functions,
745 /// variables, typedefs, etc.) in C and most kinds of names
746 /// (functions, variables, members, types, etc.) in C++.
747 LookupOrdinaryName = 0,
748 /// Tag name lookup, which finds the names of enums, classes,
749 /// structs, and unions.
750 LookupTagName,
751 /// Member name lookup, which finds the names of
752 /// class/struct/union members.
753 LookupMemberName,
Douglas Gregorf680a0f2009-02-04 16:44:47 +0000754 // Look up of an operator name (e.g., operator+) for use with
755 // operator overloading. This lookup is similar to ordinary name
756 // lookup, but will ignore any declarations that are class
757 // members.
758 LookupOperatorName,
Douglas Gregor4c921ae2009-01-30 01:04:22 +0000759 /// Look up of a name that precedes the '::' scope resolution
760 /// operator in C++. This lookup completely ignores operator,
761 /// function, and enumerator names (C++ [basic.lookup.qual]p1).
762 LookupNestedNameSpecifierName,
763 /// Look up a namespace name within a C++ using directive or
764 /// namespace alias definition, ignoring non-namespace names (C++
765 /// [basic.lookup.udir]p1).
Douglas Gregord6f7e9d2009-02-24 20:03:32 +0000766 LookupNamespaceName,
Douglas Gregor6e378de2009-04-23 23:18:26 +0000767 /// Look up an ordinary name that is going to be redeclared as a
768 /// name with linkage. This lookup ignores any declarations that
769 /// are outside of the current scope unless they have linkage. See
770 /// C99 6.2.2p4-5 and C++ [basic.link]p6.
771 LookupRedeclarationWithLinkage,
772 /// Look up the name of an Objective-C protocol.
Douglas Gregor8fc463a2009-04-24 00:11:27 +0000773 LookupObjCProtocolName,
774 /// Look up the name of an Objective-C implementation
775 LookupObjCImplementationName,
776 /// Look up the name of an Objective-C category implementation
777 LookupObjCCategoryImplName
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000778 };
779
780 /// @brief Represents the results of name lookup.
781 ///
782 /// An instance of the LookupResult class captures the results of a
783 /// single name lookup, which can return no result (nothing found),
784 /// a single declaration, a set of overloaded functions, or an
785 /// ambiguity. Use the getKind() method to determine which of these
786 /// results occurred for a given lookup.
787 ///
788 /// Any non-ambiguous lookup can be converted into a single
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000789 /// (possibly NULL) @c NamedDecl* via a conversion function or the
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000790 /// getAsDecl() method. This conversion permits the common-case
791 /// usage in C and Objective-C where name lookup will always return
792 /// a single declaration.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000793 struct LookupResult {
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000794 /// The kind of entity that is actually stored within the
795 /// LookupResult object.
Douglas Gregor69d993a2009-01-17 01:13:24 +0000796 enum {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000797 /// First is a single declaration (a NamedDecl*), which may be NULL.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000798 SingleDecl,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000799
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000800 /// First is a single declaration (an OverloadedFunctionDecl*).
801 OverloadedDeclSingleDecl,
802
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000803 /// [First, Last) is an iterator range represented as opaque
804 /// pointers used to reconstruct IdentifierResolver::iterators.
805 OverloadedDeclFromIdResolver,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000806
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000807 /// [First, Last) is an iterator range represented as opaque
808 /// pointers used to reconstruct DeclContext::lookup_iterators.
809 OverloadedDeclFromDeclContext,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000810
811 /// First is a pointer to a BasePaths structure, which is owned
812 /// by the LookupResult. Last is non-zero to indicate that the
813 /// ambiguity is caused by two names found in base class
814 /// subobjects of different types.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000815 AmbiguousLookupStoresBasePaths,
816
817 /// [First, Last) is an iterator range represented as opaque
818 /// pointers used to reconstruct new'ed Decl*[] array containing
819 /// found ambiguous decls. LookupResult is owner of this array.
820 AmbiguousLookupStoresDecls
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000821 } StoredKind;
822
823 /// The first lookup result, whose contents depend on the kind of
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000824 /// lookup result. This may be a NamedDecl* (if StoredKind ==
825 /// SingleDecl), OverloadedFunctionDecl* (if StoredKind ==
826 /// OverloadedDeclSingleDecl), the opaque pointer from an
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000827 /// IdentifierResolver::iterator (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000828 /// OverloadedDeclFromIdResolver), a DeclContext::lookup_iterator
829 /// (if StoredKind == OverloadedDeclFromDeclContext), or a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000830 /// BasePaths pointer (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000831 mutable uintptr_t First;
832
833 /// The last lookup result, whose contents depend on the kind of
834 /// lookup result. This may be unused (if StoredKind ==
Douglas Gregor7176fff2009-01-15 00:26:24 +0000835 /// SingleDecl), it may have the same type as First (for
836 /// overloaded function declarations), or is may be used as a
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000837 /// Boolean value (if StoredKind == AmbiguousLookupStoresBasePaths).
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000838 mutable uintptr_t Last;
839
840 /// Context - The context in which we will build any
841 /// OverloadedFunctionDecl nodes needed by the conversion to
842 /// Decl*.
843 ASTContext *Context;
844
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000845 /// @brief The kind of entity found by name lookup.
846 enum LookupKind {
847 /// @brief No entity found met the criteria.
848 NotFound = 0,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000849
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000850 /// @brief Name lookup found a single declaration that met the
Douglas Gregor7176fff2009-01-15 00:26:24 +0000851 /// criteria. getAsDecl will return this declaration.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000852 Found,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000853
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000854 /// @brief Name lookup found a set of overloaded functions that
Douglas Gregor7176fff2009-01-15 00:26:24 +0000855 /// met the criteria. getAsDecl will turn this set of overloaded
856 /// functions into an OverloadedFunctionDecl.
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000857 FoundOverloaded,
Douglas Gregor7176fff2009-01-15 00:26:24 +0000858
859 /// Name lookup results in an ambiguity because multiple
860 /// entities that meet the lookup criteria were found in
861 /// subobjects of different types. For example:
862 /// @code
863 /// struct A { void f(int); }
864 /// struct B { void f(double); }
865 /// struct C : A, B { };
866 /// void test(C c) {
867 /// c.f(0); // error: A::f and B::f come from subobjects of different
868 /// // types. overload resolution is not performed.
869 /// }
870 /// @endcode
871 AmbiguousBaseSubobjectTypes,
872
873 /// Name lookup results in an ambiguity because multiple
874 /// nonstatic entities that meet the lookup criteria were found
875 /// in different subobjects of the same type. For example:
876 /// @code
877 /// struct A { int x; };
878 /// struct B : A { };
879 /// struct C : A { };
880 /// struct D : B, C { };
881 /// int test(D d) {
882 /// return d.x; // error: 'x' is found in two A subobjects (of B and C)
883 /// }
884 /// @endcode
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000885 AmbiguousBaseSubobjects,
886
887 /// Name lookup results in an ambiguity because multiple definitions
888 /// of entity that meet the lookup criteria were found in different
889 /// declaration contexts.
890 /// @code
891 /// namespace A {
892 /// int i;
893 /// namespace B { int i; }
894 /// int test() {
895 /// using namespace B;
896 /// return i; // error 'i' is found in namespace A and A::B
897 /// }
898 /// }
899 /// @endcode
900 AmbiguousReference
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000901 };
902
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000903 static LookupResult CreateLookupResult(ASTContext &Context, NamedDecl *D);
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000904
Douglas Gregor69d993a2009-01-17 01:13:24 +0000905 static LookupResult CreateLookupResult(ASTContext &Context,
906 IdentifierResolver::iterator F,
907 IdentifierResolver::iterator L);
Douglas Gregor7176fff2009-01-15 00:26:24 +0000908
Douglas Gregor69d993a2009-01-17 01:13:24 +0000909 static LookupResult CreateLookupResult(ASTContext &Context,
910 DeclContext::lookup_iterator F,
911 DeclContext::lookup_iterator L);
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000912
Douglas Gregor69d993a2009-01-17 01:13:24 +0000913 static LookupResult CreateLookupResult(ASTContext &Context, BasePaths *Paths,
914 bool DifferentSubobjectTypes) {
915 LookupResult Result;
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000916 Result.StoredKind = AmbiguousLookupStoresBasePaths;
Douglas Gregor69d993a2009-01-17 01:13:24 +0000917 Result.First = reinterpret_cast<uintptr_t>(Paths);
918 Result.Last = DifferentSubobjectTypes? 1 : 0;
919 Result.Context = &Context;
920 return Result;
921 }
Douglas Gregor4bb64e72009-01-15 02:19:31 +0000922
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000923 template <typename Iterator>
924 static LookupResult CreateLookupResult(ASTContext &Context,
925 Iterator B, std::size_t Len) {
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000926 NamedDecl ** Array = new NamedDecl*[Len];
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000927 for (std::size_t Idx = 0; Idx < Len; ++Idx, ++B)
928 Array[Idx] = *B;
929 LookupResult Result;
930 Result.StoredKind = AmbiguousLookupStoresDecls;
931 Result.First = reinterpret_cast<uintptr_t>(Array);
932 Result.Last = reinterpret_cast<uintptr_t>(Array + Len);
933 Result.Context = &Context;
934 return Result;
935 }
936
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000937 LookupKind getKind() const;
938
939 /// @brief Determine whether name look found something.
940 operator bool() const { return getKind() != NotFound; }
941
Douglas Gregor7176fff2009-01-15 00:26:24 +0000942 /// @brief Determines whether the lookup resulted in an ambiguity.
Douglas Gregor2a3009a2009-02-03 19:21:40 +0000943 bool isAmbiguous() const {
944 return StoredKind == AmbiguousLookupStoresBasePaths ||
945 StoredKind == AmbiguousLookupStoresDecls;
946 }
Douglas Gregor7176fff2009-01-15 00:26:24 +0000947
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000948 /// @brief Allows conversion of a lookup result into a
949 /// declaration, with the same behavior as getAsDecl.
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000950 operator NamedDecl*() const { return getAsDecl(); }
Douglas Gregoreb11cd02009-01-14 22:20:51 +0000951
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000952 NamedDecl* getAsDecl() const;
Douglas Gregor7176fff2009-01-15 00:26:24 +0000953
954 BasePaths *getBasePaths() const;
Douglas Gregord8635172009-02-02 21:35:47 +0000955
956 /// \brief Iterate over the results of name lookup.
957 ///
958 /// The @c iterator class provides iteration over the results of a
959 /// non-ambiguous name lookup.
960 class iterator {
961 /// The LookupResult structure we're iterating through.
962 LookupResult *Result;
963
964 /// The current position of this iterator within the sequence of
965 /// results. This value will have the same representation as the
966 /// @c First field in the LookupResult structure.
967 mutable uintptr_t Current;
968
969 public:
Douglas Gregor47b9a1c2009-02-04 17:27:36 +0000970 typedef NamedDecl * value_type;
971 typedef NamedDecl * reference;
972 typedef NamedDecl * pointer;
Douglas Gregord8635172009-02-02 21:35:47 +0000973 typedef std::ptrdiff_t difference_type;
974 typedef std::forward_iterator_tag iterator_category;
975
976 iterator() : Result(0), Current(0) { }
977
978 iterator(LookupResult *Res, uintptr_t Cur) : Result(Res), Current(Cur) { }
979
980 reference operator*() const;
981
982 pointer operator->() const { return **this; }
983
984 iterator &operator++();
985
986 iterator operator++(int) {
987 iterator tmp(*this);
988 ++(*this);
989 return tmp;
990 }
991
992 friend inline bool operator==(iterator const& x, iterator const& y) {
993 return x.Current == y.Current;
994 }
995
996 friend inline bool operator!=(iterator const& x, iterator const& y) {
997 return x.Current != y.Current;
998 }
999 };
1000 friend class iterator;
1001
1002 iterator begin();
1003 iterator end();
Douglas Gregor31a19b62009-04-01 21:51:26 +00001004
1005 /// \brief Free the memory associated with this lookup.
1006 void Destroy();
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001007 };
1008
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001009private:
1010 typedef llvm::SmallVector<LookupResult, 3> LookupResultsVecTy;
1011
1012 std::pair<bool, LookupResult> CppLookupName(Scope *S, DeclarationName Name,
1013 LookupNameKind NameKind,
1014 bool RedeclarationOnly);
Fariborz Jahanianef79bc92009-04-07 18:28:06 +00001015 ObjCMethodDecl *FindMethodInNestedImplementations(
1016 const ObjCInterfaceDecl *IFace,
1017 const Selector &Sel);
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001018
1019public:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001020 /// Determines whether D is a suitable lookup result according to the
1021 /// lookup criteria.
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001022 static bool isAcceptableLookupResult(NamedDecl *D, LookupNameKind NameKind,
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001023 unsigned IDNS) {
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001024 switch (NameKind) {
1025 case Sema::LookupOrdinaryName:
1026 case Sema::LookupTagName:
1027 case Sema::LookupMemberName:
Douglas Gregord6f7e9d2009-02-24 20:03:32 +00001028 case Sema::LookupRedeclarationWithLinkage: // FIXME: check linkage, scoping
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001029 case Sema::LookupObjCProtocolName:
1030 case Sema::LookupObjCImplementationName:
1031 case Sema::LookupObjCCategoryImplName:
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001032 return D->isInIdentifierNamespace(IDNS);
1033
Douglas Gregorf680a0f2009-02-04 16:44:47 +00001034 case Sema::LookupOperatorName:
1035 return D->isInIdentifierNamespace(IDNS) &&
1036 !D->getDeclContext()->isRecord();
1037
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001038 case Sema::LookupNestedNameSpecifierName:
1039 return isa<TypedefDecl>(D) || D->isInIdentifierNamespace(Decl::IDNS_Tag);
1040
1041 case Sema::LookupNamespaceName:
Anders Carlsson81c85c42009-03-28 23:53:49 +00001042 return isa<NamespaceDecl>(D) || isa<NamespaceAliasDecl>(D);
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001043 }
1044
1045 assert(false &&
Douglas Gregor7dda67d2009-02-05 19:25:20 +00001046 "isAcceptableLookupResult always returns before this point");
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001047 return false;
1048 }
Douglas Gregor7176fff2009-01-15 00:26:24 +00001049
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001050 LookupResult LookupName(Scope *S, DeclarationName Name,
1051 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001052 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001053 bool AllowBuiltinCreation = false,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001054 SourceLocation Loc = SourceLocation());
Douglas Gregor4c921ae2009-01-30 01:04:22 +00001055 LookupResult LookupQualifiedName(DeclContext *LookupCtx, DeclarationName Name,
1056 LookupNameKind NameKind,
1057 bool RedeclarationOnly = false);
1058 LookupResult LookupParsedName(Scope *S, const CXXScopeSpec *SS,
1059 DeclarationName Name,
1060 LookupNameKind NameKind,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001061 bool RedeclarationOnly = false,
Eli Friedman6eb32f42009-06-06 02:08:44 +00001062 bool AllowBuiltinCreation = false,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001063 SourceLocation Loc = SourceLocation());
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001064
Douglas Gregor6e378de2009-04-23 23:18:26 +00001065 ObjCProtocolDecl *LookupProtocol(IdentifierInfo *II);
Douglas Gregor8fc463a2009-04-24 00:11:27 +00001066 ObjCImplementationDecl *LookupObjCImplementation(IdentifierInfo *II);
1067 ObjCCategoryImplDecl *LookupObjCCategoryImpl(IdentifierInfo *II);
Douglas Gregor6e378de2009-04-23 23:18:26 +00001068
Douglas Gregor3fd95ce2009-03-13 00:33:25 +00001069 void LookupOverloadedOperatorName(OverloadedOperatorKind Op, Scope *S,
1070 QualType T1, QualType T2,
1071 FunctionSet &Functions);
1072
1073 void ArgumentDependentLookup(DeclarationName Name,
1074 Expr **Args, unsigned NumArgs,
1075 FunctionSet &Functions);
1076
Douglas Gregorfa047642009-02-04 00:32:51 +00001077 void FindAssociatedClassesAndNamespaces(Expr **Args, unsigned NumArgs,
1078 AssociatedNamespaceSet &AssociatedNamespaces,
1079 AssociatedClassSet &AssociatedClasses);
1080
Douglas Gregor7176fff2009-01-15 00:26:24 +00001081 bool DiagnoseAmbiguousLookup(LookupResult &Result, DeclarationName Name,
1082 SourceLocation NameLoc,
1083 SourceRange LookupRange = SourceRange());
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001084 //@}
1085
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001086 ObjCInterfaceDecl *getObjCInterfaceDecl(IdentifierInfo *Id);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001087 NamedDecl *LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
Douglas Gregor3e41d602009-02-13 23:20:09 +00001088 Scope *S, bool ForRedeclaration,
1089 SourceLocation Loc);
Douglas Gregor4afa39d2009-01-20 01:17:11 +00001090 NamedDecl *ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II,
1091 Scope *S);
Douglas Gregor3c385e52009-02-14 18:57:46 +00001092 void AddKnownFunctionAttributes(FunctionDecl *FD);
Douglas Gregoreb11cd02009-01-14 22:20:51 +00001093
1094 // More parsing and symbol table subroutines.
1095
Reid Spencer5f016e22007-07-11 17:01:13 +00001096 // Decl attributes - this routine is the top level dispatcher.
Chris Lattnere5c5ee12008-06-29 00:16:31 +00001097 void ProcessDeclAttributes(Decl *D, const Declarator &PD);
Chris Lattnerf2e4bd52008-06-28 23:58:55 +00001098 void ProcessDeclAttributeList(Decl *D, const AttributeList *AttrList);
Christopher Lambebb97e92008-02-04 02:31:56 +00001099
Steve Naroff3c2eb662008-02-10 21:38:56 +00001100 void WarnUndefinedMethod(SourceLocation ImpLoc, ObjCMethodDecl *method,
1101 bool &IncompleteImpl);
Fariborz Jahanian8daab972008-12-05 18:18:52 +00001102 void WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethod,
1103 ObjCMethodDecl *IntfMethod);
Fariborz Jahanian2574a682009-05-14 23:52:54 +00001104 bool QualifiedIdConformsQualifiedId(QualType LHS, QualType RHS);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001105
1106 NamespaceDecl *GetStdNamespace();
Fariborz Jahaniand1fa6442009-01-12 19:55:42 +00001107
1108 bool isPropertyReadonly(ObjCPropertyDecl *PropertyDecl,
Steve Naroff22dc0b02009-02-26 19:11:32 +00001109 ObjCInterfaceDecl *IDecl);
Steve Naroff3c2eb662008-02-10 21:38:56 +00001110
Chris Lattner823c44e2009-01-06 07:27:21 +00001111 /// CheckProtocolMethodDefs - This routine checks unimplemented
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001112 /// methods declared in protocol, and those referenced by it.
1113 /// \param IDecl - Used for checking for methods which may have been
1114 /// inherited.
Steve Naroffefe7f362008-02-08 22:06:17 +00001115 void CheckProtocolMethodDefs(SourceLocation ImpLoc,
1116 ObjCProtocolDecl *PDecl,
Fariborz Jahanianca3adf72007-10-02 20:06:01 +00001117 bool& IncompleteImpl,
Steve Naroffeefc4182007-10-08 21:05:34 +00001118 const llvm::DenseSet<Selector> &InsMap,
Daniel Dunbar7ad1b1f2008-09-04 20:01:15 +00001119 const llvm::DenseSet<Selector> &ClsMap,
1120 ObjCInterfaceDecl *IDecl);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001121
Steve Naroffa5997c42007-10-02 21:43:37 +00001122 /// CheckImplementationIvars - This routine checks if the instance variables
1123 /// listed in the implelementation match those listed in the interface.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001124 void CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
1125 ObjCIvarDecl **Fields, unsigned nIvars,
Steve Naroff3c2eb662008-02-10 21:38:56 +00001126 SourceLocation Loc);
Steve Naroffa5997c42007-10-02 21:43:37 +00001127
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001128 /// ImplMethodsVsClassMethods - This is main routine to warn if any method
Chris Lattnercddc8882009-03-01 00:56:52 +00001129 /// remains unimplemented in the class or category @implementation.
1130 void ImplMethodsVsClassMethods(ObjCImplDecl* IMPDecl,
1131 ObjCContainerDecl* IDecl,
1132 bool IncompleteImpl = false);
Fariborz Jahanian8c74fa42007-09-29 17:14:55 +00001133
Fariborz Jahanian85ff2642007-10-05 18:00:57 +00001134 /// MatchTwoMethodDeclarations - Checks if two methods' type match and returns
1135 /// true, or false, accordingly.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001136 bool MatchTwoMethodDeclarations(const ObjCMethodDecl *Method,
Steve Narofffe6b0dc2008-10-21 10:37:50 +00001137 const ObjCMethodDecl *PrevMethod,
1138 bool matchBasedOnSizeAndAlignment = false);
Steve Naroff3b950172007-10-10 21:53:07 +00001139
Fariborz Jahanianb33f3ad2009-05-01 20:07:12 +00001140 /// MatchAllMethodDeclarations - Check methods declaraed in interface or
1141 /// or protocol against those declared in their implementations.
1142 void MatchAllMethodDeclarations(const llvm::DenseSet<Selector> &InsMap,
1143 const llvm::DenseSet<Selector> &ClsMap,
1144 llvm::DenseSet<Selector> &InsMapSeen,
1145 llvm::DenseSet<Selector> &ClsMapSeen,
1146 ObjCImplDecl* IMPDecl,
1147 ObjCContainerDecl* IDecl,
1148 bool &IncompleteImpl,
1149 bool ImmediateClass);
1150
Steve Naroff58ff9e82007-10-14 00:58:41 +00001151 /// AddInstanceMethodToGlobalPool - All instance methods in a translation
1152 /// unit are added to a global pool. This allows us to efficiently associate
1153 /// a selector with a method declaraation for purposes of typechecking
1154 /// messages sent to "id" (where the class of the object is unknown).
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001155 void AddInstanceMethodToGlobalPool(ObjCMethodDecl *Method);
Steve Naroff58ff9e82007-10-14 00:58:41 +00001156
Steve Naroff037cda52008-09-30 14:38:43 +00001157 /// LookupInstanceMethodInGlobalPool - Returns the method and warns if
1158 /// there are multiple signatures.
1159 ObjCMethodDecl *LookupInstanceMethodInGlobalPool(Selector Sel, SourceRange R);
Douglas Gregorf0aaf7a2009-04-24 21:10:55 +00001160
1161 /// LookupFactoryMethodInGlobalPool - Returns the method and warns if
1162 /// there are multiple signatures.
1163 ObjCMethodDecl *LookupFactoryMethodInGlobalPool(Selector Sel, SourceRange R);
Steve Naroff037cda52008-09-30 14:38:43 +00001164
Steve Naroff58ff9e82007-10-14 00:58:41 +00001165 /// AddFactoryMethodToGlobalPool - Same as above, but for factory methods.
Ted Kremeneka526c5c2008-01-07 19:49:32 +00001166 void AddFactoryMethodToGlobalPool(ObjCMethodDecl *Method);
Reid Spencer5f016e22007-07-11 17:01:13 +00001167 //===--------------------------------------------------------------------===//
1168 // Statement Parsing Callbacks: SemaStmt.cpp.
1169public:
Anders Carlsson6b1d2832009-05-17 21:11:30 +00001170 virtual OwningStmtResult ActOnExprStmt(FullExprArg Expr);
Sebastian Redla60528c2008-12-21 12:04:03 +00001171
1172 virtual OwningStmtResult ActOnNullStmt(SourceLocation SemiLoc);
1173 virtual OwningStmtResult ActOnCompoundStmt(SourceLocation L, SourceLocation R,
1174 MultiStmtArg Elts,
1175 bool isStmtExpr);
Chris Lattner682bf922009-03-29 16:50:03 +00001176 virtual OwningStmtResult ActOnDeclStmt(DeclGroupPtrTy Decl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001177 SourceLocation StartLoc,
Sebastian Redla60528c2008-12-21 12:04:03 +00001178 SourceLocation EndLoc);
Sebastian Redl117054a2008-12-28 16:13:43 +00001179 virtual OwningStmtResult ActOnCaseStmt(SourceLocation CaseLoc, ExprArg LHSVal,
1180 SourceLocation DotDotDotLoc, ExprArg RHSVal,
Chris Lattner24e1e702009-03-04 04:23:07 +00001181 SourceLocation ColonLoc);
1182 virtual void ActOnCaseStmtBody(StmtTy *CaseStmt, StmtArg SubStmt);
1183
Sebastian Redl117054a2008-12-28 16:13:43 +00001184 virtual OwningStmtResult ActOnDefaultStmt(SourceLocation DefaultLoc,
1185 SourceLocation ColonLoc,
1186 StmtArg SubStmt, Scope *CurScope);
Sebastian Redlde307472009-01-11 00:38:46 +00001187 virtual OwningStmtResult ActOnLabelStmt(SourceLocation IdentLoc,
1188 IdentifierInfo *II,
1189 SourceLocation ColonLoc,
1190 StmtArg SubStmt);
Anders Carlssona99fad82009-05-17 18:26:53 +00001191 virtual OwningStmtResult ActOnIfStmt(SourceLocation IfLoc,
1192 FullExprArg CondVal, StmtArg ThenVal,
1193 SourceLocation ElseLoc, StmtArg ElseVal);
Sebastian Redlde307472009-01-11 00:38:46 +00001194 virtual OwningStmtResult ActOnStartOfSwitchStmt(ExprArg Cond);
1195 virtual OwningStmtResult ActOnFinishSwitchStmt(SourceLocation SwitchLoc,
1196 StmtArg Switch, StmtArg Body);
Anders Carlsson7f537c12009-05-17 21:22:26 +00001197 virtual OwningStmtResult ActOnWhileStmt(SourceLocation WhileLoc,
1198 FullExprArg Cond, StmtArg Body);
Sebastian Redlf05b1522009-01-16 23:28:06 +00001199 virtual OwningStmtResult ActOnDoStmt(SourceLocation DoLoc, StmtArg Body,
1200 SourceLocation WhileLoc, ExprArg Cond);
1201
1202 virtual OwningStmtResult ActOnForStmt(SourceLocation ForLoc,
1203 SourceLocation LParenLoc,
1204 StmtArg First, ExprArg Second,
1205 ExprArg Third, SourceLocation RParenLoc,
1206 StmtArg Body);
1207 virtual OwningStmtResult ActOnObjCForCollectionStmt(SourceLocation ForColLoc,
1208 SourceLocation LParenLoc,
1209 StmtArg First, ExprArg Second,
1210 SourceLocation RParenLoc, StmtArg Body);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001211
1212 virtual OwningStmtResult ActOnGotoStmt(SourceLocation GotoLoc,
1213 SourceLocation LabelLoc,
1214 IdentifierInfo *LabelII);
1215 virtual OwningStmtResult ActOnIndirectGotoStmt(SourceLocation GotoLoc,
1216 SourceLocation StarLoc,
1217 ExprArg DestExp);
1218 virtual OwningStmtResult ActOnContinueStmt(SourceLocation ContinueLoc,
1219 Scope *CurScope);
1220 virtual OwningStmtResult ActOnBreakStmt(SourceLocation GotoLoc,
1221 Scope *CurScope);
1222
1223 virtual OwningStmtResult ActOnReturnStmt(SourceLocation ReturnLoc,
Anders Carlssona0ab25d2009-05-30 21:42:34 +00001224 FullExprArg RetValExp);
Sebastian Redl4cffe2f2009-01-18 13:19:59 +00001225 OwningStmtResult ActOnBlockReturnStmt(SourceLocation ReturnLoc,
1226 Expr *RetValExp);
1227
Sebastian Redl3037ed02009-01-18 16:53:17 +00001228 virtual OwningStmtResult ActOnAsmStmt(SourceLocation AsmLoc,
1229 bool IsSimple,
1230 bool IsVolatile,
1231 unsigned NumOutputs,
1232 unsigned NumInputs,
1233 std::string *Names,
1234 MultiExprArg Constraints,
1235 MultiExprArg Exprs,
1236 ExprArg AsmString,
1237 MultiExprArg Clobbers,
1238 SourceLocation RParenLoc);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001239
1240 virtual OwningStmtResult ActOnObjCAtCatchStmt(SourceLocation AtLoc,
1241 SourceLocation RParen,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001242 DeclPtrTy Parm, StmtArg Body,
Sebastian Redl431e90e2009-01-18 17:43:11 +00001243 StmtArg CatchList);
1244
1245 virtual OwningStmtResult ActOnObjCAtFinallyStmt(SourceLocation AtLoc,
1246 StmtArg Body);
1247
1248 virtual OwningStmtResult ActOnObjCAtTryStmt(SourceLocation AtLoc,
1249 StmtArg Try,
1250 StmtArg Catch, StmtArg Finally);
1251
1252 virtual OwningStmtResult ActOnObjCAtThrowStmt(SourceLocation AtLoc,
Steve Naroffe21dd6f2009-02-11 20:05:44 +00001253 ExprArg Throw,
1254 Scope *CurScope);
Sebastian Redl431e90e2009-01-18 17:43:11 +00001255 virtual OwningStmtResult ActOnObjCAtSynchronizedStmt(SourceLocation AtLoc,
1256 ExprArg SynchExpr,
1257 StmtArg SynchBody);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001258
Douglas Gregord308e622009-05-18 20:51:54 +00001259 VarDecl *BuildExceptionDeclaration(Scope *S, QualType ExDeclType,
1260 IdentifierInfo *Name,
1261 SourceLocation Loc,
1262 SourceRange Range);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001263 virtual DeclPtrTy ActOnExceptionDeclarator(Scope *S, Declarator &D);
Douglas Gregord308e622009-05-18 20:51:54 +00001264
Sebastian Redl4b07b292008-12-22 19:15:10 +00001265 virtual OwningStmtResult ActOnCXXCatchBlock(SourceLocation CatchLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001266 DeclPtrTy ExDecl,
Sebastian Redl4b07b292008-12-22 19:15:10 +00001267 StmtArg HandlerBlock);
Sebastian Redl8351da02008-12-22 21:35:02 +00001268 virtual OwningStmtResult ActOnCXXTryBlock(SourceLocation TryLoc,
1269 StmtArg TryBlock,
1270 MultiStmtArg Handlers);
Sebastian Redl13e88542009-04-27 21:33:24 +00001271 void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
Sebastian Redla0fd8652008-12-21 16:41:36 +00001272
Reid Spencer5f016e22007-07-11 17:01:13 +00001273 //===--------------------------------------------------------------------===//
1274 // Expression Parsing Callbacks: SemaExpr.cpp.
1275
Douglas Gregor48f3bb92009-02-18 21:56:37 +00001276 bool DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc);
Fariborz Jahanianc001e892009-05-08 20:20:55 +00001277 bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
1278 ObjCMethodDecl *Getter,
1279 SourceLocation Loc);
Fariborz Jahanian5b530052009-05-13 18:09:35 +00001280 void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
1281 Expr **Args, unsigned NumArgs);
Chris Lattner76a642f2009-02-15 22:43:40 +00001282
Reid Spencer5f016e22007-07-11 17:01:13 +00001283 // Primary Expressions.
Douglas Gregor4b2d3f72009-02-26 21:00:50 +00001284 virtual SourceRange getExprRange(ExprTy *E) const;
1285
Sebastian Redlcd965b92009-01-18 18:53:16 +00001286 virtual OwningExprResult ActOnIdentifierExpr(Scope *S, SourceLocation Loc,
1287 IdentifierInfo &II,
1288 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001289 const CXXScopeSpec *SS = 0,
1290 bool isAddressOfOperand = false);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001291 virtual OwningExprResult ActOnCXXOperatorFunctionIdExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001292 SourceLocation OperatorLoc,
1293 OverloadedOperatorKind Op,
1294 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001295 const CXXScopeSpec &SS,
1296 bool isAddressOfOperand);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001297 virtual OwningExprResult ActOnCXXConversionFunctionExpr(Scope *S,
Douglas Gregor487a75a2008-11-19 19:09:45 +00001298 SourceLocation OperatorLoc,
1299 TypeTy *Ty,
1300 bool HasTrailingLParen,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001301 const CXXScopeSpec &SS,
1302 bool isAddressOfOperand);
Douglas Gregor1a49af92009-01-06 05:10:23 +00001303 DeclRefExpr *BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc,
1304 bool TypeDependent, bool ValueDependent,
1305 const CXXScopeSpec *SS = 0);
Douglas Gregorffb4b6e2009-04-15 06:41:24 +00001306 VarDecl *BuildAnonymousStructUnionMemberPath(FieldDecl *Field,
1307 llvm::SmallVectorImpl<FieldDecl *> &Path);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001308 OwningExprResult
Douglas Gregorbcbffc42009-01-07 00:43:41 +00001309 BuildAnonymousStructUnionMemberReference(SourceLocation Loc,
1310 FieldDecl *Field,
1311 Expr *BaseObjectExpr = 0,
1312 SourceLocation OpLoc = SourceLocation());
Sebastian Redlcd965b92009-01-18 18:53:16 +00001313 OwningExprResult ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc,
1314 DeclarationName Name,
1315 bool HasTrailingLParen,
1316 const CXXScopeSpec *SS,
Sebastian Redlebc07d52009-02-03 20:19:35 +00001317 bool isAddressOfOperand = false);
Douglas Gregor10c42622008-11-18 15:03:34 +00001318
Sebastian Redlcd965b92009-01-18 18:53:16 +00001319 virtual OwningExprResult ActOnPredefinedExpr(SourceLocation Loc,
1320 tok::TokenKind Kind);
1321 virtual OwningExprResult ActOnNumericConstant(const Token &);
1322 virtual OwningExprResult ActOnCharacterConstant(const Token &);
1323 virtual OwningExprResult ActOnParenExpr(SourceLocation L, SourceLocation R,
1324 ExprArg Val);
Reid Spencer5f016e22007-07-11 17:01:13 +00001325
Steve Narofff69936d2007-09-16 03:34:24 +00001326 /// ActOnStringLiteral - The specified tokens were lexed as pasted string
Reid Spencer5f016e22007-07-11 17:01:13 +00001327 /// fragments (e.g. "foo" "bar" L"baz").
Sebastian Redl0eb23302009-01-19 00:08:26 +00001328 virtual OwningExprResult ActOnStringLiteral(const Token *Toks,
1329 unsigned NumToks);
Sebastian Redlcd965b92009-01-18 18:53:16 +00001330
Reid Spencer5f016e22007-07-11 17:01:13 +00001331 // Binary/Unary Operators. 'Tok' is the token for the operator.
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001332 OwningExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc,
1333 unsigned OpcIn,
1334 ExprArg InputArg);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001335 virtual OwningExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
1336 tok::TokenKind Op, ExprArg Input);
Sebastian Redl05189992008-11-11 17:56:53 +00001337
Douglas Gregorba498172009-03-13 21:01:28 +00001338 OwningExprResult CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc,
1339 bool isSizeOf, SourceRange R);
1340 OwningExprResult CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc,
1341 bool isSizeOf, SourceRange R);
Douglas Gregorbc736fc2009-03-13 23:49:33 +00001342 virtual OwningExprResult
1343 ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType,
1344 void *TyOrEx, const SourceRange &ArgRange);
Douglas Gregorba498172009-03-13 21:01:28 +00001345
Chris Lattner31e21e02009-01-24 20:17:12 +00001346 bool CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, const SourceRange &R);
Sebastian Redl05189992008-11-11 17:56:53 +00001347 bool CheckSizeOfAlignOfOperand(QualType type, SourceLocation OpLoc,
1348 const SourceRange &R, bool isSizeof);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001349
1350 virtual OwningExprResult ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc,
1351 tok::TokenKind Kind,
1352 ExprArg Input);
1353
1354 virtual OwningExprResult ActOnArraySubscriptExpr(Scope *S, ExprArg Base,
1355 SourceLocation LLoc,
1356 ExprArg Idx,
1357 SourceLocation RLoc);
1358 virtual OwningExprResult ActOnMemberReferenceExpr(Scope *S, ExprArg Base,
1359 SourceLocation OpLoc,
1360 tok::TokenKind OpKind,
1361 SourceLocation MemberLoc,
Fariborz Jahaniana6e3ac52009-03-04 22:30:12 +00001362 IdentifierInfo &Member,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001363 DeclPtrTy ImplDecl);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001364 bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
Douglas Gregor88a35142008-12-22 05:46:06 +00001365 FunctionDecl *FDecl,
Douglas Gregor72564e72009-02-26 23:50:07 +00001366 const FunctionProtoType *Proto,
Douglas Gregor88a35142008-12-22 05:46:06 +00001367 Expr **Args, unsigned NumArgs,
1368 SourceLocation RParenLoc);
Sebastian Redl0eb23302009-01-19 00:08:26 +00001369
Steve Narofff69936d2007-09-16 03:34:24 +00001370 /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Reid Spencer5f016e22007-07-11 17:01:13 +00001371 /// This provides the location of the left/right parens and a list of comma
1372 /// locations.
Sebastian Redl0eb23302009-01-19 00:08:26 +00001373 virtual OwningExprResult ActOnCallExpr(Scope *S, ExprArg Fn,
1374 SourceLocation LParenLoc,
1375 MultiExprArg Args,
1376 SourceLocation *CommaLocs,
1377 SourceLocation RParenLoc);
1378
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001379 virtual OwningExprResult ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty,
1380 SourceLocation RParenLoc, ExprArg Op);
1381
1382 virtual OwningExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,
1383 TypeTy *Ty,
1384 SourceLocation RParenLoc,
1385 ExprArg Op);
1386
1387 virtual OwningExprResult ActOnInitList(SourceLocation LParenLoc,
1388 MultiExprArg InitList,
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001389 SourceLocation RParenLoc);
1390
Douglas Gregor05c13a32009-01-22 00:58:24 +00001391 virtual OwningExprResult ActOnDesignatedInitializer(Designation &Desig,
1392 SourceLocation Loc,
Douglas Gregoreeae8f02009-03-28 00:41:23 +00001393 bool GNUSyntax,
Douglas Gregor05c13a32009-01-22 00:58:24 +00001394 OwningExprResult Init);
1395
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001396 virtual OwningExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
1397 tok::TokenKind Kind,
1398 ExprArg LHS, ExprArg RHS);
1399 OwningExprResult CreateBuiltinBinOp(SourceLocation TokLoc,
1400 unsigned Opc, Expr *lhs, Expr *rhs);
Douglas Gregoreaebc752008-11-06 23:29:22 +00001401
Steve Narofff69936d2007-09-16 03:34:24 +00001402 /// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null
Reid Spencer5f016e22007-07-11 17:01:13 +00001403 /// in the case of a the GNU conditional expr extension.
Sebastian Redlb8a6aca2009-01-19 22:31:54 +00001404 virtual OwningExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
1405 SourceLocation ColonLoc,
1406 ExprArg Cond, ExprArg LHS,
1407 ExprArg RHS);
Reid Spencer5f016e22007-07-11 17:01:13 +00001408
Steve Naroff1b273c42007-09-16 14:56:35 +00001409 /// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo".
Sebastian Redlf53597f2009-03-15 17:47:39 +00001410 virtual OwningExprResult ActOnAddrLabel(SourceLocation OpLoc,
1411 SourceLocation LabLoc,
1412 IdentifierInfo *LabelII);
1413
1414 virtual OwningExprResult ActOnStmtExpr(SourceLocation LPLoc, StmtArg SubStmt,
1415 SourceLocation RPLoc); // "({..})"
Chris Lattner73d0d4f2007-08-30 17:45:32 +00001416
1417 /// __builtin_offsetof(type, a.b[123][456].c)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001418 virtual OwningExprResult ActOnBuiltinOffsetOf(Scope *S,
1419 SourceLocation BuiltinLoc,
1420 SourceLocation TypeLoc,
1421 TypeTy *Arg1,
1422 OffsetOfComponent *CompPtr,
1423 unsigned NumComponents,
1424 SourceLocation RParenLoc);
1425
Steve Naroffd34e9152007-08-01 22:05:33 +00001426 // __builtin_types_compatible_p(type1, type2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001427 virtual OwningExprResult ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc,
1428 TypeTy *arg1, TypeTy *arg2,
1429 SourceLocation RPLoc);
1430
Steve Naroffd04fdd52007-08-03 21:21:27 +00001431 // __builtin_choose_expr(constExpr, expr1, expr2)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001432 virtual OwningExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
1433 ExprArg cond, ExprArg expr1,
1434 ExprArg expr2, SourceLocation RPLoc);
1435
Anders Carlsson7c50aca2007-10-15 20:28:48 +00001436 // __builtin_va_arg(expr, type)
Sebastian Redlf53597f2009-03-15 17:47:39 +00001437 virtual OwningExprResult ActOnVAArg(SourceLocation BuiltinLoc,
1438 ExprArg expr, TypeTy *type,
1439 SourceLocation RPLoc);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001440
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001441 // __null
Sebastian Redlf53597f2009-03-15 17:47:39 +00001442 virtual OwningExprResult ActOnGNUNullExpr(SourceLocation TokenLoc);
Douglas Gregor2d8b2732008-11-29 04:51:27 +00001443
Steve Naroff4eb206b2008-09-03 18:15:37 +00001444 //===------------------------- "Block" Extension ------------------------===//
1445
1446 /// ActOnBlockStart - This callback is invoked when a block literal is
1447 /// started.
Steve Naroff090276f2008-10-10 01:28:17 +00001448 virtual void ActOnBlockStart(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001449
Steve Naroff090276f2008-10-10 01:28:17 +00001450 /// ActOnBlockArguments - This callback allows processing of block arguments.
1451 /// If there are no arguments, this is still invoked.
Mike Stump98eb8a72009-02-04 22:31:32 +00001452 virtual void ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001453
Steve Naroff4eb206b2008-09-03 18:15:37 +00001454 /// ActOnBlockError - If there is an error parsing a block, this callback
1455 /// is invoked to pop the information about the block from the action impl.
1456 virtual void ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope);
Sebastian Redlf53597f2009-03-15 17:47:39 +00001457
Steve Naroff4eb206b2008-09-03 18:15:37 +00001458 /// ActOnBlockStmtExpr - This is called when the body of a block statement
1459 /// literal was successfully completed. ^(int x){...}
Sebastian Redlf53597f2009-03-15 17:47:39 +00001460 virtual OwningExprResult ActOnBlockStmtExpr(SourceLocation CaretLoc,
1461 StmtArg Body, Scope *CurScope);
Steve Naroff4eb206b2008-09-03 18:15:37 +00001462
Chris Lattner76a642f2009-02-15 22:43:40 +00001463 //===---------------------------- C++ Features --------------------------===//
1464
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001465 // Act on C++ namespaces
Chris Lattnerb28317a2009-03-28 19:18:32 +00001466 virtual DeclPtrTy ActOnStartNamespaceDef(Scope *S, SourceLocation IdentLoc,
1467 IdentifierInfo *Ident,
1468 SourceLocation LBrace);
1469 virtual void ActOnFinishNamespaceDef(DeclPtrTy Dcl, SourceLocation RBrace);
Argyrios Kyrtzidis2d1c5d32008-04-27 13:50:30 +00001470
Chris Lattnerb28317a2009-03-28 19:18:32 +00001471 virtual DeclPtrTy ActOnUsingDirective(Scope *CurScope,
1472 SourceLocation UsingLoc,
1473 SourceLocation NamespcLoc,
1474 const CXXScopeSpec &SS,
1475 SourceLocation IdentLoc,
1476 IdentifierInfo *NamespcName,
1477 AttributeList *AttrList);
Anders Carlssondbb00942009-03-28 05:27:17 +00001478
Douglas Gregor2a3009a2009-02-03 19:21:40 +00001479 void PushUsingDirective(Scope *S, UsingDirectiveDecl *UDir);
1480
Chris Lattnerb28317a2009-03-28 19:18:32 +00001481 virtual DeclPtrTy ActOnNamespaceAliasDef(Scope *CurScope,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001482 SourceLocation NamespaceLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001483 SourceLocation AliasLoc,
1484 IdentifierInfo *Alias,
1485 const CXXScopeSpec &SS,
Anders Carlsson03bd5a12009-03-28 22:53:22 +00001486 SourceLocation IdentLoc,
1487 IdentifierInfo *Ident);
Anders Carlssondbb00942009-03-28 05:27:17 +00001488
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001489 /// AddCXXDirectInitializerToDecl - This action is called immediately after
1490 /// ActOnDeclarator, when a C++ direct initializer is present.
1491 /// e.g: "int x(1);"
Chris Lattnerb28317a2009-03-28 19:18:32 +00001492 virtual void AddCXXDirectInitializerToDecl(DeclPtrTy Dcl,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001493 SourceLocation LParenLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001494 MultiExprArg Exprs,
Argyrios Kyrtzidis73a0d882008-10-06 17:10:33 +00001495 SourceLocation *CommaLocs,
1496 SourceLocation RParenLoc);
1497
Anders Carlsson49d44012009-04-24 05:16:06 +00001498 /// InitializeVarWithConstructor - Creates an CXXConstructExpr
1499 /// and sets it as the initializer for the the passed in VarDecl.
Anders Carlsson930e8d02009-04-16 23:50:50 +00001500 void InitializeVarWithConstructor(VarDecl *VD,
1501 CXXConstructorDecl *Constructor,
1502 QualType DeclInitType,
1503 Expr **Exprs, unsigned NumExprs);
Anders Carlssondef11992009-05-30 20:36:53 +00001504
1505 /// MaybeBindToTemporary - If the passed in expression has a record type with
1506 /// a non-trivial destructor, this will return CXXBindTemporaryExpr. Otherwise
1507 /// it simply returns the passed in expression.
1508 OwningExprResult MaybeBindToTemporary(Expr *E);
1509
Anders Carlssonb27615a2009-05-30 22:47:03 +00001510 /// RemoveOutermostTemporaryBinding - Remove and destroy the outermost
1511 /// CXXBindToTemporaryExpr if necessary. This is used when we want to not
1512 /// destroy a temporary when a full expression has been evaluated.
1513 /// For example:
1514 ///
1515 /// const T& t = T(10, T());
1516 ///
1517 /// Here the outermost T needs to be destroyed when t goes out of scope, but
1518 /// the innermost T needs to be destroyed when the expr has been evaluated.
1519 Expr *RemoveOutermostTemporaryBinding(Expr *E);
1520
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001521 /// InitializationKind - Represents which kind of C++ initialization
1522 /// [dcl.init] a routine is to perform.
1523 enum InitializationKind {
1524 IK_Direct, ///< Direct initialization
1525 IK_Copy, ///< Copy initialization
1526 IK_Default ///< Default initialization
1527 };
1528
Douglas Gregor18fe5682008-11-03 20:45:27 +00001529 CXXConstructorDecl *
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001530 PerformInitializationByConstructor(QualType ClassType,
1531 Expr **Args, unsigned NumArgs,
1532 SourceLocation Loc, SourceRange Range,
Chris Lattnerd9d22dd2008-11-24 05:29:24 +00001533 DeclarationName InitEntity,
Douglas Gregorf03d7c72008-11-05 15:29:30 +00001534 InitializationKind Kind);
Douglas Gregor18fe5682008-11-03 20:45:27 +00001535
Douglas Gregor49badde2008-10-27 19:41:14 +00001536 /// ActOnCXXNamedCast - Parse {dynamic,static,reinterpret,const}_cast's.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001537 virtual OwningExprResult ActOnCXXNamedCast(SourceLocation OpLoc,
1538 tok::TokenKind Kind,
1539 SourceLocation LAngleBracketLoc,
1540 TypeTy *Ty,
1541 SourceLocation RAngleBracketLoc,
1542 SourceLocation LParenLoc,
1543 ExprArg E,
1544 SourceLocation RParenLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00001545
Sebastian Redlf53597f2009-03-15 17:47:39 +00001546 /// ActOnCXXTypeid - Parse typeid( something ).
1547 virtual OwningExprResult ActOnCXXTypeid(SourceLocation OpLoc,
1548 SourceLocation LParenLoc, bool isType,
1549 void *TyOrExpr,
1550 SourceLocation RParenLoc);
Sebastian Redlc42e1182008-11-11 11:37:55 +00001551
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001552 //// ActOnCXXThis - Parse 'this' pointer.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001553 virtual OwningExprResult ActOnCXXThis(SourceLocation ThisLoc);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001554
Steve Naroff1b273c42007-09-16 14:56:35 +00001555 /// ActOnCXXBoolLiteral - Parse {true,false} literals.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001556 virtual OwningExprResult ActOnCXXBoolLiteral(SourceLocation OpLoc,
1557 tok::TokenKind Kind);
1558
Sebastian Redl6e8ed162009-05-10 18:38:11 +00001559 /// ActOnCXXNullPtrLiteral - Parse 'nullptr'.
1560 virtual OwningExprResult ActOnCXXNullPtrLiteral(SourceLocation Loc);
1561
Chris Lattner50dd2892008-02-26 00:51:44 +00001562 //// ActOnCXXThrow - Parse throw expressions.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001563 virtual OwningExprResult ActOnCXXThrow(SourceLocation OpLoc,
1564 ExprArg expr);
Sebastian Redl972041f2009-04-27 20:27:31 +00001565 bool CheckCXXThrowOperand(SourceLocation ThrowLoc, Expr *&E);
Chris Lattner50dd2892008-02-26 00:51:44 +00001566
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001567 /// ActOnCXXTypeConstructExpr - Parse construction of a specified type.
1568 /// Can be interpreted either as function-style casting ("int(x)")
1569 /// or class type construction ("ClassType(x,y,z)")
1570 /// or creation of a value-initialized type ("int()").
Sebastian Redlf53597f2009-03-15 17:47:39 +00001571 virtual OwningExprResult ActOnCXXTypeConstructExpr(SourceRange TypeRange,
1572 TypeTy *TypeRep,
1573 SourceLocation LParenLoc,
1574 MultiExprArg Exprs,
1575 SourceLocation *CommaLocs,
1576 SourceLocation RParenLoc);
Argyrios Kyrtzidis987a14b2008-08-22 15:38:55 +00001577
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001578 /// ActOnCXXNew - Parsed a C++ 'new' expression.
Sebastian Redlf53597f2009-03-15 17:47:39 +00001579 virtual OwningExprResult ActOnCXXNew(SourceLocation StartLoc, bool UseGlobal,
1580 SourceLocation PlacementLParen,
1581 MultiExprArg PlacementArgs,
1582 SourceLocation PlacementRParen,
1583 bool ParenTypeId, Declarator &D,
1584 SourceLocation ConstructorLParen,
1585 MultiExprArg ConstructorArgs,
1586 SourceLocation ConstructorRParen);
Douglas Gregor3433cf72009-05-21 00:00:09 +00001587 OwningExprResult BuildCXXNew(SourceLocation StartLoc, bool UseGlobal,
1588 SourceLocation PlacementLParen,
1589 MultiExprArg PlacementArgs,
1590 SourceLocation PlacementRParen,
1591 bool ParenTypeId,
1592 QualType AllocType,
1593 SourceLocation TypeLoc,
1594 SourceRange TypeRange,
1595 ExprArg ArraySize,
1596 SourceLocation ConstructorLParen,
1597 MultiExprArg ConstructorArgs,
1598 SourceLocation ConstructorRParen);
1599
1600 bool CheckAllocatedType(QualType AllocType, SourceLocation Loc,
1601 SourceRange R);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001602 bool FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range,
1603 bool UseGlobal, QualType AllocType, bool IsArray,
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001604 Expr **PlaceArgs, unsigned NumPlaceArgs,
1605 FunctionDecl *&OperatorNew,
1606 FunctionDecl *&OperatorDelete);
Sebastian Redl00e68e22009-02-09 18:24:27 +00001607 bool FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
1608 DeclarationName Name, Expr** Args,
1609 unsigned NumArgs, DeclContext *Ctx,
Sebastian Redl7f662392008-12-04 22:20:51 +00001610 bool AllowMissing, FunctionDecl *&Operator);
Sebastian Redlb5a57a62008-12-03 20:26:15 +00001611 void DeclareGlobalNewDelete();
1612 void DeclareGlobalAllocationFunction(DeclarationName Name, QualType Return,
1613 QualType Argument);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001614
1615 /// ActOnCXXDelete - Parsed a C++ 'delete' expression
Sebastian Redlf53597f2009-03-15 17:47:39 +00001616 virtual OwningExprResult ActOnCXXDelete(SourceLocation StartLoc,
1617 bool UseGlobal, bool ArrayForm,
1618 ExprArg Operand);
Sebastian Redl4c5d3202008-11-21 19:14:01 +00001619
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001620 /// ActOnCXXConditionDeclarationExpr - Parsed a condition declaration of a
1621 /// C++ if/switch/while/for statement.
1622 /// e.g: "if (int x = f()) {...}"
Sebastian Redlf53597f2009-03-15 17:47:39 +00001623 virtual OwningExprResult ActOnCXXConditionDeclarationExpr(Scope *S,
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001624 SourceLocation StartLoc,
1625 Declarator &D,
1626 SourceLocation EqualLoc,
Sebastian Redlf53597f2009-03-15 17:47:39 +00001627 ExprArg AssignExprVal);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00001628
Sebastian Redl64b45f72009-01-05 20:52:13 +00001629 /// ActOnUnaryTypeTrait - Parsed one of the unary type trait support
1630 /// pseudo-functions.
1631 virtual OwningExprResult ActOnUnaryTypeTrait(UnaryTypeTrait OTT,
1632 SourceLocation KWLoc,
1633 SourceLocation LParen,
1634 TypeTy *Ty,
1635 SourceLocation RParen);
1636
Anders Carlsson99ba36d2009-06-05 15:38:08 +00001637 /// MaybeCreateCXXExprWithTemporaries - If the list of temporaries is
1638 /// non-empty, will create a new CXXExprWithTemporaries expression.
1639 /// Otherwise, just returs the passed in expression.
1640 Expr *MaybeCreateCXXExprWithTemporaries(Expr *SubExpr,
1641 bool DestroyTemps = true);
1642
Anders Carlsson165a0a02009-05-17 18:41:29 +00001643 virtual OwningExprResult ActOnFinishFullExpr(ExprArg Expr);
1644
Douglas Gregor4fdf1fa2009-03-11 16:48:53 +00001645 bool RequireCompleteDeclContext(const CXXScopeSpec &SS);
Douglas Gregore4e5b052009-03-19 00:18:19 +00001646
1647 DeclContext *computeDeclContext(const CXXScopeSpec &SS);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00001648 bool isDependentScopeSpecifier(const CXXScopeSpec &SS);
Douglas Gregor42af25f2009-05-11 19:58:34 +00001649 CXXRecordDecl *getCurrentInstantiationOf(NestedNameSpecifier *NNS);
1650 bool isUnknownSpecialization(const CXXScopeSpec &SS);
Douglas Gregorca5e77f2009-03-18 00:36:05 +00001651
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001652 /// ActOnCXXGlobalScopeSpecifier - Return the object that represents the
1653 /// global scope ('::').
1654 virtual CXXScopeTy *ActOnCXXGlobalScopeSpecifier(Scope *S,
1655 SourceLocation CCLoc);
1656
1657 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1658 /// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now
1659 /// we want to resolve "bar::". 'SS' is empty or the previously parsed
1660 /// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar',
1661 /// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'.
1662 /// Returns a CXXScopeTy* object representing the C++ scope.
1663 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1664 const CXXScopeSpec &SS,
1665 SourceLocation IdLoc,
1666 SourceLocation CCLoc,
Douglas Gregor2def4832008-11-17 20:34:05 +00001667 IdentifierInfo &II);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001668
Douglas Gregor39a8de12009-02-25 19:37:18 +00001669 /// ActOnCXXNestedNameSpecifier - Called during parsing of a
1670 /// nested-name-specifier that involves a template-id, e.g.,
1671 /// "foo::bar<int, float>::", and now we need to build a scope
1672 /// specifier. \p SS is empty or the previously parsed nested-name
1673 /// part ("foo::"), \p Type is the already-parsed class template
1674 /// specialization (or other template-id that names a type), \p
1675 /// TypeRange is the source range where the type is located, and \p
1676 /// CCLoc is the location of the trailing '::'.
1677 virtual CXXScopeTy *ActOnCXXNestedNameSpecifier(Scope *S,
1678 const CXXScopeSpec &SS,
1679 TypeTy *Type,
1680 SourceRange TypeRange,
1681 SourceLocation CCLoc);
1682
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001683 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1684 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1685 /// After this method is called, according to [C++ 3.4.3p3], names should be
1686 /// looked up in the declarator-id's scope, until the declarator is parsed and
1687 /// ActOnCXXExitDeclaratorScope is called.
1688 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1689 virtual void ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
1690
1691 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1692 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1693 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1694 /// Used to indicate that names should revert to being looked up in the
1695 /// defining scope.
Douglas Gregor0a59acb2008-12-16 00:38:16 +00001696 virtual void ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS);
Argyrios Kyrtzidisef6e6472008-11-08 17:17:31 +00001697
Anders Carlsson55085182007-08-21 17:43:55 +00001698 // ParseObjCStringLiteral - Parse Objective-C string literals.
Chris Lattnerb3a99cd2007-12-12 01:04:12 +00001699 virtual ExprResult ParseObjCStringLiteral(SourceLocation *AtLocs,
1700 ExprTy **Strings,
1701 unsigned NumStrings);
Anders Carlssonfc0f0212009-06-07 18:45:35 +00001702
1703 Expr *BuildObjCEncodeExpression(SourceLocation AtLoc,
1704 QualType EncodedType,
1705 SourceLocation RParenLoc);
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001706 virtual ExprResult ParseObjCEncodeExpression(SourceLocation AtLoc,
Chris Lattner674af952007-10-16 22:51:17 +00001707 SourceLocation EncodeLoc,
Anders Carlssonf9bcf012007-08-22 15:14:15 +00001708 SourceLocation LParenLoc,
1709 TypeTy *Ty,
1710 SourceLocation RParenLoc);
1711
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001712 // ParseObjCSelectorExpression - Build selector expression for @selector
1713 virtual ExprResult ParseObjCSelectorExpression(Selector Sel,
1714 SourceLocation AtLoc,
Fariborz Jahanian2a35fa92007-10-16 23:21:02 +00001715 SourceLocation SelLoc,
Fariborz Jahanianb62f6812007-10-16 20:40:23 +00001716 SourceLocation LParenLoc,
1717 SourceLocation RParenLoc);
1718
Fariborz Jahanian390d50a2007-10-17 16:58:11 +00001719 // ParseObjCProtocolExpression - Build protocol expression for @protocol
1720 virtual ExprResult ParseObjCProtocolExpression(IdentifierInfo * ProtocolName,
1721 SourceLocation AtLoc,
1722 SourceLocation ProtoLoc,
1723 SourceLocation LParenLoc,
1724 SourceLocation RParenLoc);
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001725
1726 //===--------------------------------------------------------------------===//
Douglas Gregor074149e2009-01-05 19:45:36 +00001727 // C++ Declarations
1728 //
Chris Lattnerb28317a2009-03-28 19:18:32 +00001729 virtual DeclPtrTy ActOnStartLinkageSpecification(Scope *S,
1730 SourceLocation ExternLoc,
1731 SourceLocation LangLoc,
1732 const char *Lang,
1733 unsigned StrSize,
1734 SourceLocation LBraceLoc);
1735 virtual DeclPtrTy ActOnFinishLinkageSpecification(Scope *S,
1736 DeclPtrTy LinkageSpec,
1737 SourceLocation RBraceLoc);
Douglas Gregor074149e2009-01-05 19:45:36 +00001738
1739
1740 //===--------------------------------------------------------------------===//
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001741 // C++ Classes
1742 //
Argyrios Kyrtzidiseb83ecd2008-11-08 16:45:02 +00001743 virtual bool isCurrentClassName(const IdentifierInfo &II, Scope *S,
1744 const CXXScopeSpec *SS);
Sebastian Redle2b68332009-04-12 17:16:29 +00001745
Chris Lattnerb28317a2009-03-28 19:18:32 +00001746 virtual DeclPtrTy ActOnCXXMemberDeclarator(Scope *S, AccessSpecifier AS,
1747 Declarator &D,
1748 ExprTy *BitfieldWidth,
Sebastian Redle2b68332009-04-12 17:16:29 +00001749 ExprTy *Init,
1750 bool Deleted = false);
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001751
Chris Lattnerb28317a2009-03-28 19:18:32 +00001752 virtual MemInitResult ActOnMemInitializer(DeclPtrTy ConstructorD,
Douglas Gregor7ad83902008-11-05 04:29:56 +00001753 Scope *S,
1754 IdentifierInfo *MemberOrBase,
1755 SourceLocation IdLoc,
1756 SourceLocation LParenLoc,
1757 ExprTy **Args, unsigned NumArgs,
1758 SourceLocation *CommaLocs,
1759 SourceLocation RParenLoc);
1760
Douglas Gregor396b7cd2008-11-03 17:51:48 +00001761 void AddImplicitlyDeclaredMembersToClass(CXXRecordDecl *ClassDecl);
1762
Chris Lattnerb28317a2009-03-28 19:18:32 +00001763 virtual void ActOnMemInitializers(DeclPtrTy ConstructorDecl,
Anders Carlssona7b35212009-03-25 02:58:17 +00001764 SourceLocation ColonLoc,
1765 MemInitTy **MemInits, unsigned NumMemInits);
1766
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001767 virtual void ActOnFinishCXXMemberSpecification(Scope* S, SourceLocation RLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001768 DeclPtrTy TagDecl,
Argyrios Kyrtzidis07952322008-07-01 10:37:29 +00001769 SourceLocation LBrac,
1770 SourceLocation RBrac);
1771
Douglas Gregor6569d682009-05-27 23:11:45 +00001772 virtual void ActOnReenterTemplateScope(Scope *S, DeclPtrTy Template);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001773 virtual void ActOnStartDelayedCXXMethodDeclaration(Scope *S,
1774 DeclPtrTy Method);
1775 virtual void ActOnDelayedCXXMethodParameter(Scope *S, DeclPtrTy Param);
1776 virtual void ActOnFinishDelayedCXXMethodDeclaration(Scope *S,
1777 DeclPtrTy Method);
Douglas Gregor72b505b2008-12-16 21:30:33 +00001778
Chris Lattnerb28317a2009-03-28 19:18:32 +00001779 virtual DeclPtrTy ActOnStaticAssertDeclaration(SourceLocation AssertLoc,
1780 ExprArg AssertExpr,
1781 ExprArg AssertMessageExpr);
Anders Carlssonfb311762009-03-14 00:25:26 +00001782
Anders Carlsson00338362009-05-11 22:55:49 +00001783 virtual bool ActOnFriendDecl(Scope *S, SourceLocation FriendLoc,
1784 DeclPtrTy Dcl);
1785
Chris Lattner65401802009-04-25 08:28:21 +00001786 QualType CheckConstructorDeclarator(Declarator &D, QualType R,
1787 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00001788 void CheckConstructor(CXXConstructorDecl *Constructor);
Chris Lattner65401802009-04-25 08:28:21 +00001789 QualType CheckDestructorDeclarator(Declarator &D,
1790 FunctionDecl::StorageClass& SC);
Chris Lattner6e475012009-04-25 08:35:12 +00001791 void CheckConversionDeclarator(Declarator &D, QualType &R,
Douglas Gregor2f1bc522008-11-07 20:08:42 +00001792 FunctionDecl::StorageClass& SC);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001793 DeclPtrTy ActOnConversionDeclarator(CXXConversionDecl *Conversion);
Douglas Gregorb48fe382008-10-31 09:07:45 +00001794
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001795 //===--------------------------------------------------------------------===//
1796 // C++ Derived Classes
1797 //
1798
1799 /// ActOnBaseSpecifier - Parsed a base specifier
Douglas Gregor2943aed2009-03-03 04:44:36 +00001800 CXXBaseSpecifier *CheckBaseSpecifier(CXXRecordDecl *Class,
1801 SourceRange SpecifierRange,
1802 bool Virtual, AccessSpecifier Access,
1803 QualType BaseType,
1804 SourceLocation BaseLoc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001805 virtual BaseResult ActOnBaseSpecifier(DeclPtrTy classdecl,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001806 SourceRange SpecifierRange,
1807 bool Virtual, AccessSpecifier Access,
Douglas Gregor2943aed2009-03-03 04:44:36 +00001808 TypeTy *basetype, SourceLocation
1809 BaseLoc);
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001810
Douglas Gregor2943aed2009-03-03 04:44:36 +00001811 bool AttachBaseSpecifiers(CXXRecordDecl *Class, CXXBaseSpecifier **Bases,
1812 unsigned NumBases);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001813 virtual void ActOnBaseSpecifiers(DeclPtrTy ClassDecl, BaseTy **Bases,
Douglas Gregorbc0805a2008-10-23 00:40:37 +00001814 unsigned NumBases);
1815
1816 bool IsDerivedFrom(QualType Derived, QualType Base);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00001817 bool IsDerivedFrom(QualType Derived, QualType Base, BasePaths &Paths);
Douglas Gregor7176fff2009-01-15 00:26:24 +00001818 bool LookupInBases(CXXRecordDecl *Class, const MemberLookupCriteria& Criteria,
1819 BasePaths &Paths);
Douglas Gregor0575d4a2008-10-24 16:17:19 +00001820 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1821 SourceLocation Loc, SourceRange Range);
Anders Carlssond8f9cb02009-05-13 21:11:42 +00001822 bool CheckDerivedToBaseConversion(QualType Derived, QualType Base,
1823 unsigned InaccessibleBaseID,
1824 unsigned AmbigiousBaseConvID,
1825 SourceLocation Loc, SourceRange Range,
1826 DeclarationName Name);
1827
Douglas Gregor4dc6b1c2009-01-16 00:38:09 +00001828 std::string getAmbiguousPathsDisplayString(BasePaths &Paths);
Anders Carlssond7ba27d2009-05-14 01:09:04 +00001829
1830 /// CheckReturnTypeCovariance - Checks whether two types are covariant,
1831 /// according to C++ [class.virtual]p5.
1832 bool CheckOverridingFunctionReturnType(const CXXMethodDecl *New,
1833 const CXXMethodDecl *Old);
1834
Douglas Gregore37ac4f2008-04-13 21:30:24 +00001835
Anders Carlsson29f006b2009-03-27 05:05:05 +00001836 //===--------------------------------------------------------------------===//
1837 // C++ Access Control
1838 //
1839
1840 bool SetMemberAccessSpecifier(NamedDecl *MemberDecl,
1841 NamedDecl *PrevMemberDecl,
1842 AccessSpecifier LexicalAS);
1843
1844 bool CheckBaseClassAccess(QualType Derived, QualType Base,
Anders Carlssond8f9cb02009-05-13 21:11:42 +00001845 unsigned InaccessibleBaseID,
1846 BasePaths& Paths, SourceLocation AccessLoc,
1847 DeclarationName Name);
Anders Carlsson29f006b2009-03-27 05:05:05 +00001848
1849
Anders Carlsson8211eff2009-03-24 01:19:16 +00001850 enum AbstractDiagSelID {
1851 AbstractNone = -1,
1852 AbstractReturnType,
1853 AbstractParamType,
1854 AbstractVariableType,
1855 AbstractFieldType
1856 };
1857
1858 bool RequireNonAbstractType(SourceLocation Loc, QualType T, unsigned DiagID,
Anders Carlssone65a3c82009-03-24 17:23:42 +00001859 AbstractDiagSelID SelID = AbstractNone,
1860 const CXXRecordDecl *CurrentRD = 0);
Anders Carlsson4681ebd2009-03-22 20:18:17 +00001861
Douglas Gregor1cd1b1e2008-11-06 22:13:31 +00001862 //===--------------------------------------------------------------------===//
1863 // C++ Overloaded Operators [C++ 13.5]
1864 //
1865
1866 bool CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl);
1867
Douglas Gregor72c3f312008-12-05 18:15:24 +00001868 //===--------------------------------------------------------------------===//
1869 // C++ Templates [C++ 14]
1870 //
Douglas Gregorc45c2322009-03-31 00:43:58 +00001871 virtual TemplateNameKind isTemplateName(const IdentifierInfo &II, Scope *S,
Douglas Gregor7532dc62009-03-30 22:58:21 +00001872 TemplateTy &Template,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001873 const CXXScopeSpec *SS = 0);
Douglas Gregor72c3f312008-12-05 18:15:24 +00001874 bool DiagnoseTemplateParameterShadow(SourceLocation Loc, Decl *PrevDecl);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001875 TemplateDecl *AdjustDeclIfTemplate(DeclPtrTy &Decl);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00001876
Chris Lattnerb28317a2009-03-28 19:18:32 +00001877 virtual DeclPtrTy ActOnTypeParameter(Scope *S, bool Typename,
1878 SourceLocation KeyLoc,
1879 IdentifierInfo *ParamName,
1880 SourceLocation ParamNameLoc,
1881 unsigned Depth, unsigned Position);
1882 virtual void ActOnTypeParameterDefault(DeclPtrTy TypeParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001883 SourceLocation EqualLoc,
1884 SourceLocation DefaultLoc,
1885 TypeTy *Default);
1886
Douglas Gregor2943aed2009-03-03 04:44:36 +00001887 QualType CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001888 virtual DeclPtrTy ActOnNonTypeTemplateParameter(Scope *S, Declarator &D,
1889 unsigned Depth,
1890 unsigned Position);
1891 virtual void ActOnNonTypeTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001892 SourceLocation EqualLoc,
1893 ExprArg Default);
Chris Lattnerb28317a2009-03-28 19:18:32 +00001894 virtual DeclPtrTy ActOnTemplateTemplateParameter(Scope *S,
1895 SourceLocation TmpLoc,
1896 TemplateParamsTy *Params,
1897 IdentifierInfo *ParamName,
1898 SourceLocation ParamNameLoc,
1899 unsigned Depth,
1900 unsigned Position);
1901 virtual void ActOnTemplateTemplateParameterDefault(DeclPtrTy TemplateParam,
Douglas Gregord684b002009-02-10 19:49:53 +00001902 SourceLocation EqualLoc,
1903 ExprArg Default);
1904
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001905 virtual TemplateParamsTy *
1906 ActOnTemplateParameterList(unsigned Depth,
1907 SourceLocation ExportLoc,
1908 SourceLocation TemplateLoc,
1909 SourceLocation LAngleLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00001910 DeclPtrTy *Params, unsigned NumParams,
Douglas Gregorc4b4e7b2008-12-24 02:52:09 +00001911 SourceLocation RAngleLoc);
Douglas Gregord684b002009-02-10 19:49:53 +00001912 bool CheckTemplateParameterList(TemplateParameterList *NewParams,
1913 TemplateParameterList *OldParams);
1914
Douglas Gregor212e81c2009-03-25 00:13:59 +00001915 virtual DeclResult
Douglas Gregorddc29e12009-02-06 22:42:48 +00001916 ActOnClassTemplate(Scope *S, unsigned TagSpec, TagKind TK,
1917 SourceLocation KWLoc, const CXXScopeSpec &SS,
1918 IdentifierInfo *Name, SourceLocation NameLoc,
1919 AttributeList *Attr,
Anders Carlsson5aeccdb2009-03-26 00:52:18 +00001920 MultiTemplateParamsArg TemplateParameterLists,
1921 AccessSpecifier AS);
Douglas Gregorddc29e12009-02-06 22:42:48 +00001922
Douglas Gregor7532dc62009-03-30 22:58:21 +00001923 QualType CheckTemplateIdType(TemplateName Template,
1924 SourceLocation TemplateLoc,
1925 SourceLocation LAngleLoc,
1926 const TemplateArgument *TemplateArgs,
1927 unsigned NumTemplateArgs,
1928 SourceLocation RAngleLoc);
Douglas Gregor40808ce2009-03-09 23:48:35 +00001929
Douglas Gregorcc636682009-02-17 23:15:12 +00001930 virtual TypeResult
Douglas Gregor7532dc62009-03-30 22:58:21 +00001931 ActOnTemplateIdType(TemplateTy Template, SourceLocation TemplateLoc,
1932 SourceLocation LAngleLoc,
1933 ASTTemplateArgsPtr TemplateArgs,
1934 SourceLocation *TemplateArgLocs,
1935 SourceLocation RAngleLoc);
Douglas Gregorcc636682009-02-17 23:15:12 +00001936
Douglas Gregorc45c2322009-03-31 00:43:58 +00001937 virtual TemplateTy ActOnDependentTemplateName(SourceLocation TemplateKWLoc,
1938 const IdentifierInfo &Name,
1939 SourceLocation NameLoc,
1940 const CXXScopeSpec &SS);
1941
Douglas Gregor88b70942009-02-25 22:02:03 +00001942 bool CheckClassTemplateSpecializationScope(ClassTemplateDecl *ClassTemplate,
1943 ClassTemplateSpecializationDecl *PrevDecl,
1944 SourceLocation TemplateNameLoc,
Douglas Gregorff668032009-05-13 18:28:20 +00001945 SourceRange ScopeSpecifierRange,
1946 bool ExplicitInstantiation);
Douglas Gregor88b70942009-02-25 22:02:03 +00001947
Douglas Gregor212e81c2009-03-25 00:13:59 +00001948 virtual DeclResult
Douglas Gregorcc636682009-02-17 23:15:12 +00001949 ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagKind TK,
1950 SourceLocation KWLoc,
1951 const CXXScopeSpec &SS,
Douglas Gregor7532dc62009-03-30 22:58:21 +00001952 TemplateTy Template,
Douglas Gregorcc636682009-02-17 23:15:12 +00001953 SourceLocation TemplateNameLoc,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001954 SourceLocation LAngleLoc,
Douglas Gregor5908e9f2009-02-09 19:34:22 +00001955 ASTTemplateArgsPtr TemplateArgs,
Douglas Gregorc15cb382009-02-09 23:23:08 +00001956 SourceLocation *TemplateArgLocs,
Douglas Gregor55f6b142009-02-09 18:46:07 +00001957 SourceLocation RAngleLoc,
Douglas Gregorcc636682009-02-17 23:15:12 +00001958 AttributeList *Attr,
1959 MultiTemplateParamsArg TemplateParameterLists);
Douglas Gregor55f6b142009-02-09 18:46:07 +00001960
Douglas Gregor93dfdb12009-05-13 00:25:59 +00001961 virtual DeclResult
1962 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
1963 unsigned TagSpec,
1964 SourceLocation KWLoc,
1965 const CXXScopeSpec &SS,
1966 TemplateTy Template,
1967 SourceLocation TemplateNameLoc,
1968 SourceLocation LAngleLoc,
1969 ASTTemplateArgsPtr TemplateArgs,
1970 SourceLocation *TemplateArgLocs,
1971 SourceLocation RAngleLoc,
1972 AttributeList *Attr);
1973
Douglas Gregor3f5b61c2009-05-14 00:28:11 +00001974 virtual DeclResult
1975 ActOnExplicitInstantiation(Scope *S, SourceLocation TemplateLoc,
1976 unsigned TagSpec,
1977 SourceLocation KWLoc,
1978 const CXXScopeSpec &SS,
1979 IdentifierInfo *Name,
1980 SourceLocation NameLoc,
1981 AttributeList *Attr);
1982
Douglas Gregorc15cb382009-02-09 23:23:08 +00001983 bool CheckTemplateArgumentList(TemplateDecl *Template,
1984 SourceLocation TemplateLoc,
1985 SourceLocation LAngleLoc,
Douglas Gregor40808ce2009-03-09 23:48:35 +00001986 const TemplateArgument *TemplateArgs,
1987 unsigned NumTemplateArgs,
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001988 SourceLocation RAngleLoc,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00001989 TemplateArgumentListBuilder &Converted);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001990
1991 bool CheckTemplateArgument(TemplateTypeParmDecl *Param, QualType Arg,
1992 SourceLocation ArgLoc);
Douglas Gregor3e00bad2009-02-17 01:05:43 +00001993 bool CheckTemplateArgumentAddressOfObjectOrFunction(Expr *Arg,
1994 NamedDecl *&Entity);
1995 bool CheckTemplateArgumentPointerToMember(Expr *Arg, NamedDecl *&Member);
Douglas Gregor2943aed2009-03-03 04:44:36 +00001996 bool CheckTemplateArgument(NonTypeTemplateParmDecl *Param,
1997 QualType InstantiatedParamType, Expr *&Arg,
Anders Carlsson1c5976e2009-06-05 03:43:12 +00001998 TemplateArgumentListBuilder *Converted = 0);
Douglas Gregorc15cb382009-02-09 23:23:08 +00001999 bool CheckTemplateArgument(TemplateTemplateParmDecl *Param, DeclRefExpr *Arg);
Douglas Gregorddc29e12009-02-06 22:42:48 +00002000 bool TemplateParameterListsAreEqual(TemplateParameterList *New,
2001 TemplateParameterList *Old,
2002 bool Complain,
Douglas Gregordd0574e2009-02-10 00:24:35 +00002003 bool IsTemplateTemplateParm = false,
2004 SourceLocation TemplateArgLoc
2005 = SourceLocation());
Douglas Gregorddc29e12009-02-06 22:42:48 +00002006
2007 bool CheckTemplateDeclScope(Scope *S,
2008 MultiTemplateParamsArg &TemplateParameterLists);
Douglas Gregoraaba5e32009-02-04 19:02:06 +00002009
Douglas Gregord57959a2009-03-27 23:10:48 +00002010 /// \brief Called when the parser has parsed a C++ typename
2011 /// specifier, e.g., "typename T::type".
2012 ///
2013 /// \param TypenameLoc the location of the 'typename' keyword
2014 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2015 /// \param II the identifier we're retrieving (e.g., 'type' in the example).
2016 /// \param IdLoc the location of the identifier.
2017 virtual TypeResult
2018 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2019 const IdentifierInfo &II, SourceLocation IdLoc);
Douglas Gregor17343172009-04-01 00:28:59 +00002020
2021 /// \brief Called when the parser has parsed a C++ typename
2022 /// specifier that ends in a template-id, e.g.,
2023 /// "typename MetaFun::template apply<T1, T2>".
2024 ///
2025 /// \param TypenameLoc the location of the 'typename' keyword
2026 /// \param SS the nested-name-specifier following the typename (e.g., 'T::').
2027 /// \param TemplateLoc the location of the 'template' keyword, if any.
2028 /// \param Ty the type that the typename specifier refers to.
2029 virtual TypeResult
2030 ActOnTypenameType(SourceLocation TypenameLoc, const CXXScopeSpec &SS,
2031 SourceLocation TemplateLoc, TypeTy *Ty);
2032
Douglas Gregord57959a2009-03-27 23:10:48 +00002033 QualType CheckTypenameType(NestedNameSpecifier *NNS,
2034 const IdentifierInfo &II,
2035 SourceRange Range);
Douglas Gregorc8ab2562009-05-31 09:31:02 +00002036
Douglas Gregor199d9912009-06-05 00:53:49 +00002037 TemplateArgumentList *
2038 DeduceTemplateArguments(ClassTemplatePartialSpecializationDecl *Partial,
2039 const TemplateArgumentList &TemplateArgs);
Douglas Gregord57959a2009-03-27 23:10:48 +00002040
Douglas Gregor99ebf652009-02-27 19:31:52 +00002041 //===--------------------------------------------------------------------===//
2042 // C++ Template Instantiation
2043 //
Douglas Gregor26dce442009-03-10 00:06:19 +00002044
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002045 const TemplateArgumentList &getTemplateInstantiationArgs(NamedDecl *D);
2046
Douglas Gregor26dce442009-03-10 00:06:19 +00002047 /// \brief A template instantiation that is currently in progress.
2048 struct ActiveTemplateInstantiation {
Douglas Gregordf667e72009-03-10 20:44:00 +00002049 /// \brief The kind of template instantiation we are performing
2050 enum {
2051 /// We are instantiating a template declaration. The entity is
Douglas Gregorb9f1b8d2009-05-15 00:01:03 +00002052 /// the declaration we're instantiating (e.g., a CXXRecordDecl).
Douglas Gregordf667e72009-03-10 20:44:00 +00002053 TemplateInstantiation,
2054
2055 /// We are instantiating a default argument for a template
2056 /// parameter. The Entity is the template, and
2057 /// TemplateArgs/NumTemplateArguments provides the template
2058 /// arguments as specified.
Douglas Gregor637a4092009-06-10 23:47:09 +00002059 /// FIXME: Use a TemplateArgumentList
2060 DefaultTemplateArgumentInstantiation,
2061
2062 /// We are performing template argument deduction for a class
2063 /// template partial specialization. The Entity is the class
2064 /// template partial specialization, and
2065 /// TemplateArgs/NumTemplateArgs provides the deduced template
2066 /// arguments.
2067 /// FIXME: Use a TemplateArgumentList
2068 PartialSpecDeductionInstantiation
Douglas Gregordf667e72009-03-10 20:44:00 +00002069 } Kind;
2070
Douglas Gregor26dce442009-03-10 00:06:19 +00002071 /// \brief The point of instantiation within the source code.
2072 SourceLocation PointOfInstantiation;
2073
2074 /// \brief The entity that is being instantiated.
Douglas Gregordf667e72009-03-10 20:44:00 +00002075 uintptr_t Entity;
2076
2077 // \brief If this the instantiation of a default template
Douglas Gregor7e063902009-05-11 23:53:27 +00002078 // argument, the list of template arguments.
Douglas Gregordf667e72009-03-10 20:44:00 +00002079 const TemplateArgument *TemplateArgs;
2080
2081 /// \brief The number of template arguments in TemplateArgs.
2082 unsigned NumTemplateArgs;
Douglas Gregor26dce442009-03-10 00:06:19 +00002083
2084 /// \brief The source range that covers the construct that cause
2085 /// the instantiation, e.g., the template-id that causes a class
2086 /// template instantiation.
2087 SourceRange InstantiationRange;
Douglas Gregordf667e72009-03-10 20:44:00 +00002088
2089 friend bool operator==(const ActiveTemplateInstantiation &X,
2090 const ActiveTemplateInstantiation &Y) {
2091 if (X.Kind != Y.Kind)
2092 return false;
2093
2094 if (X.Entity != Y.Entity)
2095 return false;
2096
2097 switch (X.Kind) {
2098 case TemplateInstantiation:
2099 return true;
2100
2101 case DefaultTemplateArgumentInstantiation:
Douglas Gregor637a4092009-06-10 23:47:09 +00002102 case PartialSpecDeductionInstantiation:
Douglas Gregordf667e72009-03-10 20:44:00 +00002103 return X.TemplateArgs == Y.TemplateArgs;
2104 }
2105
2106 return true;
2107 }
2108
2109 friend bool operator!=(const ActiveTemplateInstantiation &X,
2110 const ActiveTemplateInstantiation &Y) {
2111 return !(X == Y);
2112 }
Douglas Gregor26dce442009-03-10 00:06:19 +00002113 };
2114
2115 /// \brief List of active template instantiations.
2116 ///
2117 /// This vector is treated as a stack. As one template instantiation
2118 /// requires another template instantiation, additional
2119 /// instantiations are pushed onto the stack up to a
2120 /// user-configurable limit LangOptions::InstantiationDepth.
2121 llvm::SmallVector<ActiveTemplateInstantiation, 16>
2122 ActiveTemplateInstantiations;
2123
Douglas Gregor27b152f2009-03-10 18:52:44 +00002124 /// \brief The last template from which a template instantiation
2125 /// error or warning was produced.
2126 ///
2127 /// This value is used to suppress printing of redundant template
2128 /// instantiation backtraces when there are multiple errors in the
2129 /// same instantiation. FIXME: Does this belong in Sema? It's tough
2130 /// to implement it anywhere else.
Douglas Gregordf667e72009-03-10 20:44:00 +00002131 ActiveTemplateInstantiation LastTemplateInstantiationErrorContext;
Douglas Gregor27b152f2009-03-10 18:52:44 +00002132
Douglas Gregor26dce442009-03-10 00:06:19 +00002133 /// \brief A stack object to be created when performing template
2134 /// instantiation.
2135 ///
2136 /// Construction of an object of type \c InstantiatingTemplate
2137 /// pushes the current instantiation onto the stack of active
2138 /// instantiations. If the size of this stack exceeds the maximum
2139 /// number of recursive template instantiations, construction
2140 /// produces an error and evaluates true.
2141 ///
2142 /// Destruction of this object will pop the named instantiation off
2143 /// the stack.
2144 struct InstantiatingTemplate {
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002145 /// \brief Note that we are instantiating a class template,
2146 /// function template, or a member thereof.
Douglas Gregor26dce442009-03-10 00:06:19 +00002147 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002148 Decl *Entity,
Douglas Gregor26dce442009-03-10 00:06:19 +00002149 SourceRange InstantiationRange = SourceRange());
Douglas Gregordf667e72009-03-10 20:44:00 +00002150
2151 /// \brief Note that we are instantiating a default argument in a
2152 /// template-id.
2153 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2154 TemplateDecl *Template,
2155 const TemplateArgument *TemplateArgs,
2156 unsigned NumTemplateArgs,
2157 SourceRange InstantiationRange = SourceRange());
2158
Douglas Gregor637a4092009-06-10 23:47:09 +00002159 /// \brief Note that we are instantiating as part of template
2160 /// argument deduction for a class template partial
2161 /// specialization.
2162 InstantiatingTemplate(Sema &SemaRef, SourceLocation PointOfInstantiation,
2163 ClassTemplatePartialSpecializationDecl *PartialSpec,
2164 const TemplateArgument *TemplateArgs,
2165 unsigned NumTemplateArgs,
2166 SourceRange InstantiationRange = SourceRange());
2167
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002168 /// \brief Note that we have finished instantiating this template.
2169 void Clear();
2170
2171 ~InstantiatingTemplate() { Clear(); }
Douglas Gregor26dce442009-03-10 00:06:19 +00002172
2173 /// \brief Determines whether we have exceeded the maximum
2174 /// recursive template instantiations.
2175 operator bool() const { return Invalid; }
2176
2177 private:
2178 Sema &SemaRef;
2179 bool Invalid;
2180
Douglas Gregordf667e72009-03-10 20:44:00 +00002181 bool CheckInstantiationDepth(SourceLocation PointOfInstantiation,
2182 SourceRange InstantiationRange);
2183
Douglas Gregor26dce442009-03-10 00:06:19 +00002184 InstantiatingTemplate(const InstantiatingTemplate&); // not implemented
2185
2186 InstantiatingTemplate&
2187 operator=(const InstantiatingTemplate&); // not implemented
2188 };
2189
Douglas Gregoree1828a2009-03-10 18:03:33 +00002190 void PrintInstantiationStack();
2191
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002192 /// \brief A stack-allocated class that identifies which local
2193 /// variable declaration instantiations are present in this scope.
2194 ///
2195 /// A new instance of this class type will be created whenever we
2196 /// instantiate a new function declaration, which will have its own
2197 /// set of parameter declarations.
2198 class LocalInstantiationScope {
2199 /// \brief Reference to the semantic analysis that is performing
2200 /// this template instantiation.
2201 Sema &SemaRef;
2202
Douglas Gregor815215d2009-05-27 05:35:12 +00002203 /// \brief A mapping from local declarations that occur
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002204 /// within a template to their instantiations.
2205 ///
2206 /// This mapping is used during instantiation to keep track of,
2207 /// e.g., function parameter and variable declarations. For example,
2208 /// given:
2209 ///
2210 /// \code
2211 /// template<typename T> T add(T x, T y) { return x + y; }
2212 /// \endcode
2213 ///
2214 /// when we instantiate add<int>, we will introduce a mapping from
2215 /// the ParmVarDecl for 'x' that occurs in the template to the
2216 /// instantiated ParmVarDecl for 'x'.
Douglas Gregor815215d2009-05-27 05:35:12 +00002217 llvm::DenseMap<const Decl *, Decl *> LocalDecls;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002218
2219 /// \brief The outer scope, in which contains local variable
2220 /// definitions from some other instantiation (that is not
2221 /// relevant to this particular scope).
2222 LocalInstantiationScope *Outer;
2223
2224 // This class is non-copyable
2225 LocalInstantiationScope(const LocalInstantiationScope &);
2226 LocalInstantiationScope &operator=(const LocalInstantiationScope &);
2227
2228 public:
2229 LocalInstantiationScope(Sema &SemaRef)
2230 : SemaRef(SemaRef), Outer(SemaRef.CurrentInstantiationScope) {
2231 SemaRef.CurrentInstantiationScope = this;
2232 }
2233
2234 ~LocalInstantiationScope() {
2235 SemaRef.CurrentInstantiationScope = Outer;
2236 }
2237
Douglas Gregor815215d2009-05-27 05:35:12 +00002238 Decl *getInstantiationOf(const Decl *D) {
2239 Decl *Result = LocalDecls[D];
2240 assert(Result && "declaration was not instantiated in this scope!");
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002241 return Result;
2242 }
2243
Douglas Gregor815215d2009-05-27 05:35:12 +00002244 VarDecl *getInstantiationOf(const VarDecl *Var) {
2245 return cast<VarDecl>(getInstantiationOf(cast<Decl>(Var)));
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002246 }
2247
Douglas Gregor815215d2009-05-27 05:35:12 +00002248 ParmVarDecl *getInstantiationOf(const ParmVarDecl *Var) {
2249 return cast<ParmVarDecl>(getInstantiationOf(cast<Decl>(Var)));
2250 }
2251
2252 void InstantiatedLocal(const Decl *D, Decl *Inst) {
2253 Decl *&Stored = LocalDecls[D];
2254 assert(!Stored && "Already instantiated this local");
2255 Stored = Inst;
Douglas Gregor48dd19b2009-05-14 21:44:34 +00002256 }
2257 };
2258
2259 /// \brief The current instantiation scope used to store local
2260 /// variables.
2261 LocalInstantiationScope *CurrentInstantiationScope;
2262
Douglas Gregor7e063902009-05-11 23:53:27 +00002263 QualType InstantiateType(QualType T, const TemplateArgumentList &TemplateArgs,
Douglas Gregor99ebf652009-02-27 19:31:52 +00002264 SourceLocation Loc, DeclarationName Entity);
Douglas Gregor199d9912009-06-05 00:53:49 +00002265
Douglas Gregora0e500d2009-03-12 16:53:44 +00002266 OwningExprResult InstantiateExpr(Expr *E,
Douglas Gregor7e063902009-05-11 23:53:27 +00002267 const TemplateArgumentList &TemplateArgs);
Douglas Gregora0e500d2009-03-12 16:53:44 +00002268
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002269 OwningStmtResult InstantiateStmt(Stmt *S,
2270 const TemplateArgumentList &TemplateArgs);
Douglas Gregor66b46be2009-05-20 22:57:03 +00002271 OwningStmtResult InstantiateCompoundStmt(CompoundStmt *S,
2272 const TemplateArgumentList &TemplateArgs,
2273 bool isStmtExpr);
Douglas Gregor54dabfc2009-05-14 23:26:13 +00002274
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002275 Decl *InstantiateDecl(Decl *D, DeclContext *Owner,
Douglas Gregor7e063902009-05-11 23:53:27 +00002276 const TemplateArgumentList &TemplateArgs);
Douglas Gregor8dbc2692009-03-17 21:15:40 +00002277
Douglas Gregor2943aed2009-03-03 04:44:36 +00002278 bool
Douglas Gregord475b8d2009-03-25 21:17:03 +00002279 InstantiateBaseSpecifiers(CXXRecordDecl *Instantiation,
2280 CXXRecordDecl *Pattern,
Douglas Gregor7e063902009-05-11 23:53:27 +00002281 const TemplateArgumentList &TemplateArgs);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002282
2283 bool
2284 InstantiateClass(SourceLocation PointOfInstantiation,
2285 CXXRecordDecl *Instantiation, CXXRecordDecl *Pattern,
Douglas Gregor93dfdb12009-05-13 00:25:59 +00002286 const TemplateArgumentList &TemplateArgs,
2287 bool ExplicitInstantiation);
Douglas Gregord475b8d2009-03-25 21:17:03 +00002288
Douglas Gregor2943aed2009-03-03 04:44:36 +00002289 bool
2290 InstantiateClassTemplateSpecialization(
2291 ClassTemplateSpecializationDecl *ClassTemplateSpec,
2292 bool ExplicitInstantiation);
Douglas Gregor99ebf652009-02-27 19:31:52 +00002293
Douglas Gregora58861f2009-05-13 20:28:22 +00002294 void InstantiateClassMembers(SourceLocation PointOfInstantiation,
2295 CXXRecordDecl *Instantiation,
2296 const TemplateArgumentList &TemplateArgs);
2297
2298 void InstantiateClassTemplateSpecializationMembers(
2299 SourceLocation PointOfInstantiation,
2300 ClassTemplateSpecializationDecl *ClassTemplateSpec);
2301
Douglas Gregorab452ba2009-03-26 23:50:42 +00002302 NestedNameSpecifier *
2303 InstantiateNestedNameSpecifier(NestedNameSpecifier *NNS,
2304 SourceRange Range,
Douglas Gregor7e063902009-05-11 23:53:27 +00002305 const TemplateArgumentList &TemplateArgs);
Douglas Gregor5953d8b2009-03-19 17:26:29 +00002306
Douglas Gregorde650ae2009-03-31 18:38:02 +00002307 TemplateName
2308 InstantiateTemplateName(TemplateName Name, SourceLocation Loc,
Douglas Gregor7e063902009-05-11 23:53:27 +00002309 const TemplateArgumentList &TemplateArgs);
Douglas Gregorde650ae2009-03-31 18:38:02 +00002310
Douglas Gregorf3e7ce42009-05-18 17:01:57 +00002311 void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation,
2312 FunctionDecl *Function);
Douglas Gregora58861f2009-05-13 20:28:22 +00002313 void InstantiateVariableDefinition(VarDecl *Var);
2314
Douglas Gregored961e72009-05-27 17:54:46 +00002315 NamedDecl *InstantiateCurrentDeclRef(NamedDecl *D);
Douglas Gregor815215d2009-05-27 05:35:12 +00002316
Anders Carlssona135fb42009-03-15 18:34:13 +00002317 // Simple function for cloning expressions.
2318 template<typename T>
2319 OwningExprResult Clone(T *E) {
2320 assert(!E->isValueDependent() && !E->isTypeDependent() &&
2321 "expression is value or type dependent!");
2322 return Owned(E->Clone(Context));
2323 }
2324
Steve Naroff3536b442007-09-06 21:24:23 +00002325 // Objective-C declarations.
Chris Lattnerb28317a2009-03-28 19:18:32 +00002326 virtual DeclPtrTy ActOnStartClassInterface(SourceLocation AtInterfaceLoc,
2327 IdentifierInfo *ClassName,
2328 SourceLocation ClassLoc,
2329 IdentifierInfo *SuperName,
2330 SourceLocation SuperLoc,
2331 const DeclPtrTy *ProtoRefs,
2332 unsigned NumProtoRefs,
2333 SourceLocation EndProtoLoc,
2334 AttributeList *AttrList);
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002335
Chris Lattnerb28317a2009-03-28 19:18:32 +00002336 virtual DeclPtrTy ActOnCompatiblityAlias(
Fariborz Jahanian243b64b2007-10-11 23:42:27 +00002337 SourceLocation AtCompatibilityAliasLoc,
2338 IdentifierInfo *AliasName, SourceLocation AliasLocation,
2339 IdentifierInfo *ClassName, SourceLocation ClassLocation);
Steve Naroff61d68522009-03-05 15:22:01 +00002340
2341 void CheckForwardProtocolDeclarationForCircularDependency(
2342 IdentifierInfo *PName,
2343 SourceLocation &PLoc, SourceLocation PrevLoc,
2344 const ObjCList<ObjCProtocolDecl> &PList);
Steve Naroff3536b442007-09-06 21:24:23 +00002345
Chris Lattnerb28317a2009-03-28 19:18:32 +00002346 virtual DeclPtrTy ActOnStartProtocolInterface(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002347 SourceLocation AtProtoInterfaceLoc,
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002348 IdentifierInfo *ProtocolName, SourceLocation ProtocolLoc,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002349 const DeclPtrTy *ProtoRefNames, unsigned NumProtoRefs,
Daniel Dunbar246e70f2008-09-26 04:48:09 +00002350 SourceLocation EndProtoLoc,
2351 AttributeList *AttrList);
Fariborz Jahanian25e077d2007-09-17 21:07:36 +00002352
Chris Lattnerb28317a2009-03-28 19:18:32 +00002353 virtual DeclPtrTy ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc,
2354 IdentifierInfo *ClassName,
2355 SourceLocation ClassLoc,
2356 IdentifierInfo *CategoryName,
2357 SourceLocation CategoryLoc,
2358 const DeclPtrTy *ProtoRefs,
2359 unsigned NumProtoRefs,
2360 SourceLocation EndProtoLoc);
Fariborz Jahanianfd225cc2007-09-18 20:26:58 +00002361
Chris Lattnerb28317a2009-03-28 19:18:32 +00002362 virtual DeclPtrTy ActOnStartClassImplementation(
Nate Begeman1abc7f62008-02-20 22:57:40 +00002363 SourceLocation AtClassImplLoc,
Fariborz Jahanianccb4f312007-09-25 18:38:09 +00002364 IdentifierInfo *ClassName, SourceLocation ClassLoc,
2365 IdentifierInfo *SuperClassname,
2366 SourceLocation SuperClassLoc);
2367
Chris Lattnerb28317a2009-03-28 19:18:32 +00002368 virtual DeclPtrTy ActOnStartCategoryImplementation(
Fariborz Jahanian8f3fde02007-10-02 16:38:50 +00002369 SourceLocation AtCatImplLoc,
2370 IdentifierInfo *ClassName,
2371 SourceLocation ClassLoc,
2372 IdentifierInfo *CatName,
2373 SourceLocation CatLoc);
2374
Chris Lattnerb28317a2009-03-28 19:18:32 +00002375 virtual DeclPtrTy ActOnForwardClassDeclaration(SourceLocation Loc,
Steve Naroff37e58d12007-10-02 22:39:18 +00002376 IdentifierInfo **IdentList,
2377 unsigned NumElts);
Fariborz Jahanian894c57f2007-09-21 15:40:54 +00002378
Chris Lattnerb28317a2009-03-28 19:18:32 +00002379 virtual DeclPtrTy ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002380 const IdentifierLocPair *IdentList,
Fariborz Jahanianbc1c8772008-12-17 01:07:27 +00002381 unsigned NumElts,
2382 AttributeList *attrList);
Fariborz Jahanian245f92a2007-10-05 21:01:53 +00002383
Chris Lattnere13b9592008-07-26 04:03:38 +00002384 virtual void FindProtocolDeclaration(bool WarnOnDeclarations,
Chris Lattner7caeabd2008-07-21 22:17:28 +00002385 const IdentifierLocPair *ProtocolId,
Fariborz Jahanian4b6c9052007-10-11 00:55:41 +00002386 unsigned NumProtocols,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002387 llvm::SmallVectorImpl<DeclPtrTy> &Protocols);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002388
Daniel Dunbar95e61fb2008-09-23 21:53:23 +00002389 /// Ensure attributes are consistent with type.
2390 /// \param [in, out] Attributes The attributes to check; they will
2391 /// be modified to be consistent with \arg PropertyTy.
2392 void CheckObjCPropertyAttributes(QualType PropertyTy,
2393 SourceLocation Loc,
2394 unsigned &Attributes);
Steve Naroff0701bbb2009-01-08 17:28:14 +00002395 void ProcessPropertyDecl(ObjCPropertyDecl *property, ObjCContainerDecl *DC);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002396 void DiagnosePropertyMismatch(ObjCPropertyDecl *Property,
2397 ObjCPropertyDecl *SuperProperty,
Chris Lattner8ec03f52008-11-24 03:54:41 +00002398 const IdentifierInfo *Name);
Fariborz Jahanian02edb982008-05-01 00:03:38 +00002399 void ComparePropertiesInBaseAndSuper(ObjCInterfaceDecl *IDecl);
Fariborz Jahanianb5e02242008-04-24 19:58:34 +00002400
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002401 void MergeProtocolPropertiesIntoClass(Decl *CDecl,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002402 DeclPtrTy MergeProtocols);
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002403
Fariborz Jahanianb7f95f52009-03-02 19:05:07 +00002404 void DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
2405 ObjCInterfaceDecl *ID);
2406
Fariborz Jahanian1ac2bc42008-12-06 23:03:39 +00002407 void MergeOneProtocolPropertiesIntoClass(Decl *CDecl,
Fariborz Jahanianaebf0cb2008-05-02 19:17:30 +00002408 ObjCProtocolDecl *PDecl);
2409
Chris Lattnerb28317a2009-03-28 19:18:32 +00002410 virtual void ActOnAtEnd(SourceLocation AtEndLoc, DeclPtrTy classDecl,
2411 DeclPtrTy *allMethods = 0, unsigned allNum = 0,
2412 DeclPtrTy *allProperties = 0, unsigned pNum = 0,
Chris Lattner682bf922009-03-29 16:50:03 +00002413 DeclGroupPtrTy *allTUVars = 0, unsigned tuvNum = 0);
Fariborz Jahaniand0b90bf2007-09-26 18:27:25 +00002414
Chris Lattnerb28317a2009-03-28 19:18:32 +00002415 virtual DeclPtrTy ActOnProperty(Scope *S, SourceLocation AtLoc,
2416 FieldDeclarator &FD, ObjCDeclSpec &ODS,
2417 Selector GetterSel, Selector SetterSel,
2418 DeclPtrTy ClassCategory,
2419 bool *OverridingProperty,
2420 tok::ObjCKeywordKind MethodImplKind);
Fariborz Jahanian46b55e52008-05-05 18:51:55 +00002421
Chris Lattnerb28317a2009-03-28 19:18:32 +00002422 virtual DeclPtrTy ActOnPropertyImplDecl(SourceLocation AtLoc,
2423 SourceLocation PropertyLoc,
2424 bool ImplKind,DeclPtrTy ClassImplDecl,
2425 IdentifierInfo *PropertyId,
2426 IdentifierInfo *PropertyIvar);
Fariborz Jahanianf624f812008-04-18 00:19:30 +00002427
Chris Lattnerb28317a2009-03-28 19:18:32 +00002428 virtual DeclPtrTy ActOnMethodDeclaration(
Steve Naroffbef11852007-10-26 20:53:56 +00002429 SourceLocation BeginLoc, // location of the + or -.
2430 SourceLocation EndLoc, // location of the ; or {.
Fariborz Jahanian1f7b6f82007-11-09 19:52:12 +00002431 tok::TokenKind MethodType,
Chris Lattnerb28317a2009-03-28 19:18:32 +00002432 DeclPtrTy ClassDecl, ObjCDeclSpec &ReturnQT, TypeTy *ReturnType,
Fariborz Jahanianf1de0ca2007-10-31 23:53:01 +00002433 Selector Sel,
Steve Naroff68d331a2007-09-27 14:38:14 +00002434 // optional arguments. The number of types/arguments is obtained
2435 // from the Sel.getNumArgs().
Chris Lattnere294d3f2009-04-11 18:57:04 +00002436 ObjCArgInfo *ArgInfo,
Fariborz Jahanian439c6582009-01-09 00:38:19 +00002437 llvm::SmallVectorImpl<Declarator> &Cdecls,
Steve Naroff335eafa2007-11-15 12:35:21 +00002438 AttributeList *AttrList, tok::ObjCKeywordKind MethodImplKind,
2439 bool isVariadic = false);
Steve Naroff81bfde92007-10-16 23:12:48 +00002440
Steve Narofff1afaf62009-02-26 15:55:06 +00002441 // Helper method for ActOnClassMethod/ActOnInstanceMethod.
2442 // Will search "local" class/category implementations for a method decl.
Fariborz Jahanian175ba1e2009-03-04 18:15:57 +00002443 // Will also search in class's root looking for instance method.
Steve Narofff1afaf62009-02-26 15:55:06 +00002444 // Returns 0 if no method is found.
Steve Naroff5609ec02009-03-08 18:56:13 +00002445 ObjCMethodDecl *LookupPrivateClassMethod(Selector Sel,
2446 ObjCInterfaceDecl *CDecl);
2447 ObjCMethodDecl *LookupPrivateInstanceMethod(Selector Sel,
2448 ObjCInterfaceDecl *ClassDecl);
Steve Narofff1afaf62009-02-26 15:55:06 +00002449
Steve Naroff61f72cb2009-03-09 21:12:44 +00002450 virtual OwningExprResult ActOnClassPropertyRefExpr(
2451 IdentifierInfo &receiverName,
2452 IdentifierInfo &propertyName,
2453 SourceLocation &receiverNameLoc,
2454 SourceLocation &propertyNameLoc);
2455
Steve Naroff68d331a2007-09-27 14:38:14 +00002456 // ActOnClassMessage - used for both unary and keyword messages.
2457 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002458 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002459 virtual ExprResult ActOnClassMessage(
Fariborz Jahanian0523aaf2007-11-12 20:13:27 +00002460 Scope *S,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002461 IdentifierInfo *receivingClassName, Selector Sel, SourceLocation lbrac,
2462 SourceLocation receiverLoc, SourceLocation selectorLoc,SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002463 ExprTy **ArgExprs, unsigned NumArgs);
Steve Naroff68d331a2007-09-27 14:38:14 +00002464
2465 // ActOnInstanceMessage - used for both unary and keyword messages.
2466 // ArgExprs is optional - if it is present, the number of expressions
Steve Naroff49f109c2007-11-15 13:05:42 +00002467 // is obtained from NumArgs.
Steve Naroff68d331a2007-09-27 14:38:14 +00002468 virtual ExprResult ActOnInstanceMessage(
Steve Naroffbcfb06a2007-09-28 22:22:11 +00002469 ExprTy *receiver, Selector Sel,
Anders Carlssonff975cf2009-02-14 18:21:46 +00002470 SourceLocation lbrac, SourceLocation receiverLoc, SourceLocation rbrac,
Steve Naroff49f109c2007-11-15 13:05:42 +00002471 ExprTy **ArgExprs, unsigned NumArgs);
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002472
2473 /// ActOnPragmaPack - Called on well formed #pragma pack(...).
2474 virtual void ActOnPragmaPack(PragmaPackKind Kind,
2475 IdentifierInfo *Name,
2476 ExprTy *Alignment,
2477 SourceLocation PragmaLoc,
2478 SourceLocation LParenLoc,
2479 SourceLocation RParenLoc);
Chris Lattner574aa402009-02-17 01:09:29 +00002480
Ted Kremenek4726d032009-03-23 22:28:25 +00002481 /// ActOnPragmaUnused - Called on well-formed '#pragma unused'.
2482 virtual void ActOnPragmaUnused(ExprTy **Exprs, unsigned NumExprs,
2483 SourceLocation PragmaLoc,
2484 SourceLocation LParenLoc,
2485 SourceLocation RParenLoc);
Eli Friedmanc49f19b2009-06-05 02:44:36 +00002486
Eli Friedmandec7c762009-06-05 06:28:29 +00002487 /// ActOnPragmaWeakID - Called on well formed #pragma weak ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00002488 virtual void ActOnPragmaWeakID(IdentifierInfo* WeakName,
2489 SourceLocation PragmaLoc,
2490 SourceLocation WeakNameLoc);
2491
Eli Friedmandec7c762009-06-05 06:28:29 +00002492 /// ActOnPragmaWeakAlias - Called on well formed #pragma weak ident = ident.
Eli Friedmanc49f19b2009-06-05 02:44:36 +00002493 virtual void ActOnPragmaWeakAlias(IdentifierInfo* WeakName,
2494 IdentifierInfo* AliasName,
2495 SourceLocation PragmaLoc,
2496 SourceLocation WeakNameLoc,
2497 SourceLocation AliasNameLoc);
2498
Chris Lattner574aa402009-02-17 01:09:29 +00002499 /// getPragmaPackAlignment() - Return the current alignment as specified by
2500 /// the current #pragma pack directive, or 0 if none is currently active.
2501 unsigned getPragmaPackAlignment() const;
2502
2503 /// FreePackedContext - Deallocate and null out PackContext.
2504 void FreePackedContext();
Daniel Dunbar4cde9272008-10-14 05:35:18 +00002505
Chris Lattner1e0a3902008-01-16 19:17:22 +00002506 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit
2507 /// cast. If there is already an implicit cast, merge into the existing one.
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002508 /// If isLvalue, the result of the cast is an lvalue.
2509 void ImpCastExprToType(Expr *&Expr, QualType Type, bool isLvalue = false);
Chris Lattner1e0a3902008-01-16 19:17:22 +00002510
Reid Spencer5f016e22007-07-11 17:01:13 +00002511 // UsualUnaryConversions - promotes integers (C99 6.3.1.1p2) and converts
Chris Lattner925e60d2007-12-28 05:29:59 +00002512 // functions and arrays to their respective pointers (C99 6.3.2.1).
2513 Expr *UsualUnaryConversions(Expr *&expr);
Eli Friedman3c0eb162008-05-27 03:33:27 +00002514
Steve Naroffc80b4ee2007-07-16 21:54:35 +00002515 // DefaultFunctionArrayConversion - converts functions and arrays
2516 // to their respective pointers (C99 6.3.2.1).
2517 void DefaultFunctionArrayConversion(Expr *&expr);
Steve Naroff90045e82007-07-13 23:32:42 +00002518
Steve Naroffb291ab62007-08-28 23:30:39 +00002519 // DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
2520 // do not have a prototype. Integer promotions are performed on each
2521 // argument, and arguments that have type float are promoted to double.
Chris Lattner925e60d2007-12-28 05:29:59 +00002522 void DefaultArgumentPromotion(Expr *&Expr);
Anders Carlssondce5e2c2009-01-16 16:48:51 +00002523
2524 // Used for emitting the right warning by DefaultVariadicArgumentPromotion
2525 enum VariadicCallType {
2526 VariadicFunction,
2527 VariadicBlock,
2528 VariadicMethod
2529 };
2530
2531 // DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but
2532 // will warn if the resulting type is not a POD type.
Chris Lattner312531a2009-04-12 08:11:20 +00002533 bool DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT);
Steve Naroffb291ab62007-08-28 23:30:39 +00002534
Reid Spencer5f016e22007-07-11 17:01:13 +00002535 // UsualArithmeticConversions - performs the UsualUnaryConversions on it's
2536 // operands and then handles various conversions that are common to binary
2537 // operators (C99 6.3.1.8). If both operands aren't arithmetic, this
2538 // routine returns the first non-arithmetic type found. The client is
2539 // responsible for emitting appropriate error diagnostics.
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002540 QualType UsualArithmeticConversions(Expr *&lExpr, Expr *&rExpr,
2541 bool isCompAssign = false);
Chris Lattnerb7b61152008-01-04 18:22:42 +00002542
Douglas Gregoreb8f3062008-11-12 17:17:38 +00002543 /// UsualArithmeticConversionsType - handles the various conversions
2544 /// that are common to binary operators (C99 6.3.1.8, C++ [expr]p9)
2545 /// and returns the result type of that conversion.
2546 QualType UsualArithmeticConversionsType(QualType lhs, QualType rhs);
2547
2548
Chris Lattnerb7b61152008-01-04 18:22:42 +00002549 /// AssignConvertType - All of the 'assignment' semantic checks return this
2550 /// enum to indicate whether the assignment was allowed. These checks are
2551 /// done for simple assignments, as well as initialization, return from
2552 /// function, argument passing, etc. The query is phrased in terms of a
2553 /// source and destination type.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002554 enum AssignConvertType {
Chris Lattnerb7b61152008-01-04 18:22:42 +00002555 /// Compatible - the types are compatible according to the standard.
Reid Spencer5f016e22007-07-11 17:01:13 +00002556 Compatible,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002557
2558 /// PointerToInt - The assignment converts a pointer to an int, which we
2559 /// accept as an extension.
2560 PointerToInt,
2561
2562 /// IntToPointer - The assignment converts an int to a pointer, which we
2563 /// accept as an extension.
2564 IntToPointer,
2565
2566 /// FunctionVoidPointer - The assignment is between a function pointer and
2567 /// void*, which the standard doesn't allow, but we accept as an extension.
Chris Lattnerbfe639e2008-01-03 22:56:36 +00002568 FunctionVoidPointer,
Chris Lattnerb7b61152008-01-04 18:22:42 +00002569
2570 /// IncompatiblePointer - The assignment is between two pointers types that
2571 /// are not compatible, but we accept them as an extension.
Reid Spencer5f016e22007-07-11 17:01:13 +00002572 IncompatiblePointer,
Eli Friedmanf05c05d2009-03-22 23:59:44 +00002573
2574 /// IncompatiblePointer - The assignment is between two pointers types which
2575 /// point to integers which have a different sign, but are otherwise identical.
2576 /// This is a subset of the above, but broken out because it's by far the most
2577 /// common case of incompatible pointers.
2578 IncompatiblePointerSign,
2579
Chris Lattnerb7b61152008-01-04 18:22:42 +00002580 /// CompatiblePointerDiscardsQualifiers - The assignment discards
2581 /// c/v/r qualifiers, which we accept as an extension.
2582 CompatiblePointerDiscardsQualifiers,
Steve Naroff1c7d0672008-09-04 15:10:53 +00002583
Anders Carlssonb0f90cc2009-01-30 23:17:46 +00002584 /// IncompatibleVectors - The assignment is between two vector types that
2585 /// have the same size, which we accept as an extension.
2586 IncompatibleVectors,
2587
Steve Naroffbfdcae62008-09-04 15:31:07 +00002588 /// IntToBlockPointer - The assignment converts an int to a block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002589 /// pointer. We disallow this.
2590 IntToBlockPointer,
2591
Steve Naroffbfdcae62008-09-04 15:31:07 +00002592 /// IncompatibleBlockPointer - The assignment is between two block
Steve Naroff1c7d0672008-09-04 15:10:53 +00002593 /// pointers types that are not compatible.
2594 IncompatibleBlockPointer,
2595
Steve Naroff39579072008-10-14 22:18:38 +00002596 /// IncompatibleObjCQualifiedId - The assignment is between a qualified
2597 /// id type and something else (that is incompatible with it). For example,
2598 /// "id <XXX>" = "Foo *", where "Foo *" doesn't implement the XXX protocol.
2599 IncompatibleObjCQualifiedId,
2600
Chris Lattnerb7b61152008-01-04 18:22:42 +00002601 /// Incompatible - We reject this conversion outright, it is invalid to
2602 /// represent it in the AST.
2603 Incompatible
Reid Spencer5f016e22007-07-11 17:01:13 +00002604 };
Chris Lattner5cf216b2008-01-04 18:04:52 +00002605
2606 /// DiagnoseAssignmentResult - Emit a diagnostic, if required, for the
2607 /// assignment conversion type specified by ConvTy. This returns true if the
2608 /// conversion was invalid or false if the conversion was accepted.
2609 bool DiagnoseAssignmentResult(AssignConvertType ConvTy,
2610 SourceLocation Loc,
2611 QualType DstType, QualType SrcType,
2612 Expr *SrcExpr, const char *Flavor);
2613
2614 /// CheckAssignmentConstraints - Perform type checking for assignment,
2615 /// argument passing, variable initialization, and function return values.
2616 /// This routine is only used by the following two methods. C99 6.5.16.
2617 AssignConvertType CheckAssignmentConstraints(QualType lhs, QualType rhs);
Steve Naroff90045e82007-07-13 23:32:42 +00002618
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002619 // CheckSingleAssignmentConstraints - Currently used by
Steve Naroff1b273c42007-09-16 14:56:35 +00002620 // CheckAssignmentOperands, and ActOnReturnStmt. Prior to type checking,
Steve Naroff90045e82007-07-13 23:32:42 +00002621 // this routine performs the default function/array converions.
Chris Lattner5cf216b2008-01-04 18:04:52 +00002622 AssignConvertType CheckSingleAssignmentConstraints(QualType lhs,
2623 Expr *&rExpr);
Douglas Gregor0c74e8a2009-04-29 22:16:16 +00002624
2625 // \brief If the lhs type is a transparent union, check whether we
2626 // can initialize the transparent union with the given expression.
2627 AssignConvertType CheckTransparentUnionArgumentConstraints(QualType lhs,
2628 Expr *&rExpr);
Steve Naroff90045e82007-07-13 23:32:42 +00002629
Reid Spencer5f016e22007-07-11 17:01:13 +00002630 // Helper function for CheckAssignmentConstraints (C99 6.5.16.1p1)
Chris Lattner5cf216b2008-01-04 18:04:52 +00002631 AssignConvertType CheckPointerTypesForAssignment(QualType lhsType,
2632 QualType rhsType);
Steve Naroff1c7d0672008-09-04 15:10:53 +00002633
2634 // Helper function for CheckAssignmentConstraints involving two
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002635 // block pointer types.
Steve Naroff1c7d0672008-09-04 15:10:53 +00002636 AssignConvertType CheckBlockPointerTypesForAssignment(QualType lhsType,
2637 QualType rhsType);
Douglas Gregor77a52232008-09-12 00:47:35 +00002638
2639 bool IsStringLiteralToNonConstPointerConversion(Expr *From, QualType ToType);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002640
Douglas Gregor45920e82008-12-19 17:40:08 +00002641 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Sebastian Redle2b68332009-04-12 17:16:29 +00002642 const char *Flavor,
2643 bool AllowExplicit = false,
2644 bool Elidable = false);
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002645 bool PerformImplicitConversion(Expr *&From, QualType ToType,
2646 const ImplicitConversionSequence& ICS,
Douglas Gregor45920e82008-12-19 17:40:08 +00002647 const char *Flavor);
Douglas Gregor94b1dd22008-10-24 04:54:22 +00002648 bool PerformImplicitConversion(Expr *&From, QualType ToType,
Douglas Gregor45920e82008-12-19 17:40:08 +00002649 const StandardConversionSequence& SCS,
2650 const char *Flavor);
Sebastian Redl22460502009-02-07 00:15:38 +00002651
Reid Spencer5f016e22007-07-11 17:01:13 +00002652 /// the following "Check" methods will return a valid/converted QualType
2653 /// or a null QualType (indicating an error diagnostic was issued).
Sebastian Redl22460502009-02-07 00:15:38 +00002654
2655 /// type checking binary operators (subroutines of CreateBuiltinBinOp).
Douglas Gregordf032512009-03-12 22:46:12 +00002656 QualType InvalidOperands(SourceLocation l, Expr *&lex, Expr *&rex);
Sebastian Redl7c8bd602009-02-07 20:10:22 +00002657 QualType CheckPointerToMemberOperands( // C++ 5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002658 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isIndirect);
Douglas Gregordf032512009-03-12 22:46:12 +00002659 QualType CheckMultiplyDivideOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002660 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002661 QualType CheckRemainderOperands( // C99 6.5.5
Sebastian Redl22460502009-02-07 00:15:38 +00002662 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002663 QualType CheckAdditionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00002664 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00002665 QualType CheckSubtractionOperands( // C99 6.5.6
Eli Friedmanab3a8522009-03-28 01:22:36 +00002666 Expr *&lex, Expr *&rex, SourceLocation OpLoc, QualType* CompLHSTy = 0);
Douglas Gregordf032512009-03-12 22:46:12 +00002667 QualType CheckShiftOperands( // C99 6.5.7
Steve Naroff9f5fa9b2007-08-24 19:07:16 +00002668 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002669 QualType CheckCompareOperands( // C99 6.5.8/9
Douglas Gregora86b8322009-04-06 18:45:53 +00002670 Expr *&lex, Expr *&rex, SourceLocation OpLoc, unsigned Opc, bool isRelational);
Douglas Gregordf032512009-03-12 22:46:12 +00002671 QualType CheckBitwiseOperands( // C99 6.5.[10...12]
Sebastian Redl22460502009-02-07 00:15:38 +00002672 Expr *&lex, Expr *&rex, SourceLocation OpLoc, bool isCompAssign = false);
Douglas Gregordf032512009-03-12 22:46:12 +00002673 QualType CheckLogicalOperands( // C99 6.5.[13,14]
Steve Naroff49b45262007-07-13 16:58:59 +00002674 Expr *&lex, Expr *&rex, SourceLocation OpLoc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002675 // CheckAssignmentOperands is used for both simple and compound assignment.
2676 // For simple assignment, pass both expressions and a null converted type.
2677 // For compound assignment, pass both expressions and the converted type.
Douglas Gregordf032512009-03-12 22:46:12 +00002678 QualType CheckAssignmentOperands( // C99 6.5.16.[1,2]
Steve Narofff1120de2007-08-24 22:33:52 +00002679 Expr *lex, Expr *&rex, SourceLocation OpLoc, QualType convertedType);
Douglas Gregordf032512009-03-12 22:46:12 +00002680 QualType CheckCommaOperands( // C99 6.5.17
Chris Lattner29a1cfb2008-11-18 01:30:42 +00002681 Expr *lex, Expr *&rex, SourceLocation OpLoc);
Douglas Gregordf032512009-03-12 22:46:12 +00002682 QualType CheckConditionalOperands( // C99 6.5.15
Steve Naroff49b45262007-07-13 16:58:59 +00002683 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002684 QualType CXXCheckConditionalOperands( // C++ 5.16
2685 Expr *&cond, Expr *&lhs, Expr *&rhs, SourceLocation questionLoc);
Sebastian Redld1bd7fc2009-04-19 19:26:31 +00002686 QualType FindCompositePointerType(Expr *&E1, Expr *&E2); // C++ 5.9
Nate Begemanbe2341d2008-07-14 18:02:46 +00002687
2688 /// type checking for vector binary operators.
2689 inline QualType CheckVectorOperands(SourceLocation l, Expr *&lex, Expr *&rex);
2690 inline QualType CheckVectorCompareOperands(Expr *&lex, Expr *&rx,
2691 SourceLocation l, bool isRel);
Reid Spencer5f016e22007-07-11 17:01:13 +00002692
Steve Narofff69936d2007-09-16 03:34:24 +00002693 /// type checking unary operators (subroutines of ActOnUnaryOp).
Reid Spencer5f016e22007-07-11 17:01:13 +00002694 /// C99 6.5.3.1, 6.5.3.2, 6.5.3.4
Sebastian Redle6d5a4a2008-12-20 09:35:34 +00002695 QualType CheckIncrementDecrementOperand(Expr *op, SourceLocation OpLoc,
2696 bool isInc);
Reid Spencer5f016e22007-07-11 17:01:13 +00002697 QualType CheckAddressOfOperand(Expr *op, SourceLocation OpLoc);
2698 QualType CheckIndirectionOperand(Expr *op, SourceLocation OpLoc);
Chris Lattnerba27e2a2009-02-17 08:12:06 +00002699 QualType CheckRealImagOperand(Expr *&Op, SourceLocation OpLoc, bool isReal);
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002700
2701 /// type checking primary expressions.
Nate Begeman213541a2008-04-18 23:10:10 +00002702 QualType CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc,
Steve Naroffe1b31fe2007-07-27 22:15:19 +00002703 IdentifierInfo &Comp, SourceLocation CmpLoc);
2704
Steve Narofff0090632007-09-02 02:04:30 +00002705 /// type checking declaration initializers (C99 6.7.8)
Anders Carlsson2078bb92009-05-27 16:10:08 +00002706
Douglas Gregorf03d7c72008-11-05 15:29:30 +00002707 bool CheckInitializerTypes(Expr *&simpleInit_or_initList, QualType &declType,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002708 SourceLocation InitLoc,DeclarationName InitEntity,
Anders Carlsson0f5f2c62009-05-30 20:41:30 +00002709 bool DirectInit);
Douglas Gregorc34ee5e2009-01-29 00:45:39 +00002710 bool CheckInitList(InitListExpr *&InitList, QualType &DeclType);
Steve Naroffd0091aa2008-01-10 22:15:12 +00002711 bool CheckForConstantInitializer(Expr *e, QualType t);
Steve Naroff2fdc3742007-12-10 22:44:33 +00002712
Douglas Gregor87fd7032009-02-02 17:43:21 +00002713 bool CheckValueInitialization(QualType Type, SourceLocation Loc);
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002714
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002715 // type checking C++ declaration initializers (C++ [dcl.init]).
2716
2717 /// ReferenceCompareResult - Expresses the result of comparing two
2718 /// types (cv1 T1 and cv2 T2) to determine their compatibility for the
2719 /// purposes of initialization by reference (C++ [dcl.init.ref]p4).
2720 enum ReferenceCompareResult {
2721 /// Ref_Incompatible - The two types are incompatible, so direct
2722 /// reference binding is not possible.
2723 Ref_Incompatible = 0,
2724 /// Ref_Related - The two types are reference-related, which means
2725 /// that their unqualified forms (T1 and T2) are either the same
2726 /// or T1 is a base class of T2.
2727 Ref_Related,
2728 /// Ref_Compatible_With_Added_Qualification - The two types are
2729 /// reference-compatible with added qualification, meaning that
2730 /// they are reference-compatible and the qualifiers on T1 (cv1)
2731 /// are greater than the qualifiers on T2 (cv2).
2732 Ref_Compatible_With_Added_Qualification,
2733 /// Ref_Compatible - The two types are reference-compatible and
2734 /// have equivalent qualifiers (cv1 == cv2).
2735 Ref_Compatible
2736 };
2737
Douglas Gregor15da57e2008-10-29 02:00:59 +00002738 ReferenceCompareResult CompareReferenceRelationship(QualType T1, QualType T2,
2739 bool& DerivedToBase);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002740
Sebastian Redl3201f6b2009-04-16 17:51:27 +00002741 bool CheckReferenceInit(Expr *&simpleInit_or_initList, QualType declType,
Douglas Gregor225c41e2008-11-03 19:09:14 +00002742 ImplicitConversionSequence *ICS = 0,
Douglas Gregor09f41cf2009-01-14 15:45:31 +00002743 bool SuppressUserConversions = false,
Sebastian Redle2b68332009-04-12 17:16:29 +00002744 bool AllowExplicit = false,
2745 bool ForceRValue = false);
Douglas Gregor27c8dc02008-10-29 00:13:59 +00002746
Argyrios Kyrtzidis6c2dc4d2008-08-16 20:27:34 +00002747 /// CheckCastTypes - Check type constraints for casting between types.
Daniel Dunbar58d5ebb2008-08-20 03:55:42 +00002748 bool CheckCastTypes(SourceRange TyRange, QualType CastTy, Expr *&CastExpr);
Steve Naroffa49e1fa2008-01-22 00:55:40 +00002749
Anders Carlsson584b2472007-11-27 07:16:40 +00002750 // CheckVectorCast - check type constraints for vectors.
2751 // Since vectors are an extension, there are no C standard reference for this.
2752 // We allow casting between vectors and integer datatypes of the same size.
Anders Carlssona64db8f2007-11-27 05:51:55 +00002753 // returns true if the cast is invalid
2754 bool CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty);
2755
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002756 /// CheckMessageArgumentTypes - Check types in an Obj-C message send.
2757 /// \param Method - May be null.
2758 /// \param [out] ReturnType - The return type of the send.
2759 /// \return true iff there were any incompatible types.
Daniel Dunbar91e19b22008-09-11 00:50:25 +00002760 bool CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs, Selector Sel,
Chris Lattner077bf5e2008-11-24 03:33:13 +00002761 ObjCMethodDecl *Method, bool isClassMessage,
Daniel Dunbar637cebb2008-09-11 00:01:56 +00002762 SourceLocation lbrac, SourceLocation rbrac,
2763 QualType &ReturnType);
Argyrios Kyrtzidis59210932008-09-10 02:17:11 +00002764
2765 /// CheckCXXBooleanCondition - Returns true if conversion to bool is invalid.
2766 bool CheckCXXBooleanCondition(Expr *&CondExpr);
Steve Naroff81bfde92007-10-16 23:12:48 +00002767
Chris Lattnerf4021e72007-08-23 05:46:52 +00002768 /// ConvertIntegerToTypeWarnOnOverflow - Convert the specified APInt to have
2769 /// the specified width and sign. If an overflow occurs, detect it and emit
2770 /// the specified diagnostic.
2771 void ConvertIntegerToTypeWarnOnOverflow(llvm::APSInt &OldVal,
2772 unsigned NewWidth, bool NewSign,
2773 SourceLocation Loc, unsigned DiagID);
2774
Chris Lattnereca7be62008-04-07 05:30:13 +00002775 bool ObjCQualifiedIdTypesAreCompatible(QualType LHS, QualType RHS,
2776 bool ForCompare);
2777
Anders Carlsson15281452008-11-04 16:57:32 +00002778 /// Checks that the Objective-C declaration is declared in the global scope.
2779 /// Emits an error and marks the declaration as invalid if it's not declared
2780 /// in the global scope.
2781 bool CheckObjCDeclScope(Decl *D);
2782
Anders Carlsson7c50aca2007-10-15 20:28:48 +00002783 void InitBuiltinVaListType();
Eli Friedman1b76ada2008-06-03 21:01:11 +00002784
Anders Carlssone21555e2008-11-30 19:50:32 +00002785 /// VerifyIntegerConstantExpression - verifies that an expression is an ICE,
2786 /// and reports the appropriate diagnostics. Returns false on success.
2787 /// Can optionally return the value of the expression.
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002788 bool VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result = 0);
Anders Carlsson4000ea62008-12-01 02:17:22 +00002789
Anders Carlsson9f1e5722008-12-06 20:33:04 +00002790 /// VerifyBitField - verifies that a bit field expression is an ICE and has
2791 /// the correct width, and that the field type is valid.
2792 /// Returns false on success.
2793 bool VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName,
2794 QualType FieldTy, const Expr *BitWidth);
Sebastian Redl0eb23302009-01-19 00:08:26 +00002795
Chris Lattner59907c42007-08-10 20:18:51 +00002796 //===--------------------------------------------------------------------===//
2797 // Extra semantic analysis beyond the C type system
Chris Lattner925e60d2007-12-28 05:29:59 +00002798private:
Sebastian Redl0eb23302009-01-19 00:08:26 +00002799 Action::OwningExprResult CheckFunctionCall(FunctionDecl *FDecl,
2800 CallExpr *TheCall);
Fariborz Jahanian725165f2009-05-18 21:05:18 +00002801
2802 Action::OwningExprResult CheckBlockCall(NamedDecl *NDecl, CallExpr *TheCall);
Chris Lattner60800082009-02-18 17:49:48 +00002803 SourceLocation getLocationOfStringLiteralByte(const StringLiteral *SL,
2804 unsigned ByteNo) const;
Chris Lattner69039812009-02-18 06:01:06 +00002805 bool CheckObjCString(Expr *Arg);
Chris Lattner925e60d2007-12-28 05:29:59 +00002806 bool SemaBuiltinVAStart(CallExpr *TheCall);
2807 bool SemaBuiltinUnorderedCompare(CallExpr *TheCall);
Eli Friedman6cfda232008-05-20 08:23:37 +00002808 bool SemaBuiltinStackAddress(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00002809
2810public:
2811 // Used by C++ template instantiation.
Sebastian Redl0eb23302009-01-19 00:08:26 +00002812 Action::OwningExprResult SemaBuiltinShuffleVector(CallExpr *TheCall);
Douglas Gregorcde01732009-05-19 22:10:17 +00002813
2814private:
Daniel Dunbar4493f792008-07-21 22:59:13 +00002815 bool SemaBuiltinPrefetch(CallExpr *TheCall);
Eli Friedmand875fed2009-05-03 04:46:36 +00002816 bool SemaBuiltinObjectSize(CallExpr *TheCall);
2817 bool SemaBuiltinLongjmp(CallExpr *TheCall);
Chris Lattner5caa3702009-05-08 06:58:22 +00002818 bool SemaBuiltinAtomicOverloaded(CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00002819 bool SemaCheckStringLiteral(const Expr *E, const CallExpr *TheCall,
2820 bool HasVAListArg, unsigned format_idx,
2821 unsigned firstDataArg);
2822 void CheckPrintfString(const StringLiteral *FExpr, const Expr *OrigFormatExpr,
2823 const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002824 unsigned format_idx, unsigned firstDataArg);
Fariborz Jahaniane898f8a2009-05-21 18:48:51 +00002825 void CheckNonNullArguments(const NonNullAttr *NonNull,
2826 const CallExpr *TheCall);
Ted Kremenek082d9362009-03-20 21:35:28 +00002827 void CheckPrintfArguments(const CallExpr *TheCall, bool HasVAListArg,
Douglas Gregor3c385e52009-02-14 18:57:46 +00002828 unsigned format_idx, unsigned firstDataArg);
Ted Kremenek06de2762007-08-17 16:46:58 +00002829 void CheckReturnStackAddr(Expr *RetValExp, QualType lhsType,
2830 SourceLocation ReturnLoc);
Ted Kremenek588e5eb2007-11-25 00:58:00 +00002831 void CheckFloatComparison(SourceLocation loc, Expr* lex, Expr* rex);
Reid Spencer5f016e22007-07-11 17:01:13 +00002832};
2833
Mike Stumpb83d2872009-02-19 22:01:56 +00002834
Ted Kremenek8189cde2009-02-07 01:47:29 +00002835//===--------------------------------------------------------------------===//
2836// Typed version of Parser::ExprArg (smart pointer for wrapping Expr pointers).
2837template <typename T>
2838class ExprOwningPtr : public Action::ExprArg {
2839public:
Douglas Gregora0e500d2009-03-12 16:53:44 +00002840 ExprOwningPtr(Sema *S, T *expr) : Action::ExprArg(*S, expr) {}
Ted Kremenek8189cde2009-02-07 01:47:29 +00002841
2842 void reset(T* p) { Action::ExprArg::operator=(p); }
2843 T* get() const { return static_cast<T*>(Action::ExprArg::get()); }
2844 T* take() { return static_cast<T*>(Action::ExprArg::take()); }
2845 T* release() { return take(); }
2846
2847 T& operator*() const { return *get(); }
2848 T* operator->() const { return get(); }
2849};
Douglas Gregord7e27052009-05-20 22:33:37 +00002850
Reid Spencer5f016e22007-07-11 17:01:13 +00002851} // end namespace clang
2852
2853#endif