blob: 75fa27bed60a191f9752757c3e01ee6ce2eed771 [file] [log] [blame]
Chris Lattnera11999d2006-10-15 22:34:45 +00001//===--- Decl.cpp - Declaration AST Node Implementation -------------------===//
2//
3// The LLVM Compiler Infrastructure
4//
Chris Lattner5b12ab82007-12-29 19:59:25 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Chris Lattnera11999d2006-10-15 22:34:45 +00007//
8//===----------------------------------------------------------------------===//
9//
Argyrios Kyrtzidis63018842008-06-04 13:04:04 +000010// This file implements the Decl subclasses.
Chris Lattnera11999d2006-10-15 22:34:45 +000011//
12//===----------------------------------------------------------------------===//
13
14#include "clang/AST/Decl.h"
Chris Lattnera7b32872008-03-15 06:12:44 +000015#include "clang/AST/ASTContext.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000016#include "clang/AST/ASTMutationListener.h"
17#include "clang/AST/Attr.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000018#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclObjC.h"
20#include "clang/AST/DeclTemplate.h"
Nuno Lopes394ec982008-12-17 23:39:55 +000021#include "clang/AST/Expr.h"
Anders Carlsson714d0962009-12-15 19:16:31 +000022#include "clang/AST/ExprCXX.h"
Douglas Gregor7de59662009-05-29 20:38:28 +000023#include "clang/AST/PrettyPrinter.h"
Benjamin Kramerea70eb32012-12-01 15:09:41 +000024#include "clang/AST/Stmt.h"
25#include "clang/AST/TypeLoc.h"
Chris Lattner15ba9492009-06-14 01:54:56 +000026#include "clang/Basic/Builtins.h"
Daniel Dunbar221fa942008-08-11 04:54:23 +000027#include "clang/Basic/IdentifierTable.h"
Douglas Gregorba345522011-12-02 23:23:56 +000028#include "clang/Basic/Module.h"
Abramo Bagnara6150c882010-05-11 21:36:43 +000029#include "clang/Basic/Specifiers.h"
Douglas Gregor1baf38f2011-03-26 12:10:19 +000030#include "clang/Basic/TargetInfo.h"
John McCall06f6fe8d2009-09-04 01:14:41 +000031#include "llvm/Support/ErrorHandling.h"
John McCall5f46c482013-02-21 23:42:58 +000032#include "llvm/Support/type_traits.h"
David Blaikie9c70e042011-09-21 18:16:56 +000033#include <algorithm>
34
Chris Lattner6d9a6852006-10-25 05:11:20 +000035using namespace clang;
Chris Lattnera11999d2006-10-15 22:34:45 +000036
Richard Smith0b87e072013-10-07 08:02:11 +000037Decl *clang::getPrimaryMergedDecl(Decl *D) {
38 return D->getASTContext().getPrimaryMergedDecl(D);
39}
40
Chris Lattner88f70d62008-03-15 05:43:15 +000041//===----------------------------------------------------------------------===//
Douglas Gregor6e6ad602009-01-20 01:17:11 +000042// NamedDecl Implementation
Argyrios Kyrtzidis9e59b572008-11-09 23:41:00 +000043//===----------------------------------------------------------------------===//
44
John McCalldf25c432013-02-16 00:17:33 +000045// Visibility rules aren't rigorously externally specified, but here
46// are the basic principles behind what we implement:
47//
48// 1. An explicit visibility attribute is generally a direct expression
49// of the user's intent and should be honored. Only the innermost
50// visibility attribute applies. If no visibility attribute applies,
51// global visibility settings are considered.
52//
53// 2. There is one caveat to the above: on or in a template pattern,
54// an explicit visibility attribute is just a default rule, and
55// visibility can be decreased by the visibility of template
56// arguments. But this, too, has an exception: an attribute on an
57// explicit specialization or instantiation causes all the visibility
58// restrictions of the template arguments to be ignored.
59//
60// 3. A variable that does not otherwise have explicit visibility can
61// be restricted by the visibility of its type.
62//
63// 4. A visibility restriction is explicit if it comes from an
64// attribute (or something like it), not a global visibility setting.
65// When emitting a reference to an external symbol, visibility
66// restrictions are ignored unless they are explicit.
John McCalld041a9b2013-02-20 01:54:26 +000067//
68// 5. When computing the visibility of a non-type, including a
69// non-type member of a class, only non-type visibility restrictions
70// are considered: the 'visibility' attribute, global value-visibility
71// settings, and a few special cases like __private_extern.
72//
73// 6. When computing the visibility of a type, including a type member
74// of a class, only type visibility restrictions are considered:
75// the 'type_visibility' attribute and global type-visibility settings.
76// However, a 'visibility' attribute counts as a 'type_visibility'
77// attribute on any declaration that only has the former.
78//
79// The visibility of a "secondary" entity, like a template argument,
80// is computed using the kind of that entity, not the kind of the
81// primary entity for which we are computing visibility. For example,
82// the visibility of a specialization of either of these templates:
83// template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X);
84// template <class T, bool (&compare)(T, X)> class matcher;
85// is restricted according to the type visibility of the argument 'T',
86// the type visibility of 'bool(&)(T,X)', and the value visibility of
87// the argument function 'compare'. That 'has_match' is a value
88// and 'matcher' is a type only matters when looking for attributes
89// and settings from the immediate context.
John McCalldf25c432013-02-16 00:17:33 +000090
John McCall5f46c482013-02-21 23:42:58 +000091const unsigned IgnoreExplicitVisibilityBit = 2;
Rafael Espindola9551d3b2013-05-28 19:43:11 +000092const unsigned IgnoreAllVisibilityBit = 4;
John McCall5f46c482013-02-21 23:42:58 +000093
John McCalldf25c432013-02-16 00:17:33 +000094/// Kinds of LV computation. The linkage side of the computation is
95/// always the same, but different things can change how visibility is
96/// computed.
97enum LVComputationKind {
John McCall5f46c482013-02-21 23:42:58 +000098 /// Do an LV computation for, ultimately, a type.
99 /// Visibility may be restricted by type visibility settings and
100 /// the visibility of template arguments.
John McCalld041a9b2013-02-20 01:54:26 +0000101 LVForType = NamedDecl::VisibilityForType,
John McCalldf25c432013-02-16 00:17:33 +0000102
John McCall5f46c482013-02-21 23:42:58 +0000103 /// Do an LV computation for, ultimately, a non-type declaration.
104 /// Visibility may be restricted by value visibility settings and
105 /// the visibility of template arguments.
John McCalld041a9b2013-02-20 01:54:26 +0000106 LVForValue = NamedDecl::VisibilityForValue,
107
John McCall5f46c482013-02-21 23:42:58 +0000108 /// Do an LV computation for, ultimately, a type that already has
109 /// some sort of explicit visibility. Visibility may only be
110 /// restricted by the visibility of template arguments.
111 LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit),
John McCalld041a9b2013-02-20 01:54:26 +0000112
John McCall5f46c482013-02-21 23:42:58 +0000113 /// Do an LV computation for, ultimately, a non-type declaration
114 /// that already has some sort of explicit visibility. Visibility
115 /// may only be restricted by the visibility of template arguments.
Rafael Espindola9551d3b2013-05-28 19:43:11 +0000116 LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit),
117
118 /// Do an LV computation when we only care about the linkage.
119 LVForLinkageOnly =
120 LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit
John McCalldf25c432013-02-16 00:17:33 +0000121};
122
John McCalld041a9b2013-02-20 01:54:26 +0000123/// Does this computation kind permit us to consider additional
124/// visibility settings from attributes and the like?
125static bool hasExplicitVisibilityAlready(LVComputationKind computation) {
John McCall5f46c482013-02-21 23:42:58 +0000126 return ((unsigned(computation) & IgnoreExplicitVisibilityBit) != 0);
John McCalld041a9b2013-02-20 01:54:26 +0000127}
128
129/// Given an LVComputationKind, return one of the same type/value sort
130/// that records that it already has explicit visibility.
131static LVComputationKind
132withExplicitVisibilityAlready(LVComputationKind oldKind) {
133 LVComputationKind newKind =
John McCall5f46c482013-02-21 23:42:58 +0000134 static_cast<LVComputationKind>(unsigned(oldKind) |
135 IgnoreExplicitVisibilityBit);
John McCalld041a9b2013-02-20 01:54:26 +0000136 assert(oldKind != LVForType || newKind == LVForExplicitType);
137 assert(oldKind != LVForValue || newKind == LVForExplicitValue);
138 assert(oldKind != LVForExplicitType || newKind == LVForExplicitType);
139 assert(oldKind != LVForExplicitValue || newKind == LVForExplicitValue);
140 return newKind;
141}
142
David Blaikie05785d12013-02-20 22:23:23 +0000143static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
144 LVComputationKind kind) {
John McCalld041a9b2013-02-20 01:54:26 +0000145 assert(!hasExplicitVisibilityAlready(kind) &&
146 "asking for explicit visibility when we shouldn't be");
147 return D->getExplicitVisibility((NamedDecl::ExplicitVisibilityKind) kind);
148}
149
John McCalldf25c432013-02-16 00:17:33 +0000150/// Is the given declaration a "type" or a "value" for the purposes of
151/// visibility computation?
152static bool usesTypeVisibility(const NamedDecl *D) {
John McCallb4a99d32013-02-19 01:57:35 +0000153 return isa<TypeDecl>(D) ||
154 isa<ClassTemplateDecl>(D) ||
155 isa<ObjCInterfaceDecl>(D);
John McCalldf25c432013-02-16 00:17:33 +0000156}
157
John McCall5f46c482013-02-21 23:42:58 +0000158/// Does the given declaration have member specialization information,
159/// and if so, is it an explicit specialization?
160template <class T> static typename
161llvm::enable_if_c<!llvm::is_base_of<RedeclarableTemplateDecl, T>::value,
162 bool>::type
163isExplicitMemberSpecialization(const T *D) {
164 if (const MemberSpecializationInfo *member =
165 D->getMemberSpecializationInfo()) {
166 return member->isExplicitSpecialization();
167 }
168 return false;
169}
170
171/// For templates, this question is easier: a member template can't be
172/// explicitly instantiated, so there's a single bit indicating whether
173/// or not this is an explicit member specialization.
174static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) {
175 return D->isMemberSpecialization();
176}
177
John McCalld041a9b2013-02-20 01:54:26 +0000178/// Given a visibility attribute, return the explicit visibility
179/// associated with it.
180template <class T>
181static Visibility getVisibilityFromAttr(const T *attr) {
182 switch (attr->getVisibility()) {
183 case T::Default:
184 return DefaultVisibility;
185 case T::Hidden:
186 return HiddenVisibility;
187 case T::Protected:
188 return ProtectedVisibility;
189 }
190 llvm_unreachable("bad visibility kind");
191}
192
John McCalldf25c432013-02-16 00:17:33 +0000193/// Return the explicit visibility of the given declaration.
David Blaikie05785d12013-02-20 22:23:23 +0000194static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
John McCalld041a9b2013-02-20 01:54:26 +0000195 NamedDecl::ExplicitVisibilityKind kind) {
196 // If we're ultimately computing the visibility of a type, look for
197 // a 'type_visibility' attribute before looking for 'visibility'.
198 if (kind == NamedDecl::VisibilityForType) {
199 if (const TypeVisibilityAttr *A = D->getAttr<TypeVisibilityAttr>()) {
200 return getVisibilityFromAttr(A);
201 }
202 }
203
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000204 // If this declaration has an explicit visibility attribute, use it.
205 if (const VisibilityAttr *A = D->getAttr<VisibilityAttr>()) {
John McCalld041a9b2013-02-20 01:54:26 +0000206 return getVisibilityFromAttr(A);
John McCall457a04e2010-10-22 21:05:15 +0000207 }
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000208
209 // If we're on Mac OS X, an 'availability' for Mac OS X attribute
210 // implies visibility(default).
Douglas Gregore8bbc122011-09-02 00:18:52 +0000211 if (D->getASTContext().getTargetInfo().getTriple().isOSDarwin()) {
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000212 for (specific_attr_iterator<AvailabilityAttr>
213 A = D->specific_attr_begin<AvailabilityAttr>(),
214 AEnd = D->specific_attr_end<AvailabilityAttr>();
215 A != AEnd; ++A)
216 if ((*A)->getPlatform()->getName().equals("macosx"))
217 return DefaultVisibility;
218 }
219
David Blaikie7a30dc52013-02-21 01:47:18 +0000220 return None;
John McCall457a04e2010-10-22 21:05:15 +0000221}
222
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000223static LinkageInfo
224getLVForType(const Type &T, LVComputationKind computation) {
225 if (computation == LVForLinkageOnly)
226 return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
227 return T.getLinkageAndVisibility();
228}
229
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000230/// \brief Get the most restrictive linkage for the types in the given
John McCalldf25c432013-02-16 00:17:33 +0000231/// template parameter list. For visibility purposes, template
232/// parameters are part of the signature of a template.
Rafael Espindola2f869a32012-01-14 00:30:36 +0000233static LinkageInfo
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000234getLVForTemplateParameterList(const TemplateParameterList *params,
235 LVComputationKind computation) {
John McCalldf25c432013-02-16 00:17:33 +0000236 LinkageInfo LV;
237 for (TemplateParameterList::const_iterator P = params->begin(),
238 PEnd = params->end();
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000239 P != PEnd; ++P) {
John McCalldf25c432013-02-16 00:17:33 +0000240
241 // Template type parameters are the most common and never
242 // contribute to visibility, pack or not.
243 if (isa<TemplateTypeParmDecl>(*P))
244 continue;
245
246 // Non-type template parameters can be restricted by the value type, e.g.
247 // template <enum X> class A { ... };
248 // We have to be careful here, though, because we can be dealing with
249 // dependent types.
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000250 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) {
John McCalldf25c432013-02-16 00:17:33 +0000251 // Handle the non-pack case first.
252 if (!NTTP->isExpandedParameterPack()) {
253 if (!NTTP->getType()->isDependentType()) {
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000254 LV.merge(getLVForType(*NTTP->getType(), computation));
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000255 }
256 continue;
257 }
Rafael Espindolaeeb9d9f2012-01-02 06:26:22 +0000258
John McCalldf25c432013-02-16 00:17:33 +0000259 // Look at all the types in an expanded pack.
260 for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
261 QualType type = NTTP->getExpansionType(i);
262 if (!type->isDependentType())
Rafael Espindola6fbfafe2013-02-27 02:27:19 +0000263 LV.merge(type->getLinkageAndVisibility());
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000264 }
John McCalldf25c432013-02-16 00:17:33 +0000265 continue;
Douglas Gregor0231d8d2011-01-19 20:10:05 +0000266 }
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000267
John McCalldf25c432013-02-16 00:17:33 +0000268 // Template template parameters can be restricted by their
269 // template parameters, recursively.
270 TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(*P);
271
272 // Handle the non-pack case first.
273 if (!TTP->isExpandedParameterPack()) {
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000274 LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
275 computation));
John McCalldf25c432013-02-16 00:17:33 +0000276 continue;
277 }
278
279 // Look at all expansions in an expanded pack.
280 for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
281 i != n; ++i) {
282 LV.merge(getLVForTemplateParameterList(
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000283 TTP->getExpansionTemplateParameters(i), computation));
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000284 }
285 }
286
John McCall457a04e2010-10-22 21:05:15 +0000287 return LV;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000288}
289
Rafael Espindola19de5612013-01-12 06:42:30 +0000290/// getLVForDecl - Get the linkage and visibility for the given declaration.
John McCalldf25c432013-02-16 00:17:33 +0000291static LinkageInfo getLVForDecl(const NamedDecl *D,
292 LVComputationKind computation);
Douglas Gregorbf62d642010-12-06 18:36:25 +0000293
Eli Friedman7e346a82013-07-01 20:22:57 +0000294static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
295 const Decl *Ret = NULL;
Rafael Espindolac1b38a22013-05-16 04:30:21 +0000296 const DeclContext *DC = D->getDeclContext();
297 while (DC->getDeclKind() != Decl::TranslationUnit) {
Eli Friedman7e346a82013-07-01 20:22:57 +0000298 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
299 Ret = cast<Decl>(DC);
Rafael Espindolac1b38a22013-05-16 04:30:21 +0000300 DC = DC->getParent();
301 }
302 return Ret;
303}
304
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000305/// \brief Get the most restrictive linkage for the types and
306/// declarations in the given template argument list.
John McCalldf25c432013-02-16 00:17:33 +0000307///
308/// Note that we don't take an LVComputationKind because we always
309/// want to honor the visibility of template arguments in the same way.
310static LinkageInfo
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000311getLVForTemplateArgumentList(ArrayRef<TemplateArgument> args,
312 LVComputationKind computation) {
John McCalldf25c432013-02-16 00:17:33 +0000313 LinkageInfo LV;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000314
John McCalldf25c432013-02-16 00:17:33 +0000315 for (unsigned i = 0, e = args.size(); i != e; ++i) {
316 const TemplateArgument &arg = args[i];
317 switch (arg.getKind()) {
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000318 case TemplateArgument::Null:
319 case TemplateArgument::Integral:
320 case TemplateArgument::Expression:
John McCalldf25c432013-02-16 00:17:33 +0000321 continue;
Rafael Espindolaeeb9d9f2012-01-02 06:26:22 +0000322
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000323 case TemplateArgument::Type:
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000324 LV.merge(getLVForType(*arg.getAsType(), computation));
John McCalldf25c432013-02-16 00:17:33 +0000325 continue;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000326
327 case TemplateArgument::Declaration:
John McCalldf25c432013-02-16 00:17:33 +0000328 if (NamedDecl *ND = dyn_cast<NamedDecl>(arg.getAsDecl())) {
329 assert(!usesTypeVisibility(ND));
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000330 LV.merge(getLVForDecl(ND, computation));
John McCalldf25c432013-02-16 00:17:33 +0000331 }
332 continue;
Eli Friedmanb826a002012-09-26 02:36:12 +0000333
334 case TemplateArgument::NullPtr:
Rafael Espindola6fbfafe2013-02-27 02:27:19 +0000335 LV.merge(arg.getNullPtrType()->getLinkageAndVisibility());
John McCalldf25c432013-02-16 00:17:33 +0000336 continue;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000337
338 case TemplateArgument::Template:
Douglas Gregore4ff4b52011-01-05 18:58:31 +0000339 case TemplateArgument::TemplateExpansion:
Rafael Espindolaeeb9d9f2012-01-02 06:26:22 +0000340 if (TemplateDecl *Template
John McCalldf25c432013-02-16 00:17:33 +0000341 = arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000342 LV.merge(getLVForDecl(Template, computation));
John McCalldf25c432013-02-16 00:17:33 +0000343 continue;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000344
345 case TemplateArgument::Pack:
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000346 LV.merge(getLVForTemplateArgumentList(arg.getPackAsArray(), computation));
John McCalldf25c432013-02-16 00:17:33 +0000347 continue;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000348 }
John McCalldf25c432013-02-16 00:17:33 +0000349 llvm_unreachable("bad template argument kind");
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000350 }
351
John McCall457a04e2010-10-22 21:05:15 +0000352 return LV;
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000353}
354
Rafael Espindola2f869a32012-01-14 00:30:36 +0000355static LinkageInfo
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000356getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
357 LVComputationKind computation) {
358 return getLVForTemplateArgumentList(TArgs.asArray(), computation);
John McCall8823c652010-08-13 08:35:10 +0000359}
360
John McCall5f46c482013-02-21 23:42:58 +0000361static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn,
362 const FunctionTemplateSpecializationInfo *specInfo) {
363 // Include visibility from the template parameters and arguments
364 // only if this is not an explicit instantiation or specialization
365 // with direct explicit visibility. (Implicit instantiations won't
366 // have a direct attribute.)
367 if (!specInfo->isExplicitInstantiationOrSpecialization())
368 return true;
369
370 return !fn->hasAttr<VisibilityAttr>();
371}
372
John McCalldf25c432013-02-16 00:17:33 +0000373/// Merge in template-related linkage and visibility for the given
374/// function template specialization.
375///
376/// We don't need a computation kind here because we can assume
377/// LVForValue.
John McCall5f46c482013-02-21 23:42:58 +0000378///
NAKAMURA Takumi62eae082013-02-22 04:06:28 +0000379/// \param[out] LV the computation to use for the parent
John McCall5f46c482013-02-21 23:42:58 +0000380static void
381mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn,
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000382 const FunctionTemplateSpecializationInfo *specInfo,
383 LVComputationKind computation) {
John McCall5f46c482013-02-21 23:42:58 +0000384 bool considerVisibility =
385 shouldConsiderTemplateVisibility(fn, specInfo);
John McCalldf25c432013-02-16 00:17:33 +0000386
387 // Merge information from the template parameters.
John McCall5f46c482013-02-21 23:42:58 +0000388 FunctionTemplateDecl *temp = specInfo->getTemplate();
John McCalldf25c432013-02-16 00:17:33 +0000389 LinkageInfo tempLV =
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000390 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
John McCalldf25c432013-02-16 00:17:33 +0000391 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
392
393 // Merge information from the template arguments.
394 const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000395 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
John McCalldf25c432013-02-16 00:17:33 +0000396 LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
John McCallb8c604a2011-06-27 23:06:04 +0000397}
398
John McCall5f46c482013-02-21 23:42:58 +0000399/// Does the given declaration have a direct visibility attribute
400/// that would match the given rules?
401static bool hasDirectVisibilityAttribute(const NamedDecl *D,
402 LVComputationKind computation) {
403 switch (computation) {
404 case LVForType:
405 case LVForExplicitType:
406 if (D->hasAttr<TypeVisibilityAttr>())
407 return true;
408 // fallthrough
409 case LVForValue:
410 case LVForExplicitValue:
411 if (D->hasAttr<VisibilityAttr>())
412 return true;
413 return false;
Rafael Espindola9551d3b2013-05-28 19:43:11 +0000414 case LVForLinkageOnly:
415 return false;
John McCall5f46c482013-02-21 23:42:58 +0000416 }
417 llvm_unreachable("bad visibility computation kind");
418}
419
John McCalld041a9b2013-02-20 01:54:26 +0000420/// Should we consider visibility associated with the template
421/// arguments and parameters of the given class template specialization?
422static bool shouldConsiderTemplateVisibility(
423 const ClassTemplateSpecializationDecl *spec,
424 LVComputationKind computation) {
John McCalldf25c432013-02-16 00:17:33 +0000425 // Include visibility from the template parameters and arguments
426 // only if this is not an explicit instantiation or specialization
427 // with direct explicit visibility (and note that implicit
428 // instantiations won't have a direct attribute).
429 //
430 // Furthermore, we want to ignore template parameters and arguments
John McCalld041a9b2013-02-20 01:54:26 +0000431 // for an explicit specialization when computing the visibility of a
432 // member thereof with explicit visibility.
John McCalldf25c432013-02-16 00:17:33 +0000433 //
434 // This is a bit complex; let's unpack it.
435 //
436 // An explicit class specialization is an independent, top-level
437 // declaration. As such, if it or any of its members has an
438 // explicit visibility attribute, that must directly express the
439 // user's intent, and we should honor it. The same logic applies to
440 // an explicit instantiation of a member of such a thing.
John McCalld041a9b2013-02-20 01:54:26 +0000441
442 // Fast path: if this is not an explicit instantiation or
443 // specialization, we always want to consider template-related
444 // visibility restrictions.
445 if (!spec->isExplicitInstantiationOrSpecialization())
446 return true;
447
448 // This is the 'member thereof' check.
449 if (spec->isExplicitSpecialization() &&
450 hasExplicitVisibilityAlready(computation))
451 return false;
452
John McCall5f46c482013-02-21 23:42:58 +0000453 return !hasDirectVisibilityAttribute(spec, computation);
John McCalld041a9b2013-02-20 01:54:26 +0000454}
455
456/// Merge in template-related linkage and visibility for the given
457/// class template specialization.
458static void mergeTemplateLV(LinkageInfo &LV,
459 const ClassTemplateSpecializationDecl *spec,
460 LVComputationKind computation) {
461 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
John McCalldf25c432013-02-16 00:17:33 +0000462
463 // Merge information from the template parameters, but ignore
464 // visibility if we're only considering template arguments.
465
John McCalld041a9b2013-02-20 01:54:26 +0000466 ClassTemplateDecl *temp = spec->getSpecializedTemplate();
John McCalldf25c432013-02-16 00:17:33 +0000467 LinkageInfo tempLV =
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000468 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
John McCalldf25c432013-02-16 00:17:33 +0000469 LV.mergeMaybeWithVisibility(tempLV,
John McCalld041a9b2013-02-20 01:54:26 +0000470 considerVisibility && !hasExplicitVisibilityAlready(computation));
John McCalldf25c432013-02-16 00:17:33 +0000471
472 // Merge information from the template arguments. We ignore
473 // template-argument visibility if we've got an explicit
474 // instantiation with a visibility attribute.
475 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000476 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
Rafael Espindola503276b2013-05-30 21:23:15 +0000477 if (considerVisibility)
478 LV.mergeVisibility(argsLV);
479 LV.mergeExternalVisibility(argsLV);
John McCallb8c604a2011-06-27 23:06:04 +0000480}
481
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000482static bool useInlineVisibilityHidden(const NamedDecl *D) {
483 // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
Rafael Espindola5cc78902012-07-13 23:26:43 +0000484 const LangOptions &Opts = D->getASTContext().getLangOpts();
485 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000486 return false;
487
488 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
489 if (!FD)
490 return false;
491
492 TemplateSpecializationKind TSK = TSK_Undeclared;
493 if (FunctionTemplateSpecializationInfo *spec
494 = FD->getTemplateSpecializationInfo()) {
495 TSK = spec->getTemplateSpecializationKind();
496 } else if (MemberSpecializationInfo *MSI =
497 FD->getMemberSpecializationInfo()) {
498 TSK = MSI->getTemplateSpecializationKind();
499 }
500
501 const FunctionDecl *Def = 0;
502 // InlineVisibilityHidden only applies to definitions, and
503 // isInlined() only gives meaningful answers on definitions
504 // anyway.
505 return TSK != TSK_ExplicitInstantiationDeclaration &&
506 TSK != TSK_ExplicitInstantiationDefinition &&
Rafael Espindolafb9d4b42012-10-11 16:32:25 +0000507 FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000508}
509
Rafael Espindola593537a2013-05-05 20:15:21 +0000510template <typename T> static bool isFirstInExternCContext(T *D) {
Rafael Espindola8db352d2013-10-17 15:37:26 +0000511 const T *First = D->getFirstDecl();
Rafael Espindola593537a2013-05-05 20:15:21 +0000512 return First->isInExternCContext();
Rafael Espindolaf4187652013-02-14 01:18:37 +0000513}
514
Rafael Espindola327be3c2013-04-26 01:30:23 +0000515static bool isSingleLineExternC(const Decl &D) {
516 if (const LinkageSpecDecl *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
517 if (SD->getLanguage() == LinkageSpecDecl::lang_c && !SD->hasBraces())
518 return true;
519 return false;
520}
521
Rafael Espindola46cb6f12012-04-21 23:28:21 +0000522static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
John McCalldf25c432013-02-16 00:17:33 +0000523 LVComputationKind computation) {
Sebastian Redl50c68252010-08-31 00:36:30 +0000524 assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
Douglas Gregorf73b2822009-11-25 22:24:25 +0000525 "Not a name having namespace scope");
526 ASTContext &Context = D->getASTContext();
527
528 // C++ [basic.link]p3:
529 // A name having namespace scope (3.3.6) has internal linkage if it
530 // is the name of
531 // - an object, reference, function or function template that is
532 // explicitly declared static; or,
533 // (This bullet corresponds to C99 6.2.2p3.)
534 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
535 // Explicitly declared static.
John McCall8e7d6562010-08-26 03:08:43 +0000536 if (Var->getStorageClass() == SC_Static)
John McCallc273f242010-10-30 11:50:40 +0000537 return LinkageInfo::internal();
Douglas Gregorf73b2822009-11-25 22:24:25 +0000538
Richard Smithdc0ef452012-10-19 06:37:48 +0000539 // - a non-volatile object or reference that is explicitly declared const
540 // or constexpr and neither explicitly declared extern nor previously
541 // declared to have external linkage; or (there is no equivalent in C99)
David Blaikiebbafb8a2012-03-11 07:00:24 +0000542 if (Context.getLangOpts().CPlusPlus &&
Richard Smithdc0ef452012-10-19 06:37:48 +0000543 Var->getType().isConstQualified() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000544 !Var->getType().isVolatileQualified()) {
Rafael Espindola985a3ab2013-04-03 19:22:20 +0000545 const VarDecl *PrevVar = Var->getPreviousDecl();
Rafael Espindola985a3ab2013-04-03 19:22:20 +0000546 if (PrevVar)
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000547 return getLVForDecl(PrevVar, computation);
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000548
549 if (Var->getStorageClass() != SC_Extern &&
Rafael Espindola327be3c2013-04-26 01:30:23 +0000550 Var->getStorageClass() != SC_PrivateExtern &&
551 !isSingleLineExternC(*Var))
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000552 return LinkageInfo::internal();
553 }
554
555 for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
556 PrevVar = PrevVar->getPreviousDecl()) {
557 if (PrevVar->getStorageClass() == SC_PrivateExtern &&
558 Var->getStorageClass() == SC_None)
559 return PrevVar->getLinkageAndVisibility();
560 // Explicitly declared static.
561 if (PrevVar->getStorageClass() == SC_Static)
562 return LinkageInfo::internal();
Fariborz Jahanian8feee2d2011-06-16 20:14:50 +0000563 }
Douglas Gregorf73b2822009-11-25 22:24:25 +0000564 } else if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) {
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000565 // C++ [temp]p4:
566 // A non-member function template can have internal linkage; any
567 // other template name shall have external linkage.
Douglas Gregorf73b2822009-11-25 22:24:25 +0000568 const FunctionDecl *Function = 0;
569 if (const FunctionTemplateDecl *FunTmpl
570 = dyn_cast<FunctionTemplateDecl>(D))
571 Function = FunTmpl->getTemplatedDecl();
572 else
573 Function = cast<FunctionDecl>(D);
574
575 // Explicitly declared static.
Rafael Espindola6ae7e502013-04-03 19:27:57 +0000576 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
John McCallc273f242010-10-30 11:50:40 +0000577 return LinkageInfo(InternalLinkage, DefaultVisibility, false);
Douglas Gregorf73b2822009-11-25 22:24:25 +0000578 }
David Majnemer0eb8bbd2013-10-23 20:52:43 +0000579 // - a data member of an anonymous union.
580 assert(!isa<IndirectFieldDecl>(D) && "Didn't expect an IndirectFieldDecl!");
581 assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!");
Douglas Gregorf73b2822009-11-25 22:24:25 +0000582
Chandler Carruth9682a2fd2011-02-24 19:03:39 +0000583 if (D->isInAnonymousNamespace()) {
584 const VarDecl *Var = dyn_cast<VarDecl>(D);
585 const FunctionDecl *Func = dyn_cast<FunctionDecl>(D);
Rafael Espindola593537a2013-05-05 20:15:21 +0000586 if ((!Var || !isFirstInExternCContext(Var)) &&
587 (!Func || !isFirstInExternCContext(Func)))
Chandler Carruth9682a2fd2011-02-24 19:03:39 +0000588 return LinkageInfo::uniqueExternal();
589 }
John McCallb7139c42010-10-28 04:18:25 +0000590
John McCall457a04e2010-10-22 21:05:15 +0000591 // Set up the defaults.
592
593 // C99 6.2.2p5:
594 // If the declaration of an identifier for an object has file
595 // scope and no storage-class specifier, its linkage is
596 // external.
John McCallc273f242010-10-30 11:50:40 +0000597 LinkageInfo LV;
598
John McCalld041a9b2013-02-20 01:54:26 +0000599 if (!hasExplicitVisibilityAlready(computation)) {
David Blaikie05785d12013-02-20 22:23:23 +0000600 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
Rafael Espindola7a5543d2012-04-19 02:22:07 +0000601 LV.mergeVisibility(*Vis, true);
Rafael Espindola78158af2012-04-16 18:46:26 +0000602 } else {
603 // If we're declared in a namespace with a visibility attribute,
John McCalldf25c432013-02-16 00:17:33 +0000604 // use that namespace's visibility, and it still counts as explicit.
Rafael Espindola78158af2012-04-16 18:46:26 +0000605 for (const DeclContext *DC = D->getDeclContext();
606 !isa<TranslationUnitDecl>(DC);
607 DC = DC->getParent()) {
608 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC);
609 if (!ND) continue;
David Blaikie05785d12013-02-20 22:23:23 +0000610 if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
Rafael Espindola7a5543d2012-04-19 02:22:07 +0000611 LV.mergeVisibility(*Vis, true);
Rafael Espindola78158af2012-04-16 18:46:26 +0000612 break;
613 }
614 }
615 }
Rafael Espindola78158af2012-04-16 18:46:26 +0000616
John McCalldf25c432013-02-16 00:17:33 +0000617 // Add in global settings if the above didn't give us direct visibility.
Rafael Espindola4a5da442013-02-27 02:56:45 +0000618 if (!LV.isVisibilityExplicit()) {
John McCallb4a99d32013-02-19 01:57:35 +0000619 // Use global type/value visibility as appropriate.
620 Visibility globalVisibility;
621 if (computation == LVForValue) {
622 globalVisibility = Context.getLangOpts().getValueVisibilityMode();
623 } else {
624 assert(computation == LVForType);
625 globalVisibility = Context.getLangOpts().getTypeVisibilityMode();
626 }
627 LV.mergeVisibility(globalVisibility, /*explicit*/ false);
John McCalldf25c432013-02-16 00:17:33 +0000628
629 // If we're paying attention to global visibility, apply
630 // -finline-visibility-hidden if this is an inline method.
631 if (useInlineVisibilityHidden(D))
632 LV.mergeVisibility(HiddenVisibility, true);
633 }
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000634 }
Rafael Espindolaaf690f52012-04-19 02:55:01 +0000635
Douglas Gregorf73b2822009-11-25 22:24:25 +0000636 // C++ [basic.link]p4:
John McCall457a04e2010-10-22 21:05:15 +0000637
Douglas Gregorf73b2822009-11-25 22:24:25 +0000638 // A name having namespace scope has external linkage if it is the
639 // name of
640 //
641 // - an object or reference, unless it has internal linkage; or
642 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
John McCall37bb6c92010-10-29 22:22:43 +0000643 // GCC applies the following optimization to variables and static
644 // data members, but not to functions:
645 //
John McCall457a04e2010-10-22 21:05:15 +0000646 // Modify the variable's LV by the LV of its type unless this is
647 // C or extern "C". This follows from [basic.link]p9:
648 // A type without linkage shall not be used as the type of a
649 // variable or function with external linkage unless
650 // - the entity has C language linkage, or
651 // - the entity is declared within an unnamed namespace, or
652 // - the entity is not used or is defined in the same
653 // translation unit.
654 // and [basic.link]p10:
655 // ...the types specified by all declarations referring to a
656 // given variable or function shall be identical...
657 // C does not have an equivalent rule.
658 //
John McCall5fe84122010-10-26 04:59:26 +0000659 // Ignore this if we've got an explicit attribute; the user
660 // probably knows what they're doing.
661 //
John McCall457a04e2010-10-22 21:05:15 +0000662 // Note that we don't want to make the variable non-external
663 // because of this, but unique-external linkage suits us.
Rafael Espindola593537a2013-05-05 20:15:21 +0000664 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var)) {
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000665 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
Rafael Espindola4a5da442013-02-27 02:56:45 +0000666 if (TypeLV.getLinkage() != ExternalLinkage)
John McCallc273f242010-10-30 11:50:40 +0000667 return LinkageInfo::uniqueExternal();
Rafael Espindola4a5da442013-02-27 02:56:45 +0000668 if (!LV.isVisibilityExplicit())
John McCalldf25c432013-02-16 00:17:33 +0000669 LV.mergeVisibility(TypeLV);
John McCall37bb6c92010-10-29 22:22:43 +0000670 }
671
John McCall23032652010-11-02 18:38:13 +0000672 if (Var->getStorageClass() == SC_PrivateExtern)
Rafael Espindola7a5543d2012-04-19 02:22:07 +0000673 LV.mergeVisibility(HiddenVisibility, true);
John McCall23032652010-11-02 18:38:13 +0000674
Rafael Espindolad5ed0332012-11-12 04:10:23 +0000675 // Note that Sema::MergeVarDecl already takes care of implementing
676 // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
677 // to do it here.
Douglas Gregorf73b2822009-11-25 22:24:25 +0000678
Douglas Gregorf73b2822009-11-25 22:24:25 +0000679 // - a function, unless it has internal linkage; or
John McCall457a04e2010-10-22 21:05:15 +0000680 } else if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
John McCall2efaf112010-10-28 07:07:52 +0000681 // In theory, we can modify the function's LV by the LV of its
682 // type unless it has C linkage (see comment above about variables
683 // for justification). In practice, GCC doesn't do this, so it's
684 // just too painful to make work.
John McCall457a04e2010-10-22 21:05:15 +0000685
John McCall23032652010-11-02 18:38:13 +0000686 if (Function->getStorageClass() == SC_PrivateExtern)
Rafael Espindola7a5543d2012-04-19 02:22:07 +0000687 LV.mergeVisibility(HiddenVisibility, true);
John McCall23032652010-11-02 18:38:13 +0000688
Rafael Espindolaa508c5d2012-11-21 02:47:19 +0000689 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
690 // merging storage classes and visibility attributes, so we don't have to
691 // look at previous decls in here.
Douglas Gregorf73b2822009-11-25 22:24:25 +0000692
John McCallf768aa72011-02-10 06:50:24 +0000693 // In C++, then if the type of the function uses a type with
694 // unique-external linkage, it's not legally usable from outside
695 // this translation unit. However, we should use the C linkage
696 // rules instead for extern "C" declarations.
David Blaikiebbafb8a2012-03-11 07:00:24 +0000697 if (Context.getLangOpts().CPlusPlus &&
Richard Smith50f4afc2013-05-12 23:17:59 +0000698 !Function->isInExternCContext()) {
699 // Only look at the type-as-written. If this function has an auto-deduced
700 // return type, we can't compute the linkage of that type because it could
701 // require looking at the linkage of this function, and we don't need this
702 // for correctness because the type is not part of the function's
703 // signature.
Faisal Valid2598e92013-10-08 04:15:04 +0000704 // FIXME: This is a hack. We should be able to solve this circularity and
705 // the one in getLVForClassMember for Functions some other way.
Richard Smith50f4afc2013-05-12 23:17:59 +0000706 QualType TypeAsWritten = Function->getType();
707 if (TypeSourceInfo *TSI = Function->getTypeSourceInfo())
708 TypeAsWritten = TSI->getType();
709 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage)
710 return LinkageInfo::uniqueExternal();
711 }
John McCallf768aa72011-02-10 06:50:24 +0000712
John McCall5f46c482013-02-21 23:42:58 +0000713 // Consider LV from the template and the template arguments.
714 // We're at file scope, so we do not need to worry about nested
715 // specializations.
John McCallb8c604a2011-06-27 23:06:04 +0000716 if (FunctionTemplateSpecializationInfo *specInfo
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000717 = Function->getTemplateSpecializationInfo()) {
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000718 mergeTemplateLV(LV, Function, specInfo, computation);
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000719 }
720
Douglas Gregorf73b2822009-11-25 22:24:25 +0000721 // - a named class (Clause 9), or an unnamed class defined in a
722 // typedef declaration in which the class has the typedef name
723 // for linkage purposes (7.1.3); or
724 // - a named enumeration (7.2), or an unnamed enumeration
725 // defined in a typedef declaration in which the enumeration
726 // has the typedef name for linkage purposes (7.1.3); or
John McCall457a04e2010-10-22 21:05:15 +0000727 } else if (const TagDecl *Tag = dyn_cast<TagDecl>(D)) {
728 // Unnamed tags have no linkage.
John McCall5ea95772013-03-09 00:54:27 +0000729 if (!Tag->hasNameForLinkage())
John McCallc273f242010-10-30 11:50:40 +0000730 return LinkageInfo::none();
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000731
John McCall457a04e2010-10-22 21:05:15 +0000732 // If this is a class template specialization, consider the
John McCall5f46c482013-02-21 23:42:58 +0000733 // linkage of the template and template arguments. We're at file
734 // scope, so we do not need to worry about nested specializations.
John McCallb8c604a2011-06-27 23:06:04 +0000735 if (const ClassTemplateSpecializationDecl *spec
John McCall457a04e2010-10-22 21:05:15 +0000736 = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
John McCalldf25c432013-02-16 00:17:33 +0000737 mergeTemplateLV(LV, spec, computation);
Douglas Gregor7dc5c172010-02-03 09:33:45 +0000738 }
Douglas Gregorf73b2822009-11-25 22:24:25 +0000739
740 // - an enumerator belonging to an enumeration with external linkage;
John McCall457a04e2010-10-22 21:05:15 +0000741 } else if (isa<EnumConstantDecl>(D)) {
Rafael Espindola46cb6f12012-04-21 23:28:21 +0000742 LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
John McCalldf25c432013-02-16 00:17:33 +0000743 computation);
Rafael Espindolab97e8962013-05-27 14:14:42 +0000744 if (!isExternalFormalLinkage(EnumLV.getLinkage()))
John McCallc273f242010-10-30 11:50:40 +0000745 return LinkageInfo::none();
746 LV.merge(EnumLV);
Douglas Gregorf73b2822009-11-25 22:24:25 +0000747
748 // - a template, unless it is a function template that has
749 // internal linkage (Clause 14);
John McCall8bc6d5b2011-03-04 10:39:25 +0000750 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) {
John McCalld041a9b2013-02-20 01:54:26 +0000751 bool considerVisibility = !hasExplicitVisibilityAlready(computation);
John McCalldf25c432013-02-16 00:17:33 +0000752 LinkageInfo tempLV =
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000753 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
John McCalldf25c432013-02-16 00:17:33 +0000754 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
755
Douglas Gregorf73b2822009-11-25 22:24:25 +0000756 // - a namespace (7.3), unless it is declared within an unnamed
757 // namespace.
John McCall457a04e2010-10-22 21:05:15 +0000758 } else if (isa<NamespaceDecl>(D) && !D->isInAnonymousNamespace()) {
759 return LV;
Douglas Gregorf73b2822009-11-25 22:24:25 +0000760
John McCall457a04e2010-10-22 21:05:15 +0000761 // By extension, we assign external linkage to Objective-C
762 // interfaces.
763 } else if (isa<ObjCInterfaceDecl>(D)) {
764 // fallout
765
766 // Everything not covered here has no linkage.
767 } else {
John McCallc273f242010-10-30 11:50:40 +0000768 return LinkageInfo::none();
John McCall457a04e2010-10-22 21:05:15 +0000769 }
770
771 // If we ended up with non-external linkage, visibility should
772 // always be default.
Rafael Espindola4a5da442013-02-27 02:56:45 +0000773 if (LV.getLinkage() != ExternalLinkage)
774 return LinkageInfo(LV.getLinkage(), DefaultVisibility, false);
John McCall457a04e2010-10-22 21:05:15 +0000775
John McCall457a04e2010-10-22 21:05:15 +0000776 return LV;
Douglas Gregorf73b2822009-11-25 22:24:25 +0000777}
778
John McCalldf25c432013-02-16 00:17:33 +0000779static LinkageInfo getLVForClassMember(const NamedDecl *D,
780 LVComputationKind computation) {
John McCall457a04e2010-10-22 21:05:15 +0000781 // Only certain class members have linkage. Note that fields don't
782 // really have linkage, but it's convenient to say they do for the
783 // purposes of calculating linkage of pointer-to-data-member
784 // template arguments.
John McCall8823c652010-08-13 08:35:10 +0000785 if (!(isa<CXXMethodDecl>(D) ||
786 isa<VarDecl>(D) ||
John McCall457a04e2010-10-22 21:05:15 +0000787 isa<FieldDecl>(D) ||
David Majnemer0eb8bbd2013-10-23 20:52:43 +0000788 isa<IndirectFieldDecl>(D) ||
David Blaikie095deba2012-11-14 01:52:05 +0000789 isa<TagDecl>(D)))
John McCallc273f242010-10-30 11:50:40 +0000790 return LinkageInfo::none();
John McCall8823c652010-08-13 08:35:10 +0000791
John McCall07072662010-11-02 01:45:15 +0000792 LinkageInfo LV;
793
John McCall07072662010-11-02 01:45:15 +0000794 // If we have an explicit visibility attribute, merge that in.
John McCalld041a9b2013-02-20 01:54:26 +0000795 if (!hasExplicitVisibilityAlready(computation)) {
David Blaikie05785d12013-02-20 22:23:23 +0000796 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation))
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000797 LV.mergeVisibility(*Vis, true);
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000798 // If we're paying attention to global visibility, apply
799 // -finline-visibility-hidden if this is an inline method.
800 //
801 // Note that we do this before merging information about
802 // the class visibility.
Rafael Espindola4a5da442013-02-27 02:56:45 +0000803 if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D))
Rafael Espindolac7c7ad52012-07-13 14:25:36 +0000804 LV.mergeVisibility(HiddenVisibility, true);
John McCall07072662010-11-02 01:45:15 +0000805 }
Rafael Espindola53cf2192012-04-19 05:50:08 +0000806
807 // If this class member has an explicit visibility attribute, the only
808 // thing that can change its visibility is the template arguments, so
Sylvestre Ledru830885c2012-07-23 08:59:39 +0000809 // only look for them when processing the class.
John McCalld041a9b2013-02-20 01:54:26 +0000810 LVComputationKind classComputation = computation;
Rafael Espindola4a5da442013-02-27 02:56:45 +0000811 if (LV.isVisibilityExplicit())
John McCalld041a9b2013-02-20 01:54:26 +0000812 classComputation = withExplicitVisibilityAlready(computation);
Rafael Espindola505a7c82012-04-16 18:25:01 +0000813
John McCall5f46c482013-02-21 23:42:58 +0000814 LinkageInfo classLV =
815 getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
John McCall8823c652010-08-13 08:35:10 +0000816 // If the class already has unique-external linkage, we can't improve.
Rafael Espindola4a5da442013-02-27 02:56:45 +0000817 if (classLV.getLinkage() == UniqueExternalLinkage)
John McCallc273f242010-10-30 11:50:40 +0000818 return LinkageInfo::uniqueExternal();
John McCall8823c652010-08-13 08:35:10 +0000819
Rafael Espindolae6190db2013-05-28 02:22:10 +0000820 if (!isExternallyVisible(classLV.getLinkage()))
821 return LinkageInfo::none();
822
823
John McCall5f46c482013-02-21 23:42:58 +0000824 // Otherwise, don't merge in classLV yet, because in certain cases
825 // we need to completely ignore the visibility from it.
826
827 // Specifically, if this decl exists and has an explicit attribute.
828 const NamedDecl *explicitSpecSuppressor = 0;
829
John McCall8823c652010-08-13 08:35:10 +0000830 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
John McCallf768aa72011-02-10 06:50:24 +0000831 // If the type of the function uses a type with unique-external
832 // linkage, it's not legally usable from outside this translation unit.
Faisal Valid2598e92013-10-08 04:15:04 +0000833 // But only look at the type-as-written. If this function has an auto-deduced
834 // return type, we can't compute the linkage of that type because it could
835 // require looking at the linkage of this function, and we don't need this
836 // for correctness because the type is not part of the function's
837 // signature.
838 // FIXME: This is a hack. We should be able to solve this circularity and the
839 // one in getLVForNamespaceScopeDecl for Functions some other way.
840 {
841 QualType TypeAsWritten = MD->getType();
842 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
843 TypeAsWritten = TSI->getType();
844 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage)
845 return LinkageInfo::uniqueExternal();
846 }
John McCall457a04e2010-10-22 21:05:15 +0000847 // If this is a method template specialization, use the linkage for
848 // the template parameters and arguments.
John McCallb8c604a2011-06-27 23:06:04 +0000849 if (FunctionTemplateSpecializationInfo *spec
John McCall8823c652010-08-13 08:35:10 +0000850 = MD->getTemplateSpecializationInfo()) {
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000851 mergeTemplateLV(LV, MD, spec, computation);
John McCall5f46c482013-02-21 23:42:58 +0000852 if (spec->isExplicitSpecialization()) {
853 explicitSpecSuppressor = MD;
854 } else if (isExplicitMemberSpecialization(spec->getTemplate())) {
855 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
856 }
857 } else if (isExplicitMemberSpecialization(MD)) {
858 explicitSpecSuppressor = MD;
John McCalle6e622e2010-11-01 01:29:57 +0000859 }
John McCall457a04e2010-10-22 21:05:15 +0000860
John McCall37bb6c92010-10-29 22:22:43 +0000861 } else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
John McCallb8c604a2011-06-27 23:06:04 +0000862 if (const ClassTemplateSpecializationDecl *spec
John McCall37bb6c92010-10-29 22:22:43 +0000863 = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
John McCalldf25c432013-02-16 00:17:33 +0000864 mergeTemplateLV(LV, spec, computation);
John McCall5f46c482013-02-21 23:42:58 +0000865 if (spec->isExplicitSpecialization()) {
866 explicitSpecSuppressor = spec;
867 } else {
868 const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
869 if (isExplicitMemberSpecialization(temp)) {
870 explicitSpecSuppressor = temp->getTemplatedDecl();
871 }
872 }
873 } else if (isExplicitMemberSpecialization(RD)) {
874 explicitSpecSuppressor = RD;
John McCall37bb6c92010-10-29 22:22:43 +0000875 }
876
John McCall37bb6c92010-10-29 22:22:43 +0000877 // Static data members.
878 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
John McCall36cd5cc2010-10-30 09:18:49 +0000879 // Modify the variable's linkage by its type, but ignore the
880 // type's visibility unless it's a definition.
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000881 LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
Rafael Espindola503276b2013-05-30 21:23:15 +0000882 if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
883 LV.mergeVisibility(typeLV);
884 LV.mergeExternalVisibility(typeLV);
John McCall5f46c482013-02-21 23:42:58 +0000885
886 if (isExplicitMemberSpecialization(VD)) {
887 explicitSpecSuppressor = VD;
888 }
John McCalldf25c432013-02-16 00:17:33 +0000889
890 // Template members.
891 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) {
892 bool considerVisibility =
Rafael Espindola4a5da442013-02-27 02:56:45 +0000893 (!LV.isVisibilityExplicit() &&
894 !classLV.isVisibilityExplicit() &&
John McCalld041a9b2013-02-20 01:54:26 +0000895 !hasExplicitVisibilityAlready(computation));
John McCalldf25c432013-02-16 00:17:33 +0000896 LinkageInfo tempLV =
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000897 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
John McCalldf25c432013-02-16 00:17:33 +0000898 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
John McCall5f46c482013-02-21 23:42:58 +0000899
900 if (const RedeclarableTemplateDecl *redeclTemp =
901 dyn_cast<RedeclarableTemplateDecl>(temp)) {
902 if (isExplicitMemberSpecialization(redeclTemp)) {
903 explicitSpecSuppressor = temp->getTemplatedDecl();
904 }
905 }
John McCall37bb6c92010-10-29 22:22:43 +0000906 }
907
John McCall5f46c482013-02-21 23:42:58 +0000908 // We should never be looking for an attribute directly on a template.
909 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
910
911 // If this member is an explicit member specialization, and it has
912 // an explicit attribute, ignore visibility from the parent.
913 bool considerClassVisibility = true;
914 if (explicitSpecSuppressor &&
Rafael Espindola4a5da442013-02-27 02:56:45 +0000915 // optimization: hasDVA() is true only with explicit visibility.
916 LV.isVisibilityExplicit() &&
917 classLV.getVisibility() != DefaultVisibility &&
John McCall5f46c482013-02-21 23:42:58 +0000918 hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
919 considerClassVisibility = false;
920 }
921
922 // Finally, merge in information from the class.
923 LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
John McCall457a04e2010-10-22 21:05:15 +0000924 return LV;
John McCall8823c652010-08-13 08:35:10 +0000925}
926
David Blaikie68e081d2011-12-20 02:48:34 +0000927void NamedDecl::anchor() { }
928
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000929static LinkageInfo computeLVForDecl(const NamedDecl *D,
930 LVComputationKind computation);
931
Rafael Espindola0e0d0092013-03-14 03:07:35 +0000932bool NamedDecl::isLinkageValid() const {
Rafael Espindola50df3a02013-05-25 17:16:20 +0000933 if (!hasCachedLinkage())
Rafael Espindola0e0d0092013-03-14 03:07:35 +0000934 return true;
John McCalld396b972011-02-08 19:01:05 +0000935
Rafael Espindolaecf63c62013-05-29 04:55:30 +0000936 return computeLVForDecl(this, LVForLinkageOnly).getLinkage() ==
Rafael Espindola50df3a02013-05-25 17:16:20 +0000937 getCachedLinkage();
John McCalld396b972011-02-08 19:01:05 +0000938}
939
Rafael Espindola3ae00052013-05-13 00:12:11 +0000940Linkage NamedDecl::getLinkageInternal() const {
John McCalld041a9b2013-02-20 01:54:26 +0000941 // We don't care about visibility here, so ask for the cheapest
942 // possible visibility analysis.
Rafael Espindola9551d3b2013-05-28 19:43:11 +0000943 return getLVForDecl(this, LVForLinkageOnly).getLinkage();
Douglas Gregorbf62d642010-12-06 18:36:25 +0000944}
945
John McCallc273f242010-10-30 11:50:40 +0000946LinkageInfo NamedDecl::getLinkageAndVisibility() const {
John McCalldf25c432013-02-16 00:17:33 +0000947 LVComputationKind computation =
948 (usesTypeVisibility(this) ? LVForType : LVForValue);
Rafael Espindola9551d3b2013-05-28 19:43:11 +0000949 return getLVForDecl(this, computation);
John McCall033caa52010-10-29 00:29:13 +0000950}
Ted Kremenek926d8602010-04-20 23:15:35 +0000951
David Blaikie05785d12013-02-20 22:23:23 +0000952Optional<Visibility>
John McCalld041a9b2013-02-20 01:54:26 +0000953NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const {
Rafael Espindola3a52c442013-02-26 19:33:14 +0000954 // Check the declaration itself first.
955 if (Optional<Visibility> V = getVisibilityOf(this, kind))
956 return V;
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000957
Rafael Espindola3a52c442013-02-26 19:33:14 +0000958 // If this is a member class of a specialization of a class template
959 // and the corresponding decl has explicit visibility, use that.
960 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(this)) {
961 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
962 if (InstantiatedFrom)
963 return getVisibilityOf(InstantiatedFrom, kind);
964 }
965
966 // If there wasn't explicit visibility there, and this is a
967 // specialization of a class template, check for visibility
968 // on the pattern.
969 if (const ClassTemplateSpecializationDecl *spec
970 = dyn_cast<ClassTemplateSpecializationDecl>(this))
971 return getVisibilityOf(spec->getSpecializedTemplate()->getTemplatedDecl(),
972 kind);
973
974 // Use the most recent declaration.
Rafael Espindola7b56f6c2013-10-19 16:55:03 +0000975 const NamedDecl *MostRecent = getMostRecentDecl();
Rafael Espindola3a52c442013-02-26 19:33:14 +0000976 if (MostRecent != this)
977 return MostRecent->getExplicitVisibility(kind);
978
979 if (const VarDecl *Var = dyn_cast<VarDecl>(this)) {
Rafael Espindola96e68242012-05-16 02:10:38 +0000980 if (Var->isStaticDataMember()) {
981 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
982 if (InstantiatedFrom)
John McCalld041a9b2013-02-20 01:54:26 +0000983 return getVisibilityOf(InstantiatedFrom, kind);
Rafael Espindola96e68242012-05-16 02:10:38 +0000984 }
985
David Blaikie7a30dc52013-02-21 01:47:18 +0000986 return None;
Rafael Espindola96e68242012-05-16 02:10:38 +0000987 }
Rafael Espindola3a52c442013-02-26 19:33:14 +0000988 // Also handle function template specializations.
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000989 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(this)) {
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000990 // If the function is a specialization of a template with an
991 // explicit visibility attribute, use that.
992 if (FunctionTemplateSpecializationInfo *templateInfo
993 = fn->getTemplateSpecializationInfo())
John McCalld041a9b2013-02-20 01:54:26 +0000994 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
995 kind);
Douglas Gregor1baf38f2011-03-26 12:10:19 +0000996
Rafael Espindola8093fdf2012-02-23 04:17:32 +0000997 // If the function is a member of a specialization of a class template
998 // and the corresponding decl has explicit visibility, use that.
999 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
1000 if (InstantiatedFrom)
John McCalld041a9b2013-02-20 01:54:26 +00001001 return getVisibilityOf(InstantiatedFrom, kind);
Rafael Espindola8093fdf2012-02-23 04:17:32 +00001002
David Blaikie7a30dc52013-02-21 01:47:18 +00001003 return None;
Douglas Gregor1baf38f2011-03-26 12:10:19 +00001004 }
1005
Rafael Espindolafb4263f2012-07-31 19:02:02 +00001006 // The visibility of a template is stored in the templated decl.
1007 if (const TemplateDecl *TD = dyn_cast<TemplateDecl>(this))
John McCalld041a9b2013-02-20 01:54:26 +00001008 return getVisibilityOf(TD->getTemplatedDecl(), kind);
Rafael Espindolafb4263f2012-07-31 19:02:02 +00001009
David Blaikie7a30dc52013-02-21 01:47:18 +00001010 return None;
Douglas Gregor1baf38f2011-03-26 12:10:19 +00001011}
1012
Eli Friedman7e346a82013-07-01 20:22:57 +00001013static LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl,
1014 LVComputationKind computation) {
1015 // This lambda has its linkage/visibility determined by its owner.
1016 if (ContextDecl) {
1017 if (isa<ParmVarDecl>(ContextDecl))
1018 DC = ContextDecl->getDeclContext()->getRedeclContext();
1019 else
1020 return getLVForDecl(cast<NamedDecl>(ContextDecl), computation);
1021 }
Faisal Vali98b8e182013-09-29 20:27:06 +00001022
Eli Friedman7e346a82013-07-01 20:22:57 +00001023 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC))
1024 return getLVForDecl(ND, computation);
Faisal Vali98b8e182013-09-29 20:27:06 +00001025
Eli Friedman7e346a82013-07-01 20:22:57 +00001026 return LinkageInfo::external();
1027}
1028
John McCalldf25c432013-02-16 00:17:33 +00001029static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
1030 LVComputationKind computation) {
1031 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1032 if (Function->isInAnonymousNamespace() &&
Rafael Espindola593537a2013-05-05 20:15:21 +00001033 !Function->isInExternCContext())
John McCalldf25c432013-02-16 00:17:33 +00001034 return LinkageInfo::uniqueExternal();
1035
1036 // This is a "void f();" which got merged with a file static.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001037 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
John McCalldf25c432013-02-16 00:17:33 +00001038 return LinkageInfo::internal();
1039
1040 LinkageInfo LV;
John McCalld041a9b2013-02-20 01:54:26 +00001041 if (!hasExplicitVisibilityAlready(computation)) {
David Blaikie05785d12013-02-20 22:23:23 +00001042 if (Optional<Visibility> Vis =
1043 getExplicitVisibility(Function, computation))
John McCalldf25c432013-02-16 00:17:33 +00001044 LV.mergeVisibility(*Vis, true);
1045 }
1046
1047 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
1048 // merging storage classes and visibility attributes, so we don't have to
1049 // look at previous decls in here.
1050
1051 return LV;
1052 }
1053
1054 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001055 if (Var->hasExternalStorage()) {
Rafael Espindola593537a2013-05-05 20:15:21 +00001056 if (Var->isInAnonymousNamespace() && !Var->isInExternCContext())
John McCalldf25c432013-02-16 00:17:33 +00001057 return LinkageInfo::uniqueExternal();
1058
John McCalldf25c432013-02-16 00:17:33 +00001059 LinkageInfo LV;
1060 if (Var->getStorageClass() == SC_PrivateExtern)
1061 LV.mergeVisibility(HiddenVisibility, true);
John McCalld041a9b2013-02-20 01:54:26 +00001062 else if (!hasExplicitVisibilityAlready(computation)) {
David Blaikie05785d12013-02-20 22:23:23 +00001063 if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
John McCalldf25c432013-02-16 00:17:33 +00001064 LV.mergeVisibility(*Vis, true);
1065 }
1066
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001067 if (const VarDecl *Prev = Var->getPreviousDecl()) {
1068 LinkageInfo PrevLV = getLVForDecl(Prev, computation);
1069 if (PrevLV.getLinkage())
1070 LV.setLinkage(PrevLV.getLinkage());
1071 LV.mergeVisibility(PrevLV);
1072 }
1073
John McCalldf25c432013-02-16 00:17:33 +00001074 return LV;
1075 }
Rafael Espindolaa4184182013-06-17 20:04:51 +00001076
1077 if (!Var->isStaticLocal())
1078 return LinkageInfo::none();
John McCalldf25c432013-02-16 00:17:33 +00001079 }
1080
Rafael Espindolaa4184182013-06-17 20:04:51 +00001081 ASTContext &Context = D->getASTContext();
1082 if (!Context.getLangOpts().CPlusPlus)
Rafael Espindola50df3a02013-05-25 17:16:20 +00001083 return LinkageInfo::none();
1084
Eli Friedman7e346a82013-07-01 20:22:57 +00001085 const Decl *OuterD = getOutermostFuncOrBlockContext(D);
1086 if (!OuterD)
Rafael Espindola50df3a02013-05-25 17:16:20 +00001087 return LinkageInfo::none();
Rafael Espindola52189362013-06-04 13:43:35 +00001088
Eli Friedman7e346a82013-07-01 20:22:57 +00001089 LinkageInfo LV;
1090 if (const BlockDecl *BD = dyn_cast<BlockDecl>(OuterD)) {
1091 if (!BD->getBlockManglingNumber())
1092 return LinkageInfo::none();
Rafael Espindola52189362013-06-04 13:43:35 +00001093
Eli Friedman7e346a82013-07-01 20:22:57 +00001094 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1095 BD->getBlockManglingContextDecl(), computation);
1096 } else {
1097 const FunctionDecl *FD = cast<FunctionDecl>(OuterD);
1098 if (!FD->isInlined() &&
1099 FD->getTemplateSpecializationKind() == TSK_Undeclared)
1100 return LinkageInfo::none();
1101
1102 LV = getLVForDecl(FD, computation);
1103 }
Rafael Espindola111bb2e2013-05-27 14:50:21 +00001104 if (!isExternallyVisible(LV.getLinkage()))
Rafael Espindola50df3a02013-05-25 17:16:20 +00001105 return LinkageInfo::none();
1106 return LinkageInfo(VisibleNoLinkage, LV.getVisibility(),
1107 LV.isVisibilityExplicit());
John McCalldf25c432013-02-16 00:17:33 +00001108}
1109
Faisal Vali49b4c1f2013-10-01 02:51:53 +00001110static inline const CXXRecordDecl*
1111getOutermostEnclosingLambda(const CXXRecordDecl *Record) {
1112 const CXXRecordDecl *Ret = Record;
1113 while (Record && Record->isLambda()) {
1114 Ret = Record;
1115 if (!Record->getParent()) break;
1116 // Get the Containing Class of this Lambda Class
1117 Record = dyn_cast_or_null<CXXRecordDecl>(
1118 Record->getParent()->getParent());
1119 }
1120 return Ret;
1121}
1122
Rafael Espindola9551d3b2013-05-28 19:43:11 +00001123static LinkageInfo computeLVForDecl(const NamedDecl *D,
1124 LVComputationKind computation) {
Ted Kremenek926d8602010-04-20 23:15:35 +00001125 // Objective-C: treat all Objective-C declarations as having external
1126 // linkage.
John McCall033caa52010-10-29 00:29:13 +00001127 switch (D->getKind()) {
Ted Kremenek926d8602010-04-20 23:15:35 +00001128 default:
1129 break;
Argyrios Kyrtzidis79d04282011-12-01 01:28:21 +00001130 case Decl::ParmVar:
1131 return LinkageInfo::none();
John McCall457a04e2010-10-22 21:05:15 +00001132 case Decl::TemplateTemplateParm: // count these as external
1133 case Decl::NonTypeTemplateParm:
Ted Kremenek926d8602010-04-20 23:15:35 +00001134 case Decl::ObjCAtDefsField:
1135 case Decl::ObjCCategory:
1136 case Decl::ObjCCategoryImpl:
Ted Kremenek926d8602010-04-20 23:15:35 +00001137 case Decl::ObjCCompatibleAlias:
Ted Kremenek926d8602010-04-20 23:15:35 +00001138 case Decl::ObjCImplementation:
Ted Kremenek926d8602010-04-20 23:15:35 +00001139 case Decl::ObjCMethod:
1140 case Decl::ObjCProperty:
1141 case Decl::ObjCPropertyImpl:
1142 case Decl::ObjCProtocol:
John McCallc273f242010-10-30 11:50:40 +00001143 return LinkageInfo::external();
Douglas Gregor6f88e5e2012-02-21 04:17:39 +00001144
1145 case Decl::CXXRecord: {
1146 const CXXRecordDecl *Record = cast<CXXRecordDecl>(D);
1147 if (Record->isLambda()) {
1148 if (!Record->getLambdaManglingNumber()) {
1149 // This lambda has no mangling number, so it's internal.
1150 return LinkageInfo::internal();
1151 }
Douglas Gregor6f88e5e2012-02-21 04:17:39 +00001152
Faisal Vali49b4c1f2013-10-01 02:51:53 +00001153 // This lambda has its linkage/visibility determined:
1154 // - either by the outermost lambda if that lambda has no mangling
1155 // number.
1156 // - or by the parent of the outer most lambda
1157 // This prevents infinite recursion in settings such as nested lambdas
1158 // used in NSDMI's, for e.g.
1159 // struct L {
1160 // int t{};
1161 // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);
1162 // };
1163 const CXXRecordDecl *OuterMostLambda =
1164 getOutermostEnclosingLambda(Record);
1165 if (!OuterMostLambda->getLambdaManglingNumber())
1166 return LinkageInfo::internal();
1167
1168 return getLVForClosure(
1169 OuterMostLambda->getDeclContext()->getRedeclContext(),
1170 OuterMostLambda->getLambdaContextDecl(), computation);
Douglas Gregor6f88e5e2012-02-21 04:17:39 +00001171 }
1172
1173 break;
1174 }
Ted Kremenek926d8602010-04-20 23:15:35 +00001175 }
1176
Douglas Gregorf73b2822009-11-25 22:24:25 +00001177 // Handle linkage for namespace-scope names.
John McCall033caa52010-10-29 00:29:13 +00001178 if (D->getDeclContext()->getRedeclContext()->isFileContext())
John McCalldf25c432013-02-16 00:17:33 +00001179 return getLVForNamespaceScopeDecl(D, computation);
Douglas Gregorf73b2822009-11-25 22:24:25 +00001180
1181 // C++ [basic.link]p5:
1182 // In addition, a member function, static data member, a named
1183 // class or enumeration of class scope, or an unnamed class or
1184 // enumeration defined in a class-scope typedef declaration such
1185 // that the class or enumeration has the typedef name for linkage
1186 // purposes (7.1.3), has external linkage if the name of the class
1187 // has external linkage.
John McCall033caa52010-10-29 00:29:13 +00001188 if (D->getDeclContext()->isRecord())
John McCalldf25c432013-02-16 00:17:33 +00001189 return getLVForClassMember(D, computation);
Douglas Gregorf73b2822009-11-25 22:24:25 +00001190
1191 // C++ [basic.link]p6:
1192 // The name of a function declared in block scope and the name of
1193 // an object declared by a block scope extern declaration have
1194 // linkage. If there is a visible declaration of an entity with
1195 // linkage having the same name and type, ignoring entities
1196 // declared outside the innermost enclosing namespace scope, the
1197 // block scope declaration declares that same entity and receives
1198 // the linkage of the previous declaration. If there is more than
1199 // one such matching entity, the program is ill-formed. Otherwise,
1200 // if no matching entity is found, the block scope entity receives
1201 // external linkage.
John McCalldf25c432013-02-16 00:17:33 +00001202 if (D->getDeclContext()->isFunctionOrMethod())
1203 return getLVForLocalDecl(D, computation);
Douglas Gregorf73b2822009-11-25 22:24:25 +00001204
1205 // C++ [basic.link]p6:
1206 // Names not covered by these rules have no linkage.
John McCallc273f242010-10-30 11:50:40 +00001207 return LinkageInfo::none();
John McCall457a04e2010-10-22 21:05:15 +00001208}
Douglas Gregorf73b2822009-11-25 22:24:25 +00001209
Rafael Espindola9551d3b2013-05-28 19:43:11 +00001210namespace clang {
1211class LinkageComputer {
1212public:
1213 static LinkageInfo getLVForDecl(const NamedDecl *D,
1214 LVComputationKind computation) {
1215 if (computation == LVForLinkageOnly && D->hasCachedLinkage())
1216 return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
1217
1218 LinkageInfo LV = computeLVForDecl(D, computation);
1219 if (D->hasCachedLinkage())
1220 assert(D->getCachedLinkage() == LV.getLinkage());
1221
1222 D->setCachedLinkage(LV.getLinkage());
1223
1224#ifndef NDEBUG
1225 // In C (because of gnu inline) and in c++ with microsoft extensions an
1226 // static can follow an extern, so we can have two decls with different
1227 // linkages.
1228 const LangOptions &Opts = D->getASTContext().getLangOpts();
1229 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1230 return LV;
1231
1232 // We have just computed the linkage for this decl. By induction we know
1233 // that all other computed linkages match, check that the one we just
1234 // computed
1235 // also does.
1236 NamedDecl *Old = NULL;
1237 for (NamedDecl::redecl_iterator I = D->redecls_begin(),
1238 E = D->redecls_end();
1239 I != E; ++I) {
1240 NamedDecl *T = cast<NamedDecl>(*I);
1241 if (T == D)
1242 continue;
1243 if (T->hasCachedLinkage()) {
1244 Old = T;
1245 break;
1246 }
1247 }
1248 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
1249#endif
1250
1251 return LV;
1252 }
1253};
1254}
1255
1256static LinkageInfo getLVForDecl(const NamedDecl *D,
1257 LVComputationKind computation) {
1258 return clang::LinkageComputer::getLVForDecl(D, computation);
1259}
1260
Douglas Gregor2ada0482009-02-04 17:27:36 +00001261std::string NamedDecl::getQualifiedNameAsString() const {
Douglas Gregor78254c82012-03-27 23:34:16 +00001262 return getQualifiedNameAsString(getASTContext().getPrintingPolicy());
Anders Carlsson2fb08242009-09-08 18:24:21 +00001263}
1264
1265std::string NamedDecl::getQualifiedNameAsString(const PrintingPolicy &P) const {
Benjamin Kramer24ebf7c2013-02-23 13:53:57 +00001266 std::string QualName;
1267 llvm::raw_string_ostream OS(QualName);
1268 printQualifiedName(OS, P);
1269 return OS.str();
1270}
1271
1272void NamedDecl::printQualifiedName(raw_ostream &OS) const {
1273 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1274}
1275
1276void NamedDecl::printQualifiedName(raw_ostream &OS,
1277 const PrintingPolicy &P) const {
Douglas Gregor2ada0482009-02-04 17:27:36 +00001278 const DeclContext *Ctx = getDeclContext();
1279
Benjamin Kramer24ebf7c2013-02-23 13:53:57 +00001280 if (Ctx->isFunctionOrMethod()) {
1281 printName(OS);
1282 return;
1283 }
Douglas Gregor2ada0482009-02-04 17:27:36 +00001284
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001285 typedef SmallVector<const DeclContext *, 8> ContextsTy;
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001286 ContextsTy Contexts;
1287
1288 // Collect contexts.
1289 while (Ctx && isa<NamedDecl>(Ctx)) {
1290 Contexts.push_back(Ctx);
1291 Ctx = Ctx->getParent();
Benjamin Kramer24ebf7c2013-02-23 13:53:57 +00001292 }
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001293
1294 for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend();
1295 I != E; ++I) {
Mike Stump11289f42009-09-09 15:08:12 +00001296 if (const ClassTemplateSpecializationDecl *Spec
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001297 = dyn_cast<ClassTemplateSpecializationDecl>(*I)) {
Benjamin Kramer9170e912013-02-22 15:46:01 +00001298 OS << Spec->getName();
Douglas Gregor85673582009-05-18 17:01:57 +00001299 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
Benjamin Kramer9170e912013-02-22 15:46:01 +00001300 TemplateSpecializationType::PrintTemplateArgumentList(OS,
1301 TemplateArgs.data(),
1302 TemplateArgs.size(),
1303 P);
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001304 } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) {
Sam Weinig07d211e2009-12-24 23:15:03 +00001305 if (ND->isAnonymousNamespace())
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001306 OS << "<anonymous namespace>";
Sam Weinig07d211e2009-12-24 23:15:03 +00001307 else
Benjamin Kramerb89514a2011-10-14 18:45:37 +00001308 OS << *ND;
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001309 } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) {
1310 if (!RD->getIdentifier())
1311 OS << "<anonymous " << RD->getKindName() << '>';
1312 else
Benjamin Kramerb89514a2011-10-14 18:45:37 +00001313 OS << *RD;
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001314 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
Sam Weinigb999f682009-12-28 03:19:38 +00001315 const FunctionProtoType *FT = 0;
1316 if (FD->hasWrittenPrototype())
Eli Friedman5c27c4c2012-08-30 22:22:09 +00001317 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
Sam Weinigb999f682009-12-28 03:19:38 +00001318
Benjamin Kramerb89514a2011-10-14 18:45:37 +00001319 OS << *FD << '(';
Sam Weinigb999f682009-12-28 03:19:38 +00001320 if (FT) {
Sam Weinigb999f682009-12-28 03:19:38 +00001321 unsigned NumParams = FD->getNumParams();
1322 for (unsigned i = 0; i < NumParams; ++i) {
1323 if (i)
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001324 OS << ", ";
Argyrios Kyrtzidisa18347e2012-05-05 04:20:37 +00001325 OS << FD->getParamDecl(i)->getType().stream(P);
Sam Weinigb999f682009-12-28 03:19:38 +00001326 }
1327
1328 if (FT->isVariadic()) {
1329 if (NumParams > 0)
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001330 OS << ", ";
1331 OS << "...";
Sam Weinigb999f682009-12-28 03:19:38 +00001332 }
1333 }
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001334 OS << ')';
1335 } else {
Benjamin Kramerb89514a2011-10-14 18:45:37 +00001336 OS << *cast<NamedDecl>(*I);
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001337 }
1338 OS << "::";
Douglas Gregor2ada0482009-02-04 17:27:36 +00001339 }
1340
John McCalla2a3f7d2010-03-16 21:48:18 +00001341 if (getDeclName())
Benjamin Kramerb89514a2011-10-14 18:45:37 +00001342 OS << *this;
John McCalla2a3f7d2010-03-16 21:48:18 +00001343 else
Benjamin Kramerd76b6982010-04-28 14:33:51 +00001344 OS << "<anonymous>";
Benjamin Kramer24ebf7c2013-02-23 13:53:57 +00001345}
Douglas Gregor2ada0482009-02-04 17:27:36 +00001346
Benjamin Kramer24ebf7c2013-02-23 13:53:57 +00001347void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
1348 const PrintingPolicy &Policy,
1349 bool Qualified) const {
1350 if (Qualified)
1351 printQualifiedName(OS, Policy);
1352 else
1353 printName(OS);
Douglas Gregor2ada0482009-02-04 17:27:36 +00001354}
1355
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001356bool NamedDecl::declarationReplaces(NamedDecl *OldD) const {
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001357 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch");
1358
Douglas Gregor889ceb72009-02-03 19:21:40 +00001359 // UsingDirectiveDecl's are not really NamedDecl's, and all have same name.
1360 // We want to keep it, unless it nominates same namespace.
1361 if (getKind() == Decl::UsingDirective) {
Douglas Gregor12441b32011-02-25 16:33:46 +00001362 return cast<UsingDirectiveDecl>(this)->getNominatedNamespace()
1363 ->getOriginalNamespace() ==
1364 cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace()
1365 ->getOriginalNamespace();
Douglas Gregor889ceb72009-02-03 19:21:40 +00001366 }
Mike Stump11289f42009-09-09 15:08:12 +00001367
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001368 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this))
1369 // For function declarations, we keep track of redeclarations.
Douglas Gregorec9fd132012-01-14 16:38:05 +00001370 return FD->getPreviousDecl() == OldD;
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001371
Douglas Gregorad3f2fc2009-06-25 22:08:12 +00001372 // For function templates, the underlying function declarations are linked.
1373 if (const FunctionTemplateDecl *FunctionTemplate
1374 = dyn_cast<FunctionTemplateDecl>(this))
1375 if (const FunctionTemplateDecl *OldFunctionTemplate
1376 = dyn_cast<FunctionTemplateDecl>(OldD))
1377 return FunctionTemplate->getTemplatedDecl()
1378 ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl());
Mike Stump11289f42009-09-09 15:08:12 +00001379
Steve Naroffc4173fa2009-02-22 19:35:57 +00001380 // For method declarations, we keep track of redeclarations.
1381 if (isa<ObjCMethodDecl>(this))
1382 return false;
Mike Stump11289f42009-09-09 15:08:12 +00001383
John McCall9f3059a2009-10-09 21:13:30 +00001384 if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD))
1385 return true;
1386
John McCall3f746822009-11-17 05:59:44 +00001387 if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD))
1388 return cast<UsingShadowDecl>(this)->getTargetDecl() ==
1389 cast<UsingShadowDecl>(OldD)->getTargetDecl();
1390
Douglas Gregora9d87bc2011-02-25 00:36:19 +00001391 if (isa<UsingDecl>(this) && isa<UsingDecl>(OldD)) {
1392 ASTContext &Context = getASTContext();
1393 return Context.getCanonicalNestedNameSpecifier(
1394 cast<UsingDecl>(this)->getQualifier()) ==
1395 Context.getCanonicalNestedNameSpecifier(
1396 cast<UsingDecl>(OldD)->getQualifier());
1397 }
Argyrios Kyrtzidis4b520072010-11-04 08:48:52 +00001398
Eli Friedman0eaf10b2013-08-20 00:39:40 +00001399 if (isa<UnresolvedUsingValueDecl>(this) &&
1400 isa<UnresolvedUsingValueDecl>(OldD)) {
1401 ASTContext &Context = getASTContext();
1402 return Context.getCanonicalNestedNameSpecifier(
1403 cast<UnresolvedUsingValueDecl>(this)->getQualifier()) ==
1404 Context.getCanonicalNestedNameSpecifier(
1405 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1406 }
1407
Douglas Gregorb59643b2012-01-03 23:26:26 +00001408 // A typedef of an Objective-C class type can replace an Objective-C class
1409 // declaration or definition, and vice versa.
1410 if ((isa<TypedefNameDecl>(this) && isa<ObjCInterfaceDecl>(OldD)) ||
1411 (isa<ObjCInterfaceDecl>(this) && isa<TypedefNameDecl>(OldD)))
1412 return true;
1413
Douglas Gregor8b9ccca2008-12-23 21:05:05 +00001414 // For non-function declarations, if the declarations are of the
1415 // same kind then this must be a redeclaration, or semantic analysis
1416 // would not have given us the new declaration.
1417 return this->getKind() == OldD->getKind();
1418}
1419
Douglas Gregoreddf4332009-02-24 20:03:32 +00001420bool NamedDecl::hasLinkage() const {
Rafael Espindola50df3a02013-05-25 17:16:20 +00001421 return getFormalLinkage() != NoLinkage;
Douglas Gregoreddf4332009-02-24 20:03:32 +00001422}
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001423
Daniel Dunbar166ea9ad2012-03-08 18:20:41 +00001424NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
Anders Carlsson6915bf62009-06-26 06:29:23 +00001425 NamedDecl *ND = this;
Benjamin Kramerba0495a2012-03-08 21:00:45 +00001426 while (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND))
1427 ND = UD->getTargetDecl();
1428
1429 if (ObjCCompatibleAliasDecl *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1430 return AD->getClassInterface();
1431
1432 return ND;
Anders Carlsson6915bf62009-06-26 06:29:23 +00001433}
1434
John McCalla8ae2222010-04-06 21:38:20 +00001435bool NamedDecl::isCXXInstanceMember() const {
Douglas Gregor3f28ec22012-03-08 02:08:05 +00001436 if (!isCXXClassMember())
1437 return false;
1438
John McCalla8ae2222010-04-06 21:38:20 +00001439 const NamedDecl *D = this;
1440 if (isa<UsingShadowDecl>(D))
1441 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1442
John McCall5e77d762013-04-16 07:28:30 +00001443 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
John McCalla8ae2222010-04-06 21:38:20 +00001444 return true;
1445 if (isa<CXXMethodDecl>(D))
1446 return cast<CXXMethodDecl>(D)->isInstance();
1447 if (isa<FunctionTemplateDecl>(D))
1448 return cast<CXXMethodDecl>(cast<FunctionTemplateDecl>(D)
1449 ->getTemplatedDecl())->isInstance();
1450 return false;
1451}
1452
Argyrios Kyrtzidis9e59b572008-11-09 23:41:00 +00001453//===----------------------------------------------------------------------===//
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00001454// DeclaratorDecl Implementation
1455//===----------------------------------------------------------------------===//
1456
Douglas Gregorec9c6ae2010-07-06 18:42:40 +00001457template <typename DeclT>
1458static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) {
1459 if (decl->getNumTemplateParameterLists() > 0)
1460 return decl->getTemplateParameterList(0)->getTemplateLoc();
1461 else
1462 return decl->getInnerLocStart();
1463}
1464
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00001465SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const {
John McCallf7bcc812010-05-28 23:32:21 +00001466 TypeSourceInfo *TSI = getTypeSourceInfo();
1467 if (TSI) return TSI->getTypeLoc().getBeginLoc();
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00001468 return SourceLocation();
1469}
1470
Douglas Gregor14454802011-02-25 02:25:35 +00001471void DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
1472 if (QualifierLoc) {
John McCall3e11ebe2010-03-15 10:12:16 +00001473 // Make sure the extended decl info is allocated.
1474 if (!hasExtInfo()) {
1475 // Save (non-extended) type source info pointer.
1476 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1477 // Allocate external info struct.
1478 DeclInfo = new (getASTContext()) ExtInfo;
1479 // Restore savedTInfo into (extended) decl info.
1480 getExtInfo()->TInfo = savedTInfo;
1481 }
1482 // Set qualifier info.
Douglas Gregor14454802011-02-25 02:25:35 +00001483 getExtInfo()->QualifierLoc = QualifierLoc;
Chad Rosier6fdf38b2011-08-17 23:08:45 +00001484 } else {
John McCall3e11ebe2010-03-15 10:12:16 +00001485 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
John McCall3e11ebe2010-03-15 10:12:16 +00001486 if (hasExtInfo()) {
Abramo Bagnara60804e12011-03-18 15:16:37 +00001487 if (getExtInfo()->NumTemplParamLists == 0) {
1488 // Save type source info pointer.
1489 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo;
1490 // Deallocate the extended decl info.
1491 getASTContext().Deallocate(getExtInfo());
1492 // Restore savedTInfo into (non-extended) decl info.
1493 DeclInfo = savedTInfo;
1494 }
1495 else
1496 getExtInfo()->QualifierLoc = QualifierLoc;
John McCall3e11ebe2010-03-15 10:12:16 +00001497 }
1498 }
1499}
1500
Abramo Bagnara60804e12011-03-18 15:16:37 +00001501void
1502DeclaratorDecl::setTemplateParameterListsInfo(ASTContext &Context,
1503 unsigned NumTPLists,
1504 TemplateParameterList **TPLists) {
1505 assert(NumTPLists > 0);
1506 // Make sure the extended decl info is allocated.
1507 if (!hasExtInfo()) {
1508 // Save (non-extended) type source info pointer.
1509 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1510 // Allocate external info struct.
1511 DeclInfo = new (getASTContext()) ExtInfo;
1512 // Restore savedTInfo into (extended) decl info.
1513 getExtInfo()->TInfo = savedTInfo;
1514 }
1515 // Set the template parameter lists info.
1516 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists);
1517}
1518
Douglas Gregorec9c6ae2010-07-06 18:42:40 +00001519SourceLocation DeclaratorDecl::getOuterLocStart() const {
1520 return getTemplateOrInnerLocStart(this);
1521}
1522
Abramo Bagnaraea947882011-03-08 16:41:52 +00001523namespace {
1524
1525// Helper function: returns true if QT is or contains a type
1526// having a postfix component.
1527bool typeIsPostfix(clang::QualType QT) {
1528 while (true) {
1529 const Type* T = QT.getTypePtr();
1530 switch (T->getTypeClass()) {
1531 default:
1532 return false;
1533 case Type::Pointer:
1534 QT = cast<PointerType>(T)->getPointeeType();
1535 break;
1536 case Type::BlockPointer:
1537 QT = cast<BlockPointerType>(T)->getPointeeType();
1538 break;
1539 case Type::MemberPointer:
1540 QT = cast<MemberPointerType>(T)->getPointeeType();
1541 break;
1542 case Type::LValueReference:
1543 case Type::RValueReference:
1544 QT = cast<ReferenceType>(T)->getPointeeType();
1545 break;
1546 case Type::PackExpansion:
1547 QT = cast<PackExpansionType>(T)->getPattern();
1548 break;
1549 case Type::Paren:
1550 case Type::ConstantArray:
1551 case Type::DependentSizedArray:
1552 case Type::IncompleteArray:
1553 case Type::VariableArray:
1554 case Type::FunctionProto:
1555 case Type::FunctionNoProto:
1556 return true;
1557 }
1558 }
1559}
1560
1561} // namespace
1562
1563SourceRange DeclaratorDecl::getSourceRange() const {
1564 SourceLocation RangeEnd = getLocation();
1565 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
1566 if (typeIsPostfix(TInfo->getType()))
1567 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
1568 }
1569 return SourceRange(getOuterLocStart(), RangeEnd);
1570}
1571
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00001572void
Douglas Gregor20527e22010-06-15 17:44:38 +00001573QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context,
1574 unsigned NumTPLists,
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00001575 TemplateParameterList **TPLists) {
1576 assert((NumTPLists == 0 || TPLists != 0) &&
1577 "Empty array of template parameters with positive size!");
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00001578
1579 // Free previous template parameters (if any).
1580 if (NumTemplParamLists > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +00001581 Context.Deallocate(TemplParamLists);
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00001582 TemplParamLists = 0;
1583 NumTemplParamLists = 0;
1584 }
1585 // Set info on matched template parameter lists (if any).
1586 if (NumTPLists > 0) {
Douglas Gregor20527e22010-06-15 17:44:38 +00001587 TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
Abramo Bagnarada41d0c2010-06-12 08:15:14 +00001588 NumTemplParamLists = NumTPLists;
1589 for (unsigned i = NumTPLists; i-- > 0; )
1590 TemplParamLists[i] = TPLists[i];
1591 }
1592}
1593
Argyrios Kyrtzidis6032ef12009-08-21 00:31:54 +00001594//===----------------------------------------------------------------------===//
Nuno Lopes394ec982008-12-17 23:39:55 +00001595// VarDecl Implementation
1596//===----------------------------------------------------------------------===//
1597
Sebastian Redl833ef452010-01-26 22:01:41 +00001598const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
1599 switch (SC) {
Peter Collingbourne2dbb7082011-09-19 21:14:35 +00001600 case SC_None: break;
Peter Collingbourne9a8f1532011-09-20 12:40:26 +00001601 case SC_Auto: return "auto";
1602 case SC_Extern: return "extern";
1603 case SC_OpenCLWorkGroupLocal: return "<<work-group-local>>";
1604 case SC_PrivateExtern: return "__private_extern__";
1605 case SC_Register: return "register";
1606 case SC_Static: return "static";
Sebastian Redl833ef452010-01-26 22:01:41 +00001607 }
1608
Peter Collingbourne9a8f1532011-09-20 12:40:26 +00001609 llvm_unreachable("Invalid storage class");
Sebastian Redl833ef452010-01-26 22:01:41 +00001610}
1611
Larisse Voufo39a1e502013-08-06 01:03:05 +00001612VarDecl::VarDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
1613 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1614 TypeSourceInfo *TInfo, StorageClass SC)
1615 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc), Init() {
1616 assert(sizeof(VarDeclBitfields) <= sizeof(unsigned));
1617 assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned));
1618 AllBits = 0;
1619 VarDeclBits.SClass = SC;
1620 // Everything else is implicitly initialized to false.
1621}
1622
Abramo Bagnaradff19302011-03-08 08:55:46 +00001623VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
1624 SourceLocation StartL, SourceLocation IdL,
John McCallbcd03502009-12-07 02:54:59 +00001625 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001626 StorageClass S) {
Richard Smithf7981722013-11-22 09:01:48 +00001627 return new (C, DC) VarDecl(Var, DC, StartL, IdL, Id, T, TInfo, S);
Nuno Lopes394ec982008-12-17 23:39:55 +00001628}
1629
Douglas Gregor72172e92012-01-05 21:55:30 +00001630VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00001631 return new (C, ID) VarDecl(Var, 0, SourceLocation(), SourceLocation(), 0,
1632 QualType(), 0, SC_None);
Douglas Gregor72172e92012-01-05 21:55:30 +00001633}
1634
Douglas Gregorbf62d642010-12-06 18:36:25 +00001635void VarDecl::setStorageClass(StorageClass SC) {
1636 assert(isLegalForVariable(SC));
John McCallbeaa11c2011-05-01 02:13:58 +00001637 VarDeclBits.SClass = SC;
Douglas Gregorbf62d642010-12-06 18:36:25 +00001638}
1639
Douglas Gregorec9c6ae2010-07-06 18:42:40 +00001640SourceRange VarDecl::getSourceRange() const {
Argyrios Kyrtzidise0d64972012-10-08 23:08:41 +00001641 if (const Expr *Init = getInit()) {
1642 SourceLocation InitEnd = Init->getLocEnd();
Nico Weberbbe13942013-01-22 17:00:09 +00001643 // If Init is implicit, ignore its source range and fallback on
1644 // DeclaratorDecl::getSourceRange() to handle postfix elements.
1645 if (InitEnd.isValid() && InitEnd != getLocation())
Argyrios Kyrtzidise0d64972012-10-08 23:08:41 +00001646 return SourceRange(getOuterLocStart(), InitEnd);
1647 }
Abramo Bagnaraea947882011-03-08 16:41:52 +00001648 return DeclaratorDecl::getSourceRange();
Argyrios Kyrtzidisa3aeb5a2009-06-20 08:09:14 +00001649}
1650
Rafael Espindola88510672013-01-04 21:18:45 +00001651template<typename T>
Rafael Espindolaf4187652013-02-14 01:18:37 +00001652static LanguageLinkage getLanguageLinkageTemplate(const T &D) {
Rafael Espindola5bda63f2013-02-14 01:47:04 +00001653 // C++ [dcl.link]p1: All function types, function names with external linkage,
1654 // and variable names with external linkage have a language linkage.
Rafael Espindola3ae00052013-05-13 00:12:11 +00001655 if (!D.hasExternalFormalLinkage())
Rafael Espindola5bda63f2013-02-14 01:47:04 +00001656 return NoLanguageLinkage;
1657
1658 // Language linkage is a C++ concept, but saying that everything else in C has
Rafael Espindola66748e92013-01-04 20:41:40 +00001659 // C language linkage fits the implementation nicely.
Rafael Espindola576127d2012-12-28 14:21:58 +00001660 ASTContext &Context = D.getASTContext();
1661 if (!Context.getLangOpts().CPlusPlus)
Rafael Espindolaf4187652013-02-14 01:18:37 +00001662 return CLanguageLinkage;
1663
Rafael Espindola5bda63f2013-02-14 01:47:04 +00001664 // C++ [dcl.link]p4: A C language linkage is ignored in determining the
1665 // language linkage of the names of class members and the function type of
1666 // class member functions.
Rafael Espindola576127d2012-12-28 14:21:58 +00001667 const DeclContext *DC = D.getDeclContext();
1668 if (DC->isRecord())
Rafael Espindolaf4187652013-02-14 01:18:37 +00001669 return CXXLanguageLinkage;
Rafael Espindola576127d2012-12-28 14:21:58 +00001670
1671 // If the first decl is in an extern "C" context, any other redeclaration
1672 // will have C language linkage. If the first one is not in an extern "C"
1673 // context, we would have reported an error for any other decl being in one.
Rafael Espindola593537a2013-05-05 20:15:21 +00001674 if (isFirstInExternCContext(&D))
Rafael Espindolaf4187652013-02-14 01:18:37 +00001675 return CLanguageLinkage;
1676 return CXXLanguageLinkage;
Rafael Espindola576127d2012-12-28 14:21:58 +00001677}
1678
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001679template<typename T>
1680static bool isExternCTemplate(const T &D) {
1681 // Since the context is ignored for class members, they can only have C++
1682 // language linkage or no language linkage.
1683 const DeclContext *DC = D.getDeclContext();
1684 if (DC->isRecord()) {
1685 assert(D.getASTContext().getLangOpts().CPlusPlus);
1686 return false;
1687 }
1688
1689 return D.getLanguageLinkage() == CLanguageLinkage;
1690}
1691
Rafael Espindolaf4187652013-02-14 01:18:37 +00001692LanguageLinkage VarDecl::getLanguageLinkage() const {
1693 return getLanguageLinkageTemplate(*this);
Rafael Espindola576127d2012-12-28 14:21:58 +00001694}
1695
Rafael Espindola0e0d0092013-03-14 03:07:35 +00001696bool VarDecl::isExternC() const {
1697 return isExternCTemplate(*this);
1698}
1699
Rafael Espindola593537a2013-05-05 20:15:21 +00001700bool VarDecl::isInExternCContext() const {
Serge Pavlov3cb80222013-11-14 02:13:03 +00001701 return getLexicalDeclContext()->isExternCContext();
Rafael Espindola593537a2013-05-05 20:15:21 +00001702}
1703
1704bool VarDecl::isInExternCXXContext() const {
Serge Pavlov3cb80222013-11-14 02:13:03 +00001705 return getLexicalDeclContext()->isExternCXXContext();
Rafael Espindola593537a2013-05-05 20:15:21 +00001706}
1707
Rafael Espindola8db352d2013-10-17 15:37:26 +00001708VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); }
Sebastian Redl833ef452010-01-26 22:01:41 +00001709
Daniel Dunbar9d355812012-03-09 01:51:51 +00001710VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition(
1711 ASTContext &C) const
1712{
Sebastian Redl35351a92010-01-31 22:27:38 +00001713 // C++ [basic.def]p2:
1714 // A declaration is a definition unless [...] it contains the 'extern'
1715 // specifier or a linkage-specification and neither an initializer [...],
1716 // it declares a static data member in a class declaration [...].
Richard Smith8809a0c2013-09-27 20:14:12 +00001717 // C++1y [temp.expl.spec]p15:
1718 // An explicit specialization of a static data member or an explicit
1719 // specialization of a static data member template is a definition if the
1720 // declaration includes an initializer; otherwise, it is a declaration.
1721 //
1722 // FIXME: How do you declare (but not define) a partial specialization of
1723 // a static data member template outside the containing class?
Sebastian Redl35351a92010-01-31 22:27:38 +00001724 if (isStaticDataMember()) {
Richard Smith8809a0c2013-09-27 20:14:12 +00001725 if (isOutOfLine() &&
1726 (hasInit() ||
1727 // If the first declaration is out-of-line, this may be an
1728 // instantiation of an out-of-line partial specialization of a variable
1729 // template for which we have not yet instantiated the initializer.
Rafael Espindola8db352d2013-10-17 15:37:26 +00001730 (getFirstDecl()->isOutOfLine()
Richard Smith8809a0c2013-09-27 20:14:12 +00001731 ? getTemplateSpecializationKind() == TSK_Undeclared
1732 : getTemplateSpecializationKind() !=
1733 TSK_ExplicitSpecialization) ||
1734 isa<VarTemplatePartialSpecializationDecl>(this)))
Sebastian Redl35351a92010-01-31 22:27:38 +00001735 return Definition;
1736 else
1737 return DeclarationOnly;
1738 }
1739 // C99 6.7p5:
1740 // A definition of an identifier is a declaration for that identifier that
1741 // [...] causes storage to be reserved for that object.
1742 // Note: that applies for all non-file-scope objects.
1743 // C99 6.9.2p1:
1744 // If the declaration of an identifier for an object has file scope and an
1745 // initializer, the declaration is an external definition for the identifier
1746 if (hasInit())
1747 return Definition;
Rafael Espindolabff59562013-04-25 12:11:36 +00001748
Rafael Espindolad53ffa02013-10-22 21:39:03 +00001749 if (hasAttr<AliasAttr>())
1750 return Definition;
1751
Richard Smith8809a0c2013-09-27 20:14:12 +00001752 // A variable template specialization (other than a static data member
1753 // template or an explicit specialization) is a declaration until we
1754 // instantiate its initializer.
1755 if (isa<VarTemplateSpecializationDecl>(this) &&
1756 getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
1757 return DeclarationOnly;
1758
Sebastian Redl35351a92010-01-31 22:27:38 +00001759 if (hasExternalStorage())
1760 return DeclarationOnly;
Rafael Espindola8f326a52013-03-07 01:42:44 +00001761
Rafael Espindolabff59562013-04-25 12:11:36 +00001762 // [dcl.link] p7:
1763 // A declaration directly contained in a linkage-specification is treated
1764 // as if it contains the extern specifier for the purpose of determining
1765 // the linkage of the declared name and whether it is a definition.
Rafael Espindola327be3c2013-04-26 01:30:23 +00001766 if (isSingleLineExternC(*this))
1767 return DeclarationOnly;
Rafael Espindolabff59562013-04-25 12:11:36 +00001768
Sebastian Redl35351a92010-01-31 22:27:38 +00001769 // C99 6.9.2p2:
1770 // A declaration of an object that has file scope without an initializer,
1771 // and without a storage class specifier or the scs 'static', constitutes
1772 // a tentative definition.
1773 // No such thing in C++.
David Blaikiebbafb8a2012-03-11 07:00:24 +00001774 if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
Sebastian Redl35351a92010-01-31 22:27:38 +00001775 return TentativeDefinition;
1776
1777 // What's left is (in C, block-scope) declarations without initializers or
1778 // external storage. These are definitions.
1779 return Definition;
1780}
1781
Sebastian Redl35351a92010-01-31 22:27:38 +00001782VarDecl *VarDecl::getActingDefinition() {
1783 DefinitionKind Kind = isThisDeclarationADefinition();
1784 if (Kind != TentativeDefinition)
1785 return 0;
1786
Chris Lattner48eb14d2010-06-14 18:31:46 +00001787 VarDecl *LastTentative = 0;
Rafael Espindola8db352d2013-10-17 15:37:26 +00001788 VarDecl *First = getFirstDecl();
Sebastian Redl35351a92010-01-31 22:27:38 +00001789 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end();
1790 I != E; ++I) {
1791 Kind = (*I)->isThisDeclarationADefinition();
1792 if (Kind == Definition)
1793 return 0;
1794 else if (Kind == TentativeDefinition)
1795 LastTentative = *I;
1796 }
1797 return LastTentative;
1798}
1799
Daniel Dunbar9d355812012-03-09 01:51:51 +00001800VarDecl *VarDecl::getDefinition(ASTContext &C) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00001801 VarDecl *First = getFirstDecl();
Sebastian Redlccdb5ff2010-02-02 17:55:12 +00001802 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end();
1803 I != E; ++I) {
Daniel Dunbar9d355812012-03-09 01:51:51 +00001804 if ((*I)->isThisDeclarationADefinition(C) == Definition)
Sebastian Redl5ca79842010-02-01 20:16:42 +00001805 return *I;
1806 }
1807 return 0;
1808}
1809
Daniel Dunbar9d355812012-03-09 01:51:51 +00001810VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
John McCall37bb6c92010-10-29 22:22:43 +00001811 DefinitionKind Kind = DeclarationOnly;
1812
Rafael Espindola8db352d2013-10-17 15:37:26 +00001813 const VarDecl *First = getFirstDecl();
John McCall37bb6c92010-10-29 22:22:43 +00001814 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end();
Daniel Dunbar082c62d2012-03-06 23:52:46 +00001815 I != E; ++I) {
Daniel Dunbar9d355812012-03-09 01:51:51 +00001816 Kind = std::max(Kind, (*I)->isThisDeclarationADefinition(C));
Daniel Dunbar082c62d2012-03-06 23:52:46 +00001817 if (Kind == Definition)
1818 break;
1819 }
John McCall37bb6c92010-10-29 22:22:43 +00001820
1821 return Kind;
1822}
1823
Sebastian Redl5ca79842010-02-01 20:16:42 +00001824const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
Sebastian Redl833ef452010-01-26 22:01:41 +00001825 redecl_iterator I = redecls_begin(), E = redecls_end();
1826 while (I != E && !I->getInit())
1827 ++I;
1828
1829 if (I != E) {
Sebastian Redl5ca79842010-02-01 20:16:42 +00001830 D = *I;
Sebastian Redl833ef452010-01-26 22:01:41 +00001831 return I->getInit();
1832 }
1833 return 0;
1834}
1835
Douglas Gregor3cc3cde2009-10-14 21:29:40 +00001836bool VarDecl::isOutOfLine() const {
Douglas Gregorb11aad82011-02-19 18:51:44 +00001837 if (Decl::isOutOfLine())
Douglas Gregor3cc3cde2009-10-14 21:29:40 +00001838 return true;
Chandler Carruthf50ef6e2010-02-21 07:08:09 +00001839
1840 if (!isStaticDataMember())
1841 return false;
1842
Douglas Gregor3cc3cde2009-10-14 21:29:40 +00001843 // If this static data member was instantiated from a static data member of
1844 // a class template, check whether that static data member was defined
1845 // out-of-line.
1846 if (VarDecl *VD = getInstantiatedFromStaticDataMember())
1847 return VD->isOutOfLine();
1848
1849 return false;
1850}
1851
Douglas Gregor1d957a32009-10-27 18:42:08 +00001852VarDecl *VarDecl::getOutOfLineDefinition() {
1853 if (!isStaticDataMember())
1854 return 0;
1855
1856 for (VarDecl::redecl_iterator RD = redecls_begin(), RDEnd = redecls_end();
1857 RD != RDEnd; ++RD) {
1858 if (RD->getLexicalDeclContext()->isFileContext())
1859 return *RD;
1860 }
1861
1862 return 0;
1863}
1864
Douglas Gregord5058122010-02-11 01:19:42 +00001865void VarDecl::setInit(Expr *I) {
Sebastian Redl833ef452010-01-26 22:01:41 +00001866 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
1867 Eval->~EvaluatedStmt();
Douglas Gregord5058122010-02-11 01:19:42 +00001868 getASTContext().Deallocate(Eval);
Sebastian Redl833ef452010-01-26 22:01:41 +00001869 }
1870
1871 Init = I;
1872}
1873
Daniel Dunbar9d355812012-03-09 01:51:51 +00001874bool VarDecl::isUsableInConstantExpressions(ASTContext &C) const {
David Blaikiebbafb8a2012-03-11 07:00:24 +00001875 const LangOptions &Lang = C.getLangOpts();
Richard Smith242ad892011-12-21 02:55:12 +00001876
Richard Smith35ecb362012-03-02 04:14:40 +00001877 if (!Lang.CPlusPlus)
1878 return false;
1879
1880 // In C++11, any variable of reference type can be used in a constant
1881 // expression if it is initialized by a constant expression.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001882 if (Lang.CPlusPlus11 && getType()->isReferenceType())
Richard Smith35ecb362012-03-02 04:14:40 +00001883 return true;
1884
1885 // Only const objects can be used in constant expressions in C++. C++98 does
Richard Smith242ad892011-12-21 02:55:12 +00001886 // not require the variable to be non-volatile, but we consider this to be a
1887 // defect.
Richard Smith35ecb362012-03-02 04:14:40 +00001888 if (!getType().isConstQualified() || getType().isVolatileQualified())
Richard Smith242ad892011-12-21 02:55:12 +00001889 return false;
1890
1891 // In C++, const, non-volatile variables of integral or enumeration types
1892 // can be used in constant expressions.
1893 if (getType()->isIntegralOrEnumerationType())
1894 return true;
1895
Richard Smith35ecb362012-03-02 04:14:40 +00001896 // Additionally, in C++11, non-volatile constexpr variables can be used in
1897 // constant expressions.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001898 return Lang.CPlusPlus11 && isConstexpr();
Richard Smith242ad892011-12-21 02:55:12 +00001899}
1900
Richard Smithd0b4dd62011-12-19 06:19:21 +00001901/// Convert the initializer for this declaration to the elaborated EvaluatedStmt
1902/// form, which contains extra information on the evaluated value of the
1903/// initializer.
1904EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const {
1905 EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>();
1906 if (!Eval) {
1907 Stmt *S = Init.get<Stmt *>();
Manuel Klimeka7328992013-06-03 13:51:33 +00001908 // Note: EvaluatedStmt contains an APValue, which usually holds
1909 // resources not allocated from the ASTContext. We need to do some
1910 // work to avoid leaking those, but we do so in VarDecl::evaluateValue
1911 // where we can detect whether there's anything to clean up or not.
Richard Smithd0b4dd62011-12-19 06:19:21 +00001912 Eval = new (getASTContext()) EvaluatedStmt;
1913 Eval->Value = S;
1914 Init = Eval;
1915 }
1916 return Eval;
1917}
1918
Richard Smithdafff942012-01-14 04:30:29 +00001919APValue *VarDecl::evaluateValue() const {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001920 SmallVector<PartialDiagnosticAt, 8> Notes;
Richard Smithdafff942012-01-14 04:30:29 +00001921 return evaluateValue(Notes);
1922}
1923
Manuel Klimeka7328992013-06-03 13:51:33 +00001924namespace {
1925// Destroy an APValue that was allocated in an ASTContext.
1926void DestroyAPValue(void* UntypedValue) {
1927 static_cast<APValue*>(UntypedValue)->~APValue();
1928}
1929} // namespace
1930
Richard Smithdafff942012-01-14 04:30:29 +00001931APValue *VarDecl::evaluateValue(
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001932 SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
Richard Smithd0b4dd62011-12-19 06:19:21 +00001933 EvaluatedStmt *Eval = ensureEvaluatedStmt();
1934
1935 // We only produce notes indicating why an initializer is non-constant the
1936 // first time it is evaluated. FIXME: The notes won't always be emitted the
1937 // first time we try evaluation, so might not be produced at all.
1938 if (Eval->WasEvaluated)
Richard Smithdafff942012-01-14 04:30:29 +00001939 return Eval->Evaluated.isUninit() ? 0 : &Eval->Evaluated;
Richard Smithd0b4dd62011-12-19 06:19:21 +00001940
1941 const Expr *Init = cast<Expr>(Eval->Value);
1942 assert(!Init->isValueDependent());
1943
1944 if (Eval->IsEvaluating) {
1945 // FIXME: Produce a diagnostic for self-initialization.
1946 Eval->CheckedICE = true;
1947 Eval->IsICE = false;
Richard Smithdafff942012-01-14 04:30:29 +00001948 return 0;
Richard Smithd0b4dd62011-12-19 06:19:21 +00001949 }
1950
1951 Eval->IsEvaluating = true;
1952
1953 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(),
1954 this, Notes);
1955
Manuel Klimeka7328992013-06-03 13:51:33 +00001956 // Ensure the computed APValue is cleaned up later if evaluation succeeded,
1957 // or that it's empty (so that there's nothing to clean up) if evaluation
1958 // failed.
Richard Smithd0b4dd62011-12-19 06:19:21 +00001959 if (!Result)
1960 Eval->Evaluated = APValue();
Manuel Klimeka7328992013-06-03 13:51:33 +00001961 else if (Eval->Evaluated.needsCleanup())
1962 getASTContext().AddDeallocation(DestroyAPValue, &Eval->Evaluated);
Richard Smithd0b4dd62011-12-19 06:19:21 +00001963
1964 Eval->IsEvaluating = false;
1965 Eval->WasEvaluated = true;
1966
1967 // In C++11, we have determined whether the initializer was a constant
1968 // expression as a side-effect.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001969 if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) {
Richard Smithd0b4dd62011-12-19 06:19:21 +00001970 Eval->CheckedICE = true;
Eli Friedman8f66cdf2012-02-06 21:50:18 +00001971 Eval->IsICE = Result && Notes.empty();
Richard Smithd0b4dd62011-12-19 06:19:21 +00001972 }
1973
Richard Smithdafff942012-01-14 04:30:29 +00001974 return Result ? &Eval->Evaluated : 0;
Richard Smithd0b4dd62011-12-19 06:19:21 +00001975}
1976
1977bool VarDecl::checkInitIsICE() const {
John McCalla59dc2f2012-01-05 00:13:19 +00001978 // Initializers of weak variables are never ICEs.
1979 if (isWeak())
1980 return false;
1981
Richard Smithd0b4dd62011-12-19 06:19:21 +00001982 EvaluatedStmt *Eval = ensureEvaluatedStmt();
1983 if (Eval->CheckedICE)
1984 // We have already checked whether this subexpression is an
1985 // integral constant expression.
1986 return Eval->IsICE;
1987
1988 const Expr *Init = cast<Expr>(Eval->Value);
1989 assert(!Init->isValueDependent());
1990
1991 // In C++11, evaluate the initializer to check whether it's a constant
1992 // expression.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001993 if (getASTContext().getLangOpts().CPlusPlus11) {
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001994 SmallVector<PartialDiagnosticAt, 8> Notes;
Richard Smithd0b4dd62011-12-19 06:19:21 +00001995 evaluateValue(Notes);
1996 return Eval->IsICE;
1997 }
1998
1999 // It's an ICE whether or not the definition we found is
2000 // out-of-line. See DR 721 and the discussion in Clang PR
2001 // 6206 for details.
2002
2003 if (Eval->CheckingICE)
2004 return false;
2005 Eval->CheckingICE = true;
2006
2007 Eval->IsICE = Init->isIntegerConstantExpr(getASTContext());
2008 Eval->CheckingICE = false;
2009 Eval->CheckedICE = true;
2010 return Eval->IsICE;
2011}
2012
Douglas Gregor3cc3cde2009-10-14 21:29:40 +00002013VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
Douglas Gregor06db9f52009-10-12 20:18:28 +00002014 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
Douglas Gregor86d142a2009-10-08 07:24:58 +00002015 return cast<VarDecl>(MSI->getInstantiatedFrom());
2016
2017 return 0;
2018}
2019
Douglas Gregor3c74d412009-10-14 20:14:33 +00002020TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
Larisse Voufo39a1e502013-08-06 01:03:05 +00002021 if (const VarTemplateSpecializationDecl *Spec =
2022 dyn_cast<VarTemplateSpecializationDecl>(this))
2023 return Spec->getSpecializationKind();
2024
Sebastian Redl35351a92010-01-31 22:27:38 +00002025 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
Douglas Gregor86d142a2009-10-08 07:24:58 +00002026 return MSI->getTemplateSpecializationKind();
Richard Smith8809a0c2013-09-27 20:14:12 +00002027
Douglas Gregor86d142a2009-10-08 07:24:58 +00002028 return TSK_Undeclared;
2029}
2030
Richard Smith8809a0c2013-09-27 20:14:12 +00002031SourceLocation VarDecl::getPointOfInstantiation() const {
2032 if (const VarTemplateSpecializationDecl *Spec =
2033 dyn_cast<VarTemplateSpecializationDecl>(this))
2034 return Spec->getPointOfInstantiation();
2035
2036 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2037 return MSI->getPointOfInstantiation();
2038
2039 return SourceLocation();
2040}
2041
Larisse Voufo39a1e502013-08-06 01:03:05 +00002042VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
2043 return getASTContext().getTemplateOrSpecializationInfo(this)
2044 .dyn_cast<VarTemplateDecl *>();
2045}
2046
2047void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
2048 getASTContext().setTemplateOrSpecializationInfo(this, Template);
2049}
2050
Douglas Gregor3cc3cde2009-10-14 21:29:40 +00002051MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
Richard Smithb71782b2013-08-01 04:12:04 +00002052 if (isStaticDataMember())
Larisse Voufo39a1e502013-08-06 01:03:05 +00002053 // FIXME: Remove ?
2054 // return getASTContext().getInstantiatedFromStaticDataMember(this);
2055 return getASTContext().getTemplateOrSpecializationInfo(this)
2056 .dyn_cast<MemberSpecializationInfo *>();
Richard Smithb71782b2013-08-01 04:12:04 +00002057 return 0;
Douglas Gregor06db9f52009-10-12 20:18:28 +00002058}
2059
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00002060void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2061 SourceLocation PointOfInstantiation) {
Richard Smith8809a0c2013-09-27 20:14:12 +00002062 assert((isa<VarTemplateSpecializationDecl>(this) ||
2063 getMemberSpecializationInfo()) &&
2064 "not a variable or static data member template specialization");
2065
Larisse Voufo39a1e502013-08-06 01:03:05 +00002066 if (VarTemplateSpecializationDecl *Spec =
2067 dyn_cast<VarTemplateSpecializationDecl>(this)) {
2068 Spec->setSpecializationKind(TSK);
2069 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2070 Spec->getPointOfInstantiation().isInvalid())
2071 Spec->setPointOfInstantiation(PointOfInstantiation);
Larisse Voufo39a1e502013-08-06 01:03:05 +00002072 }
2073
2074 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) {
2075 MSI->setTemplateSpecializationKind(TSK);
2076 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2077 MSI->getPointOfInstantiation().isInvalid())
2078 MSI->setPointOfInstantiation(PointOfInstantiation);
Larisse Voufo39a1e502013-08-06 01:03:05 +00002079 }
Larisse Voufo39a1e502013-08-06 01:03:05 +00002080}
2081
2082void
2083VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
2084 TemplateSpecializationKind TSK) {
2085 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
2086 "Previous template or instantiation?");
2087 getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK);
Douglas Gregora6ef8f02009-07-24 20:34:43 +00002088}
2089
Sebastian Redl833ef452010-01-26 22:01:41 +00002090//===----------------------------------------------------------------------===//
2091// ParmVarDecl Implementation
2092//===----------------------------------------------------------------------===//
Douglas Gregor0760fa12009-03-10 23:43:53 +00002093
Sebastian Redl833ef452010-01-26 22:01:41 +00002094ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnaradff19302011-03-08 08:55:46 +00002095 SourceLocation StartLoc,
2096 SourceLocation IdLoc, IdentifierInfo *Id,
Sebastian Redl833ef452010-01-26 22:01:41 +00002097 QualType T, TypeSourceInfo *TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002098 StorageClass S, Expr *DefArg) {
Richard Smithf7981722013-11-22 09:01:48 +00002099 return new (C, DC) ParmVarDecl(ParmVar, DC, StartLoc, IdLoc, Id, T, TInfo,
2100 S, DefArg);
Douglas Gregor0760fa12009-03-10 23:43:53 +00002101}
2102
Reid Kleckner8a365022013-06-24 17:51:48 +00002103QualType ParmVarDecl::getOriginalType() const {
2104 TypeSourceInfo *TSI = getTypeSourceInfo();
2105 QualType T = TSI ? TSI->getType() : getType();
2106 if (const DecayedType *DT = dyn_cast<DecayedType>(T))
2107 return DT->getOriginalType();
2108 return T;
2109}
2110
Douglas Gregor72172e92012-01-05 21:55:30 +00002111ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00002112 return new (C, ID) ParmVarDecl(ParmVar, 0, SourceLocation(), SourceLocation(),
2113 0, QualType(), 0, SC_None, 0);
Douglas Gregor72172e92012-01-05 21:55:30 +00002114}
2115
Argyrios Kyrtzidis4c6efa622011-07-30 17:23:26 +00002116SourceRange ParmVarDecl::getSourceRange() const {
2117 if (!hasInheritedDefaultArg()) {
2118 SourceRange ArgRange = getDefaultArgRange();
2119 if (ArgRange.isValid())
2120 return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2121 }
2122
Argyrios Kyrtzidisa0772792013-04-17 01:56:48 +00002123 // DeclaratorDecl considers the range of postfix types as overlapping with the
2124 // declaration name, but this is not the case with parameters in ObjC methods.
2125 if (isa<ObjCMethodDecl>(getDeclContext()))
2126 return SourceRange(DeclaratorDecl::getLocStart(), getLocation());
2127
Argyrios Kyrtzidis4c6efa622011-07-30 17:23:26 +00002128 return DeclaratorDecl::getSourceRange();
2129}
2130
Sebastian Redl833ef452010-01-26 22:01:41 +00002131Expr *ParmVarDecl::getDefaultArg() {
2132 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
2133 assert(!hasUninstantiatedDefaultArg() &&
2134 "Default argument is not yet instantiated!");
2135
2136 Expr *Arg = getInit();
John McCall5d413782010-12-06 08:20:24 +00002137 if (ExprWithCleanups *E = dyn_cast_or_null<ExprWithCleanups>(Arg))
Sebastian Redl833ef452010-01-26 22:01:41 +00002138 return E->getSubExpr();
Douglas Gregor0760fa12009-03-10 23:43:53 +00002139
Sebastian Redl833ef452010-01-26 22:01:41 +00002140 return Arg;
2141}
2142
Sebastian Redl833ef452010-01-26 22:01:41 +00002143SourceRange ParmVarDecl::getDefaultArgRange() const {
2144 if (const Expr *E = getInit())
2145 return E->getSourceRange();
2146
2147 if (hasUninstantiatedDefaultArg())
2148 return getUninstantiatedDefaultArg()->getSourceRange();
2149
2150 return SourceRange();
Argyrios Kyrtzidis02dd4f92009-07-05 22:21:56 +00002151}
2152
Douglas Gregor3c6bd2a2011-01-05 21:11:38 +00002153bool ParmVarDecl::isParameterPack() const {
2154 return isa<PackExpansionType>(getType());
2155}
2156
Ted Kremenek540017e2011-10-06 05:00:56 +00002157void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
2158 getASTContext().setParameterIndex(this, parameterIndex);
2159 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
2160}
2161
2162unsigned ParmVarDecl::getParameterIndexLarge() const {
2163 return getASTContext().getParameterIndex(this);
2164}
2165
Nuno Lopes394ec982008-12-17 23:39:55 +00002166//===----------------------------------------------------------------------===//
Chris Lattner59a25942008-03-31 00:36:02 +00002167// FunctionDecl Implementation
2168//===----------------------------------------------------------------------===//
2169
Benjamin Kramer9170e912013-02-22 15:46:01 +00002170void FunctionDecl::getNameForDiagnostic(
2171 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
2172 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
Douglas Gregorb11aad82011-02-19 18:51:44 +00002173 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
2174 if (TemplateArgs)
Benjamin Kramer9170e912013-02-22 15:46:01 +00002175 TemplateSpecializationType::PrintTemplateArgumentList(
2176 OS, TemplateArgs->data(), TemplateArgs->size(), Policy);
Douglas Gregorb11aad82011-02-19 18:51:44 +00002177}
2178
Ted Kremenek186a0742010-04-29 16:49:01 +00002179bool FunctionDecl::isVariadic() const {
2180 if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>())
2181 return FT->isVariadic();
2182 return false;
2183}
2184
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002185bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
2186 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) {
Francois Pichet1c229c02011-04-22 22:18:13 +00002187 if (I->Body || I->IsLateTemplateParsed) {
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002188 Definition = *I;
2189 return true;
2190 }
2191 }
2192
2193 return false;
2194}
2195
Anders Carlsson9bd7d162011-05-14 23:26:09 +00002196bool FunctionDecl::hasTrivialBody() const
2197{
2198 Stmt *S = getBody();
2199 if (!S) {
2200 // Since we don't have a body for this function, we don't know if it's
2201 // trivial or not.
2202 return false;
2203 }
2204
2205 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
2206 return true;
2207 return false;
2208}
2209
Alexis Hunt4a8ea102011-05-06 20:44:56 +00002210bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const {
2211 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) {
Rafael Espindolad53ffa02013-10-22 21:39:03 +00002212 if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed ||
2213 I->hasAttr<AliasAttr>()) {
Alexis Hunt4a8ea102011-05-06 20:44:56 +00002214 Definition = I->IsDeleted ? I->getCanonicalDecl() : *I;
2215 return true;
2216 }
2217 }
2218
2219 return false;
2220}
2221
Argyrios Kyrtzidisddcd1322009-06-30 02:35:26 +00002222Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
Rafael Espindola44503012013-10-19 01:37:17 +00002223 if (!hasBody(Definition))
2224 return 0;
2225
2226 if (Definition->Body)
2227 return Definition->Body.get(getASTContext().getExternalSource());
Douglas Gregor89f238c2008-04-21 02:02:58 +00002228
2229 return 0;
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00002230}
2231
Argyrios Kyrtzidisa3aeb5a2009-06-20 08:09:14 +00002232void FunctionDecl::setBody(Stmt *B) {
2233 Body = B;
Douglas Gregor027ba502010-12-06 17:49:01 +00002234 if (B)
Argyrios Kyrtzidisa3aeb5a2009-06-20 08:09:14 +00002235 EndRangeLoc = B->getLocEnd();
2236}
2237
Douglas Gregor7d9120c2010-09-28 21:55:22 +00002238void FunctionDecl::setPure(bool P) {
2239 IsPure = P;
2240 if (P)
2241 if (CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
2242 Parent->markedVirtualFunctionPure();
2243}
2244
Richard Smith8d0dc312013-07-21 23:12:18 +00002245template<std::size_t Len>
2246static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
2247 IdentifierInfo *II = ND->getIdentifier();
2248 return II && II->isStr(Str);
2249}
2250
Douglas Gregor16618f22009-09-12 00:17:51 +00002251bool FunctionDecl::isMain() const {
John McCall53ffd372011-05-15 17:49:20 +00002252 const TranslationUnitDecl *tunit =
2253 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2254 return tunit &&
David Blaikiebbafb8a2012-03-11 07:00:24 +00002255 !tunit->getASTContext().getLangOpts().Freestanding &&
Richard Smith8d0dc312013-07-21 23:12:18 +00002256 isNamed(this, "main");
John McCall53ffd372011-05-15 17:49:20 +00002257}
2258
David Majnemerc729b0b2013-09-16 22:44:20 +00002259bool FunctionDecl::isMSVCRTEntryPoint() const {
2260 const TranslationUnitDecl *TUnit =
2261 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2262 if (!TUnit)
2263 return false;
2264
2265 // Even though we aren't really targeting MSVCRT if we are freestanding,
2266 // semantic analysis for these functions remains the same.
2267
2268 // MSVCRT entry points only exist on MSVCRT targets.
2269 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
2270 return false;
2271
2272 // Nameless functions like constructors cannot be entry points.
2273 if (!getIdentifier())
2274 return false;
2275
2276 return llvm::StringSwitch<bool>(getName())
2277 .Cases("main", // an ANSI console app
2278 "wmain", // a Unicode console App
2279 "WinMain", // an ANSI GUI app
2280 "wWinMain", // a Unicode GUI app
2281 "DllMain", // a DLL
2282 true)
2283 .Default(false);
2284}
2285
John McCall53ffd372011-05-15 17:49:20 +00002286bool FunctionDecl::isReservedGlobalPlacementOperator() const {
2287 assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName);
2288 assert(getDeclName().getCXXOverloadedOperator() == OO_New ||
2289 getDeclName().getCXXOverloadedOperator() == OO_Delete ||
2290 getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
2291 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
2292
2293 if (isa<CXXRecordDecl>(getDeclContext())) return false;
2294 assert(getDeclContext()->getRedeclContext()->isTranslationUnit());
2295
2296 const FunctionProtoType *proto = getType()->castAs<FunctionProtoType>();
2297 if (proto->getNumArgs() != 2 || proto->isVariadic()) return false;
2298
2299 ASTContext &Context =
2300 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
2301 ->getASTContext();
2302
2303 // The result type and first argument type are constant across all
2304 // these operators. The second argument must be exactly void*.
2305 return (proto->getArgType(1).getCanonicalType() == Context.VoidPtrTy);
Douglas Gregore62c0a42009-02-24 01:23:02 +00002306}
2307
Richard Smith8d0dc312013-07-21 23:12:18 +00002308static bool isNamespaceStd(const DeclContext *DC) {
2309 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC->getRedeclContext());
2310 return ND && isNamed(ND, "std") &&
2311 ND->getParent()->getRedeclContext()->isTranslationUnit();
2312}
2313
2314bool FunctionDecl::isReplaceableGlobalAllocationFunction() const {
2315 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2316 return false;
2317 if (getDeclName().getCXXOverloadedOperator() != OO_New &&
2318 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2319 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
2320 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2321 return false;
2322
2323 if (isa<CXXRecordDecl>(getDeclContext()))
2324 return false;
2325 assert(getDeclContext()->getRedeclContext()->isTranslationUnit());
2326
2327 const FunctionProtoType *FPT = getType()->castAs<FunctionProtoType>();
2328 if (FPT->getNumArgs() > 2 || FPT->isVariadic())
2329 return false;
2330
2331 // If this is a single-parameter function, it must be a replaceable global
2332 // allocation or deallocation function.
2333 if (FPT->getNumArgs() == 1)
2334 return true;
2335
2336 // Otherwise, we're looking for a second parameter whose type is
Richard Smith1cdec012013-09-29 04:40:38 +00002337 // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'.
Richard Smith8d0dc312013-07-21 23:12:18 +00002338 QualType Ty = FPT->getArgType(1);
Richard Smith1cdec012013-09-29 04:40:38 +00002339 ASTContext &Ctx = getASTContext();
Richard Smithb47c36f2013-11-05 09:12:18 +00002340 if (Ctx.getLangOpts().SizedDeallocation &&
2341 Ctx.hasSameType(Ty, Ctx.getSizeType()))
Richard Smith1cdec012013-09-29 04:40:38 +00002342 return true;
Richard Smith8d0dc312013-07-21 23:12:18 +00002343 if (!Ty->isReferenceType())
2344 return false;
2345 Ty = Ty->getPointeeType();
2346 if (Ty.getCVRQualifiers() != Qualifiers::Const)
2347 return false;
2348 // FIXME: Recognise nothrow_t in an inline namespace inside std?
2349 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2350 return RD && isNamed(RD, "nothrow_t") && isNamespaceStd(RD->getDeclContext());
2351}
2352
Richard Smithb47c36f2013-11-05 09:12:18 +00002353FunctionDecl *
2354FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const {
2355 ASTContext &Ctx = getASTContext();
2356 if (!Ctx.getLangOpts().SizedDeallocation)
2357 return 0;
2358
2359 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2360 return 0;
2361 if (getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2362 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2363 return 0;
2364 if (isa<CXXRecordDecl>(getDeclContext()))
2365 return 0;
2366 assert(getDeclContext()->getRedeclContext()->isTranslationUnit());
2367
2368 if (getNumParams() != 2 || isVariadic() ||
2369 !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getArgType(1),
2370 Ctx.getSizeType()))
2371 return 0;
2372
2373 // This is a sized deallocation function. Find the corresponding unsized
2374 // deallocation function.
2375 lookup_const_result R = getDeclContext()->lookup(getDeclName());
2376 for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE;
2377 ++RI)
2378 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI))
2379 if (FD->getNumParams() == 1 && !FD->isVariadic())
2380 return FD;
2381 return 0;
2382}
2383
Rafael Espindolaf4187652013-02-14 01:18:37 +00002384LanguageLinkage FunctionDecl::getLanguageLinkage() const {
Rafael Espindolaf4187652013-02-14 01:18:37 +00002385 return getLanguageLinkageTemplate(*this);
Rafael Espindola576127d2012-12-28 14:21:58 +00002386}
2387
Rafael Espindola0e0d0092013-03-14 03:07:35 +00002388bool FunctionDecl::isExternC() const {
2389 return isExternCTemplate(*this);
2390}
2391
Rafael Espindola593537a2013-05-05 20:15:21 +00002392bool FunctionDecl::isInExternCContext() const {
Serge Pavlov3cb80222013-11-14 02:13:03 +00002393 return getLexicalDeclContext()->isExternCContext();
Rafael Espindola593537a2013-05-05 20:15:21 +00002394}
2395
2396bool FunctionDecl::isInExternCXXContext() const {
Serge Pavlov3cb80222013-11-14 02:13:03 +00002397 return getLexicalDeclContext()->isExternCXXContext();
Rafael Espindola593537a2013-05-05 20:15:21 +00002398}
2399
Douglas Gregorf1b876d2009-03-31 16:35:03 +00002400bool FunctionDecl::isGlobal() const {
2401 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this))
2402 return Method->isStatic();
2403
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002404 if (getCanonicalDecl()->getStorageClass() == SC_Static)
Douglas Gregorf1b876d2009-03-31 16:35:03 +00002405 return false;
2406
Mike Stump11289f42009-09-09 15:08:12 +00002407 for (const DeclContext *DC = getDeclContext();
Douglas Gregorf1b876d2009-03-31 16:35:03 +00002408 DC->isNamespace();
2409 DC = DC->getParent()) {
2410 if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) {
2411 if (!Namespace->getDeclName())
2412 return false;
2413 break;
2414 }
2415 }
2416
2417 return true;
2418}
2419
Richard Smith10876ef2013-01-17 01:30:42 +00002420bool FunctionDecl::isNoReturn() const {
2421 return hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
Richard Smithdebc59d2013-01-30 05:45:05 +00002422 hasAttr<C11NoReturnAttr>() ||
Richard Smith10876ef2013-01-17 01:30:42 +00002423 getType()->getAs<FunctionType>()->getNoReturnAttr();
2424}
2425
Sebastian Redl833ef452010-01-26 22:01:41 +00002426void
2427FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002428 redeclarable_base::setPreviousDecl(PrevDecl);
Sebastian Redl833ef452010-01-26 22:01:41 +00002429
2430 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
2431 FunctionTemplateDecl *PrevFunTmpl
2432 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : 0;
2433 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
Rafael Espindola8db352d2013-10-17 15:37:26 +00002434 FunTmpl->setPreviousDecl(PrevFunTmpl);
Sebastian Redl833ef452010-01-26 22:01:41 +00002435 }
Douglas Gregorff76cb92010-12-09 16:59:22 +00002436
Axel Naumannfbc7b982011-11-08 18:21:06 +00002437 if (PrevDecl && PrevDecl->IsInline)
Douglas Gregorff76cb92010-12-09 16:59:22 +00002438 IsInline = true;
Sebastian Redl833ef452010-01-26 22:01:41 +00002439}
2440
2441const FunctionDecl *FunctionDecl::getCanonicalDecl() const {
Rafael Espindola8db352d2013-10-17 15:37:26 +00002442 return getFirstDecl();
Sebastian Redl833ef452010-01-26 22:01:41 +00002443}
2444
Rafael Espindola8db352d2013-10-17 15:37:26 +00002445FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
Sebastian Redl833ef452010-01-26 22:01:41 +00002446
Douglas Gregorb9063fc2009-02-13 23:20:09 +00002447/// \brief Returns a value indicating whether this function
2448/// corresponds to a builtin function.
2449///
2450/// The function corresponds to a built-in function if it is
2451/// declared at translation scope or within an extern "C" block and
2452/// its name matches with the name of a builtin. The returned value
2453/// will be 0 for functions that do not correspond to a builtin, a
Mike Stump11289f42009-09-09 15:08:12 +00002454/// value of type \c Builtin::ID if in the target-independent range
Douglas Gregorb9063fc2009-02-13 23:20:09 +00002455/// \c [1,Builtin::First), or a target-specific builtin value.
Douglas Gregor15fc9562009-09-12 00:22:50 +00002456unsigned FunctionDecl::getBuiltinID() const {
Daniel Dunbar304314d2012-03-06 23:52:37 +00002457 if (!getIdentifier())
Douglas Gregore711f702009-02-14 18:57:46 +00002458 return 0;
2459
2460 unsigned BuiltinID = getIdentifier()->getBuiltinID();
Daniel Dunbar304314d2012-03-06 23:52:37 +00002461 if (!BuiltinID)
2462 return 0;
2463
2464 ASTContext &Context = getASTContext();
Warren Hunt445d83e2013-11-01 23:46:51 +00002465 if (Context.getLangOpts().CPlusPlus) {
2466 const LinkageSpecDecl *LinkageDecl = dyn_cast<LinkageSpecDecl>(
2467 getFirstDecl()->getDeclContext());
2468 // In C++, the first declaration of a builtin is always inside an implicit
2469 // extern "C".
2470 // FIXME: A recognised library function may not be directly in an extern "C"
2471 // declaration, for instance "extern "C" { namespace std { decl } }".
2472 if (!LinkageDecl || LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c)
2473 return 0;
2474 }
2475
2476 // If the function is marked "overloadable", it has a different mangled name
2477 // and is not the C library function.
2478 if (getAttr<OverloadableAttr>())
2479 return 0;
2480
Douglas Gregore711f702009-02-14 18:57:46 +00002481 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
2482 return BuiltinID;
2483
2484 // This function has the name of a known C library
2485 // function. Determine whether it actually refers to the C library
2486 // function or whether it just has the same name.
2487
Douglas Gregora908e7f2009-02-17 03:23:10 +00002488 // If this is a static function, it's not a builtin.
John McCall8e7d6562010-08-26 03:08:43 +00002489 if (getStorageClass() == SC_Static)
Douglas Gregora908e7f2009-02-17 03:23:10 +00002490 return 0;
2491
Warren Hunt445d83e2013-11-01 23:46:51 +00002492 return BuiltinID;
Douglas Gregorb9063fc2009-02-13 23:20:09 +00002493}
2494
2495
Chris Lattner47c0d002009-04-25 06:03:53 +00002496/// getNumParams - Return the number of parameters this function must have
Bob Wilsonb39017a2011-01-10 18:23:55 +00002497/// based on its FunctionType. This is the length of the ParamInfo array
Chris Lattner47c0d002009-04-25 06:03:53 +00002498/// after it has been created.
2499unsigned FunctionDecl::getNumParams() const {
Eli Friedman5c27c4c2012-08-30 22:22:09 +00002500 const FunctionType *FT = getType()->castAs<FunctionType>();
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002501 if (isa<FunctionNoProtoType>(FT))
Chris Lattner88f70d62008-03-15 05:43:15 +00002502 return 0;
Douglas Gregordeaad8c2009-02-26 23:50:07 +00002503 return cast<FunctionProtoType>(FT)->getNumArgs();
Mike Stump11289f42009-09-09 15:08:12 +00002504
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00002505}
2506
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00002507void FunctionDecl::setParams(ASTContext &C,
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002508 ArrayRef<ParmVarDecl *> NewParamInfo) {
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00002509 assert(ParamInfo == 0 && "Already has param info!");
David Blaikie9c70e042011-09-21 18:16:56 +00002510 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
Mike Stump11289f42009-09-09 15:08:12 +00002511
Chris Lattner8f5bf2f2007-01-21 19:04:10 +00002512 // Zero params -> null pointer.
David Blaikie9c70e042011-09-21 18:16:56 +00002513 if (!NewParamInfo.empty()) {
2514 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
2515 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
Chris Lattner8f5bf2f2007-01-21 19:04:10 +00002516 }
Chris Lattnerc5cdf4d2007-01-21 07:42:07 +00002517}
Chris Lattner41943152007-01-25 04:52:46 +00002518
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002519void FunctionDecl::setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls) {
James Molloy6f8780b2012-02-29 10:24:19 +00002520 assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!");
2521
2522 if (!NewDecls.empty()) {
2523 NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()];
2524 std::copy(NewDecls.begin(), NewDecls.end(), A);
Dmitri Gribenkof8579502013-01-12 19:30:44 +00002525 DeclsInPrototypeScope = ArrayRef<NamedDecl *>(A, NewDecls.size());
James Molloy6f8780b2012-02-29 10:24:19 +00002526 }
2527}
2528
Chris Lattner58258242008-04-10 02:22:51 +00002529/// getMinRequiredArguments - Returns the minimum number of arguments
2530/// needed to call this function. This may be fewer than the number of
2531/// function parameters, if some of the parameters have default
Douglas Gregor7825bf32011-01-06 22:09:01 +00002532/// arguments (in C++) or the last parameter is a parameter pack.
Chris Lattner58258242008-04-10 02:22:51 +00002533unsigned FunctionDecl::getMinRequiredArguments() const {
David Blaikiebbafb8a2012-03-11 07:00:24 +00002534 if (!getASTContext().getLangOpts().CPlusPlus)
Douglas Gregor0dd423e2011-01-11 01:52:23 +00002535 return getNumParams();
2536
Douglas Gregor7825bf32011-01-06 22:09:01 +00002537 unsigned NumRequiredArgs = getNumParams();
2538
2539 // If the last parameter is a parameter pack, we don't need an argument for
2540 // it.
2541 if (NumRequiredArgs > 0 &&
2542 getParamDecl(NumRequiredArgs - 1)->isParameterPack())
2543 --NumRequiredArgs;
2544
2545 // If this parameter has a default argument, we don't need an argument for
2546 // it.
2547 while (NumRequiredArgs > 0 &&
2548 getParamDecl(NumRequiredArgs-1)->hasDefaultArg())
Chris Lattner58258242008-04-10 02:22:51 +00002549 --NumRequiredArgs;
2550
Douglas Gregor0dd423e2011-01-11 01:52:23 +00002551 // We might have parameter packs before the end. These can't be deduced,
2552 // but they can still handle multiple arguments.
2553 unsigned ArgIdx = NumRequiredArgs;
2554 while (ArgIdx > 0) {
2555 if (getParamDecl(ArgIdx - 1)->isParameterPack())
2556 NumRequiredArgs = ArgIdx;
2557
2558 --ArgIdx;
2559 }
2560
Chris Lattner58258242008-04-10 02:22:51 +00002561 return NumRequiredArgs;
2562}
2563
Eli Friedman1b125c32012-02-07 03:50:18 +00002564static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
2565 // Only consider file-scope declarations in this test.
2566 if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
2567 return false;
2568
2569 // Only consider explicit declarations; the presence of a builtin for a
2570 // libcall shouldn't affect whether a definition is externally visible.
2571 if (Redecl->isImplicit())
2572 return false;
2573
2574 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
2575 return true; // Not an inline definition
2576
2577 return false;
2578}
2579
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002580/// \brief For a function declaration in C or C++, determine whether this
2581/// declaration causes the definition to be externally visible.
2582///
Eli Friedman1b125c32012-02-07 03:50:18 +00002583/// Specifically, this determines if adding the current declaration to the set
2584/// of redeclarations of the given functions causes
2585/// isInlineDefinitionExternallyVisible to change from false to true.
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002586bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
2587 assert(!doesThisDeclarationHaveABody() &&
2588 "Must have a declaration without a body.");
2589
2590 ASTContext &Context = getASTContext();
2591
David Blaikiebbafb8a2012-03-11 07:00:24 +00002592 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
Eli Friedman1b125c32012-02-07 03:50:18 +00002593 // With GNU inlining, a declaration with 'inline' but not 'extern', forces
2594 // an externally visible definition.
2595 //
2596 // FIXME: What happens if gnu_inline gets added on after the first
2597 // declaration?
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002598 if (!isInlineSpecified() || getStorageClass() == SC_Extern)
Eli Friedman1b125c32012-02-07 03:50:18 +00002599 return false;
2600
2601 const FunctionDecl *Prev = this;
2602 bool FoundBody = false;
2603 while ((Prev = Prev->getPreviousDecl())) {
David Blaikie7d170102013-05-15 07:37:26 +00002604 FoundBody |= Prev->Body.isValid();
Eli Friedman1b125c32012-02-07 03:50:18 +00002605
2606 if (Prev->Body) {
2607 // If it's not the case that both 'inline' and 'extern' are
2608 // specified on the definition, then it is always externally visible.
2609 if (!Prev->isInlineSpecified() ||
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002610 Prev->getStorageClass() != SC_Extern)
Eli Friedman1b125c32012-02-07 03:50:18 +00002611 return false;
2612 } else if (Prev->isInlineSpecified() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002613 Prev->getStorageClass() != SC_Extern) {
Eli Friedman1b125c32012-02-07 03:50:18 +00002614 return false;
2615 }
2616 }
2617 return FoundBody;
2618 }
2619
David Blaikiebbafb8a2012-03-11 07:00:24 +00002620 if (Context.getLangOpts().CPlusPlus)
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002621 return false;
Eli Friedman1b125c32012-02-07 03:50:18 +00002622
2623 // C99 6.7.4p6:
2624 // [...] If all of the file scope declarations for a function in a
2625 // translation unit include the inline function specifier without extern,
2626 // then the definition in that translation unit is an inline definition.
2627 if (isInlineSpecified() && getStorageClass() != SC_Extern)
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002628 return false;
Eli Friedman1b125c32012-02-07 03:50:18 +00002629 const FunctionDecl *Prev = this;
2630 bool FoundBody = false;
2631 while ((Prev = Prev->getPreviousDecl())) {
David Blaikie7d170102013-05-15 07:37:26 +00002632 FoundBody |= Prev->Body.isValid();
Eli Friedman1b125c32012-02-07 03:50:18 +00002633 if (RedeclForcesDefC99(Prev))
2634 return false;
2635 }
2636 return FoundBody;
Nick Lewycky26da4dd2011-07-18 05:26:13 +00002637}
2638
Richard Smithf3814ad2013-01-25 00:08:28 +00002639/// \brief For an inline function definition in C, or for a gnu_inline function
2640/// in C++, determine whether the definition will be externally visible.
Douglas Gregor299d76e2009-09-13 07:46:26 +00002641///
2642/// Inline function definitions are always available for inlining optimizations.
2643/// However, depending on the language dialect, declaration specifiers, and
2644/// attributes, the definition of an inline function may or may not be
2645/// "externally" visible to other translation units in the program.
2646///
2647/// In C99, inline definitions are not externally visible by default. However,
Mike Stump13c66702010-01-06 02:05:39 +00002648/// if even one of the global-scope declarations is marked "extern inline", the
Douglas Gregor299d76e2009-09-13 07:46:26 +00002649/// inline definition becomes externally visible (C99 6.7.4p6).
2650///
2651/// In GNU89 mode, or if the gnu_inline attribute is attached to the function
2652/// definition, we use the GNU semantics for inline, which are nearly the
2653/// opposite of C99 semantics. In particular, "inline" by itself will create
2654/// an externally visible symbol, but "extern inline" will not create an
2655/// externally visible symbol.
2656bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
Alexis Hunt4a8ea102011-05-06 20:44:56 +00002657 assert(doesThisDeclarationHaveABody() && "Must have the function definition");
Douglas Gregor583dcaf2009-10-27 21:11:48 +00002658 assert(isInlined() && "Function must be inline");
Douglas Gregorb7e5c842009-10-27 23:26:40 +00002659 ASTContext &Context = getASTContext();
Douglas Gregor299d76e2009-09-13 07:46:26 +00002660
David Blaikiebbafb8a2012-03-11 07:00:24 +00002661 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
Eli Friedman1b125c32012-02-07 03:50:18 +00002662 // Note: If you change the logic here, please change
2663 // doesDeclarationForceExternallyVisibleDefinition as well.
2664 //
Douglas Gregorff76cb92010-12-09 16:59:22 +00002665 // If it's not the case that both 'inline' and 'extern' are
2666 // specified on the definition, then this inline definition is
2667 // externally visible.
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002668 if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
Douglas Gregorff76cb92010-12-09 16:59:22 +00002669 return true;
2670
2671 // If any declaration is 'inline' but not 'extern', then this definition
2672 // is externally visible.
Douglas Gregor299d76e2009-09-13 07:46:26 +00002673 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end();
2674 Redecl != RedeclEnd;
2675 ++Redecl) {
Douglas Gregorff76cb92010-12-09 16:59:22 +00002676 if (Redecl->isInlineSpecified() &&
Rafael Espindola6ae7e502013-04-03 19:27:57 +00002677 Redecl->getStorageClass() != SC_Extern)
Douglas Gregor299d76e2009-09-13 07:46:26 +00002678 return true;
Douglas Gregorff76cb92010-12-09 16:59:22 +00002679 }
Douglas Gregor299d76e2009-09-13 07:46:26 +00002680
Douglas Gregor76fe50c2009-04-28 06:37:30 +00002681 return false;
Douglas Gregor299d76e2009-09-13 07:46:26 +00002682 }
Eli Friedman1b125c32012-02-07 03:50:18 +00002683
Richard Smithf3814ad2013-01-25 00:08:28 +00002684 // The rest of this function is C-only.
2685 assert(!Context.getLangOpts().CPlusPlus &&
2686 "should not use C inline rules in C++");
2687
Douglas Gregor299d76e2009-09-13 07:46:26 +00002688 // C99 6.7.4p6:
2689 // [...] If all of the file scope declarations for a function in a
2690 // translation unit include the inline function specifier without extern,
2691 // then the definition in that translation unit is an inline definition.
2692 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end();
2693 Redecl != RedeclEnd;
2694 ++Redecl) {
Eli Friedman1b125c32012-02-07 03:50:18 +00002695 if (RedeclForcesDefC99(*Redecl))
2696 return true;
Douglas Gregor299d76e2009-09-13 07:46:26 +00002697 }
2698
2699 // C99 6.7.4p6:
2700 // An inline definition does not provide an external definition for the
2701 // function, and does not forbid an external definition in another
2702 // translation unit.
Douglas Gregor76fe50c2009-04-28 06:37:30 +00002703 return false;
2704}
2705
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00002706/// getOverloadedOperator - Which C++ overloaded operator this
2707/// function represents, if any.
2708OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const {
Douglas Gregor163c5852008-11-18 14:39:36 +00002709 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
2710 return getDeclName().getCXXOverloadedOperator();
Douglas Gregor11d0c4c2008-11-06 22:13:31 +00002711 else
2712 return OO_None;
2713}
2714
Alexis Huntc88db062010-01-13 09:01:02 +00002715/// getLiteralIdentifier - The literal suffix identifier this function
2716/// represents, if any.
2717const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
2718 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
2719 return getDeclName().getCXXLiteralIdentifier();
2720 else
2721 return 0;
2722}
2723
Argyrios Kyrtzidiscb6f3462010-06-22 09:54:51 +00002724FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const {
2725 if (TemplateOrSpecialization.isNull())
2726 return TK_NonTemplate;
2727 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>())
2728 return TK_FunctionTemplate;
2729 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>())
2730 return TK_MemberSpecialization;
2731 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
2732 return TK_FunctionTemplateSpecialization;
2733 if (TemplateOrSpecialization.is
2734 <DependentFunctionTemplateSpecializationInfo*>())
2735 return TK_DependentFunctionTemplateSpecialization;
2736
David Blaikie83d382b2011-09-23 05:06:16 +00002737 llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
Argyrios Kyrtzidiscb6f3462010-06-22 09:54:51 +00002738}
2739
Douglas Gregord801b062009-10-07 23:56:10 +00002740FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
Douglas Gregor06db9f52009-10-12 20:18:28 +00002741 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo())
Douglas Gregord801b062009-10-07 23:56:10 +00002742 return cast<FunctionDecl>(Info->getInstantiatedFrom());
2743
2744 return 0;
2745}
2746
2747void
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00002748FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
2749 FunctionDecl *FD,
Douglas Gregord801b062009-10-07 23:56:10 +00002750 TemplateSpecializationKind TSK) {
2751 assert(TemplateOrSpecialization.isNull() &&
2752 "Member function is already a specialization");
2753 MemberSpecializationInfo *Info
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00002754 = new (C) MemberSpecializationInfo(FD, TSK);
Douglas Gregord801b062009-10-07 23:56:10 +00002755 TemplateOrSpecialization = Info;
2756}
2757
Douglas Gregorafca3b42009-10-27 20:53:28 +00002758bool FunctionDecl::isImplicitlyInstantiable() const {
Douglas Gregor69f6a362010-05-17 17:34:56 +00002759 // If the function is invalid, it can't be implicitly instantiated.
2760 if (isInvalidDecl())
Douglas Gregorafca3b42009-10-27 20:53:28 +00002761 return false;
2762
2763 switch (getTemplateSpecializationKind()) {
2764 case TSK_Undeclared:
Douglas Gregorafca3b42009-10-27 20:53:28 +00002765 case TSK_ExplicitInstantiationDefinition:
2766 return false;
2767
2768 case TSK_ImplicitInstantiation:
2769 return true;
2770
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002771 // It is possible to instantiate TSK_ExplicitSpecialization kind
2772 // if the FunctionDecl has a class scope specialization pattern.
2773 case TSK_ExplicitSpecialization:
2774 return getClassScopeSpecializationPattern() != 0;
2775
Douglas Gregorafca3b42009-10-27 20:53:28 +00002776 case TSK_ExplicitInstantiationDeclaration:
2777 // Handled below.
2778 break;
2779 }
2780
2781 // Find the actual template from which we will instantiate.
2782 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002783 bool HasPattern = false;
Douglas Gregorafca3b42009-10-27 20:53:28 +00002784 if (PatternDecl)
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002785 HasPattern = PatternDecl->hasBody(PatternDecl);
Douglas Gregorafca3b42009-10-27 20:53:28 +00002786
2787 // C++0x [temp.explicit]p9:
2788 // Except for inline functions, other explicit instantiation declarations
2789 // have the effect of suppressing the implicit instantiation of the entity
2790 // to which they refer.
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002791 if (!HasPattern || !PatternDecl)
Douglas Gregorafca3b42009-10-27 20:53:28 +00002792 return true;
2793
Douglas Gregor583dcaf2009-10-27 21:11:48 +00002794 return PatternDecl->isInlined();
Ted Kremenek85825ae2011-12-01 00:59:17 +00002795}
2796
2797bool FunctionDecl::isTemplateInstantiation() const {
2798 switch (getTemplateSpecializationKind()) {
2799 case TSK_Undeclared:
2800 case TSK_ExplicitSpecialization:
2801 return false;
2802 case TSK_ImplicitInstantiation:
2803 case TSK_ExplicitInstantiationDeclaration:
2804 case TSK_ExplicitInstantiationDefinition:
2805 return true;
2806 }
2807 llvm_unreachable("All TSK values handled.");
2808}
Douglas Gregorafca3b42009-10-27 20:53:28 +00002809
2810FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const {
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002811 // Handle class scope explicit specialization special case.
2812 if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
2813 return getClassScopeSpecializationPattern();
2814
Douglas Gregorafca3b42009-10-27 20:53:28 +00002815 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
2816 while (Primary->getInstantiatedFromMemberTemplate()) {
2817 // If we have hit a point where the user provided a specialization of
2818 // this template, we're done looking.
2819 if (Primary->isMemberSpecialization())
2820 break;
2821
2822 Primary = Primary->getInstantiatedFromMemberTemplate();
2823 }
2824
2825 return Primary->getTemplatedDecl();
2826 }
2827
2828 return getInstantiatedFromMemberFunction();
2829}
2830
Douglas Gregor70d83e22009-06-29 17:30:29 +00002831FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
Mike Stump11289f42009-09-09 15:08:12 +00002832 if (FunctionTemplateSpecializationInfo *Info
Douglas Gregor70d83e22009-06-29 17:30:29 +00002833 = TemplateOrSpecialization
2834 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
Douglas Gregore8925db2009-06-29 22:39:32 +00002835 return Info->Template.getPointer();
Douglas Gregor70d83e22009-06-29 17:30:29 +00002836 }
2837 return 0;
2838}
2839
Francois Pichet00c7e6c2011-08-14 03:52:19 +00002840FunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const {
2841 return getASTContext().getClassScopeSpecializationPattern(this);
2842}
2843
Douglas Gregor70d83e22009-06-29 17:30:29 +00002844const TemplateArgumentList *
2845FunctionDecl::getTemplateSpecializationArgs() const {
Mike Stump11289f42009-09-09 15:08:12 +00002846 if (FunctionTemplateSpecializationInfo *Info
Douglas Gregorcf915552009-10-13 16:30:37 +00002847 = TemplateOrSpecialization
2848 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
Douglas Gregor70d83e22009-06-29 17:30:29 +00002849 return Info->TemplateArguments;
2850 }
2851 return 0;
2852}
2853
Argyrios Kyrtzidise9a24432011-09-22 20:07:09 +00002854const ASTTemplateArgumentListInfo *
Abramo Bagnara02ccd282010-05-20 15:32:11 +00002855FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
2856 if (FunctionTemplateSpecializationInfo *Info
2857 = TemplateOrSpecialization
2858 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
2859 return Info->TemplateArgumentsAsWritten;
2860 }
2861 return 0;
2862}
2863
Mike Stump11289f42009-09-09 15:08:12 +00002864void
Argyrios Kyrtzidisf4bc0d82010-09-08 19:31:22 +00002865FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
2866 FunctionTemplateDecl *Template,
Douglas Gregor8f5d4422009-06-29 20:59:39 +00002867 const TemplateArgumentList *TemplateArgs,
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00002868 void *InsertPos,
Abramo Bagnara02ccd282010-05-20 15:32:11 +00002869 TemplateSpecializationKind TSK,
Argyrios Kyrtzidis927d8e02010-07-05 10:37:55 +00002870 const TemplateArgumentListInfo *TemplateArgsAsWritten,
2871 SourceLocation PointOfInstantiation) {
Douglas Gregor3a923c2d2009-09-24 23:14:47 +00002872 assert(TSK != TSK_Undeclared &&
2873 "Must specify the type of function template specialization");
Mike Stump11289f42009-09-09 15:08:12 +00002874 FunctionTemplateSpecializationInfo *Info
Douglas Gregor70d83e22009-06-29 17:30:29 +00002875 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
Douglas Gregor4adbc6d2009-06-26 00:10:03 +00002876 if (!Info)
Argyrios Kyrtzidise262a952010-09-09 11:28:23 +00002877 Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK,
2878 TemplateArgs,
2879 TemplateArgsAsWritten,
2880 PointOfInstantiation);
Douglas Gregor4adbc6d2009-06-26 00:10:03 +00002881 TemplateOrSpecialization = Info;
Douglas Gregorce9978f2012-03-28 14:34:23 +00002882 Template->addSpecialization(Info, InsertPos);
Douglas Gregor4adbc6d2009-06-26 00:10:03 +00002883}
2884
John McCallb9c78482010-04-08 09:05:18 +00002885void
2886FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context,
2887 const UnresolvedSetImpl &Templates,
2888 const TemplateArgumentListInfo &TemplateArgs) {
2889 assert(TemplateOrSpecialization.isNull());
2890 size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo);
2891 Size += Templates.size() * sizeof(FunctionTemplateDecl*);
John McCall900d9802010-04-13 22:18:28 +00002892 Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc);
John McCallb9c78482010-04-08 09:05:18 +00002893 void *Buffer = Context.Allocate(Size);
2894 DependentFunctionTemplateSpecializationInfo *Info =
2895 new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates,
2896 TemplateArgs);
2897 TemplateOrSpecialization = Info;
2898}
2899
2900DependentFunctionTemplateSpecializationInfo::
2901DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
2902 const TemplateArgumentListInfo &TArgs)
2903 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
2904
2905 d.NumTemplates = Ts.size();
2906 d.NumArgs = TArgs.size();
2907
2908 FunctionTemplateDecl **TsArray =
2909 const_cast<FunctionTemplateDecl**>(getTemplates());
2910 for (unsigned I = 0, E = Ts.size(); I != E; ++I)
2911 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
2912
2913 TemplateArgumentLoc *ArgsArray =
2914 const_cast<TemplateArgumentLoc*>(getTemplateArgs());
2915 for (unsigned I = 0, E = TArgs.size(); I != E; ++I)
2916 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]);
2917}
2918
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002919TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const {
Mike Stump11289f42009-09-09 15:08:12 +00002920 // For a function template specialization, query the specialization
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002921 // information object.
Douglas Gregord801b062009-10-07 23:56:10 +00002922 FunctionTemplateSpecializationInfo *FTSInfo
Douglas Gregore8925db2009-06-29 22:39:32 +00002923 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
Douglas Gregord801b062009-10-07 23:56:10 +00002924 if (FTSInfo)
2925 return FTSInfo->getTemplateSpecializationKind();
Mike Stump11289f42009-09-09 15:08:12 +00002926
Douglas Gregord801b062009-10-07 23:56:10 +00002927 MemberSpecializationInfo *MSInfo
2928 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
2929 if (MSInfo)
2930 return MSInfo->getTemplateSpecializationKind();
2931
2932 return TSK_Undeclared;
Douglas Gregor34ec2ef2009-09-04 22:48:11 +00002933}
2934
Mike Stump11289f42009-09-09 15:08:12 +00002935void
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00002936FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2937 SourceLocation PointOfInstantiation) {
2938 if (FunctionTemplateSpecializationInfo *FTSInfo
2939 = TemplateOrSpecialization.dyn_cast<
2940 FunctionTemplateSpecializationInfo*>()) {
2941 FTSInfo->setTemplateSpecializationKind(TSK);
2942 if (TSK != TSK_ExplicitSpecialization &&
2943 PointOfInstantiation.isValid() &&
2944 FTSInfo->getPointOfInstantiation().isInvalid())
2945 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
2946 } else if (MemberSpecializationInfo *MSInfo
2947 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) {
2948 MSInfo->setTemplateSpecializationKind(TSK);
2949 if (TSK != TSK_ExplicitSpecialization &&
2950 PointOfInstantiation.isValid() &&
2951 MSInfo->getPointOfInstantiation().isInvalid())
2952 MSInfo->setPointOfInstantiation(PointOfInstantiation);
2953 } else
David Blaikie83d382b2011-09-23 05:06:16 +00002954 llvm_unreachable("Function cannot have a template specialization kind");
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00002955}
2956
2957SourceLocation FunctionDecl::getPointOfInstantiation() const {
Douglas Gregord801b062009-10-07 23:56:10 +00002958 if (FunctionTemplateSpecializationInfo *FTSInfo
2959 = TemplateOrSpecialization.dyn_cast<
2960 FunctionTemplateSpecializationInfo*>())
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00002961 return FTSInfo->getPointOfInstantiation();
Douglas Gregord801b062009-10-07 23:56:10 +00002962 else if (MemberSpecializationInfo *MSInfo
2963 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>())
Douglas Gregor3d7e69f2009-10-15 17:21:20 +00002964 return MSInfo->getPointOfInstantiation();
2965
2966 return SourceLocation();
Douglas Gregore8925db2009-06-29 22:39:32 +00002967}
2968
Douglas Gregor6411b922009-09-11 20:15:17 +00002969bool FunctionDecl::isOutOfLine() const {
Douglas Gregorb11aad82011-02-19 18:51:44 +00002970 if (Decl::isOutOfLine())
Douglas Gregor6411b922009-09-11 20:15:17 +00002971 return true;
2972
2973 // If this function was instantiated from a member function of a
2974 // class template, check whether that member function was defined out-of-line.
2975 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) {
2976 const FunctionDecl *Definition;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002977 if (FD->hasBody(Definition))
Douglas Gregor6411b922009-09-11 20:15:17 +00002978 return Definition->isOutOfLine();
2979 }
2980
2981 // If this function was instantiated from a function template,
2982 // check whether that function template was defined out-of-line.
2983 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
2984 const FunctionDecl *Definition;
Argyrios Kyrtzidis36ea3222010-07-07 11:31:19 +00002985 if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
Douglas Gregor6411b922009-09-11 20:15:17 +00002986 return Definition->isOutOfLine();
2987 }
2988
2989 return false;
2990}
2991
Abramo Bagnaraea947882011-03-08 16:41:52 +00002992SourceRange FunctionDecl::getSourceRange() const {
2993 return SourceRange(getOuterLocStart(), EndRangeLoc);
2994}
2995
Anna Zaks28db7ce2012-01-18 02:45:01 +00002996unsigned FunctionDecl::getMemoryFunctionKind() const {
Anna Zaks201d4892012-01-13 21:52:01 +00002997 IdentifierInfo *FnInfo = getIdentifier();
2998
2999 if (!FnInfo)
Anna Zaks22122702012-01-17 00:37:07 +00003000 return 0;
Anna Zaks201d4892012-01-13 21:52:01 +00003001
3002 // Builtin handling.
3003 switch (getBuiltinID()) {
3004 case Builtin::BI__builtin_memset:
3005 case Builtin::BI__builtin___memset_chk:
3006 case Builtin::BImemset:
Anna Zaks22122702012-01-17 00:37:07 +00003007 return Builtin::BImemset;
Anna Zaks201d4892012-01-13 21:52:01 +00003008
3009 case Builtin::BI__builtin_memcpy:
3010 case Builtin::BI__builtin___memcpy_chk:
3011 case Builtin::BImemcpy:
Anna Zaks22122702012-01-17 00:37:07 +00003012 return Builtin::BImemcpy;
Anna Zaks201d4892012-01-13 21:52:01 +00003013
3014 case Builtin::BI__builtin_memmove:
3015 case Builtin::BI__builtin___memmove_chk:
3016 case Builtin::BImemmove:
Anna Zaks22122702012-01-17 00:37:07 +00003017 return Builtin::BImemmove;
Anna Zaks201d4892012-01-13 21:52:01 +00003018
3019 case Builtin::BIstrlcpy:
Anna Zaks22122702012-01-17 00:37:07 +00003020 return Builtin::BIstrlcpy;
Anna Zaks201d4892012-01-13 21:52:01 +00003021 case Builtin::BIstrlcat:
Anna Zaks22122702012-01-17 00:37:07 +00003022 return Builtin::BIstrlcat;
Anna Zaks201d4892012-01-13 21:52:01 +00003023
3024 case Builtin::BI__builtin_memcmp:
Anna Zaks22122702012-01-17 00:37:07 +00003025 case Builtin::BImemcmp:
3026 return Builtin::BImemcmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003027
3028 case Builtin::BI__builtin_strncpy:
3029 case Builtin::BI__builtin___strncpy_chk:
3030 case Builtin::BIstrncpy:
Anna Zaks22122702012-01-17 00:37:07 +00003031 return Builtin::BIstrncpy;
Anna Zaks201d4892012-01-13 21:52:01 +00003032
3033 case Builtin::BI__builtin_strncmp:
Anna Zaks22122702012-01-17 00:37:07 +00003034 case Builtin::BIstrncmp:
3035 return Builtin::BIstrncmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003036
3037 case Builtin::BI__builtin_strncasecmp:
Anna Zaks22122702012-01-17 00:37:07 +00003038 case Builtin::BIstrncasecmp:
3039 return Builtin::BIstrncasecmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003040
3041 case Builtin::BI__builtin_strncat:
Anna Zaks314cd092012-02-01 19:08:57 +00003042 case Builtin::BI__builtin___strncat_chk:
Anna Zaks201d4892012-01-13 21:52:01 +00003043 case Builtin::BIstrncat:
Anna Zaks22122702012-01-17 00:37:07 +00003044 return Builtin::BIstrncat;
Anna Zaks201d4892012-01-13 21:52:01 +00003045
3046 case Builtin::BI__builtin_strndup:
3047 case Builtin::BIstrndup:
Anna Zaks22122702012-01-17 00:37:07 +00003048 return Builtin::BIstrndup;
Anna Zaks201d4892012-01-13 21:52:01 +00003049
Anna Zaks314cd092012-02-01 19:08:57 +00003050 case Builtin::BI__builtin_strlen:
3051 case Builtin::BIstrlen:
3052 return Builtin::BIstrlen;
3053
Anna Zaks201d4892012-01-13 21:52:01 +00003054 default:
Rafael Espindola5bda63f2013-02-14 01:47:04 +00003055 if (isExternC()) {
Anna Zaks201d4892012-01-13 21:52:01 +00003056 if (FnInfo->isStr("memset"))
Anna Zaks22122702012-01-17 00:37:07 +00003057 return Builtin::BImemset;
Anna Zaks201d4892012-01-13 21:52:01 +00003058 else if (FnInfo->isStr("memcpy"))
Anna Zaks22122702012-01-17 00:37:07 +00003059 return Builtin::BImemcpy;
Anna Zaks201d4892012-01-13 21:52:01 +00003060 else if (FnInfo->isStr("memmove"))
Anna Zaks22122702012-01-17 00:37:07 +00003061 return Builtin::BImemmove;
Anna Zaks201d4892012-01-13 21:52:01 +00003062 else if (FnInfo->isStr("memcmp"))
Anna Zaks22122702012-01-17 00:37:07 +00003063 return Builtin::BImemcmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003064 else if (FnInfo->isStr("strncpy"))
Anna Zaks22122702012-01-17 00:37:07 +00003065 return Builtin::BIstrncpy;
Anna Zaks201d4892012-01-13 21:52:01 +00003066 else if (FnInfo->isStr("strncmp"))
Anna Zaks22122702012-01-17 00:37:07 +00003067 return Builtin::BIstrncmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003068 else if (FnInfo->isStr("strncasecmp"))
Anna Zaks22122702012-01-17 00:37:07 +00003069 return Builtin::BIstrncasecmp;
Anna Zaks201d4892012-01-13 21:52:01 +00003070 else if (FnInfo->isStr("strncat"))
Anna Zaks22122702012-01-17 00:37:07 +00003071 return Builtin::BIstrncat;
Anna Zaks201d4892012-01-13 21:52:01 +00003072 else if (FnInfo->isStr("strndup"))
Anna Zaks22122702012-01-17 00:37:07 +00003073 return Builtin::BIstrndup;
Anna Zaks314cd092012-02-01 19:08:57 +00003074 else if (FnInfo->isStr("strlen"))
3075 return Builtin::BIstrlen;
Anna Zaks201d4892012-01-13 21:52:01 +00003076 }
3077 break;
3078 }
Anna Zaks22122702012-01-17 00:37:07 +00003079 return 0;
Anna Zaks201d4892012-01-13 21:52:01 +00003080}
3081
Chris Lattner59a25942008-03-31 00:36:02 +00003082//===----------------------------------------------------------------------===//
Sebastian Redl833ef452010-01-26 22:01:41 +00003083// FieldDecl Implementation
3084//===----------------------------------------------------------------------===//
3085
Jay Foad39c79802011-01-12 09:06:06 +00003086FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC,
Abramo Bagnaradff19302011-03-08 08:55:46 +00003087 SourceLocation StartLoc, SourceLocation IdLoc,
3088 IdentifierInfo *Id, QualType T,
Richard Smith938f40b2011-06-11 17:19:42 +00003089 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
Richard Smith2b013182012-06-10 03:12:00 +00003090 InClassInitStyle InitStyle) {
Richard Smithf7981722013-11-22 09:01:48 +00003091 return new (C, DC) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo,
3092 BW, Mutable, InitStyle);
Sebastian Redl833ef452010-01-26 22:01:41 +00003093}
3094
Douglas Gregor72172e92012-01-05 21:55:30 +00003095FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003096 return new (C, ID) FieldDecl(Field, 0, SourceLocation(), SourceLocation(),
3097 0, QualType(), 0, 0, false, ICIS_NoInit);
Douglas Gregor72172e92012-01-05 21:55:30 +00003098}
3099
Sebastian Redl833ef452010-01-26 22:01:41 +00003100bool FieldDecl::isAnonymousStructOrUnion() const {
3101 if (!isImplicit() || getDeclName())
3102 return false;
3103
3104 if (const RecordType *Record = getType()->getAs<RecordType>())
3105 return Record->getDecl()->isAnonymousStructOrUnion();
3106
3107 return false;
3108}
3109
Richard Smithcaf33902011-10-10 18:28:20 +00003110unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const {
3111 assert(isBitField() && "not a bitfield");
3112 Expr *BitWidth = InitializerOrBitWidth.getPointer();
3113 return BitWidth->EvaluateKnownConstInt(Ctx).getZExtValue();
3114}
3115
John McCall4e819612011-01-20 07:57:12 +00003116unsigned FieldDecl::getFieldIndex() const {
Richard Smith0b87e072013-10-07 08:02:11 +00003117 const FieldDecl *Canonical = getCanonicalDecl();
3118 if (Canonical != this)
3119 return Canonical->getFieldIndex();
3120
John McCall4e819612011-01-20 07:57:12 +00003121 if (CachedFieldIndex) return CachedFieldIndex - 1;
3122
Richard Smithd62306a2011-11-10 06:34:14 +00003123 unsigned Index = 0;
Fariborz Jahanian8409bce42011-04-28 22:49:46 +00003124 const RecordDecl *RD = getParent();
Richard Smithd62306a2011-11-10 06:34:14 +00003125
3126 for (RecordDecl::field_iterator I = RD->field_begin(), E = RD->field_end();
Eli Friedman2782dac2013-06-26 20:50:34 +00003127 I != E; ++I, ++Index)
Richard Smith0b87e072013-10-07 08:02:11 +00003128 I->getCanonicalDecl()->CachedFieldIndex = Index + 1;
John McCall4e819612011-01-20 07:57:12 +00003129
Richard Smithd62306a2011-11-10 06:34:14 +00003130 assert(CachedFieldIndex && "failed to find field in parent");
3131 return CachedFieldIndex - 1;
John McCall4e819612011-01-20 07:57:12 +00003132}
3133
Abramo Bagnara20c9e242011-03-08 11:07:11 +00003134SourceRange FieldDecl::getSourceRange() const {
Abramo Bagnaraff371ac2011-08-05 08:02:55 +00003135 if (const Expr *E = InitializerOrBitWidth.getPointer())
3136 return SourceRange(getInnerLocStart(), E->getLocEnd());
Abramo Bagnaraea947882011-03-08 16:41:52 +00003137 return DeclaratorDecl::getSourceRange();
Abramo Bagnara20c9e242011-03-08 11:07:11 +00003138}
3139
Abramo Bagnarab1cdde72012-07-02 20:35:48 +00003140void FieldDecl::setBitWidth(Expr *Width) {
3141 assert(!InitializerOrBitWidth.getPointer() && !hasInClassInitializer() &&
3142 "bit width or initializer already set");
3143 InitializerOrBitWidth.setPointer(Width);
3144}
3145
Richard Smith938f40b2011-06-11 17:19:42 +00003146void FieldDecl::setInClassInitializer(Expr *Init) {
Richard Smith2b013182012-06-10 03:12:00 +00003147 assert(!InitializerOrBitWidth.getPointer() && hasInClassInitializer() &&
Richard Smith938f40b2011-06-11 17:19:42 +00003148 "bit width or initializer already set");
3149 InitializerOrBitWidth.setPointer(Init);
Richard Smith938f40b2011-06-11 17:19:42 +00003150}
3151
Sebastian Redl833ef452010-01-26 22:01:41 +00003152//===----------------------------------------------------------------------===//
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003153// TagDecl Implementation
Ted Kremenek21475702008-09-05 17:16:31 +00003154//===----------------------------------------------------------------------===//
3155
Douglas Gregorec9c6ae2010-07-06 18:42:40 +00003156SourceLocation TagDecl::getOuterLocStart() const {
3157 return getTemplateOrInnerLocStart(this);
3158}
3159
Argyrios Kyrtzidis575fa052009-07-14 03:17:17 +00003160SourceRange TagDecl::getSourceRange() const {
3161 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
Douglas Gregorec9c6ae2010-07-06 18:42:40 +00003162 return SourceRange(getOuterLocStart(), E);
Argyrios Kyrtzidis575fa052009-07-14 03:17:17 +00003163}
3164
Rafael Espindola8db352d2013-10-17 15:37:26 +00003165TagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); }
Argyrios Kyrtzidis5614aef2009-07-18 00:34:07 +00003166
Rafael Espindolabf5c33b2013-03-12 21:06:00 +00003167void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) {
David Majnemer50ce8352013-09-17 23:57:10 +00003168 NamedDeclOrQualifier = TDD;
Douglas Gregora72a4e32010-05-19 18:39:18 +00003169 if (TypeForDecl)
Rafael Espindola0e0d0092013-03-14 03:07:35 +00003170 assert(TypeForDecl->isLinkageValid());
3171 assert(isLinkageValid());
Douglas Gregora72a4e32010-05-19 18:39:18 +00003172}
3173
Douglas Gregordee1be82009-01-17 00:42:38 +00003174void TagDecl::startDefinition() {
Sebastian Redl9d8854e2010-08-02 18:27:05 +00003175 IsBeingDefined = true;
John McCall67da35c2010-02-04 22:26:26 +00003176
David Blaikie095deba2012-11-14 01:52:05 +00003177 if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(this)) {
John McCall67da35c2010-02-04 22:26:26 +00003178 struct CXXRecordDecl::DefinitionData *Data =
3179 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
John McCall93cc7322010-03-26 21:56:38 +00003180 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I)
3181 cast<CXXRecordDecl>(*I)->DefinitionData = Data;
John McCall67da35c2010-02-04 22:26:26 +00003182 }
Douglas Gregordee1be82009-01-17 00:42:38 +00003183}
3184
3185void TagDecl::completeDefinition() {
John McCallae580fe2010-02-05 01:33:36 +00003186 assert((!isa<CXXRecordDecl>(this) ||
3187 cast<CXXRecordDecl>(this)->hasDefinition()) &&
3188 "definition completed but not started");
3189
John McCallf937c022011-10-07 06:10:15 +00003190 IsCompleteDefinition = true;
Sebastian Redl9d8854e2010-08-02 18:27:05 +00003191 IsBeingDefined = false;
Argyrios Kyrtzidisd170d842010-10-24 17:26:50 +00003192
3193 if (ASTMutationListener *L = getASTMutationListener())
3194 L->CompletedTagDefinition(this);
Douglas Gregordee1be82009-01-17 00:42:38 +00003195}
3196
John McCallf937c022011-10-07 06:10:15 +00003197TagDecl *TagDecl::getDefinition() const {
3198 if (isCompleteDefinition())
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +00003199 return const_cast<TagDecl *>(this);
Douglas Gregor7dab26b2013-02-09 01:35:03 +00003200
3201 // If it's possible for us to have an out-of-date definition, check now.
3202 if (MayHaveOutOfDateDef) {
3203 if (IdentifierInfo *II = getIdentifier()) {
3204 if (II->isOutOfDate()) {
3205 updateOutOfDate(*II);
3206 }
3207 }
3208 }
3209
Andrew Trickba266ee2010-10-19 21:54:32 +00003210 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this))
3211 return CXXRD->getDefinition();
Mike Stump11289f42009-09-09 15:08:12 +00003212
3213 for (redecl_iterator R = redecls_begin(), REnd = redecls_end();
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +00003214 R != REnd; ++R)
John McCallf937c022011-10-07 06:10:15 +00003215 if (R->isCompleteDefinition())
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +00003216 return *R;
Mike Stump11289f42009-09-09 15:08:12 +00003217
Douglas Gregorb6b8f9e2009-07-29 23:36:44 +00003218 return 0;
Ted Kremenek21475702008-09-05 17:16:31 +00003219}
3220
Douglas Gregor14454802011-02-25 02:25:35 +00003221void TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
3222 if (QualifierLoc) {
John McCall3e11ebe2010-03-15 10:12:16 +00003223 // Make sure the extended qualifier info is allocated.
3224 if (!hasExtInfo())
David Majnemer50ce8352013-09-17 23:57:10 +00003225 NamedDeclOrQualifier = new (getASTContext()) ExtInfo;
John McCall3e11ebe2010-03-15 10:12:16 +00003226 // Set qualifier info.
Douglas Gregor14454802011-02-25 02:25:35 +00003227 getExtInfo()->QualifierLoc = QualifierLoc;
Chad Rosier6fdf38b2011-08-17 23:08:45 +00003228 } else {
John McCall3e11ebe2010-03-15 10:12:16 +00003229 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
John McCall3e11ebe2010-03-15 10:12:16 +00003230 if (hasExtInfo()) {
Abramo Bagnara60804e12011-03-18 15:16:37 +00003231 if (getExtInfo()->NumTemplParamLists == 0) {
3232 getASTContext().Deallocate(getExtInfo());
David Majnemer50ce8352013-09-17 23:57:10 +00003233 NamedDeclOrQualifier = (TypedefNameDecl*) 0;
Abramo Bagnara60804e12011-03-18 15:16:37 +00003234 }
3235 else
3236 getExtInfo()->QualifierLoc = QualifierLoc;
John McCall3e11ebe2010-03-15 10:12:16 +00003237 }
3238 }
3239}
3240
Abramo Bagnara60804e12011-03-18 15:16:37 +00003241void TagDecl::setTemplateParameterListsInfo(ASTContext &Context,
3242 unsigned NumTPLists,
3243 TemplateParameterList **TPLists) {
3244 assert(NumTPLists > 0);
3245 // Make sure the extended decl info is allocated.
3246 if (!hasExtInfo())
3247 // Allocate external info struct.
David Majnemer50ce8352013-09-17 23:57:10 +00003248 NamedDeclOrQualifier = new (getASTContext()) ExtInfo;
Abramo Bagnara60804e12011-03-18 15:16:37 +00003249 // Set the template parameter lists info.
3250 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists);
3251}
3252
Ted Kremenek21475702008-09-05 17:16:31 +00003253//===----------------------------------------------------------------------===//
Sebastian Redl833ef452010-01-26 22:01:41 +00003254// EnumDecl Implementation
3255//===----------------------------------------------------------------------===//
3256
David Blaikie68e081d2011-12-20 02:48:34 +00003257void EnumDecl::anchor() { }
3258
Abramo Bagnara29c2d462011-03-09 14:09:51 +00003259EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC,
3260 SourceLocation StartLoc, SourceLocation IdLoc,
3261 IdentifierInfo *Id,
Abramo Bagnara0e05e242010-12-03 18:54:17 +00003262 EnumDecl *PrevDecl, bool IsScoped,
3263 bool IsScopedUsingClassTag, bool IsFixed) {
Richard Smithf7981722013-11-22 09:01:48 +00003264 EnumDecl *Enum = new (C, DC) EnumDecl(DC, StartLoc, IdLoc, Id, PrevDecl,
3265 IsScoped, IsScopedUsingClassTag,
3266 IsFixed);
Douglas Gregor7dab26b2013-02-09 01:35:03 +00003267 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
Sebastian Redl833ef452010-01-26 22:01:41 +00003268 C.getTypeDeclType(Enum, PrevDecl);
3269 return Enum;
3270}
3271
Douglas Gregor72172e92012-01-05 21:55:30 +00003272EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003273 EnumDecl *Enum = new (C, ID) EnumDecl(0, SourceLocation(), SourceLocation(),
3274 0, 0, false, false, false);
Douglas Gregor7dab26b2013-02-09 01:35:03 +00003275 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3276 return Enum;
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00003277}
3278
Douglas Gregord5058122010-02-11 01:19:42 +00003279void EnumDecl::completeDefinition(QualType NewType,
John McCall9aa35be2010-05-06 08:49:23 +00003280 QualType NewPromotionType,
3281 unsigned NumPositiveBits,
3282 unsigned NumNegativeBits) {
John McCallf937c022011-10-07 06:10:15 +00003283 assert(!isCompleteDefinition() && "Cannot redefine enums!");
Douglas Gregor0bf31402010-10-08 23:50:27 +00003284 if (!IntegerType)
3285 IntegerType = NewType.getTypePtr();
Sebastian Redl833ef452010-01-26 22:01:41 +00003286 PromotionType = NewPromotionType;
John McCall9aa35be2010-05-06 08:49:23 +00003287 setNumPositiveBits(NumPositiveBits);
3288 setNumNegativeBits(NumNegativeBits);
Sebastian Redl833ef452010-01-26 22:01:41 +00003289 TagDecl::completeDefinition();
3290}
3291
Richard Smith7d137e32012-03-23 03:33:32 +00003292TemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const {
3293 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
3294 return MSI->getTemplateSpecializationKind();
3295
3296 return TSK_Undeclared;
3297}
3298
3299void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3300 SourceLocation PointOfInstantiation) {
3301 MemberSpecializationInfo *MSI = getMemberSpecializationInfo();
3302 assert(MSI && "Not an instantiated member enumeration?");
3303 MSI->setTemplateSpecializationKind(TSK);
3304 if (TSK != TSK_ExplicitSpecialization &&
3305 PointOfInstantiation.isValid() &&
3306 MSI->getPointOfInstantiation().isInvalid())
3307 MSI->setPointOfInstantiation(PointOfInstantiation);
3308}
3309
Richard Smith4b38ded2012-03-14 23:13:10 +00003310EnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const {
3311 if (SpecializationInfo)
3312 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom());
3313
3314 return 0;
3315}
3316
3317void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3318 TemplateSpecializationKind TSK) {
3319 assert(!SpecializationInfo && "Member enum is already a specialization");
3320 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK);
3321}
3322
Sebastian Redl833ef452010-01-26 22:01:41 +00003323//===----------------------------------------------------------------------===//
Chris Lattner59a25942008-03-31 00:36:02 +00003324// RecordDecl Implementation
3325//===----------------------------------------------------------------------===//
Chris Lattner41943152007-01-25 04:52:46 +00003326
Abramo Bagnara29c2d462011-03-09 14:09:51 +00003327RecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC,
3328 SourceLocation StartLoc, SourceLocation IdLoc,
3329 IdentifierInfo *Id, RecordDecl *PrevDecl)
3330 : TagDecl(DK, TK, DC, IdLoc, Id, PrevDecl, StartLoc) {
Ted Kremenek52baf502008-09-02 21:12:32 +00003331 HasFlexibleArrayMember = false;
Douglas Gregor9ac7a072009-01-07 00:43:41 +00003332 AnonymousStructOrUnion = false;
Fariborz Jahanian5f21d2f2009-07-08 01:18:33 +00003333 HasObjectMember = false;
Fariborz Jahanian78652202013-01-25 23:57:05 +00003334 HasVolatileMember = false;
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003335 LoadedFieldsFromExternalStorage = false;
Ted Kremenek52baf502008-09-02 21:12:32 +00003336 assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!");
Ted Kremenek52baf502008-09-02 21:12:32 +00003337}
3338
Jay Foad39c79802011-01-12 09:06:06 +00003339RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
Abramo Bagnara29c2d462011-03-09 14:09:51 +00003340 SourceLocation StartLoc, SourceLocation IdLoc,
3341 IdentifierInfo *Id, RecordDecl* PrevDecl) {
Richard Smithf7981722013-11-22 09:01:48 +00003342 RecordDecl* R = new (C, DC) RecordDecl(Record, TK, DC, StartLoc, IdLoc, Id,
3343 PrevDecl);
Douglas Gregor7dab26b2013-02-09 01:35:03 +00003344 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3345
Ted Kremenek21475702008-09-05 17:16:31 +00003346 C.getTypeDeclType(R, PrevDecl);
3347 return R;
Ted Kremenek52baf502008-09-02 21:12:32 +00003348}
3349
Douglas Gregor72172e92012-01-05 21:55:30 +00003350RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003351 RecordDecl *R = new (C, ID) RecordDecl(Record, TTK_Struct, 0, SourceLocation(),
3352 SourceLocation(), 0, 0);
Douglas Gregor7dab26b2013-02-09 01:35:03 +00003353 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3354 return R;
Argyrios Kyrtzidis39f0e302010-07-02 11:54:55 +00003355}
3356
Douglas Gregordfcad112009-03-25 15:59:44 +00003357bool RecordDecl::isInjectedClassName() const {
Mike Stump11289f42009-09-09 15:08:12 +00003358 return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
Douglas Gregordfcad112009-03-25 15:59:44 +00003359 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
3360}
3361
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003362RecordDecl::field_iterator RecordDecl::field_begin() const {
3363 if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage)
3364 LoadFieldsFromExternalStorage();
3365
3366 return field_iterator(decl_iterator(FirstDecl));
3367}
3368
Douglas Gregorb11aad82011-02-19 18:51:44 +00003369/// completeDefinition - Notes that the definition of this type is now
3370/// complete.
3371void RecordDecl::completeDefinition() {
John McCallf937c022011-10-07 06:10:15 +00003372 assert(!isCompleteDefinition() && "Cannot redefine record!");
Douglas Gregorb11aad82011-02-19 18:51:44 +00003373 TagDecl::completeDefinition();
3374}
3375
Eli Friedman9ee2d0472012-10-12 23:29:20 +00003376/// isMsStruct - Get whether or not this record uses ms_struct layout.
3377/// This which can be turned on with an attribute, pragma, or the
3378/// -mms-bitfields command-line option.
3379bool RecordDecl::isMsStruct(const ASTContext &C) const {
3380 return hasAttr<MsStructAttr>() || C.getLangOpts().MSBitfields == 1;
3381}
3382
Argyrios Kyrtzidisf89a9272012-09-10 22:04:22 +00003383static bool isFieldOrIndirectField(Decl::Kind K) {
3384 return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
3385}
3386
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003387void RecordDecl::LoadFieldsFromExternalStorage() const {
3388 ExternalASTSource *Source = getASTContext().getExternalSource();
3389 assert(hasExternalLexicalStorage() && Source && "No external storage?");
3390
3391 // Notify that we have a RecordDecl doing some initialization.
3392 ExternalASTSource::Deserializing TheFields(Source);
3393
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003394 SmallVector<Decl*, 64> Decls;
Douglas Gregor3d0adb32011-07-15 21:46:17 +00003395 LoadedFieldsFromExternalStorage = true;
Argyrios Kyrtzidisf89a9272012-09-10 22:04:22 +00003396 switch (Source->FindExternalLexicalDecls(this, isFieldOrIndirectField,
3397 Decls)) {
Douglas Gregor3d0adb32011-07-15 21:46:17 +00003398 case ELR_Success:
3399 break;
3400
3401 case ELR_AlreadyLoaded:
3402 case ELR_Failure:
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003403 return;
Douglas Gregor3d0adb32011-07-15 21:46:17 +00003404 }
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003405
3406#ifndef NDEBUG
3407 // Check that all decls we got were FieldDecls.
3408 for (unsigned i=0, e=Decls.size(); i != e; ++i)
Argyrios Kyrtzidisf89a9272012-09-10 22:04:22 +00003409 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003410#endif
3411
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003412 if (Decls.empty())
3413 return;
3414
Argyrios Kyrtzidis094da732011-10-07 21:55:43 +00003415 llvm::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls,
3416 /*FieldsAlreadyLoaded=*/false);
Argyrios Kyrtzidis0e88a562010-10-14 20:14:34 +00003417}
3418
Steve Naroff415d3d52008-10-08 17:01:13 +00003419//===----------------------------------------------------------------------===//
3420// BlockDecl Implementation
3421//===----------------------------------------------------------------------===//
3422
Dmitri Gribenkof8579502013-01-12 19:30:44 +00003423void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
Steve Naroffc4b30e52009-03-13 16:56:44 +00003424 assert(ParamInfo == 0 && "Already has param info!");
Mike Stump11289f42009-09-09 15:08:12 +00003425
Steve Naroffc4b30e52009-03-13 16:56:44 +00003426 // Zero params -> null pointer.
David Blaikie9c70e042011-09-21 18:16:56 +00003427 if (!NewParamInfo.empty()) {
3428 NumParams = NewParamInfo.size();
3429 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
3430 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
Steve Naroffc4b30e52009-03-13 16:56:44 +00003431 }
3432}
3433
John McCall351762c2011-02-07 10:33:21 +00003434void BlockDecl::setCaptures(ASTContext &Context,
3435 const Capture *begin,
3436 const Capture *end,
3437 bool capturesCXXThis) {
John McCallc63de662011-02-02 13:00:07 +00003438 CapturesCXXThis = capturesCXXThis;
3439
3440 if (begin == end) {
John McCall351762c2011-02-07 10:33:21 +00003441 NumCaptures = 0;
3442 Captures = 0;
John McCallc63de662011-02-02 13:00:07 +00003443 return;
3444 }
3445
John McCall351762c2011-02-07 10:33:21 +00003446 NumCaptures = end - begin;
3447
3448 // Avoid new Capture[] because we don't want to provide a default
3449 // constructor.
3450 size_t allocationSize = NumCaptures * sizeof(Capture);
3451 void *buffer = Context.Allocate(allocationSize, /*alignment*/sizeof(void*));
3452 memcpy(buffer, begin, allocationSize);
3453 Captures = static_cast<Capture*>(buffer);
Steve Naroffc4b30e52009-03-13 16:56:44 +00003454}
Sebastian Redl833ef452010-01-26 22:01:41 +00003455
John McCallce45f882011-06-15 22:51:16 +00003456bool BlockDecl::capturesVariable(const VarDecl *variable) const {
3457 for (capture_const_iterator
3458 i = capture_begin(), e = capture_end(); i != e; ++i)
3459 // Only auto vars can be captured, so no redeclaration worries.
3460 if (i->getVariable() == variable)
3461 return true;
3462
3463 return false;
3464}
3465
Douglas Gregor70226da2010-12-21 16:27:07 +00003466SourceRange BlockDecl::getSourceRange() const {
3467 return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation());
3468}
Sebastian Redl833ef452010-01-26 22:01:41 +00003469
3470//===----------------------------------------------------------------------===//
3471// Other Decl Allocation/Deallocation Method Implementations
3472//===----------------------------------------------------------------------===//
3473
David Blaikie68e081d2011-12-20 02:48:34 +00003474void TranslationUnitDecl::anchor() { }
3475
Sebastian Redl833ef452010-01-26 22:01:41 +00003476TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) {
Richard Smithf7981722013-11-22 09:01:48 +00003477 return new (C, (DeclContext*)0) TranslationUnitDecl(C);
Sebastian Redl833ef452010-01-26 22:01:41 +00003478}
3479
David Blaikie68e081d2011-12-20 02:48:34 +00003480void LabelDecl::anchor() { }
3481
Chris Lattnerc8e630e2011-02-17 07:39:24 +00003482LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnara1c3af962011-03-05 18:21:20 +00003483 SourceLocation IdentL, IdentifierInfo *II) {
Richard Smithf7981722013-11-22 09:01:48 +00003484 return new (C, DC) LabelDecl(DC, IdentL, II, 0, IdentL);
Abramo Bagnara1c3af962011-03-05 18:21:20 +00003485}
3486
3487LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
3488 SourceLocation IdentL, IdentifierInfo *II,
3489 SourceLocation GnuLabelL) {
3490 assert(GnuLabelL != IdentL && "Use this only for GNU local labels");
Richard Smithf7981722013-11-22 09:01:48 +00003491 return new (C, DC) LabelDecl(DC, IdentL, II, 0, GnuLabelL);
Chris Lattnerc8e630e2011-02-17 07:39:24 +00003492}
3493
Douglas Gregor72172e92012-01-05 21:55:30 +00003494LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003495 return new (C, ID) LabelDecl(0, SourceLocation(), 0, 0, SourceLocation());
Douglas Gregor417e87c2010-10-27 19:49:05 +00003496}
3497
David Blaikie68e081d2011-12-20 02:48:34 +00003498void ValueDecl::anchor() { }
3499
Benjamin Kramerea70eb32012-12-01 15:09:41 +00003500bool ValueDecl::isWeak() const {
3501 for (attr_iterator I = attr_begin(), E = attr_end(); I != E; ++I)
3502 if (isa<WeakAttr>(*I) || isa<WeakRefAttr>(*I))
3503 return true;
3504
3505 return isWeakImported();
3506}
3507
David Blaikie68e081d2011-12-20 02:48:34 +00003508void ImplicitParamDecl::anchor() { }
3509
Sebastian Redl833ef452010-01-26 22:01:41 +00003510ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnaradff19302011-03-08 08:55:46 +00003511 SourceLocation IdLoc,
3512 IdentifierInfo *Id,
3513 QualType Type) {
Richard Smithf7981722013-11-22 09:01:48 +00003514 return new (C, DC) ImplicitParamDecl(DC, IdLoc, Id, Type);
Sebastian Redl833ef452010-01-26 22:01:41 +00003515}
3516
Richard Smithf7981722013-11-22 09:01:48 +00003517ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C,
Douglas Gregor72172e92012-01-05 21:55:30 +00003518 unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003519 return new (C, ID) ImplicitParamDecl(0, SourceLocation(), 0, QualType());
Douglas Gregor72172e92012-01-05 21:55:30 +00003520}
3521
Sebastian Redl833ef452010-01-26 22:01:41 +00003522FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnaradff19302011-03-08 08:55:46 +00003523 SourceLocation StartLoc,
Abramo Bagnarad6d2f182010-08-11 22:01:17 +00003524 const DeclarationNameInfo &NameInfo,
3525 QualType T, TypeSourceInfo *TInfo,
Rafael Espindola6ae7e502013-04-03 19:27:57 +00003526 StorageClass SC,
Richard Smithf7981722013-11-22 09:01:48 +00003527 bool isInlineSpecified,
Richard Smitha77a0a62011-08-15 21:04:07 +00003528 bool hasWrittenPrototype,
3529 bool isConstexprSpecified) {
Richard Smithf7981722013-11-22 09:01:48 +00003530 FunctionDecl *New =
3531 new (C, DC) FunctionDecl(Function, DC, StartLoc, NameInfo, T, TInfo, SC,
3532 isInlineSpecified, isConstexprSpecified);
Sebastian Redl833ef452010-01-26 22:01:41 +00003533 New->HasWrittenPrototype = hasWrittenPrototype;
3534 return New;
3535}
3536
Douglas Gregor72172e92012-01-05 21:55:30 +00003537FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003538 return new (C, ID) FunctionDecl(Function, 0, SourceLocation(),
3539 DeclarationNameInfo(), QualType(), 0,
3540 SC_None, false, false);
Douglas Gregor72172e92012-01-05 21:55:30 +00003541}
3542
Sebastian Redl833ef452010-01-26 22:01:41 +00003543BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
Richard Smithf7981722013-11-22 09:01:48 +00003544 return new (C, DC) BlockDecl(DC, L);
Sebastian Redl833ef452010-01-26 22:01:41 +00003545}
3546
Douglas Gregor72172e92012-01-05 21:55:30 +00003547BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003548 return new (C, ID) BlockDecl(0, SourceLocation());
John McCall5e77d762013-04-16 07:28:30 +00003549}
3550
Ben Langmuir37943a72013-05-03 19:00:33 +00003551CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC,
3552 unsigned NumParams) {
Richard Smithf7981722013-11-22 09:01:48 +00003553 return new (C, DC, NumParams * sizeof(ImplicitParamDecl *))
3554 CapturedDecl(DC, NumParams);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00003555}
3556
Ben Langmuirce914fc2013-05-03 19:20:19 +00003557CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID,
Richard Smithf7981722013-11-22 09:01:48 +00003558 unsigned NumParams) {
3559 return new (C, ID, NumParams * sizeof(ImplicitParamDecl *))
3560 CapturedDecl(0, NumParams);
Ben Langmuirce914fc2013-05-03 19:20:19 +00003561}
3562
Sebastian Redl833ef452010-01-26 22:01:41 +00003563EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD,
3564 SourceLocation L,
3565 IdentifierInfo *Id, QualType T,
3566 Expr *E, const llvm::APSInt &V) {
Richard Smithf7981722013-11-22 09:01:48 +00003567 return new (C, CD) EnumConstantDecl(CD, L, Id, T, E, V);
Sebastian Redl833ef452010-01-26 22:01:41 +00003568}
3569
Douglas Gregor72172e92012-01-05 21:55:30 +00003570EnumConstantDecl *
3571EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003572 return new (C, ID) EnumConstantDecl(0, SourceLocation(), 0, QualType(), 0,
3573 llvm::APSInt());
Douglas Gregor72172e92012-01-05 21:55:30 +00003574}
3575
David Blaikie68e081d2011-12-20 02:48:34 +00003576void IndirectFieldDecl::anchor() { }
3577
Benjamin Kramer39593702010-11-21 14:11:41 +00003578IndirectFieldDecl *
3579IndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
3580 IdentifierInfo *Id, QualType T, NamedDecl **CH,
3581 unsigned CHS) {
Richard Smithf7981722013-11-22 09:01:48 +00003582 return new (C, DC) IndirectFieldDecl(DC, L, Id, T, CH, CHS);
Francois Pichet783dd6e2010-11-21 06:08:52 +00003583}
3584
Douglas Gregor72172e92012-01-05 21:55:30 +00003585IndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C,
3586 unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003587 return new (C, ID) IndirectFieldDecl(0, SourceLocation(), DeclarationName(),
3588 QualType(), 0, 0);
Douglas Gregor72172e92012-01-05 21:55:30 +00003589}
3590
Douglas Gregorbe996932010-09-01 20:41:53 +00003591SourceRange EnumConstantDecl::getSourceRange() const {
3592 SourceLocation End = getLocation();
3593 if (Init)
3594 End = Init->getLocEnd();
3595 return SourceRange(getLocation(), End);
3596}
3597
David Blaikie68e081d2011-12-20 02:48:34 +00003598void TypeDecl::anchor() { }
3599
Sebastian Redl833ef452010-01-26 22:01:41 +00003600TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnarab3185b02011-03-06 15:48:19 +00003601 SourceLocation StartLoc, SourceLocation IdLoc,
3602 IdentifierInfo *Id, TypeSourceInfo *TInfo) {
Richard Smithf7981722013-11-22 09:01:48 +00003603 return new (C, DC) TypedefDecl(DC, StartLoc, IdLoc, Id, TInfo);
Sebastian Redl833ef452010-01-26 22:01:41 +00003604}
3605
David Blaikie68e081d2011-12-20 02:48:34 +00003606void TypedefNameDecl::anchor() { }
3607
Douglas Gregor72172e92012-01-05 21:55:30 +00003608TypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003609 return new (C, ID) TypedefDecl(0, SourceLocation(), SourceLocation(), 0, 0);
Douglas Gregor72172e92012-01-05 21:55:30 +00003610}
3611
Richard Smithdda56e42011-04-15 14:24:37 +00003612TypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC,
3613 SourceLocation StartLoc,
3614 SourceLocation IdLoc, IdentifierInfo *Id,
3615 TypeSourceInfo *TInfo) {
Richard Smithf7981722013-11-22 09:01:48 +00003616 return new (C, DC) TypeAliasDecl(DC, StartLoc, IdLoc, Id, TInfo);
Richard Smithdda56e42011-04-15 14:24:37 +00003617}
3618
Douglas Gregor72172e92012-01-05 21:55:30 +00003619TypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003620 return new (C, ID) TypeAliasDecl(0, SourceLocation(), SourceLocation(), 0, 0);
Douglas Gregor72172e92012-01-05 21:55:30 +00003621}
3622
Abramo Bagnaraea947882011-03-08 16:41:52 +00003623SourceRange TypedefDecl::getSourceRange() const {
3624 SourceLocation RangeEnd = getLocation();
3625 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
3626 if (typeIsPostfix(TInfo->getType()))
3627 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
3628 }
3629 return SourceRange(getLocStart(), RangeEnd);
3630}
3631
Richard Smithdda56e42011-04-15 14:24:37 +00003632SourceRange TypeAliasDecl::getSourceRange() const {
3633 SourceLocation RangeEnd = getLocStart();
3634 if (TypeSourceInfo *TInfo = getTypeSourceInfo())
3635 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
3636 return SourceRange(getLocStart(), RangeEnd);
3637}
3638
David Blaikie68e081d2011-12-20 02:48:34 +00003639void FileScopeAsmDecl::anchor() { }
3640
Sebastian Redl833ef452010-01-26 22:01:41 +00003641FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC,
Abramo Bagnara348823a2011-03-03 14:20:18 +00003642 StringLiteral *Str,
3643 SourceLocation AsmLoc,
3644 SourceLocation RParenLoc) {
Richard Smithf7981722013-11-22 09:01:48 +00003645 return new (C, DC) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc);
Sebastian Redl833ef452010-01-26 22:01:41 +00003646}
Douglas Gregorba345522011-12-02 23:23:56 +00003647
Richard Smithf7981722013-11-22 09:01:48 +00003648FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C,
Douglas Gregor72172e92012-01-05 21:55:30 +00003649 unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003650 return new (C, ID) FileScopeAsmDecl(0, 0, SourceLocation(), SourceLocation());
Douglas Gregor72172e92012-01-05 21:55:30 +00003651}
3652
Michael Han84324352013-02-22 17:15:32 +00003653void EmptyDecl::anchor() {}
3654
3655EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
Richard Smithf7981722013-11-22 09:01:48 +00003656 return new (C, DC) EmptyDecl(DC, L);
Michael Han84324352013-02-22 17:15:32 +00003657}
3658
3659EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
Richard Smithf7981722013-11-22 09:01:48 +00003660 return new (C, ID) EmptyDecl(0, SourceLocation());
Michael Han84324352013-02-22 17:15:32 +00003661}
3662
Douglas Gregorba345522011-12-02 23:23:56 +00003663//===----------------------------------------------------------------------===//
3664// ImportDecl Implementation
3665//===----------------------------------------------------------------------===//
3666
3667/// \brief Retrieve the number of module identifiers needed to name the given
3668/// module.
3669static unsigned getNumModuleIdentifiers(Module *Mod) {
3670 unsigned Result = 1;
3671 while (Mod->Parent) {
3672 Mod = Mod->Parent;
3673 ++Result;
3674 }
3675 return Result;
3676}
3677
Douglas Gregor22d09742012-01-03 18:04:46 +00003678ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
Douglas Gregorba345522011-12-02 23:23:56 +00003679 Module *Imported,
3680 ArrayRef<SourceLocation> IdentifierLocs)
Douglas Gregor22d09742012-01-03 18:04:46 +00003681 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true),
Douglas Gregor0f2a3602011-12-03 00:30:27 +00003682 NextLocalImport()
Douglas Gregorba345522011-12-02 23:23:56 +00003683{
3684 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size());
3685 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(this + 1);
3686 memcpy(StoredLocs, IdentifierLocs.data(),
3687 IdentifierLocs.size() * sizeof(SourceLocation));
3688}
3689
Douglas Gregor22d09742012-01-03 18:04:46 +00003690ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
Douglas Gregorba345522011-12-02 23:23:56 +00003691 Module *Imported, SourceLocation EndLoc)
Douglas Gregor22d09742012-01-03 18:04:46 +00003692 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false),
Douglas Gregor0f2a3602011-12-03 00:30:27 +00003693 NextLocalImport()
Douglas Gregorba345522011-12-02 23:23:56 +00003694{
3695 *reinterpret_cast<SourceLocation *>(this + 1) = EndLoc;
3696}
3697
Richard Smithf7981722013-11-22 09:01:48 +00003698ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC,
Douglas Gregor22d09742012-01-03 18:04:46 +00003699 SourceLocation StartLoc, Module *Imported,
Douglas Gregorba345522011-12-02 23:23:56 +00003700 ArrayRef<SourceLocation> IdentifierLocs) {
Richard Smithf7981722013-11-22 09:01:48 +00003701 return new (C, DC, IdentifierLocs.size() * sizeof(SourceLocation))
3702 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
Douglas Gregorba345522011-12-02 23:23:56 +00003703}
3704
Richard Smithf7981722013-11-22 09:01:48 +00003705ImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC,
Douglas Gregor22d09742012-01-03 18:04:46 +00003706 SourceLocation StartLoc,
Richard Smithf7981722013-11-22 09:01:48 +00003707 Module *Imported,
Douglas Gregorba345522011-12-02 23:23:56 +00003708 SourceLocation EndLoc) {
Richard Smithf7981722013-11-22 09:01:48 +00003709 ImportDecl *Import =
3710 new (C, DC, sizeof(SourceLocation)) ImportDecl(DC, StartLoc,
3711 Imported, EndLoc);
Douglas Gregorba345522011-12-02 23:23:56 +00003712 Import->setImplicit();
3713 return Import;
3714}
3715
Douglas Gregor72172e92012-01-05 21:55:30 +00003716ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID,
3717 unsigned NumLocations) {
Richard Smithf7981722013-11-22 09:01:48 +00003718 return new (C, ID, NumLocations * sizeof(SourceLocation))
3719 ImportDecl(EmptyShell());
Douglas Gregorba345522011-12-02 23:23:56 +00003720}
3721
3722ArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const {
3723 if (!ImportedAndComplete.getInt())
Dmitri Gribenko44ebbd52013-05-05 00:41:58 +00003724 return None;
Douglas Gregorba345522011-12-02 23:23:56 +00003725
3726 const SourceLocation *StoredLocs
3727 = reinterpret_cast<const SourceLocation *>(this + 1);
3728 return ArrayRef<SourceLocation>(StoredLocs,
3729 getNumModuleIdentifiers(getImportedModule()));
3730}
3731
3732SourceRange ImportDecl::getSourceRange() const {
3733 if (!ImportedAndComplete.getInt())
3734 return SourceRange(getLocation(),
3735 *reinterpret_cast<const SourceLocation *>(this + 1));
3736
3737 return SourceRange(getLocation(), getIdentifierLocs().back());
3738}