1 //===--- Decl.cpp - Declaration AST Node Implementation -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the Decl subclasses.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/Decl.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTLambda.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/Attr.h"
19 #include "clang/AST/DeclCXX.h"
20 #include "clang/AST/DeclObjC.h"
21 #include "clang/AST/DeclTemplate.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExprCXX.h"
24 #include "clang/AST/PrettyPrinter.h"
25 #include "clang/AST/Stmt.h"
26 #include "clang/AST/TypeLoc.h"
27 #include "clang/Basic/Builtins.h"
28 #include "clang/Basic/IdentifierTable.h"
29 #include "clang/Basic/Module.h"
30 #include "clang/Basic/Specifiers.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "clang/Frontend/FrontendDiagnostic.h"
33 #include "llvm/Support/ErrorHandling.h"
36 using namespace clang;
38 Decl *clang::getPrimaryMergedDecl(Decl *D) {
39 return D->getASTContext().getPrimaryMergedDecl(D);
42 // Defined here so that it can be inlined into its direct callers.
43 bool Decl::isOutOfLine() const {
44 return !getLexicalDeclContext()->Equals(getDeclContext());
47 //===----------------------------------------------------------------------===//
48 // NamedDecl Implementation
49 //===----------------------------------------------------------------------===//
51 // Visibility rules aren't rigorously externally specified, but here
52 // are the basic principles behind what we implement:
54 // 1. An explicit visibility attribute is generally a direct expression
55 // of the user's intent and should be honored. Only the innermost
56 // visibility attribute applies. If no visibility attribute applies,
57 // global visibility settings are considered.
59 // 2. There is one caveat to the above: on or in a template pattern,
60 // an explicit visibility attribute is just a default rule, and
61 // visibility can be decreased by the visibility of template
62 // arguments. But this, too, has an exception: an attribute on an
63 // explicit specialization or instantiation causes all the visibility
64 // restrictions of the template arguments to be ignored.
66 // 3. A variable that does not otherwise have explicit visibility can
67 // be restricted by the visibility of its type.
69 // 4. A visibility restriction is explicit if it comes from an
70 // attribute (or something like it), not a global visibility setting.
71 // When emitting a reference to an external symbol, visibility
72 // restrictions are ignored unless they are explicit.
74 // 5. When computing the visibility of a non-type, including a
75 // non-type member of a class, only non-type visibility restrictions
76 // are considered: the 'visibility' attribute, global value-visibility
77 // settings, and a few special cases like __private_extern.
79 // 6. When computing the visibility of a type, including a type member
80 // of a class, only type visibility restrictions are considered:
81 // the 'type_visibility' attribute and global type-visibility settings.
82 // However, a 'visibility' attribute counts as a 'type_visibility'
83 // attribute on any declaration that only has the former.
85 // The visibility of a "secondary" entity, like a template argument,
86 // is computed using the kind of that entity, not the kind of the
87 // primary entity for which we are computing visibility. For example,
88 // the visibility of a specialization of either of these templates:
89 // template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X);
90 // template <class T, bool (&compare)(T, X)> class matcher;
91 // is restricted according to the type visibility of the argument 'T',
92 // the type visibility of 'bool(&)(T,X)', and the value visibility of
93 // the argument function 'compare'. That 'has_match' is a value
94 // and 'matcher' is a type only matters when looking for attributes
95 // and settings from the immediate context.
97 const unsigned IgnoreExplicitVisibilityBit = 2;
98 const unsigned IgnoreAllVisibilityBit = 4;
100 /// Kinds of LV computation. The linkage side of the computation is
101 /// always the same, but different things can change how visibility is
103 enum LVComputationKind {
104 /// Do an LV computation for, ultimately, a type.
105 /// Visibility may be restricted by type visibility settings and
106 /// the visibility of template arguments.
107 LVForType = NamedDecl::VisibilityForType,
109 /// Do an LV computation for, ultimately, a non-type declaration.
110 /// Visibility may be restricted by value visibility settings and
111 /// the visibility of template arguments.
112 LVForValue = NamedDecl::VisibilityForValue,
114 /// Do an LV computation for, ultimately, a type that already has
115 /// some sort of explicit visibility. Visibility may only be
116 /// restricted by the visibility of template arguments.
117 LVForExplicitType = (LVForType | IgnoreExplicitVisibilityBit),
119 /// Do an LV computation for, ultimately, a non-type declaration
120 /// that already has some sort of explicit visibility. Visibility
121 /// may only be restricted by the visibility of template arguments.
122 LVForExplicitValue = (LVForValue | IgnoreExplicitVisibilityBit),
124 /// Do an LV computation when we only care about the linkage.
126 LVForValue | IgnoreExplicitVisibilityBit | IgnoreAllVisibilityBit
129 /// Does this computation kind permit us to consider additional
130 /// visibility settings from attributes and the like?
131 static bool hasExplicitVisibilityAlready(LVComputationKind computation) {
132 return ((unsigned(computation) & IgnoreExplicitVisibilityBit) != 0);
135 /// Given an LVComputationKind, return one of the same type/value sort
136 /// that records that it already has explicit visibility.
137 static LVComputationKind
138 withExplicitVisibilityAlready(LVComputationKind oldKind) {
139 LVComputationKind newKind =
140 static_cast<LVComputationKind>(unsigned(oldKind) |
141 IgnoreExplicitVisibilityBit);
142 assert(oldKind != LVForType || newKind == LVForExplicitType);
143 assert(oldKind != LVForValue || newKind == LVForExplicitValue);
144 assert(oldKind != LVForExplicitType || newKind == LVForExplicitType);
145 assert(oldKind != LVForExplicitValue || newKind == LVForExplicitValue);
149 static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
150 LVComputationKind kind) {
151 assert(!hasExplicitVisibilityAlready(kind) &&
152 "asking for explicit visibility when we shouldn't be");
153 return D->getExplicitVisibility((NamedDecl::ExplicitVisibilityKind) kind);
156 /// Is the given declaration a "type" or a "value" for the purposes of
157 /// visibility computation?
158 static bool usesTypeVisibility(const NamedDecl *D) {
159 return isa<TypeDecl>(D) ||
160 isa<ClassTemplateDecl>(D) ||
161 isa<ObjCInterfaceDecl>(D);
164 /// Does the given declaration have member specialization information,
165 /// and if so, is it an explicit specialization?
166 template <class T> static typename
167 std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
168 isExplicitMemberSpecialization(const T *D) {
169 if (const MemberSpecializationInfo *member =
170 D->getMemberSpecializationInfo()) {
171 return member->isExplicitSpecialization();
176 /// For templates, this question is easier: a member template can't be
177 /// explicitly instantiated, so there's a single bit indicating whether
178 /// or not this is an explicit member specialization.
179 static bool isExplicitMemberSpecialization(const RedeclarableTemplateDecl *D) {
180 return D->isMemberSpecialization();
183 /// Given a visibility attribute, return the explicit visibility
184 /// associated with it.
186 static Visibility getVisibilityFromAttr(const T *attr) {
187 switch (attr->getVisibility()) {
189 return DefaultVisibility;
191 return HiddenVisibility;
193 return ProtectedVisibility;
195 llvm_unreachable("bad visibility kind");
198 /// Return the explicit visibility of the given declaration.
199 static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
200 NamedDecl::ExplicitVisibilityKind kind) {
201 // If we're ultimately computing the visibility of a type, look for
202 // a 'type_visibility' attribute before looking for 'visibility'.
203 if (kind == NamedDecl::VisibilityForType) {
204 if (const TypeVisibilityAttr *A = D->getAttr<TypeVisibilityAttr>()) {
205 return getVisibilityFromAttr(A);
209 // If this declaration has an explicit visibility attribute, use it.
210 if (const VisibilityAttr *A = D->getAttr<VisibilityAttr>()) {
211 return getVisibilityFromAttr(A);
214 // If we're on Mac OS X, an 'availability' for Mac OS X attribute
215 // implies visibility(default).
216 if (D->getASTContext().getTargetInfo().getTriple().isOSDarwin()) {
217 for (const auto *A : D->specific_attrs<AvailabilityAttr>())
218 if (A->getPlatform()->getName().equals("macosx"))
219 return DefaultVisibility;
226 getLVForType(const Type &T, LVComputationKind computation) {
227 if (computation == LVForLinkageOnly)
228 return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
229 return T.getLinkageAndVisibility();
232 /// \brief Get the most restrictive linkage for the types in the given
233 /// template parameter list. For visibility purposes, template
234 /// parameters are part of the signature of a template.
236 getLVForTemplateParameterList(const TemplateParameterList *Params,
237 LVComputationKind computation) {
239 for (const NamedDecl *P : *Params) {
240 // Template type parameters are the most common and never
241 // contribute to visibility, pack or not.
242 if (isa<TemplateTypeParmDecl>(P))
245 // Non-type template parameters can be restricted by the value type, e.g.
246 // template <enum X> class A { ... };
247 // We have to be careful here, though, because we can be dealing with
249 if (const NonTypeTemplateParmDecl *NTTP =
250 dyn_cast<NonTypeTemplateParmDecl>(P)) {
251 // Handle the non-pack case first.
252 if (!NTTP->isExpandedParameterPack()) {
253 if (!NTTP->getType()->isDependentType()) {
254 LV.merge(getLVForType(*NTTP->getType(), computation));
259 // 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())
263 LV.merge(type->getLinkageAndVisibility());
268 // Template template parameters can be restricted by their
269 // template parameters, recursively.
270 const TemplateTemplateParmDecl *TTP = cast<TemplateTemplateParmDecl>(P);
272 // Handle the non-pack case first.
273 if (!TTP->isExpandedParameterPack()) {
274 LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
279 // Look at all expansions in an expanded pack.
280 for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
282 LV.merge(getLVForTemplateParameterList(
283 TTP->getExpansionTemplateParameters(i), computation));
290 /// getLVForDecl - Get the linkage and visibility for the given declaration.
291 static LinkageInfo getLVForDecl(const NamedDecl *D,
292 LVComputationKind computation);
294 static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
295 const Decl *Ret = nullptr;
296 const DeclContext *DC = D->getDeclContext();
297 while (DC->getDeclKind() != Decl::TranslationUnit) {
298 if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
299 Ret = cast<Decl>(DC);
300 DC = DC->getParent();
305 /// \brief Get the most restrictive linkage for the types and
306 /// declarations in the given template argument list.
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.
310 static LinkageInfo getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
311 LVComputationKind computation) {
314 for (const TemplateArgument &Arg : Args) {
315 switch (Arg.getKind()) {
316 case TemplateArgument::Null:
317 case TemplateArgument::Integral:
318 case TemplateArgument::Expression:
321 case TemplateArgument::Type:
322 LV.merge(getLVForType(*Arg.getAsType(), computation));
325 case TemplateArgument::Declaration:
326 if (NamedDecl *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) {
327 assert(!usesTypeVisibility(ND));
328 LV.merge(getLVForDecl(ND, computation));
332 case TemplateArgument::NullPtr:
333 LV.merge(Arg.getNullPtrType()->getLinkageAndVisibility());
336 case TemplateArgument::Template:
337 case TemplateArgument::TemplateExpansion:
338 if (TemplateDecl *Template =
339 Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
340 LV.merge(getLVForDecl(Template, computation));
343 case TemplateArgument::Pack:
344 LV.merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
347 llvm_unreachable("bad template argument kind");
354 getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
355 LVComputationKind computation) {
356 return getLVForTemplateArgumentList(TArgs.asArray(), computation);
359 static bool shouldConsiderTemplateVisibility(const FunctionDecl *fn,
360 const FunctionTemplateSpecializationInfo *specInfo) {
361 // Include visibility from the template parameters and arguments
362 // only if this is not an explicit instantiation or specialization
363 // with direct explicit visibility. (Implicit instantiations won't
364 // have a direct attribute.)
365 if (!specInfo->isExplicitInstantiationOrSpecialization())
368 return !fn->hasAttr<VisibilityAttr>();
371 /// Merge in template-related linkage and visibility for the given
372 /// function template specialization.
374 /// We don't need a computation kind here because we can assume
377 /// \param[out] LV the computation to use for the parent
379 mergeTemplateLV(LinkageInfo &LV, const FunctionDecl *fn,
380 const FunctionTemplateSpecializationInfo *specInfo,
381 LVComputationKind computation) {
382 bool considerVisibility =
383 shouldConsiderTemplateVisibility(fn, specInfo);
385 // Merge information from the template parameters.
386 FunctionTemplateDecl *temp = specInfo->getTemplate();
388 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
389 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
391 // Merge information from the template arguments.
392 const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
393 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
394 LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
397 /// Does the given declaration have a direct visibility attribute
398 /// that would match the given rules?
399 static bool hasDirectVisibilityAttribute(const NamedDecl *D,
400 LVComputationKind computation) {
401 switch (computation) {
403 case LVForExplicitType:
404 if (D->hasAttr<TypeVisibilityAttr>())
408 case LVForExplicitValue:
409 if (D->hasAttr<VisibilityAttr>())
412 case LVForLinkageOnly:
415 llvm_unreachable("bad visibility computation kind");
418 /// Should we consider visibility associated with the template
419 /// arguments and parameters of the given class template specialization?
420 static bool shouldConsiderTemplateVisibility(
421 const ClassTemplateSpecializationDecl *spec,
422 LVComputationKind computation) {
423 // Include visibility from the template parameters and arguments
424 // only if this is not an explicit instantiation or specialization
425 // with direct explicit visibility (and note that implicit
426 // instantiations won't have a direct attribute).
428 // Furthermore, we want to ignore template parameters and arguments
429 // for an explicit specialization when computing the visibility of a
430 // member thereof with explicit visibility.
432 // This is a bit complex; let's unpack it.
434 // An explicit class specialization is an independent, top-level
435 // declaration. As such, if it or any of its members has an
436 // explicit visibility attribute, that must directly express the
437 // user's intent, and we should honor it. The same logic applies to
438 // an explicit instantiation of a member of such a thing.
440 // Fast path: if this is not an explicit instantiation or
441 // specialization, we always want to consider template-related
442 // visibility restrictions.
443 if (!spec->isExplicitInstantiationOrSpecialization())
446 // This is the 'member thereof' check.
447 if (spec->isExplicitSpecialization() &&
448 hasExplicitVisibilityAlready(computation))
451 return !hasDirectVisibilityAttribute(spec, computation);
454 /// Merge in template-related linkage and visibility for the given
455 /// class template specialization.
456 static void mergeTemplateLV(LinkageInfo &LV,
457 const ClassTemplateSpecializationDecl *spec,
458 LVComputationKind computation) {
459 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
461 // Merge information from the template parameters, but ignore
462 // visibility if we're only considering template arguments.
464 ClassTemplateDecl *temp = spec->getSpecializedTemplate();
466 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
467 LV.mergeMaybeWithVisibility(tempLV,
468 considerVisibility && !hasExplicitVisibilityAlready(computation));
470 // Merge information from the template arguments. We ignore
471 // template-argument visibility if we've got an explicit
472 // instantiation with a visibility attribute.
473 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
474 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
475 if (considerVisibility)
476 LV.mergeVisibility(argsLV);
477 LV.mergeExternalVisibility(argsLV);
480 /// Should we consider visibility associated with the template
481 /// arguments and parameters of the given variable template
482 /// specialization? As usual, follow class template specialization
483 /// logic up to initialization.
484 static bool shouldConsiderTemplateVisibility(
485 const VarTemplateSpecializationDecl *spec,
486 LVComputationKind computation) {
487 // Include visibility from the template parameters and arguments
488 // only if this is not an explicit instantiation or specialization
489 // with direct explicit visibility (and note that implicit
490 // instantiations won't have a direct attribute).
491 if (!spec->isExplicitInstantiationOrSpecialization())
494 // An explicit variable specialization is an independent, top-level
495 // declaration. As such, if it has an explicit visibility attribute,
496 // that must directly express the user's intent, and we should honor
498 if (spec->isExplicitSpecialization() &&
499 hasExplicitVisibilityAlready(computation))
502 return !hasDirectVisibilityAttribute(spec, computation);
505 /// Merge in template-related linkage and visibility for the given
506 /// variable template specialization. As usual, follow class template
507 /// specialization logic up to initialization.
508 static void mergeTemplateLV(LinkageInfo &LV,
509 const VarTemplateSpecializationDecl *spec,
510 LVComputationKind computation) {
511 bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
513 // Merge information from the template parameters, but ignore
514 // visibility if we're only considering template arguments.
516 VarTemplateDecl *temp = spec->getSpecializedTemplate();
518 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
519 LV.mergeMaybeWithVisibility(tempLV,
520 considerVisibility && !hasExplicitVisibilityAlready(computation));
522 // Merge information from the template arguments. We ignore
523 // template-argument visibility if we've got an explicit
524 // instantiation with a visibility attribute.
525 const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
526 LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
527 if (considerVisibility)
528 LV.mergeVisibility(argsLV);
529 LV.mergeExternalVisibility(argsLV);
532 static bool useInlineVisibilityHidden(const NamedDecl *D) {
533 // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
534 const LangOptions &Opts = D->getASTContext().getLangOpts();
535 if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
538 const FunctionDecl *FD = dyn_cast<FunctionDecl>(D);
542 TemplateSpecializationKind TSK = TSK_Undeclared;
543 if (FunctionTemplateSpecializationInfo *spec
544 = FD->getTemplateSpecializationInfo()) {
545 TSK = spec->getTemplateSpecializationKind();
546 } else if (MemberSpecializationInfo *MSI =
547 FD->getMemberSpecializationInfo()) {
548 TSK = MSI->getTemplateSpecializationKind();
551 const FunctionDecl *Def = nullptr;
552 // InlineVisibilityHidden only applies to definitions, and
553 // isInlined() only gives meaningful answers on definitions
555 return TSK != TSK_ExplicitInstantiationDeclaration &&
556 TSK != TSK_ExplicitInstantiationDefinition &&
557 FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
560 template <typename T> static bool isFirstInExternCContext(T *D) {
561 const T *First = D->getFirstDecl();
562 return First->isInExternCContext();
565 static bool isSingleLineLanguageLinkage(const Decl &D) {
566 if (const LinkageSpecDecl *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
567 if (!SD->hasBraces())
572 static LinkageInfo getLVForNamespaceScopeDecl(const NamedDecl *D,
573 LVComputationKind computation) {
574 assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
575 "Not a name having namespace scope");
576 ASTContext &Context = D->getASTContext();
578 // C++ [basic.link]p3:
579 // A name having namespace scope (3.3.6) has internal linkage if it
581 // - an object, reference, function or function template that is
582 // explicitly declared static; or,
583 // (This bullet corresponds to C99 6.2.2p3.)
584 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
585 // Explicitly declared static.
586 if (Var->getStorageClass() == SC_Static)
587 return LinkageInfo::internal();
589 // - a non-volatile object or reference that is explicitly declared const
590 // or constexpr and neither explicitly declared extern nor previously
591 // declared to have external linkage; or (there is no equivalent in C99)
592 if (Context.getLangOpts().CPlusPlus &&
593 Var->getType().isConstQualified() &&
594 !Var->getType().isVolatileQualified()) {
595 const VarDecl *PrevVar = Var->getPreviousDecl();
597 return getLVForDecl(PrevVar, computation);
599 if (Var->getStorageClass() != SC_Extern &&
600 Var->getStorageClass() != SC_PrivateExtern &&
601 !isSingleLineLanguageLinkage(*Var))
602 return LinkageInfo::internal();
605 for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
606 PrevVar = PrevVar->getPreviousDecl()) {
607 if (PrevVar->getStorageClass() == SC_PrivateExtern &&
608 Var->getStorageClass() == SC_None)
609 return PrevVar->getLinkageAndVisibility();
610 // Explicitly declared static.
611 if (PrevVar->getStorageClass() == SC_Static)
612 return LinkageInfo::internal();
614 } else if (const FunctionDecl *Function = D->getAsFunction()) {
616 // A non-member function template can have internal linkage; any
617 // other template name shall have external linkage.
619 // Explicitly declared static.
620 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
621 return LinkageInfo(InternalLinkage, DefaultVisibility, false);
622 } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
623 // - a data member of an anonymous union.
624 const VarDecl *VD = IFD->getVarDecl();
625 assert(VD && "Expected a VarDecl in this IndirectFieldDecl!");
626 return getLVForNamespaceScopeDecl(VD, computation);
628 assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!");
630 if (D->isInAnonymousNamespace()) {
631 const VarDecl *Var = dyn_cast<VarDecl>(D);
632 const FunctionDecl *Func = dyn_cast<FunctionDecl>(D);
633 if ((!Var || !isFirstInExternCContext(Var)) &&
634 (!Func || !isFirstInExternCContext(Func)))
635 return LinkageInfo::uniqueExternal();
638 // Set up the defaults.
641 // If the declaration of an identifier for an object has file
642 // scope and no storage-class specifier, its linkage is
646 if (!hasExplicitVisibilityAlready(computation)) {
647 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
648 LV.mergeVisibility(*Vis, true);
650 // If we're declared in a namespace with a visibility attribute,
651 // use that namespace's visibility, and it still counts as explicit.
652 for (const DeclContext *DC = D->getDeclContext();
653 !isa<TranslationUnitDecl>(DC);
654 DC = DC->getParent()) {
655 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC);
657 if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
658 LV.mergeVisibility(*Vis, true);
664 // Add in global settings if the above didn't give us direct visibility.
665 if (!LV.isVisibilityExplicit()) {
666 // Use global type/value visibility as appropriate.
667 Visibility globalVisibility;
668 if (computation == LVForValue) {
669 globalVisibility = Context.getLangOpts().getValueVisibilityMode();
671 assert(computation == LVForType);
672 globalVisibility = Context.getLangOpts().getTypeVisibilityMode();
674 LV.mergeVisibility(globalVisibility, /*explicit*/ false);
676 // If we're paying attention to global visibility, apply
677 // -finline-visibility-hidden if this is an inline method.
678 if (useInlineVisibilityHidden(D))
679 LV.mergeVisibility(HiddenVisibility, true);
683 // C++ [basic.link]p4:
685 // A name having namespace scope has external linkage if it is the
688 // - an object or reference, unless it has internal linkage; or
689 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
690 // GCC applies the following optimization to variables and static
691 // data members, but not to functions:
693 // Modify the variable's LV by the LV of its type unless this is
694 // C or extern "C". This follows from [basic.link]p9:
695 // A type without linkage shall not be used as the type of a
696 // variable or function with external linkage unless
697 // - the entity has C language linkage, or
698 // - the entity is declared within an unnamed namespace, or
699 // - the entity is not used or is defined in the same
701 // and [basic.link]p10:
702 // ...the types specified by all declarations referring to a
703 // given variable or function shall be identical...
704 // C does not have an equivalent rule.
706 // Ignore this if we've got an explicit attribute; the user
707 // probably knows what they're doing.
709 // Note that we don't want to make the variable non-external
710 // because of this, but unique-external linkage suits us.
711 if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var)) {
712 LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
713 if (TypeLV.getLinkage() != ExternalLinkage)
714 return LinkageInfo::uniqueExternal();
715 if (!LV.isVisibilityExplicit())
716 LV.mergeVisibility(TypeLV);
719 if (Var->getStorageClass() == SC_PrivateExtern)
720 LV.mergeVisibility(HiddenVisibility, true);
722 // Note that Sema::MergeVarDecl already takes care of implementing
723 // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
726 // As per function and class template specializations (below),
727 // consider LV for the template and template arguments. We're at file
728 // scope, so we do not need to worry about nested specializations.
729 if (const VarTemplateSpecializationDecl *spec
730 = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
731 mergeTemplateLV(LV, spec, computation);
734 // - a function, unless it has internal linkage; or
735 } else if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
736 // In theory, we can modify the function's LV by the LV of its
737 // type unless it has C linkage (see comment above about variables
738 // for justification). In practice, GCC doesn't do this, so it's
739 // just too painful to make work.
741 if (Function->getStorageClass() == SC_PrivateExtern)
742 LV.mergeVisibility(HiddenVisibility, true);
744 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
745 // merging storage classes and visibility attributes, so we don't have to
746 // look at previous decls in here.
748 // In C++, then if the type of the function uses a type with
749 // unique-external linkage, it's not legally usable from outside
750 // this translation unit. However, we should use the C linkage
751 // rules instead for extern "C" declarations.
752 if (Context.getLangOpts().CPlusPlus &&
753 !Function->isInExternCContext()) {
754 // Only look at the type-as-written. If this function has an auto-deduced
755 // return type, we can't compute the linkage of that type because it could
756 // require looking at the linkage of this function, and we don't need this
757 // for correctness because the type is not part of the function's
759 // FIXME: This is a hack. We should be able to solve this circularity and
760 // the one in getLVForClassMember for Functions some other way.
761 QualType TypeAsWritten = Function->getType();
762 if (TypeSourceInfo *TSI = Function->getTypeSourceInfo())
763 TypeAsWritten = TSI->getType();
764 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage)
765 return LinkageInfo::uniqueExternal();
768 // Consider LV from the template and the template arguments.
769 // We're at file scope, so we do not need to worry about nested
771 if (FunctionTemplateSpecializationInfo *specInfo
772 = Function->getTemplateSpecializationInfo()) {
773 mergeTemplateLV(LV, Function, specInfo, computation);
776 // - a named class (Clause 9), or an unnamed class defined in a
777 // typedef declaration in which the class has the typedef name
778 // for linkage purposes (7.1.3); or
779 // - a named enumeration (7.2), or an unnamed enumeration
780 // defined in a typedef declaration in which the enumeration
781 // has the typedef name for linkage purposes (7.1.3); or
782 } else if (const TagDecl *Tag = dyn_cast<TagDecl>(D)) {
783 // Unnamed tags have no linkage.
784 if (!Tag->hasNameForLinkage())
785 return LinkageInfo::none();
787 // If this is a class template specialization, consider the
788 // linkage of the template and template arguments. We're at file
789 // scope, so we do not need to worry about nested specializations.
790 if (const ClassTemplateSpecializationDecl *spec
791 = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
792 mergeTemplateLV(LV, spec, computation);
795 // - an enumerator belonging to an enumeration with external linkage;
796 } else if (isa<EnumConstantDecl>(D)) {
797 LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
799 if (!isExternalFormalLinkage(EnumLV.getLinkage()))
800 return LinkageInfo::none();
803 // - a template, unless it is a function template that has
804 // internal linkage (Clause 14);
805 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) {
806 bool considerVisibility = !hasExplicitVisibilityAlready(computation);
808 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
809 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
811 // - a namespace (7.3), unless it is declared within an unnamed
813 } else if (isa<NamespaceDecl>(D) && !D->isInAnonymousNamespace()) {
816 // By extension, we assign external linkage to Objective-C
818 } else if (isa<ObjCInterfaceDecl>(D)) {
821 // Everything not covered here has no linkage.
823 // FIXME: A typedef declaration has linkage if it gives a type a name for
825 return LinkageInfo::none();
828 // If we ended up with non-external linkage, visibility should
829 // always be default.
830 if (LV.getLinkage() != ExternalLinkage)
831 return LinkageInfo(LV.getLinkage(), DefaultVisibility, false);
836 static LinkageInfo getLVForClassMember(const NamedDecl *D,
837 LVComputationKind computation) {
838 // Only certain class members have linkage. Note that fields don't
839 // really have linkage, but it's convenient to say they do for the
840 // purposes of calculating linkage of pointer-to-data-member
841 // template arguments.
843 // Templates also don't officially have linkage, but since we ignore
844 // the C++ standard and look at template arguments when determining
845 // linkage and visibility of a template specialization, we might hit
846 // a template template argument that way. If we do, we need to
847 // consider its linkage.
848 if (!(isa<CXXMethodDecl>(D) ||
851 isa<IndirectFieldDecl>(D) ||
853 isa<TemplateDecl>(D)))
854 return LinkageInfo::none();
858 // If we have an explicit visibility attribute, merge that in.
859 if (!hasExplicitVisibilityAlready(computation)) {
860 if (Optional<Visibility> Vis = getExplicitVisibility(D, computation))
861 LV.mergeVisibility(*Vis, true);
862 // If we're paying attention to global visibility, apply
863 // -finline-visibility-hidden if this is an inline method.
865 // Note that we do this before merging information about
866 // the class visibility.
867 if (!LV.isVisibilityExplicit() && useInlineVisibilityHidden(D))
868 LV.mergeVisibility(HiddenVisibility, true);
871 // If this class member has an explicit visibility attribute, the only
872 // thing that can change its visibility is the template arguments, so
873 // only look for them when processing the class.
874 LVComputationKind classComputation = computation;
875 if (LV.isVisibilityExplicit())
876 classComputation = withExplicitVisibilityAlready(computation);
878 LinkageInfo classLV =
879 getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
880 // If the class already has unique-external linkage, we can't improve.
881 if (classLV.getLinkage() == UniqueExternalLinkage)
882 return LinkageInfo::uniqueExternal();
884 if (!isExternallyVisible(classLV.getLinkage()))
885 return LinkageInfo::none();
888 // Otherwise, don't merge in classLV yet, because in certain cases
889 // we need to completely ignore the visibility from it.
891 // Specifically, if this decl exists and has an explicit attribute.
892 const NamedDecl *explicitSpecSuppressor = nullptr;
894 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
895 // If the type of the function uses a type with unique-external
896 // linkage, it's not legally usable from outside this translation unit.
897 // But only look at the type-as-written. If this function has an auto-deduced
898 // return type, we can't compute the linkage of that type because it could
899 // require looking at the linkage of this function, and we don't need this
900 // for correctness because the type is not part of the function's
902 // FIXME: This is a hack. We should be able to solve this circularity and the
903 // one in getLVForNamespaceScopeDecl for Functions some other way.
905 QualType TypeAsWritten = MD->getType();
906 if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
907 TypeAsWritten = TSI->getType();
908 if (TypeAsWritten->getLinkage() == UniqueExternalLinkage)
909 return LinkageInfo::uniqueExternal();
911 // If this is a method template specialization, use the linkage for
912 // the template parameters and arguments.
913 if (FunctionTemplateSpecializationInfo *spec
914 = MD->getTemplateSpecializationInfo()) {
915 mergeTemplateLV(LV, MD, spec, computation);
916 if (spec->isExplicitSpecialization()) {
917 explicitSpecSuppressor = MD;
918 } else if (isExplicitMemberSpecialization(spec->getTemplate())) {
919 explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
921 } else if (isExplicitMemberSpecialization(MD)) {
922 explicitSpecSuppressor = MD;
925 } else if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D)) {
926 if (const ClassTemplateSpecializationDecl *spec
927 = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
928 mergeTemplateLV(LV, spec, computation);
929 if (spec->isExplicitSpecialization()) {
930 explicitSpecSuppressor = spec;
932 const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
933 if (isExplicitMemberSpecialization(temp)) {
934 explicitSpecSuppressor = temp->getTemplatedDecl();
937 } else if (isExplicitMemberSpecialization(RD)) {
938 explicitSpecSuppressor = RD;
941 // Static data members.
942 } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
943 if (const VarTemplateSpecializationDecl *spec
944 = dyn_cast<VarTemplateSpecializationDecl>(VD))
945 mergeTemplateLV(LV, spec, computation);
947 // Modify the variable's linkage by its type, but ignore the
948 // type's visibility unless it's a definition.
949 LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
950 if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
951 LV.mergeVisibility(typeLV);
952 LV.mergeExternalVisibility(typeLV);
954 if (isExplicitMemberSpecialization(VD)) {
955 explicitSpecSuppressor = VD;
959 } else if (const TemplateDecl *temp = dyn_cast<TemplateDecl>(D)) {
960 bool considerVisibility =
961 (!LV.isVisibilityExplicit() &&
962 !classLV.isVisibilityExplicit() &&
963 !hasExplicitVisibilityAlready(computation));
965 getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
966 LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
968 if (const RedeclarableTemplateDecl *redeclTemp =
969 dyn_cast<RedeclarableTemplateDecl>(temp)) {
970 if (isExplicitMemberSpecialization(redeclTemp)) {
971 explicitSpecSuppressor = temp->getTemplatedDecl();
976 // We should never be looking for an attribute directly on a template.
977 assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
979 // If this member is an explicit member specialization, and it has
980 // an explicit attribute, ignore visibility from the parent.
981 bool considerClassVisibility = true;
982 if (explicitSpecSuppressor &&
983 // optimization: hasDVA() is true only with explicit visibility.
984 LV.isVisibilityExplicit() &&
985 classLV.getVisibility() != DefaultVisibility &&
986 hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
987 considerClassVisibility = false;
990 // Finally, merge in information from the class.
991 LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
995 void NamedDecl::anchor() { }
997 static LinkageInfo computeLVForDecl(const NamedDecl *D,
998 LVComputationKind computation);
1000 bool NamedDecl::isLinkageValid() const {
1001 if (!hasCachedLinkage())
1004 return computeLVForDecl(this, LVForLinkageOnly).getLinkage() ==
1008 ObjCStringFormatFamily NamedDecl::getObjCFStringFormattingFamily() const {
1009 StringRef name = getName();
1010 if (name.empty()) return SFF_None;
1012 if (name.front() == 'C')
1013 if (name == "CFStringCreateWithFormat" ||
1014 name == "CFStringCreateWithFormatAndArguments" ||
1015 name == "CFStringAppendFormat" ||
1016 name == "CFStringAppendFormatAndArguments")
1017 return SFF_CFString;
1021 Linkage NamedDecl::getLinkageInternal() const {
1022 // We don't care about visibility here, so ask for the cheapest
1023 // possible visibility analysis.
1024 return getLVForDecl(this, LVForLinkageOnly).getLinkage();
1027 LinkageInfo NamedDecl::getLinkageAndVisibility() const {
1028 LVComputationKind computation =
1029 (usesTypeVisibility(this) ? LVForType : LVForValue);
1030 return getLVForDecl(this, computation);
1033 static Optional<Visibility>
1034 getExplicitVisibilityAux(const NamedDecl *ND,
1035 NamedDecl::ExplicitVisibilityKind kind,
1036 bool IsMostRecent) {
1037 assert(!IsMostRecent || ND == ND->getMostRecentDecl());
1039 // Check the declaration itself first.
1040 if (Optional<Visibility> V = getVisibilityOf(ND, kind))
1043 // If this is a member class of a specialization of a class template
1044 // and the corresponding decl has explicit visibility, use that.
1045 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(ND)) {
1046 CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
1047 if (InstantiatedFrom)
1048 return getVisibilityOf(InstantiatedFrom, kind);
1051 // If there wasn't explicit visibility there, and this is a
1052 // specialization of a class template, check for visibility
1054 if (const ClassTemplateSpecializationDecl *spec
1055 = dyn_cast<ClassTemplateSpecializationDecl>(ND))
1056 return getVisibilityOf(spec->getSpecializedTemplate()->getTemplatedDecl(),
1059 // Use the most recent declaration.
1060 if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1061 const NamedDecl *MostRecent = ND->getMostRecentDecl();
1062 if (MostRecent != ND)
1063 return getExplicitVisibilityAux(MostRecent, kind, true);
1066 if (const VarDecl *Var = dyn_cast<VarDecl>(ND)) {
1067 if (Var->isStaticDataMember()) {
1068 VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
1069 if (InstantiatedFrom)
1070 return getVisibilityOf(InstantiatedFrom, kind);
1073 if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1074 return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1079 // Also handle function template specializations.
1080 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) {
1081 // If the function is a specialization of a template with an
1082 // explicit visibility attribute, use that.
1083 if (FunctionTemplateSpecializationInfo *templateInfo
1084 = fn->getTemplateSpecializationInfo())
1085 return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1088 // If the function is a member of a specialization of a class template
1089 // and the corresponding decl has explicit visibility, use that.
1090 FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
1091 if (InstantiatedFrom)
1092 return getVisibilityOf(InstantiatedFrom, kind);
1097 // The visibility of a template is stored in the templated decl.
1098 if (const TemplateDecl *TD = dyn_cast<TemplateDecl>(ND))
1099 return getVisibilityOf(TD->getTemplatedDecl(), kind);
1104 Optional<Visibility>
1105 NamedDecl::getExplicitVisibility(ExplicitVisibilityKind kind) const {
1106 return getExplicitVisibilityAux(this, kind, false);
1109 static LinkageInfo getLVForClosure(const DeclContext *DC, Decl *ContextDecl,
1110 LVComputationKind computation) {
1111 // This lambda has its linkage/visibility determined by its owner.
1113 if (isa<ParmVarDecl>(ContextDecl))
1114 DC = ContextDecl->getDeclContext()->getRedeclContext();
1116 return getLVForDecl(cast<NamedDecl>(ContextDecl), computation);
1119 if (const NamedDecl *ND = dyn_cast<NamedDecl>(DC))
1120 return getLVForDecl(ND, computation);
1122 return LinkageInfo::external();
1125 static LinkageInfo getLVForLocalDecl(const NamedDecl *D,
1126 LVComputationKind computation) {
1127 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) {
1128 if (Function->isInAnonymousNamespace() &&
1129 !Function->isInExternCContext())
1130 return LinkageInfo::uniqueExternal();
1132 // This is a "void f();" which got merged with a file static.
1133 if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
1134 return LinkageInfo::internal();
1137 if (!hasExplicitVisibilityAlready(computation)) {
1138 if (Optional<Visibility> Vis =
1139 getExplicitVisibility(Function, computation))
1140 LV.mergeVisibility(*Vis, true);
1143 // Note that Sema::MergeCompatibleFunctionDecls already takes care of
1144 // merging storage classes and visibility attributes, so we don't have to
1145 // look at previous decls in here.
1150 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) {
1151 if (Var->hasExternalStorage()) {
1152 if (Var->isInAnonymousNamespace() && !Var->isInExternCContext())
1153 return LinkageInfo::uniqueExternal();
1156 if (Var->getStorageClass() == SC_PrivateExtern)
1157 LV.mergeVisibility(HiddenVisibility, true);
1158 else if (!hasExplicitVisibilityAlready(computation)) {
1159 if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
1160 LV.mergeVisibility(*Vis, true);
1163 if (const VarDecl *Prev = Var->getPreviousDecl()) {
1164 LinkageInfo PrevLV = getLVForDecl(Prev, computation);
1165 if (PrevLV.getLinkage())
1166 LV.setLinkage(PrevLV.getLinkage());
1167 LV.mergeVisibility(PrevLV);
1173 if (!Var->isStaticLocal())
1174 return LinkageInfo::none();
1177 ASTContext &Context = D->getASTContext();
1178 if (!Context.getLangOpts().CPlusPlus)
1179 return LinkageInfo::none();
1181 const Decl *OuterD = getOutermostFuncOrBlockContext(D);
1183 return LinkageInfo::none();
1186 if (const BlockDecl *BD = dyn_cast<BlockDecl>(OuterD)) {
1187 if (!BD->getBlockManglingNumber())
1188 return LinkageInfo::none();
1190 LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1191 BD->getBlockManglingContextDecl(), computation);
1193 const FunctionDecl *FD = cast<FunctionDecl>(OuterD);
1194 if (!FD->isInlined() &&
1195 !isTemplateInstantiation(FD->getTemplateSpecializationKind()))
1196 return LinkageInfo::none();
1198 LV = getLVForDecl(FD, computation);
1200 if (!isExternallyVisible(LV.getLinkage()))
1201 return LinkageInfo::none();
1202 return LinkageInfo(VisibleNoLinkage, LV.getVisibility(),
1203 LV.isVisibilityExplicit());
1206 static inline const CXXRecordDecl*
1207 getOutermostEnclosingLambda(const CXXRecordDecl *Record) {
1208 const CXXRecordDecl *Ret = Record;
1209 while (Record && Record->isLambda()) {
1211 if (!Record->getParent()) break;
1212 // Get the Containing Class of this Lambda Class
1213 Record = dyn_cast_or_null<CXXRecordDecl>(
1214 Record->getParent()->getParent());
1219 static LinkageInfo computeLVForDecl(const NamedDecl *D,
1220 LVComputationKind computation) {
1221 // Objective-C: treat all Objective-C declarations as having external
1223 switch (D->getKind()) {
1227 return LinkageInfo::none();
1228 case Decl::TemplateTemplateParm: // count these as external
1229 case Decl::NonTypeTemplateParm:
1230 case Decl::ObjCAtDefsField:
1231 case Decl::ObjCCategory:
1232 case Decl::ObjCCategoryImpl:
1233 case Decl::ObjCCompatibleAlias:
1234 case Decl::ObjCImplementation:
1235 case Decl::ObjCMethod:
1236 case Decl::ObjCProperty:
1237 case Decl::ObjCPropertyImpl:
1238 case Decl::ObjCProtocol:
1239 return LinkageInfo::external();
1241 case Decl::CXXRecord: {
1242 const CXXRecordDecl *Record = cast<CXXRecordDecl>(D);
1243 if (Record->isLambda()) {
1244 if (!Record->getLambdaManglingNumber()) {
1245 // This lambda has no mangling number, so it's internal.
1246 return LinkageInfo::internal();
1249 // This lambda has its linkage/visibility determined:
1250 // - either by the outermost lambda if that lambda has no mangling
1252 // - or by the parent of the outer most lambda
1253 // This prevents infinite recursion in settings such as nested lambdas
1254 // used in NSDMI's, for e.g.
1257 // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);
1259 const CXXRecordDecl *OuterMostLambda =
1260 getOutermostEnclosingLambda(Record);
1261 if (!OuterMostLambda->getLambdaManglingNumber())
1262 return LinkageInfo::internal();
1264 return getLVForClosure(
1265 OuterMostLambda->getDeclContext()->getRedeclContext(),
1266 OuterMostLambda->getLambdaContextDecl(), computation);
1273 // Handle linkage for namespace-scope names.
1274 if (D->getDeclContext()->getRedeclContext()->isFileContext())
1275 return getLVForNamespaceScopeDecl(D, computation);
1277 // C++ [basic.link]p5:
1278 // In addition, a member function, static data member, a named
1279 // class or enumeration of class scope, or an unnamed class or
1280 // enumeration defined in a class-scope typedef declaration such
1281 // that the class or enumeration has the typedef name for linkage
1282 // purposes (7.1.3), has external linkage if the name of the class
1283 // has external linkage.
1284 if (D->getDeclContext()->isRecord())
1285 return getLVForClassMember(D, computation);
1287 // C++ [basic.link]p6:
1288 // The name of a function declared in block scope and the name of
1289 // an object declared by a block scope extern declaration have
1290 // linkage. If there is a visible declaration of an entity with
1291 // linkage having the same name and type, ignoring entities
1292 // declared outside the innermost enclosing namespace scope, the
1293 // block scope declaration declares that same entity and receives
1294 // the linkage of the previous declaration. If there is more than
1295 // one such matching entity, the program is ill-formed. Otherwise,
1296 // if no matching entity is found, the block scope entity receives
1297 // external linkage.
1298 if (D->getDeclContext()->isFunctionOrMethod())
1299 return getLVForLocalDecl(D, computation);
1301 // C++ [basic.link]p6:
1302 // Names not covered by these rules have no linkage.
1303 return LinkageInfo::none();
1307 class LinkageComputer {
1309 static LinkageInfo getLVForDecl(const NamedDecl *D,
1310 LVComputationKind computation) {
1311 if (computation == LVForLinkageOnly && D->hasCachedLinkage())
1312 return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
1314 LinkageInfo LV = computeLVForDecl(D, computation);
1315 if (D->hasCachedLinkage())
1316 assert(D->getCachedLinkage() == LV.getLinkage());
1318 D->setCachedLinkage(LV.getLinkage());
1321 // In C (because of gnu inline) and in c++ with microsoft extensions an
1322 // static can follow an extern, so we can have two decls with different
1324 const LangOptions &Opts = D->getASTContext().getLangOpts();
1325 if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1328 // We have just computed the linkage for this decl. By induction we know
1329 // that all other computed linkages match, check that the one we just
1330 // computed also does.
1331 NamedDecl *Old = nullptr;
1332 for (auto I : D->redecls()) {
1333 NamedDecl *T = cast<NamedDecl>(I);
1336 if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1341 assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
1349 static LinkageInfo getLVForDecl(const NamedDecl *D,
1350 LVComputationKind computation) {
1351 return clang::LinkageComputer::getLVForDecl(D, computation);
1354 std::string NamedDecl::getQualifiedNameAsString() const {
1355 std::string QualName;
1356 llvm::raw_string_ostream OS(QualName);
1357 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1361 void NamedDecl::printQualifiedName(raw_ostream &OS) const {
1362 printQualifiedName(OS, getASTContext().getPrintingPolicy());
1365 void NamedDecl::printQualifiedName(raw_ostream &OS,
1366 const PrintingPolicy &P) const {
1367 const DeclContext *Ctx = getDeclContext();
1369 if (Ctx->isFunctionOrMethod()) {
1374 typedef SmallVector<const DeclContext *, 8> ContextsTy;
1375 ContextsTy Contexts;
1377 // Collect contexts.
1378 while (Ctx && isa<NamedDecl>(Ctx)) {
1379 Contexts.push_back(Ctx);
1380 Ctx = Ctx->getParent();
1383 for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend();
1385 if (const ClassTemplateSpecializationDecl *Spec
1386 = dyn_cast<ClassTemplateSpecializationDecl>(*I)) {
1387 OS << Spec->getName();
1388 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1389 TemplateSpecializationType::PrintTemplateArgumentList(OS,
1390 TemplateArgs.data(),
1391 TemplateArgs.size(),
1393 } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) {
1394 if (P.SuppressUnwrittenScope &&
1395 (ND->isAnonymousNamespace() || ND->isInline()))
1397 if (ND->isAnonymousNamespace())
1398 OS << "(anonymous namespace)";
1401 } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) {
1402 if (!RD->getIdentifier())
1403 OS << "(anonymous " << RD->getKindName() << ')';
1406 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1407 const FunctionProtoType *FT = nullptr;
1408 if (FD->hasWrittenPrototype())
1409 FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
1413 unsigned NumParams = FD->getNumParams();
1414 for (unsigned i = 0; i < NumParams; ++i) {
1417 OS << FD->getParamDecl(i)->getType().stream(P);
1420 if (FT->isVariadic()) {
1428 OS << *cast<NamedDecl>(*I);
1436 OS << "(anonymous)";
1439 void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
1440 const PrintingPolicy &Policy,
1441 bool Qualified) const {
1443 printQualifiedName(OS, Policy);
1448 bool NamedDecl::declarationReplaces(NamedDecl *OldD) const {
1449 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch");
1451 // UsingDirectiveDecl's are not really NamedDecl's, and all have same name.
1452 // We want to keep it, unless it nominates same namespace.
1453 if (getKind() == Decl::UsingDirective) {
1454 return cast<UsingDirectiveDecl>(this)->getNominatedNamespace()
1455 ->getOriginalNamespace() ==
1456 cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace()
1457 ->getOriginalNamespace();
1460 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this))
1461 // For function declarations, we keep track of redeclarations.
1462 return FD->getPreviousDecl() == OldD;
1464 // For function templates, the underlying function declarations are linked.
1465 if (const FunctionTemplateDecl *FunctionTemplate
1466 = dyn_cast<FunctionTemplateDecl>(this))
1467 if (const FunctionTemplateDecl *OldFunctionTemplate
1468 = dyn_cast<FunctionTemplateDecl>(OldD))
1469 return FunctionTemplate->getTemplatedDecl()
1470 ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl());
1472 // For method declarations, we keep track of redeclarations.
1473 if (isa<ObjCMethodDecl>(this))
1476 // FIXME: Is this correct if one of the decls comes from an inline namespace?
1477 if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD))
1480 if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD))
1481 return cast<UsingShadowDecl>(this)->getTargetDecl() ==
1482 cast<UsingShadowDecl>(OldD)->getTargetDecl();
1484 if (isa<UsingDecl>(this) && isa<UsingDecl>(OldD)) {
1485 ASTContext &Context = getASTContext();
1486 return Context.getCanonicalNestedNameSpecifier(
1487 cast<UsingDecl>(this)->getQualifier()) ==
1488 Context.getCanonicalNestedNameSpecifier(
1489 cast<UsingDecl>(OldD)->getQualifier());
1492 if (isa<UnresolvedUsingValueDecl>(this) &&
1493 isa<UnresolvedUsingValueDecl>(OldD)) {
1494 ASTContext &Context = getASTContext();
1495 return Context.getCanonicalNestedNameSpecifier(
1496 cast<UnresolvedUsingValueDecl>(this)->getQualifier()) ==
1497 Context.getCanonicalNestedNameSpecifier(
1498 cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1501 // A typedef of an Objective-C class type can replace an Objective-C class
1502 // declaration or definition, and vice versa.
1503 // FIXME: Is this correct if one of the decls comes from an inline namespace?
1504 if ((isa<TypedefNameDecl>(this) && isa<ObjCInterfaceDecl>(OldD)) ||
1505 (isa<ObjCInterfaceDecl>(this) && isa<TypedefNameDecl>(OldD)))
1508 // For non-function declarations, if the declarations are of the
1509 // same kind and have the same parent then this must be a redeclaration,
1510 // or semantic analysis would not have given us the new declaration.
1511 // Note that inline namespaces can give us two declarations with the same
1512 // name and kind in the same scope but different contexts.
1513 return this->getKind() == OldD->getKind() &&
1514 this->getDeclContext()->getRedeclContext()->Equals(
1515 OldD->getDeclContext()->getRedeclContext());
1518 bool NamedDecl::hasLinkage() const {
1519 return getFormalLinkage() != NoLinkage;
1522 NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1523 NamedDecl *ND = this;
1524 while (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND))
1525 ND = UD->getTargetDecl();
1527 if (ObjCCompatibleAliasDecl *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1528 return AD->getClassInterface();
1533 bool NamedDecl::isCXXInstanceMember() const {
1534 if (!isCXXClassMember())
1537 const NamedDecl *D = this;
1538 if (isa<UsingShadowDecl>(D))
1539 D = cast<UsingShadowDecl>(D)->getTargetDecl();
1541 if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1543 if (const CXXMethodDecl *MD =
1544 dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()))
1545 return MD->isInstance();
1549 //===----------------------------------------------------------------------===//
1550 // DeclaratorDecl Implementation
1551 //===----------------------------------------------------------------------===//
1553 template <typename DeclT>
1554 static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) {
1555 if (decl->getNumTemplateParameterLists() > 0)
1556 return decl->getTemplateParameterList(0)->getTemplateLoc();
1558 return decl->getInnerLocStart();
1561 SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const {
1562 TypeSourceInfo *TSI = getTypeSourceInfo();
1563 if (TSI) return TSI->getTypeLoc().getBeginLoc();
1564 return SourceLocation();
1567 void DeclaratorDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
1569 // Make sure the extended decl info is allocated.
1570 if (!hasExtInfo()) {
1571 // Save (non-extended) type source info pointer.
1572 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1573 // Allocate external info struct.
1574 DeclInfo = new (getASTContext()) ExtInfo;
1575 // Restore savedTInfo into (extended) decl info.
1576 getExtInfo()->TInfo = savedTInfo;
1578 // Set qualifier info.
1579 getExtInfo()->QualifierLoc = QualifierLoc;
1581 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
1583 if (getExtInfo()->NumTemplParamLists == 0) {
1584 // Save type source info pointer.
1585 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo;
1586 // Deallocate the extended decl info.
1587 getASTContext().Deallocate(getExtInfo());
1588 // Restore savedTInfo into (non-extended) decl info.
1589 DeclInfo = savedTInfo;
1592 getExtInfo()->QualifierLoc = QualifierLoc;
1598 DeclaratorDecl::setTemplateParameterListsInfo(ASTContext &Context,
1599 unsigned NumTPLists,
1600 TemplateParameterList **TPLists) {
1601 assert(NumTPLists > 0);
1602 // Make sure the extended decl info is allocated.
1603 if (!hasExtInfo()) {
1604 // Save (non-extended) type source info pointer.
1605 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1606 // Allocate external info struct.
1607 DeclInfo = new (getASTContext()) ExtInfo;
1608 // Restore savedTInfo into (extended) decl info.
1609 getExtInfo()->TInfo = savedTInfo;
1611 // Set the template parameter lists info.
1612 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists);
1615 SourceLocation DeclaratorDecl::getOuterLocStart() const {
1616 return getTemplateOrInnerLocStart(this);
1621 // Helper function: returns true if QT is or contains a type
1622 // having a postfix component.
1623 bool typeIsPostfix(clang::QualType QT) {
1625 const Type* T = QT.getTypePtr();
1626 switch (T->getTypeClass()) {
1630 QT = cast<PointerType>(T)->getPointeeType();
1632 case Type::BlockPointer:
1633 QT = cast<BlockPointerType>(T)->getPointeeType();
1635 case Type::MemberPointer:
1636 QT = cast<MemberPointerType>(T)->getPointeeType();
1638 case Type::LValueReference:
1639 case Type::RValueReference:
1640 QT = cast<ReferenceType>(T)->getPointeeType();
1642 case Type::PackExpansion:
1643 QT = cast<PackExpansionType>(T)->getPattern();
1646 case Type::ConstantArray:
1647 case Type::DependentSizedArray:
1648 case Type::IncompleteArray:
1649 case Type::VariableArray:
1650 case Type::FunctionProto:
1651 case Type::FunctionNoProto:
1659 SourceRange DeclaratorDecl::getSourceRange() const {
1660 SourceLocation RangeEnd = getLocation();
1661 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
1662 // If the declaration has no name or the type extends past the name take the
1663 // end location of the type.
1664 if (!getDeclName() || typeIsPostfix(TInfo->getType()))
1665 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
1667 return SourceRange(getOuterLocStart(), RangeEnd);
1671 QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context,
1672 unsigned NumTPLists,
1673 TemplateParameterList **TPLists) {
1674 assert((NumTPLists == 0 || TPLists != nullptr) &&
1675 "Empty array of template parameters with positive size!");
1677 // Free previous template parameters (if any).
1678 if (NumTemplParamLists > 0) {
1679 Context.Deallocate(TemplParamLists);
1680 TemplParamLists = nullptr;
1681 NumTemplParamLists = 0;
1683 // Set info on matched template parameter lists (if any).
1684 if (NumTPLists > 0) {
1685 TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
1686 NumTemplParamLists = NumTPLists;
1687 for (unsigned i = NumTPLists; i-- > 0; )
1688 TemplParamLists[i] = TPLists[i];
1692 //===----------------------------------------------------------------------===//
1693 // VarDecl Implementation
1694 //===----------------------------------------------------------------------===//
1696 const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
1698 case SC_None: break;
1699 case SC_Auto: return "auto";
1700 case SC_Extern: return "extern";
1701 case SC_OpenCLWorkGroupLocal: return "<<work-group-local>>";
1702 case SC_PrivateExtern: return "__private_extern__";
1703 case SC_Register: return "register";
1704 case SC_Static: return "static";
1707 llvm_unreachable("Invalid storage class");
1710 VarDecl::VarDecl(Kind DK, ASTContext &C, DeclContext *DC,
1711 SourceLocation StartLoc, SourceLocation IdLoc,
1712 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1714 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
1715 redeclarable_base(C), Init() {
1716 static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
1717 "VarDeclBitfields too large!");
1718 static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
1719 "ParmVarDeclBitfields too large!");
1721 VarDeclBits.SClass = SC;
1722 // Everything else is implicitly initialized to false.
1725 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
1726 SourceLocation StartL, SourceLocation IdL,
1727 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1729 return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
1732 VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
1734 VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1735 QualType(), nullptr, SC_None);
1738 void VarDecl::setStorageClass(StorageClass SC) {
1739 assert(isLegalForVariable(SC));
1740 VarDeclBits.SClass = SC;
1743 VarDecl::TLSKind VarDecl::getTLSKind() const {
1744 switch (VarDeclBits.TSCSpec) {
1745 case TSCS_unspecified:
1746 if (hasAttr<ThreadAttr>())
1749 case TSCS___thread: // Fall through.
1750 case TSCS__Thread_local:
1752 case TSCS_thread_local:
1755 llvm_unreachable("Unknown thread storage class specifier!");
1758 SourceRange VarDecl::getSourceRange() const {
1759 if (const Expr *Init = getInit()) {
1760 SourceLocation InitEnd = Init->getLocEnd();
1761 // If Init is implicit, ignore its source range and fallback on
1762 // DeclaratorDecl::getSourceRange() to handle postfix elements.
1763 if (InitEnd.isValid() && InitEnd != getLocation())
1764 return SourceRange(getOuterLocStart(), InitEnd);
1766 return DeclaratorDecl::getSourceRange();
1769 template<typename T>
1770 static LanguageLinkage getDeclLanguageLinkage(const T &D) {
1771 // C++ [dcl.link]p1: All function types, function names with external linkage,
1772 // and variable names with external linkage have a language linkage.
1773 if (!D.hasExternalFormalLinkage())
1774 return NoLanguageLinkage;
1776 // Language linkage is a C++ concept, but saying that everything else in C has
1777 // C language linkage fits the implementation nicely.
1778 ASTContext &Context = D.getASTContext();
1779 if (!Context.getLangOpts().CPlusPlus)
1780 return CLanguageLinkage;
1782 // C++ [dcl.link]p4: A C language linkage is ignored in determining the
1783 // language linkage of the names of class members and the function type of
1784 // class member functions.
1785 const DeclContext *DC = D.getDeclContext();
1787 return CXXLanguageLinkage;
1789 // If the first decl is in an extern "C" context, any other redeclaration
1790 // will have C language linkage. If the first one is not in an extern "C"
1791 // context, we would have reported an error for any other decl being in one.
1792 if (isFirstInExternCContext(&D))
1793 return CLanguageLinkage;
1794 return CXXLanguageLinkage;
1797 template<typename T>
1798 static bool isDeclExternC(const T &D) {
1799 // Since the context is ignored for class members, they can only have C++
1800 // language linkage or no language linkage.
1801 const DeclContext *DC = D.getDeclContext();
1802 if (DC->isRecord()) {
1803 assert(D.getASTContext().getLangOpts().CPlusPlus);
1807 return D.getLanguageLinkage() == CLanguageLinkage;
1810 LanguageLinkage VarDecl::getLanguageLinkage() const {
1811 return getDeclLanguageLinkage(*this);
1814 bool VarDecl::isExternC() const {
1815 return isDeclExternC(*this);
1818 bool VarDecl::isInExternCContext() const {
1819 return getLexicalDeclContext()->isExternCContext();
1822 bool VarDecl::isInExternCXXContext() const {
1823 return getLexicalDeclContext()->isExternCXXContext();
1826 VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); }
1828 VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition(
1829 ASTContext &C) const
1831 // C++ [basic.def]p2:
1832 // A declaration is a definition unless [...] it contains the 'extern'
1833 // specifier or a linkage-specification and neither an initializer [...],
1834 // it declares a static data member in a class declaration [...].
1835 // C++1y [temp.expl.spec]p15:
1836 // An explicit specialization of a static data member or an explicit
1837 // specialization of a static data member template is a definition if the
1838 // declaration includes an initializer; otherwise, it is a declaration.
1840 // FIXME: How do you declare (but not define) a partial specialization of
1841 // a static data member template outside the containing class?
1842 if (isStaticDataMember()) {
1843 if (isOutOfLine() &&
1845 // If the first declaration is out-of-line, this may be an
1846 // instantiation of an out-of-line partial specialization of a variable
1847 // template for which we have not yet instantiated the initializer.
1848 (getFirstDecl()->isOutOfLine()
1849 ? getTemplateSpecializationKind() == TSK_Undeclared
1850 : getTemplateSpecializationKind() !=
1851 TSK_ExplicitSpecialization) ||
1852 isa<VarTemplatePartialSpecializationDecl>(this)))
1855 return DeclarationOnly;
1858 // A definition of an identifier is a declaration for that identifier that
1859 // [...] causes storage to be reserved for that object.
1860 // Note: that applies for all non-file-scope objects.
1862 // If the declaration of an identifier for an object has file scope and an
1863 // initializer, the declaration is an external definition for the identifier
1867 if (hasAttr<AliasAttr>())
1870 // A variable template specialization (other than a static data member
1871 // template or an explicit specialization) is a declaration until we
1872 // instantiate its initializer.
1873 if (isa<VarTemplateSpecializationDecl>(this) &&
1874 getTemplateSpecializationKind() != TSK_ExplicitSpecialization)
1875 return DeclarationOnly;
1877 if (hasExternalStorage())
1878 return DeclarationOnly;
1881 // A declaration directly contained in a linkage-specification is treated
1882 // as if it contains the extern specifier for the purpose of determining
1883 // the linkage of the declared name and whether it is a definition.
1884 if (isSingleLineLanguageLinkage(*this))
1885 return DeclarationOnly;
1888 // A declaration of an object that has file scope without an initializer,
1889 // and without a storage class specifier or the scs 'static', constitutes
1890 // a tentative definition.
1891 // No such thing in C++.
1892 if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
1893 return TentativeDefinition;
1895 // What's left is (in C, block-scope) declarations without initializers or
1896 // external storage. These are definitions.
1900 VarDecl *VarDecl::getActingDefinition() {
1901 DefinitionKind Kind = isThisDeclarationADefinition();
1902 if (Kind != TentativeDefinition)
1905 VarDecl *LastTentative = nullptr;
1906 VarDecl *First = getFirstDecl();
1907 for (auto I : First->redecls()) {
1908 Kind = I->isThisDeclarationADefinition();
1909 if (Kind == Definition)
1911 else if (Kind == TentativeDefinition)
1914 return LastTentative;
1917 VarDecl *VarDecl::getDefinition(ASTContext &C) {
1918 VarDecl *First = getFirstDecl();
1919 for (auto I : First->redecls()) {
1920 if (I->isThisDeclarationADefinition(C) == Definition)
1926 VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
1927 DefinitionKind Kind = DeclarationOnly;
1929 const VarDecl *First = getFirstDecl();
1930 for (auto I : First->redecls()) {
1931 Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
1932 if (Kind == Definition)
1939 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
1940 for (auto I : redecls()) {
1941 if (auto Expr = I->getInit()) {
1949 bool VarDecl::isOutOfLine() const {
1950 if (Decl::isOutOfLine())
1953 if (!isStaticDataMember())
1956 // If this static data member was instantiated from a static data member of
1957 // a class template, check whether that static data member was defined
1959 if (VarDecl *VD = getInstantiatedFromStaticDataMember())
1960 return VD->isOutOfLine();
1965 VarDecl *VarDecl::getOutOfLineDefinition() {
1966 if (!isStaticDataMember())
1969 for (auto RD : redecls()) {
1970 if (RD->getLexicalDeclContext()->isFileContext())
1977 void VarDecl::setInit(Expr *I) {
1978 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
1979 Eval->~EvaluatedStmt();
1980 getASTContext().Deallocate(Eval);
1986 bool VarDecl::isUsableInConstantExpressions(ASTContext &C) const {
1987 const LangOptions &Lang = C.getLangOpts();
1989 if (!Lang.CPlusPlus)
1992 // In C++11, any variable of reference type can be used in a constant
1993 // expression if it is initialized by a constant expression.
1994 if (Lang.CPlusPlus11 && getType()->isReferenceType())
1997 // Only const objects can be used in constant expressions in C++. C++98 does
1998 // not require the variable to be non-volatile, but we consider this to be a
2000 if (!getType().isConstQualified() || getType().isVolatileQualified())
2003 // In C++, const, non-volatile variables of integral or enumeration types
2004 // can be used in constant expressions.
2005 if (getType()->isIntegralOrEnumerationType())
2008 // Additionally, in C++11, non-volatile constexpr variables can be used in
2009 // constant expressions.
2010 return Lang.CPlusPlus11 && isConstexpr();
2013 /// Convert the initializer for this declaration to the elaborated EvaluatedStmt
2014 /// form, which contains extra information on the evaluated value of the
2016 EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const {
2017 EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>();
2019 Stmt *S = Init.get<Stmt *>();
2020 // Note: EvaluatedStmt contains an APValue, which usually holds
2021 // resources not allocated from the ASTContext. We need to do some
2022 // work to avoid leaking those, but we do so in VarDecl::evaluateValue
2023 // where we can detect whether there's anything to clean up or not.
2024 Eval = new (getASTContext()) EvaluatedStmt;
2031 APValue *VarDecl::evaluateValue() const {
2032 SmallVector<PartialDiagnosticAt, 8> Notes;
2033 return evaluateValue(Notes);
2037 // Destroy an APValue that was allocated in an ASTContext.
2038 void DestroyAPValue(void* UntypedValue) {
2039 static_cast<APValue*>(UntypedValue)->~APValue();
2043 APValue *VarDecl::evaluateValue(
2044 SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
2045 EvaluatedStmt *Eval = ensureEvaluatedStmt();
2047 // We only produce notes indicating why an initializer is non-constant the
2048 // first time it is evaluated. FIXME: The notes won't always be emitted the
2049 // first time we try evaluation, so might not be produced at all.
2050 if (Eval->WasEvaluated)
2051 return Eval->Evaluated.isUninit() ? nullptr : &Eval->Evaluated;
2053 const Expr *Init = cast<Expr>(Eval->Value);
2054 assert(!Init->isValueDependent());
2056 if (Eval->IsEvaluating) {
2057 // FIXME: Produce a diagnostic for self-initialization.
2058 Eval->CheckedICE = true;
2059 Eval->IsICE = false;
2063 Eval->IsEvaluating = true;
2065 bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(),
2068 // Ensure the computed APValue is cleaned up later if evaluation succeeded,
2069 // or that it's empty (so that there's nothing to clean up) if evaluation
2072 Eval->Evaluated = APValue();
2073 else if (Eval->Evaluated.needsCleanup())
2074 getASTContext().AddDeallocation(DestroyAPValue, &Eval->Evaluated);
2076 Eval->IsEvaluating = false;
2077 Eval->WasEvaluated = true;
2079 // In C++11, we have determined whether the initializer was a constant
2080 // expression as a side-effect.
2081 if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) {
2082 Eval->CheckedICE = true;
2083 Eval->IsICE = Result && Notes.empty();
2086 return Result ? &Eval->Evaluated : nullptr;
2089 bool VarDecl::checkInitIsICE() const {
2090 // Initializers of weak variables are never ICEs.
2094 EvaluatedStmt *Eval = ensureEvaluatedStmt();
2095 if (Eval->CheckedICE)
2096 // We have already checked whether this subexpression is an
2097 // integral constant expression.
2100 const Expr *Init = cast<Expr>(Eval->Value);
2101 assert(!Init->isValueDependent());
2103 // In C++11, evaluate the initializer to check whether it's a constant
2105 if (getASTContext().getLangOpts().CPlusPlus11) {
2106 SmallVector<PartialDiagnosticAt, 8> Notes;
2107 evaluateValue(Notes);
2111 // It's an ICE whether or not the definition we found is
2112 // out-of-line. See DR 721 and the discussion in Clang PR
2113 // 6206 for details.
2115 if (Eval->CheckingICE)
2117 Eval->CheckingICE = true;
2119 Eval->IsICE = Init->isIntegerConstantExpr(getASTContext());
2120 Eval->CheckingICE = false;
2121 Eval->CheckedICE = true;
2125 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
2126 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2127 return cast<VarDecl>(MSI->getInstantiatedFrom());
2132 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
2133 if (const VarTemplateSpecializationDecl *Spec =
2134 dyn_cast<VarTemplateSpecializationDecl>(this))
2135 return Spec->getSpecializationKind();
2137 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2138 return MSI->getTemplateSpecializationKind();
2140 return TSK_Undeclared;
2143 SourceLocation VarDecl::getPointOfInstantiation() const {
2144 if (const VarTemplateSpecializationDecl *Spec =
2145 dyn_cast<VarTemplateSpecializationDecl>(this))
2146 return Spec->getPointOfInstantiation();
2148 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2149 return MSI->getPointOfInstantiation();
2151 return SourceLocation();
2154 VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
2155 return getASTContext().getTemplateOrSpecializationInfo(this)
2156 .dyn_cast<VarTemplateDecl *>();
2159 void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
2160 getASTContext().setTemplateOrSpecializationInfo(this, Template);
2163 MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
2164 if (isStaticDataMember())
2166 // return getASTContext().getInstantiatedFromStaticDataMember(this);
2167 return getASTContext().getTemplateOrSpecializationInfo(this)
2168 .dyn_cast<MemberSpecializationInfo *>();
2172 void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2173 SourceLocation PointOfInstantiation) {
2174 assert((isa<VarTemplateSpecializationDecl>(this) ||
2175 getMemberSpecializationInfo()) &&
2176 "not a variable or static data member template specialization");
2178 if (VarTemplateSpecializationDecl *Spec =
2179 dyn_cast<VarTemplateSpecializationDecl>(this)) {
2180 Spec->setSpecializationKind(TSK);
2181 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2182 Spec->getPointOfInstantiation().isInvalid())
2183 Spec->setPointOfInstantiation(PointOfInstantiation);
2186 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) {
2187 MSI->setTemplateSpecializationKind(TSK);
2188 if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2189 MSI->getPointOfInstantiation().isInvalid())
2190 MSI->setPointOfInstantiation(PointOfInstantiation);
2195 VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
2196 TemplateSpecializationKind TSK) {
2197 assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
2198 "Previous template or instantiation?");
2199 getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK);
2202 //===----------------------------------------------------------------------===//
2203 // ParmVarDecl Implementation
2204 //===----------------------------------------------------------------------===//
2206 ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
2207 SourceLocation StartLoc,
2208 SourceLocation IdLoc, IdentifierInfo *Id,
2209 QualType T, TypeSourceInfo *TInfo,
2210 StorageClass S, Expr *DefArg) {
2211 return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
2215 QualType ParmVarDecl::getOriginalType() const {
2216 TypeSourceInfo *TSI = getTypeSourceInfo();
2217 QualType T = TSI ? TSI->getType() : getType();
2218 if (const DecayedType *DT = dyn_cast<DecayedType>(T))
2219 return DT->getOriginalType();
2223 ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2225 ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
2226 nullptr, QualType(), nullptr, SC_None, nullptr);
2229 SourceRange ParmVarDecl::getSourceRange() const {
2230 if (!hasInheritedDefaultArg()) {
2231 SourceRange ArgRange = getDefaultArgRange();
2232 if (ArgRange.isValid())
2233 return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2236 // DeclaratorDecl considers the range of postfix types as overlapping with the
2237 // declaration name, but this is not the case with parameters in ObjC methods.
2238 if (isa<ObjCMethodDecl>(getDeclContext()))
2239 return SourceRange(DeclaratorDecl::getLocStart(), getLocation());
2241 return DeclaratorDecl::getSourceRange();
2244 Expr *ParmVarDecl::getDefaultArg() {
2245 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
2246 assert(!hasUninstantiatedDefaultArg() &&
2247 "Default argument is not yet instantiated!");
2249 Expr *Arg = getInit();
2250 if (ExprWithCleanups *E = dyn_cast_or_null<ExprWithCleanups>(Arg))
2251 return E->getSubExpr();
2256 SourceRange ParmVarDecl::getDefaultArgRange() const {
2257 if (const Expr *E = getInit())
2258 return E->getSourceRange();
2260 if (hasUninstantiatedDefaultArg())
2261 return getUninstantiatedDefaultArg()->getSourceRange();
2263 return SourceRange();
2266 bool ParmVarDecl::isParameterPack() const {
2267 return isa<PackExpansionType>(getType());
2270 void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
2271 getASTContext().setParameterIndex(this, parameterIndex);
2272 ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
2275 unsigned ParmVarDecl::getParameterIndexLarge() const {
2276 return getASTContext().getParameterIndex(this);
2279 //===----------------------------------------------------------------------===//
2280 // FunctionDecl Implementation
2281 //===----------------------------------------------------------------------===//
2283 void FunctionDecl::getNameForDiagnostic(
2284 raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
2285 NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
2286 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
2288 TemplateSpecializationType::PrintTemplateArgumentList(
2289 OS, TemplateArgs->data(), TemplateArgs->size(), Policy);
2292 bool FunctionDecl::isVariadic() const {
2293 if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>())
2294 return FT->isVariadic();
2298 bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
2299 for (auto I : redecls()) {
2300 if (I->Body || I->IsLateTemplateParsed) {
2309 bool FunctionDecl::hasTrivialBody() const
2311 Stmt *S = getBody();
2313 // Since we don't have a body for this function, we don't know if it's
2318 if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
2323 bool FunctionDecl::isDefined(const FunctionDecl *&Definition) const {
2324 for (auto I : redecls()) {
2325 if (I->IsDeleted || I->IsDefaulted || I->Body || I->IsLateTemplateParsed ||
2326 I->hasAttr<AliasAttr>()) {
2327 Definition = I->IsDeleted ? I->getCanonicalDecl() : I;
2335 Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
2336 if (!hasBody(Definition))
2339 if (Definition->Body)
2340 return Definition->Body.get(getASTContext().getExternalSource());
2345 void FunctionDecl::setBody(Stmt *B) {
2348 EndRangeLoc = B->getLocEnd();
2351 void FunctionDecl::setPure(bool P) {
2354 if (CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
2355 Parent->markedVirtualFunctionPure();
2358 template<std::size_t Len>
2359 static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
2360 IdentifierInfo *II = ND->getIdentifier();
2361 return II && II->isStr(Str);
2364 bool FunctionDecl::isMain() const {
2365 const TranslationUnitDecl *tunit =
2366 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2368 !tunit->getASTContext().getLangOpts().Freestanding &&
2369 isNamed(this, "main");
2372 bool FunctionDecl::isMSVCRTEntryPoint() const {
2373 const TranslationUnitDecl *TUnit =
2374 dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
2378 // Even though we aren't really targeting MSVCRT if we are freestanding,
2379 // semantic analysis for these functions remains the same.
2381 // MSVCRT entry points only exist on MSVCRT targets.
2382 if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
2385 // Nameless functions like constructors cannot be entry points.
2386 if (!getIdentifier())
2389 return llvm::StringSwitch<bool>(getName())
2390 .Cases("main", // an ANSI console app
2391 "wmain", // a Unicode console App
2392 "WinMain", // an ANSI GUI app
2393 "wWinMain", // a Unicode GUI app
2399 bool FunctionDecl::isReservedGlobalPlacementOperator() const {
2400 assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName);
2401 assert(getDeclName().getCXXOverloadedOperator() == OO_New ||
2402 getDeclName().getCXXOverloadedOperator() == OO_Delete ||
2403 getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
2404 getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
2406 if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2409 const FunctionProtoType *proto = getType()->castAs<FunctionProtoType>();
2410 if (proto->getNumParams() != 2 || proto->isVariadic())
2413 ASTContext &Context =
2414 cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
2417 // The result type and first argument type are constant across all
2418 // these operators. The second argument must be exactly void*.
2419 return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
2422 bool FunctionDecl::isReplaceableGlobalAllocationFunction() const {
2423 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2425 if (getDeclName().getCXXOverloadedOperator() != OO_New &&
2426 getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2427 getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
2428 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2431 if (isa<CXXRecordDecl>(getDeclContext()))
2434 // This can only fail for an invalid 'operator new' declaration.
2435 if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2438 const FunctionProtoType *FPT = getType()->castAs<FunctionProtoType>();
2439 if (FPT->getNumParams() == 0 || FPT->getNumParams() > 2 || FPT->isVariadic())
2442 // If this is a single-parameter function, it must be a replaceable global
2443 // allocation or deallocation function.
2444 if (FPT->getNumParams() == 1)
2447 // Otherwise, we're looking for a second parameter whose type is
2448 // 'const std::nothrow_t &', or, in C++1y, 'std::size_t'.
2449 QualType Ty = FPT->getParamType(1);
2450 ASTContext &Ctx = getASTContext();
2451 if (Ctx.getLangOpts().SizedDeallocation &&
2452 Ctx.hasSameType(Ty, Ctx.getSizeType()))
2454 if (!Ty->isReferenceType())
2456 Ty = Ty->getPointeeType();
2457 if (Ty.getCVRQualifiers() != Qualifiers::Const)
2459 const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2460 return RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace();
2464 FunctionDecl::getCorrespondingUnsizedGlobalDeallocationFunction() const {
2465 ASTContext &Ctx = getASTContext();
2466 if (!Ctx.getLangOpts().SizedDeallocation)
2469 if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2471 if (getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2472 getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2474 if (isa<CXXRecordDecl>(getDeclContext()))
2477 if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2480 if (getNumParams() != 2 || isVariadic() ||
2481 !Ctx.hasSameType(getType()->castAs<FunctionProtoType>()->getParamType(1),
2485 // This is a sized deallocation function. Find the corresponding unsized
2486 // deallocation function.
2487 lookup_const_result R = getDeclContext()->lookup(getDeclName());
2488 for (lookup_const_result::iterator RI = R.begin(), RE = R.end(); RI != RE;
2490 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*RI))
2491 if (FD->getNumParams() == 1 && !FD->isVariadic())
2496 LanguageLinkage FunctionDecl::getLanguageLinkage() const {
2497 return getDeclLanguageLinkage(*this);
2500 bool FunctionDecl::isExternC() const {
2501 return isDeclExternC(*this);
2504 bool FunctionDecl::isInExternCContext() const {
2505 return getLexicalDeclContext()->isExternCContext();
2508 bool FunctionDecl::isInExternCXXContext() const {
2509 return getLexicalDeclContext()->isExternCXXContext();
2512 bool FunctionDecl::isGlobal() const {
2513 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this))
2514 return Method->isStatic();
2516 if (getCanonicalDecl()->getStorageClass() == SC_Static)
2519 for (const DeclContext *DC = getDeclContext();
2521 DC = DC->getParent()) {
2522 if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) {
2523 if (!Namespace->getDeclName())
2532 bool FunctionDecl::isNoReturn() const {
2533 return hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
2534 hasAttr<C11NoReturnAttr>() ||
2535 getType()->getAs<FunctionType>()->getNoReturnAttr();
2539 FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
2540 redeclarable_base::setPreviousDecl(PrevDecl);
2542 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
2543 FunctionTemplateDecl *PrevFunTmpl
2544 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
2545 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
2546 FunTmpl->setPreviousDecl(PrevFunTmpl);
2549 if (PrevDecl && PrevDecl->IsInline)
2553 const FunctionDecl *FunctionDecl::getCanonicalDecl() const {
2554 return getFirstDecl();
2557 FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
2559 /// \brief Returns a value indicating whether this function
2560 /// corresponds to a builtin function.
2562 /// The function corresponds to a built-in function if it is
2563 /// declared at translation scope or within an extern "C" block and
2564 /// its name matches with the name of a builtin. The returned value
2565 /// will be 0 for functions that do not correspond to a builtin, a
2566 /// value of type \c Builtin::ID if in the target-independent range
2567 /// \c [1,Builtin::First), or a target-specific builtin value.
2568 unsigned FunctionDecl::getBuiltinID() const {
2569 if (!getIdentifier())
2572 unsigned BuiltinID = getIdentifier()->getBuiltinID();
2576 ASTContext &Context = getASTContext();
2577 if (Context.getLangOpts().CPlusPlus) {
2578 const LinkageSpecDecl *LinkageDecl = dyn_cast<LinkageSpecDecl>(
2579 getFirstDecl()->getDeclContext());
2580 // In C++, the first declaration of a builtin is always inside an implicit
2582 // FIXME: A recognised library function may not be directly in an extern "C"
2583 // declaration, for instance "extern "C" { namespace std { decl } }".
2584 if (!LinkageDecl || LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c)
2588 // If the function is marked "overloadable", it has a different mangled name
2589 // and is not the C library function.
2590 if (hasAttr<OverloadableAttr>())
2593 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
2596 // This function has the name of a known C library
2597 // function. Determine whether it actually refers to the C library
2598 // function or whether it just has the same name.
2600 // If this is a static function, it's not a builtin.
2601 if (getStorageClass() == SC_Static)
2608 /// getNumParams - Return the number of parameters this function must have
2609 /// based on its FunctionType. This is the length of the ParamInfo array
2610 /// after it has been created.
2611 unsigned FunctionDecl::getNumParams() const {
2612 const FunctionProtoType *FPT = getType()->getAs<FunctionProtoType>();
2613 return FPT ? FPT->getNumParams() : 0;
2616 void FunctionDecl::setParams(ASTContext &C,
2617 ArrayRef<ParmVarDecl *> NewParamInfo) {
2618 assert(!ParamInfo && "Already has param info!");
2619 assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
2621 // Zero params -> null pointer.
2622 if (!NewParamInfo.empty()) {
2623 ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
2624 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
2628 void FunctionDecl::setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls) {
2629 assert(DeclsInPrototypeScope.empty() && "Already has prototype decls!");
2631 if (!NewDecls.empty()) {
2632 NamedDecl **A = new (getASTContext()) NamedDecl*[NewDecls.size()];
2633 std::copy(NewDecls.begin(), NewDecls.end(), A);
2634 DeclsInPrototypeScope = llvm::makeArrayRef(A, NewDecls.size());
2635 // Move declarations introduced in prototype to the function context.
2636 for (auto I : NewDecls) {
2637 DeclContext *DC = I->getDeclContext();
2638 // Forward-declared reference to an enumeration is not added to
2639 // declaration scope, so skip declaration that is absent from its
2640 // declaration contexts.
2641 if (DC->containsDecl(I)) {
2643 I->setDeclContext(this);
2650 /// getMinRequiredArguments - Returns the minimum number of arguments
2651 /// needed to call this function. This may be fewer than the number of
2652 /// function parameters, if some of the parameters have default
2653 /// arguments (in C++) or are parameter packs (C++11).
2654 unsigned FunctionDecl::getMinRequiredArguments() const {
2655 if (!getASTContext().getLangOpts().CPlusPlus)
2656 return getNumParams();
2658 unsigned NumRequiredArgs = 0;
2659 for (auto *Param : params())
2660 if (!Param->isParameterPack() && !Param->hasDefaultArg())
2662 return NumRequiredArgs;
2665 /// \brief The combination of the extern and inline keywords under MSVC forces
2666 /// the function to be required.
2668 /// Note: This function assumes that we will only get called when isInlined()
2669 /// would return true for this FunctionDecl.
2670 bool FunctionDecl::isMSExternInline() const {
2671 assert(isInlined() && "expected to get called on an inlined function!");
2673 const ASTContext &Context = getASTContext();
2674 if (!Context.getLangOpts().MSVCCompat && !hasAttr<DLLExportAttr>())
2677 for (const FunctionDecl *FD = this; FD; FD = FD->getPreviousDecl())
2678 if (FD->getStorageClass() == SC_Extern)
2684 static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
2685 if (Redecl->getStorageClass() != SC_Extern)
2688 for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
2689 FD = FD->getPreviousDecl())
2690 if (FD->getStorageClass() == SC_Extern)
2696 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
2697 // Only consider file-scope declarations in this test.
2698 if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
2701 // Only consider explicit declarations; the presence of a builtin for a
2702 // libcall shouldn't affect whether a definition is externally visible.
2703 if (Redecl->isImplicit())
2706 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
2707 return true; // Not an inline definition
2712 /// \brief For a function declaration in C or C++, determine whether this
2713 /// declaration causes the definition to be externally visible.
2715 /// For instance, this determines if adding the current declaration to the set
2716 /// of redeclarations of the given functions causes
2717 /// isInlineDefinitionExternallyVisible to change from false to true.
2718 bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
2719 assert(!doesThisDeclarationHaveABody() &&
2720 "Must have a declaration without a body.");
2722 ASTContext &Context = getASTContext();
2724 if (Context.getLangOpts().MSVCCompat) {
2725 const FunctionDecl *Definition;
2726 if (hasBody(Definition) && Definition->isInlined() &&
2727 redeclForcesDefMSVC(this))
2731 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
2732 // With GNU inlining, a declaration with 'inline' but not 'extern', forces
2733 // an externally visible definition.
2735 // FIXME: What happens if gnu_inline gets added on after the first
2737 if (!isInlineSpecified() || getStorageClass() == SC_Extern)
2740 const FunctionDecl *Prev = this;
2741 bool FoundBody = false;
2742 while ((Prev = Prev->getPreviousDecl())) {
2743 FoundBody |= Prev->Body.isValid();
2746 // If it's not the case that both 'inline' and 'extern' are
2747 // specified on the definition, then it is always externally visible.
2748 if (!Prev->isInlineSpecified() ||
2749 Prev->getStorageClass() != SC_Extern)
2751 } else if (Prev->isInlineSpecified() &&
2752 Prev->getStorageClass() != SC_Extern) {
2759 if (Context.getLangOpts().CPlusPlus)
2763 // [...] If all of the file scope declarations for a function in a
2764 // translation unit include the inline function specifier without extern,
2765 // then the definition in that translation unit is an inline definition.
2766 if (isInlineSpecified() && getStorageClass() != SC_Extern)
2768 const FunctionDecl *Prev = this;
2769 bool FoundBody = false;
2770 while ((Prev = Prev->getPreviousDecl())) {
2771 FoundBody |= Prev->Body.isValid();
2772 if (RedeclForcesDefC99(Prev))
2778 SourceRange FunctionDecl::getReturnTypeSourceRange() const {
2779 const TypeSourceInfo *TSI = getTypeSourceInfo();
2781 return SourceRange();
2782 FunctionTypeLoc FTL =
2783 TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>();
2785 return SourceRange();
2787 // Skip self-referential return types.
2788 const SourceManager &SM = getASTContext().getSourceManager();
2789 SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
2790 SourceLocation Boundary = getNameInfo().getLocStart();
2791 if (RTRange.isInvalid() || Boundary.isInvalid() ||
2792 !SM.isBeforeInTranslationUnit(RTRange.getEnd(), Boundary))
2793 return SourceRange();
2798 /// \brief For an inline function definition in C, or for a gnu_inline function
2799 /// in C++, determine whether the definition will be externally visible.
2801 /// Inline function definitions are always available for inlining optimizations.
2802 /// However, depending on the language dialect, declaration specifiers, and
2803 /// attributes, the definition of an inline function may or may not be
2804 /// "externally" visible to other translation units in the program.
2806 /// In C99, inline definitions are not externally visible by default. However,
2807 /// if even one of the global-scope declarations is marked "extern inline", the
2808 /// inline definition becomes externally visible (C99 6.7.4p6).
2810 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function
2811 /// definition, we use the GNU semantics for inline, which are nearly the
2812 /// opposite of C99 semantics. In particular, "inline" by itself will create
2813 /// an externally visible symbol, but "extern inline" will not create an
2814 /// externally visible symbol.
2815 bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
2816 assert(doesThisDeclarationHaveABody() && "Must have the function definition");
2817 assert(isInlined() && "Function must be inline");
2818 ASTContext &Context = getASTContext();
2820 if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
2821 // Note: If you change the logic here, please change
2822 // doesDeclarationForceExternallyVisibleDefinition as well.
2824 // If it's not the case that both 'inline' and 'extern' are
2825 // specified on the definition, then this inline definition is
2826 // externally visible.
2827 if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
2830 // If any declaration is 'inline' but not 'extern', then this definition
2831 // is externally visible.
2832 for (auto Redecl : redecls()) {
2833 if (Redecl->isInlineSpecified() &&
2834 Redecl->getStorageClass() != SC_Extern)
2841 // The rest of this function is C-only.
2842 assert(!Context.getLangOpts().CPlusPlus &&
2843 "should not use C inline rules in C++");
2846 // [...] If all of the file scope declarations for a function in a
2847 // translation unit include the inline function specifier without extern,
2848 // then the definition in that translation unit is an inline definition.
2849 for (auto Redecl : redecls()) {
2850 if (RedeclForcesDefC99(Redecl))
2855 // An inline definition does not provide an external definition for the
2856 // function, and does not forbid an external definition in another
2857 // translation unit.
2861 /// getOverloadedOperator - Which C++ overloaded operator this
2862 /// function represents, if any.
2863 OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const {
2864 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
2865 return getDeclName().getCXXOverloadedOperator();
2870 /// getLiteralIdentifier - The literal suffix identifier this function
2871 /// represents, if any.
2872 const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
2873 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
2874 return getDeclName().getCXXLiteralIdentifier();
2879 FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const {
2880 if (TemplateOrSpecialization.isNull())
2881 return TK_NonTemplate;
2882 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>())
2883 return TK_FunctionTemplate;
2884 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>())
2885 return TK_MemberSpecialization;
2886 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
2887 return TK_FunctionTemplateSpecialization;
2888 if (TemplateOrSpecialization.is
2889 <DependentFunctionTemplateSpecializationInfo*>())
2890 return TK_DependentFunctionTemplateSpecialization;
2892 llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
2895 FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
2896 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo())
2897 return cast<FunctionDecl>(Info->getInstantiatedFrom());
2903 FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
2905 TemplateSpecializationKind TSK) {
2906 assert(TemplateOrSpecialization.isNull() &&
2907 "Member function is already a specialization");
2908 MemberSpecializationInfo *Info
2909 = new (C) MemberSpecializationInfo(FD, TSK);
2910 TemplateOrSpecialization = Info;
2913 bool FunctionDecl::isImplicitlyInstantiable() const {
2914 // If the function is invalid, it can't be implicitly instantiated.
2915 if (isInvalidDecl())
2918 switch (getTemplateSpecializationKind()) {
2919 case TSK_Undeclared:
2920 case TSK_ExplicitInstantiationDefinition:
2923 case TSK_ImplicitInstantiation:
2926 // It is possible to instantiate TSK_ExplicitSpecialization kind
2927 // if the FunctionDecl has a class scope specialization pattern.
2928 case TSK_ExplicitSpecialization:
2929 return getClassScopeSpecializationPattern() != nullptr;
2931 case TSK_ExplicitInstantiationDeclaration:
2936 // Find the actual template from which we will instantiate.
2937 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
2938 bool HasPattern = false;
2940 HasPattern = PatternDecl->hasBody(PatternDecl);
2942 // C++0x [temp.explicit]p9:
2943 // Except for inline functions, other explicit instantiation declarations
2944 // have the effect of suppressing the implicit instantiation of the entity
2945 // to which they refer.
2946 if (!HasPattern || !PatternDecl)
2949 return PatternDecl->isInlined();
2952 bool FunctionDecl::isTemplateInstantiation() const {
2953 switch (getTemplateSpecializationKind()) {
2954 case TSK_Undeclared:
2955 case TSK_ExplicitSpecialization:
2957 case TSK_ImplicitInstantiation:
2958 case TSK_ExplicitInstantiationDeclaration:
2959 case TSK_ExplicitInstantiationDefinition:
2962 llvm_unreachable("All TSK values handled.");
2965 FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const {
2966 // Handle class scope explicit specialization special case.
2967 if (getTemplateSpecializationKind() == TSK_ExplicitSpecialization)
2968 return getClassScopeSpecializationPattern();
2970 // If this is a generic lambda call operator specialization, its
2971 // instantiation pattern is always its primary template's pattern
2972 // even if its primary template was instantiated from another
2973 // member template (which happens with nested generic lambdas).
2974 // Since a lambda's call operator's body is transformed eagerly,
2975 // we don't have to go hunting for a prototype definition template
2976 // (i.e. instantiated-from-member-template) to use as an instantiation
2979 if (isGenericLambdaCallOperatorSpecialization(
2980 dyn_cast<CXXMethodDecl>(this))) {
2981 assert(getPrimaryTemplate() && "A generic lambda specialization must be "
2982 "generated from a primary call operator "
2984 assert(getPrimaryTemplate()->getTemplatedDecl()->getBody() &&
2985 "A generic lambda call operator template must always have a body - "
2986 "even if instantiated from a prototype (i.e. as written) member "
2988 return getPrimaryTemplate()->getTemplatedDecl();
2991 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
2992 while (Primary->getInstantiatedFromMemberTemplate()) {
2993 // If we have hit a point where the user provided a specialization of
2994 // this template, we're done looking.
2995 if (Primary->isMemberSpecialization())
2997 Primary = Primary->getInstantiatedFromMemberTemplate();
3000 return Primary->getTemplatedDecl();
3003 return getInstantiatedFromMemberFunction();
3006 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
3007 if (FunctionTemplateSpecializationInfo *Info
3008 = TemplateOrSpecialization
3009 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3010 return Info->Template.getPointer();
3015 FunctionDecl *FunctionDecl::getClassScopeSpecializationPattern() const {
3016 return getASTContext().getClassScopeSpecializationPattern(this);
3019 const TemplateArgumentList *
3020 FunctionDecl::getTemplateSpecializationArgs() const {
3021 if (FunctionTemplateSpecializationInfo *Info
3022 = TemplateOrSpecialization
3023 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3024 return Info->TemplateArguments;
3029 const ASTTemplateArgumentListInfo *
3030 FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
3031 if (FunctionTemplateSpecializationInfo *Info
3032 = TemplateOrSpecialization
3033 .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3034 return Info->TemplateArgumentsAsWritten;
3040 FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
3041 FunctionTemplateDecl *Template,
3042 const TemplateArgumentList *TemplateArgs,
3044 TemplateSpecializationKind TSK,
3045 const TemplateArgumentListInfo *TemplateArgsAsWritten,
3046 SourceLocation PointOfInstantiation) {
3047 assert(TSK != TSK_Undeclared &&
3048 "Must specify the type of function template specialization");
3049 FunctionTemplateSpecializationInfo *Info
3050 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
3052 Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK,
3054 TemplateArgsAsWritten,
3055 PointOfInstantiation);
3056 TemplateOrSpecialization = Info;
3057 Template->addSpecialization(Info, InsertPos);
3061 FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context,
3062 const UnresolvedSetImpl &Templates,
3063 const TemplateArgumentListInfo &TemplateArgs) {
3064 assert(TemplateOrSpecialization.isNull());
3065 size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo);
3066 Size += Templates.size() * sizeof(FunctionTemplateDecl*);
3067 Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc);
3068 void *Buffer = Context.Allocate(Size);
3069 DependentFunctionTemplateSpecializationInfo *Info =
3070 new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates,
3072 TemplateOrSpecialization = Info;
3075 DependentFunctionTemplateSpecializationInfo::
3076 DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
3077 const TemplateArgumentListInfo &TArgs)
3078 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
3080 d.NumTemplates = Ts.size();
3081 d.NumArgs = TArgs.size();
3083 FunctionTemplateDecl **TsArray =
3084 const_cast<FunctionTemplateDecl**>(getTemplates());
3085 for (unsigned I = 0, E = Ts.size(); I != E; ++I)
3086 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
3088 TemplateArgumentLoc *ArgsArray =
3089 const_cast<TemplateArgumentLoc*>(getTemplateArgs());
3090 for (unsigned I = 0, E = TArgs.size(); I != E; ++I)
3091 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]);
3094 TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const {
3095 // For a function template specialization, query the specialization
3096 // information object.
3097 FunctionTemplateSpecializationInfo *FTSInfo
3098 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
3100 return FTSInfo->getTemplateSpecializationKind();
3102 MemberSpecializationInfo *MSInfo
3103 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
3105 return MSInfo->getTemplateSpecializationKind();
3107 return TSK_Undeclared;
3111 FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3112 SourceLocation PointOfInstantiation) {
3113 if (FunctionTemplateSpecializationInfo *FTSInfo
3114 = TemplateOrSpecialization.dyn_cast<
3115 FunctionTemplateSpecializationInfo*>()) {
3116 FTSInfo->setTemplateSpecializationKind(TSK);
3117 if (TSK != TSK_ExplicitSpecialization &&
3118 PointOfInstantiation.isValid() &&
3119 FTSInfo->getPointOfInstantiation().isInvalid())
3120 FTSInfo->setPointOfInstantiation(PointOfInstantiation);
3121 } else if (MemberSpecializationInfo *MSInfo
3122 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) {
3123 MSInfo->setTemplateSpecializationKind(TSK);
3124 if (TSK != TSK_ExplicitSpecialization &&
3125 PointOfInstantiation.isValid() &&
3126 MSInfo->getPointOfInstantiation().isInvalid())
3127 MSInfo->setPointOfInstantiation(PointOfInstantiation);
3129 llvm_unreachable("Function cannot have a template specialization kind");
3132 SourceLocation FunctionDecl::getPointOfInstantiation() const {
3133 if (FunctionTemplateSpecializationInfo *FTSInfo
3134 = TemplateOrSpecialization.dyn_cast<
3135 FunctionTemplateSpecializationInfo*>())
3136 return FTSInfo->getPointOfInstantiation();
3137 else if (MemberSpecializationInfo *MSInfo
3138 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>())
3139 return MSInfo->getPointOfInstantiation();
3141 return SourceLocation();
3144 bool FunctionDecl::isOutOfLine() const {
3145 if (Decl::isOutOfLine())
3148 // If this function was instantiated from a member function of a
3149 // class template, check whether that member function was defined out-of-line.
3150 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) {
3151 const FunctionDecl *Definition;
3152 if (FD->hasBody(Definition))
3153 return Definition->isOutOfLine();
3156 // If this function was instantiated from a function template,
3157 // check whether that function template was defined out-of-line.
3158 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
3159 const FunctionDecl *Definition;
3160 if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
3161 return Definition->isOutOfLine();
3167 SourceRange FunctionDecl::getSourceRange() const {
3168 return SourceRange(getOuterLocStart(), EndRangeLoc);
3171 unsigned FunctionDecl::getMemoryFunctionKind() const {
3172 IdentifierInfo *FnInfo = getIdentifier();
3177 // Builtin handling.
3178 switch (getBuiltinID()) {
3179 case Builtin::BI__builtin_memset:
3180 case Builtin::BI__builtin___memset_chk:
3181 case Builtin::BImemset:
3182 return Builtin::BImemset;
3184 case Builtin::BI__builtin_memcpy:
3185 case Builtin::BI__builtin___memcpy_chk:
3186 case Builtin::BImemcpy:
3187 return Builtin::BImemcpy;
3189 case Builtin::BI__builtin_memmove:
3190 case Builtin::BI__builtin___memmove_chk:
3191 case Builtin::BImemmove:
3192 return Builtin::BImemmove;
3194 case Builtin::BIstrlcpy:
3195 case Builtin::BI__builtin___strlcpy_chk:
3196 return Builtin::BIstrlcpy;
3198 case Builtin::BIstrlcat:
3199 case Builtin::BI__builtin___strlcat_chk:
3200 return Builtin::BIstrlcat;
3202 case Builtin::BI__builtin_memcmp:
3203 case Builtin::BImemcmp:
3204 return Builtin::BImemcmp;
3206 case Builtin::BI__builtin_strncpy:
3207 case Builtin::BI__builtin___strncpy_chk:
3208 case Builtin::BIstrncpy:
3209 return Builtin::BIstrncpy;
3211 case Builtin::BI__builtin_strncmp:
3212 case Builtin::BIstrncmp:
3213 return Builtin::BIstrncmp;
3215 case Builtin::BI__builtin_strncasecmp:
3216 case Builtin::BIstrncasecmp:
3217 return Builtin::BIstrncasecmp;
3219 case Builtin::BI__builtin_strncat:
3220 case Builtin::BI__builtin___strncat_chk:
3221 case Builtin::BIstrncat:
3222 return Builtin::BIstrncat;
3224 case Builtin::BI__builtin_strndup:
3225 case Builtin::BIstrndup:
3226 return Builtin::BIstrndup;
3228 case Builtin::BI__builtin_strlen:
3229 case Builtin::BIstrlen:
3230 return Builtin::BIstrlen;
3234 if (FnInfo->isStr("memset"))
3235 return Builtin::BImemset;
3236 else if (FnInfo->isStr("memcpy"))
3237 return Builtin::BImemcpy;
3238 else if (FnInfo->isStr("memmove"))
3239 return Builtin::BImemmove;
3240 else if (FnInfo->isStr("memcmp"))
3241 return Builtin::BImemcmp;
3242 else if (FnInfo->isStr("strncpy"))
3243 return Builtin::BIstrncpy;
3244 else if (FnInfo->isStr("strncmp"))
3245 return Builtin::BIstrncmp;
3246 else if (FnInfo->isStr("strncasecmp"))
3247 return Builtin::BIstrncasecmp;
3248 else if (FnInfo->isStr("strncat"))
3249 return Builtin::BIstrncat;
3250 else if (FnInfo->isStr("strndup"))
3251 return Builtin::BIstrndup;
3252 else if (FnInfo->isStr("strlen"))
3253 return Builtin::BIstrlen;
3260 //===----------------------------------------------------------------------===//
3261 // FieldDecl Implementation
3262 //===----------------------------------------------------------------------===//
3264 FieldDecl *FieldDecl::Create(const ASTContext &C, DeclContext *DC,
3265 SourceLocation StartLoc, SourceLocation IdLoc,
3266 IdentifierInfo *Id, QualType T,
3267 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
3268 InClassInitStyle InitStyle) {
3269 return new (C, DC) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo,
3270 BW, Mutable, InitStyle);
3273 FieldDecl *FieldDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3274 return new (C, ID) FieldDecl(Field, nullptr, SourceLocation(),
3275 SourceLocation(), nullptr, QualType(), nullptr,
3276 nullptr, false, ICIS_NoInit);
3279 bool FieldDecl::isAnonymousStructOrUnion() const {
3280 if (!isImplicit() || getDeclName())
3283 if (const RecordType *Record = getType()->getAs<RecordType>())
3284 return Record->getDecl()->isAnonymousStructOrUnion();
3289 unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const {
3290 assert(isBitField() && "not a bitfield");
3291 Expr *BitWidth = static_cast<Expr *>(InitStorage.getPointer());
3292 return BitWidth->EvaluateKnownConstInt(Ctx).getZExtValue();
3295 unsigned FieldDecl::getFieldIndex() const {
3296 const FieldDecl *Canonical = getCanonicalDecl();
3297 if (Canonical != this)
3298 return Canonical->getFieldIndex();
3300 if (CachedFieldIndex) return CachedFieldIndex - 1;
3303 const RecordDecl *RD = getParent();
3305 for (auto *Field : RD->fields()) {
3306 Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
3310 assert(CachedFieldIndex && "failed to find field in parent");
3311 return CachedFieldIndex - 1;
3314 SourceRange FieldDecl::getSourceRange() const {
3315 switch (InitStorage.getInt()) {
3316 // All three of these cases store an optional Expr*.
3317 case ISK_BitWidthOrNothing:
3318 case ISK_InClassCopyInit:
3319 case ISK_InClassListInit:
3320 if (const Expr *E = static_cast<const Expr *>(InitStorage.getPointer()))
3321 return SourceRange(getInnerLocStart(), E->getLocEnd());
3324 case ISK_CapturedVLAType:
3325 return DeclaratorDecl::getSourceRange();
3327 llvm_unreachable("bad init storage kind");
3330 void FieldDecl::setCapturedVLAType(const VariableArrayType *VLAType) {
3331 assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
3332 "capturing type in non-lambda or captured record.");
3333 assert(InitStorage.getInt() == ISK_BitWidthOrNothing &&
3334 InitStorage.getPointer() == nullptr &&
3335 "bit width, initializer or captured type already set");
3336 InitStorage.setPointerAndInt(const_cast<VariableArrayType *>(VLAType),
3337 ISK_CapturedVLAType);
3340 //===----------------------------------------------------------------------===//
3341 // TagDecl Implementation
3342 //===----------------------------------------------------------------------===//
3344 SourceLocation TagDecl::getOuterLocStart() const {
3345 return getTemplateOrInnerLocStart(this);
3348 SourceRange TagDecl::getSourceRange() const {
3349 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
3350 return SourceRange(getOuterLocStart(), E);
3353 TagDecl *TagDecl::getCanonicalDecl() { return getFirstDecl(); }
3355 void TagDecl::setTypedefNameForAnonDecl(TypedefNameDecl *TDD) {
3356 NamedDeclOrQualifier = TDD;
3357 if (const Type *T = getTypeForDecl()) {
3359 assert(T->isLinkageValid());
3361 assert(isLinkageValid());
3364 void TagDecl::startDefinition() {
3365 IsBeingDefined = true;
3367 if (CXXRecordDecl *D = dyn_cast<CXXRecordDecl>(this)) {
3368 struct CXXRecordDecl::DefinitionData *Data =
3369 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
3370 for (auto I : redecls())
3371 cast<CXXRecordDecl>(I)->DefinitionData = Data;
3375 void TagDecl::completeDefinition() {
3376 assert((!isa<CXXRecordDecl>(this) ||
3377 cast<CXXRecordDecl>(this)->hasDefinition()) &&
3378 "definition completed but not started");
3380 IsCompleteDefinition = true;
3381 IsBeingDefined = false;
3383 if (ASTMutationListener *L = getASTMutationListener())
3384 L->CompletedTagDefinition(this);
3387 TagDecl *TagDecl::getDefinition() const {
3388 if (isCompleteDefinition())
3389 return const_cast<TagDecl *>(this);
3391 // If it's possible for us to have an out-of-date definition, check now.
3392 if (MayHaveOutOfDateDef) {
3393 if (IdentifierInfo *II = getIdentifier()) {
3394 if (II->isOutOfDate()) {
3395 updateOutOfDate(*II);
3400 if (const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this))
3401 return CXXRD->getDefinition();
3403 for (auto R : redecls())
3404 if (R->isCompleteDefinition())
3410 void TagDecl::setQualifierInfo(NestedNameSpecifierLoc QualifierLoc) {
3412 // Make sure the extended qualifier info is allocated.
3414 NamedDeclOrQualifier = new (getASTContext()) ExtInfo;
3415 // Set qualifier info.
3416 getExtInfo()->QualifierLoc = QualifierLoc;
3418 // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
3420 if (getExtInfo()->NumTemplParamLists == 0) {
3421 getASTContext().Deallocate(getExtInfo());
3422 NamedDeclOrQualifier = (TypedefNameDecl*)nullptr;
3425 getExtInfo()->QualifierLoc = QualifierLoc;
3430 void TagDecl::setTemplateParameterListsInfo(ASTContext &Context,
3431 unsigned NumTPLists,
3432 TemplateParameterList **TPLists) {
3433 assert(NumTPLists > 0);
3434 // Make sure the extended decl info is allocated.
3436 // Allocate external info struct.
3437 NamedDeclOrQualifier = new (getASTContext()) ExtInfo;
3438 // Set the template parameter lists info.
3439 getExtInfo()->setTemplateParameterListsInfo(Context, NumTPLists, TPLists);
3442 //===----------------------------------------------------------------------===//
3443 // EnumDecl Implementation
3444 //===----------------------------------------------------------------------===//
3446 void EnumDecl::anchor() { }
3448 EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC,
3449 SourceLocation StartLoc, SourceLocation IdLoc,
3451 EnumDecl *PrevDecl, bool IsScoped,
3452 bool IsScopedUsingClassTag, bool IsFixed) {
3453 EnumDecl *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
3454 IsScoped, IsScopedUsingClassTag,
3456 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3457 C.getTypeDeclType(Enum, PrevDecl);
3461 EnumDecl *EnumDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3463 new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
3464 nullptr, nullptr, false, false, false);
3465 Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3469 SourceRange EnumDecl::getIntegerTypeRange() const {
3470 if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
3471 return TI->getTypeLoc().getSourceRange();
3472 return SourceRange();
3475 void EnumDecl::completeDefinition(QualType NewType,
3476 QualType NewPromotionType,
3477 unsigned NumPositiveBits,
3478 unsigned NumNegativeBits) {
3479 assert(!isCompleteDefinition() && "Cannot redefine enums!");
3481 IntegerType = NewType.getTypePtr();
3482 PromotionType = NewPromotionType;
3483 setNumPositiveBits(NumPositiveBits);
3484 setNumNegativeBits(NumNegativeBits);
3485 TagDecl::completeDefinition();
3488 TemplateSpecializationKind EnumDecl::getTemplateSpecializationKind() const {
3489 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
3490 return MSI->getTemplateSpecializationKind();
3492 return TSK_Undeclared;
3495 void EnumDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3496 SourceLocation PointOfInstantiation) {
3497 MemberSpecializationInfo *MSI = getMemberSpecializationInfo();
3498 assert(MSI && "Not an instantiated member enumeration?");
3499 MSI->setTemplateSpecializationKind(TSK);
3500 if (TSK != TSK_ExplicitSpecialization &&
3501 PointOfInstantiation.isValid() &&
3502 MSI->getPointOfInstantiation().isInvalid())
3503 MSI->setPointOfInstantiation(PointOfInstantiation);
3506 EnumDecl *EnumDecl::getInstantiatedFromMemberEnum() const {
3507 if (SpecializationInfo)
3508 return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom());
3513 void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3514 TemplateSpecializationKind TSK) {
3515 assert(!SpecializationInfo && "Member enum is already a specialization");
3516 SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK);
3519 //===----------------------------------------------------------------------===//
3520 // RecordDecl Implementation
3521 //===----------------------------------------------------------------------===//
3523 RecordDecl::RecordDecl(Kind DK, TagKind TK, const ASTContext &C,
3524 DeclContext *DC, SourceLocation StartLoc,
3525 SourceLocation IdLoc, IdentifierInfo *Id,
3526 RecordDecl *PrevDecl)
3527 : TagDecl(DK, TK, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
3528 HasFlexibleArrayMember = false;
3529 AnonymousStructOrUnion = false;
3530 HasObjectMember = false;
3531 HasVolatileMember = false;
3532 LoadedFieldsFromExternalStorage = false;
3533 assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!");
3536 RecordDecl *RecordDecl::Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3537 SourceLocation StartLoc, SourceLocation IdLoc,
3538 IdentifierInfo *Id, RecordDecl* PrevDecl) {
3539 RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
3540 StartLoc, IdLoc, Id, PrevDecl);
3541 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3543 C.getTypeDeclType(R, PrevDecl);
3547 RecordDecl *RecordDecl::CreateDeserialized(const ASTContext &C, unsigned ID) {
3549 new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
3550 SourceLocation(), nullptr, nullptr);
3551 R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3555 bool RecordDecl::isInjectedClassName() const {
3556 return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
3557 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
3560 bool RecordDecl::isLambda() const {
3561 if (auto RD = dyn_cast<CXXRecordDecl>(this))
3562 return RD->isLambda();
3566 bool RecordDecl::isCapturedRecord() const {
3567 return hasAttr<CapturedRecordAttr>();
3570 void RecordDecl::setCapturedRecord() {
3571 addAttr(CapturedRecordAttr::CreateImplicit(getASTContext()));
3574 RecordDecl::field_iterator RecordDecl::field_begin() const {
3575 if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage)
3576 LoadFieldsFromExternalStorage();
3578 return field_iterator(decl_iterator(FirstDecl));
3581 /// completeDefinition - Notes that the definition of this type is now
3583 void RecordDecl::completeDefinition() {
3584 assert(!isCompleteDefinition() && "Cannot redefine record!");
3585 TagDecl::completeDefinition();
3588 /// isMsStruct - Get whether or not this record uses ms_struct layout.
3589 /// This which can be turned on with an attribute, pragma, or the
3590 /// -mms-bitfields command-line option.
3591 bool RecordDecl::isMsStruct(const ASTContext &C) const {
3592 return hasAttr<MsStructAttr>() || C.getLangOpts().MSBitfields == 1;
3595 static bool isFieldOrIndirectField(Decl::Kind K) {
3596 return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
3599 void RecordDecl::LoadFieldsFromExternalStorage() const {
3600 ExternalASTSource *Source = getASTContext().getExternalSource();
3601 assert(hasExternalLexicalStorage() && Source && "No external storage?");
3603 // Notify that we have a RecordDecl doing some initialization.
3604 ExternalASTSource::Deserializing TheFields(Source);
3606 SmallVector<Decl*, 64> Decls;
3607 LoadedFieldsFromExternalStorage = true;
3608 switch (Source->FindExternalLexicalDecls(this, isFieldOrIndirectField,
3613 case ELR_AlreadyLoaded:
3619 // Check that all decls we got were FieldDecls.
3620 for (unsigned i=0, e=Decls.size(); i != e; ++i)
3621 assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
3627 std::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls,
3628 /*FieldsAlreadyLoaded=*/false);
3631 bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
3632 ASTContext &Context = getASTContext();
3633 if (!Context.getLangOpts().Sanitize.has(SanitizerKind::Address) ||
3634 !Context.getLangOpts().SanitizeAddressFieldPadding)
3636 const auto &Blacklist = Context.getSanitizerBlacklist();
3637 const CXXRecordDecl *CXXRD = dyn_cast<CXXRecordDecl>(this);
3638 // We may be able to relax some of these requirements.
3639 int ReasonToReject = -1;
3640 if (!CXXRD || CXXRD->isExternCContext())
3641 ReasonToReject = 0; // is not C++.
3642 else if (CXXRD->hasAttr<PackedAttr>())
3643 ReasonToReject = 1; // is packed.
3644 else if (CXXRD->isUnion())
3645 ReasonToReject = 2; // is a union.
3646 else if (CXXRD->isTriviallyCopyable())
3647 ReasonToReject = 3; // is trivially copyable.
3648 else if (CXXRD->hasTrivialDestructor())
3649 ReasonToReject = 4; // has trivial destructor.
3650 else if (CXXRD->isStandardLayout())
3651 ReasonToReject = 5; // is standard layout.
3652 else if (Blacklist.isBlacklistedLocation(getLocation(), "field-padding"))
3653 ReasonToReject = 6; // is in a blacklisted file.
3654 else if (Blacklist.isBlacklistedType(getQualifiedNameAsString(),
3656 ReasonToReject = 7; // is blacklisted.
3659 if (ReasonToReject >= 0)
3660 Context.getDiagnostics().Report(
3662 diag::remark_sanitize_address_insert_extra_padding_rejected)
3663 << getQualifiedNameAsString() << ReasonToReject;
3665 Context.getDiagnostics().Report(
3667 diag::remark_sanitize_address_insert_extra_padding_accepted)
3668 << getQualifiedNameAsString();
3670 return ReasonToReject < 0;
3673 const FieldDecl *RecordDecl::findFirstNamedDataMember() const {
3674 for (const auto *I : fields()) {
3675 if (I->getIdentifier())
3678 if (const RecordType *RT = I->getType()->getAs<RecordType>())
3679 if (const FieldDecl *NamedDataMember =
3680 RT->getDecl()->findFirstNamedDataMember())
3681 return NamedDataMember;
3684 // We didn't find a named data member.
3689 //===----------------------------------------------------------------------===//
3690 // BlockDecl Implementation
3691 //===----------------------------------------------------------------------===//
3693 void BlockDecl::setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
3694 assert(!ParamInfo && "Already has param info!");
3696 // Zero params -> null pointer.
3697 if (!NewParamInfo.empty()) {
3698 NumParams = NewParamInfo.size();
3699 ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
3700 std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3704 void BlockDecl::setCaptures(ASTContext &Context,
3705 const Capture *begin,
3707 bool capturesCXXThis) {
3708 CapturesCXXThis = capturesCXXThis;
3716 NumCaptures = end - begin;
3718 // Avoid new Capture[] because we don't want to provide a default
3720 size_t allocationSize = NumCaptures * sizeof(Capture);
3721 void *buffer = Context.Allocate(allocationSize, /*alignment*/sizeof(void*));
3722 memcpy(buffer, begin, allocationSize);
3723 Captures = static_cast<Capture*>(buffer);
3726 bool BlockDecl::capturesVariable(const VarDecl *variable) const {
3727 for (const auto &I : captures())
3728 // Only auto vars can be captured, so no redeclaration worries.
3729 if (I.getVariable() == variable)
3735 SourceRange BlockDecl::getSourceRange() const {
3736 return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation());
3739 //===----------------------------------------------------------------------===//
3740 // Other Decl Allocation/Deallocation Method Implementations
3741 //===----------------------------------------------------------------------===//
3743 void TranslationUnitDecl::anchor() { }
3745 TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) {
3746 return new (C, (DeclContext *)nullptr) TranslationUnitDecl(C);
3749 void LabelDecl::anchor() { }
3751 LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
3752 SourceLocation IdentL, IdentifierInfo *II) {
3753 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, IdentL);
3756 LabelDecl *LabelDecl::Create(ASTContext &C, DeclContext *DC,
3757 SourceLocation IdentL, IdentifierInfo *II,
3758 SourceLocation GnuLabelL) {
3759 assert(GnuLabelL != IdentL && "Use this only for GNU local labels");
3760 return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, GnuLabelL);
3763 LabelDecl *LabelDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3764 return new (C, ID) LabelDecl(nullptr, SourceLocation(), nullptr, nullptr,
3768 void LabelDecl::setMSAsmLabel(StringRef Name) {
3769 char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
3770 memcpy(Buffer, Name.data(), Name.size());
3771 Buffer[Name.size()] = '\0';
3775 void ValueDecl::anchor() { }
3777 bool ValueDecl::isWeak() const {
3778 for (const auto *I : attrs())
3779 if (isa<WeakAttr>(I) || isa<WeakRefAttr>(I))
3782 return isWeakImported();
3785 void ImplicitParamDecl::anchor() { }
3787 ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC,
3788 SourceLocation IdLoc,
3791 return new (C, DC) ImplicitParamDecl(C, DC, IdLoc, Id, Type);
3794 ImplicitParamDecl *ImplicitParamDecl::CreateDeserialized(ASTContext &C,
3796 return new (C, ID) ImplicitParamDecl(C, nullptr, SourceLocation(), nullptr,
3800 FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC,
3801 SourceLocation StartLoc,
3802 const DeclarationNameInfo &NameInfo,
3803 QualType T, TypeSourceInfo *TInfo,
3805 bool isInlineSpecified,
3806 bool hasWrittenPrototype,
3807 bool isConstexprSpecified) {
3809 new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
3810 SC, isInlineSpecified, isConstexprSpecified);
3811 New->HasWrittenPrototype = hasWrittenPrototype;
3815 FunctionDecl *FunctionDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3816 return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
3817 DeclarationNameInfo(), QualType(), nullptr,
3818 SC_None, false, false);
3821 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
3822 return new (C, DC) BlockDecl(DC, L);
3825 BlockDecl *BlockDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3826 return new (C, ID) BlockDecl(nullptr, SourceLocation());
3829 CapturedDecl *CapturedDecl::Create(ASTContext &C, DeclContext *DC,
3830 unsigned NumParams) {
3831 return new (C, DC, NumParams * sizeof(ImplicitParamDecl *))
3832 CapturedDecl(DC, NumParams);
3835 CapturedDecl *CapturedDecl::CreateDeserialized(ASTContext &C, unsigned ID,
3836 unsigned NumParams) {
3837 return new (C, ID, NumParams * sizeof(ImplicitParamDecl *))
3838 CapturedDecl(nullptr, NumParams);
3841 EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD,
3843 IdentifierInfo *Id, QualType T,
3844 Expr *E, const llvm::APSInt &V) {
3845 return new (C, CD) EnumConstantDecl(CD, L, Id, T, E, V);
3849 EnumConstantDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3850 return new (C, ID) EnumConstantDecl(nullptr, SourceLocation(), nullptr,
3851 QualType(), nullptr, llvm::APSInt());
3854 void IndirectFieldDecl::anchor() { }
3857 IndirectFieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L,
3858 IdentifierInfo *Id, QualType T, NamedDecl **CH,
3860 return new (C, DC) IndirectFieldDecl(DC, L, Id, T, CH, CHS);
3863 IndirectFieldDecl *IndirectFieldDecl::CreateDeserialized(ASTContext &C,
3865 return new (C, ID) IndirectFieldDecl(nullptr, SourceLocation(),
3866 DeclarationName(), QualType(), nullptr,
3870 SourceRange EnumConstantDecl::getSourceRange() const {
3871 SourceLocation End = getLocation();
3873 End = Init->getLocEnd();
3874 return SourceRange(getLocation(), End);
3877 void TypeDecl::anchor() { }
3879 TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC,
3880 SourceLocation StartLoc, SourceLocation IdLoc,
3881 IdentifierInfo *Id, TypeSourceInfo *TInfo) {
3882 return new (C, DC) TypedefDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
3885 void TypedefNameDecl::anchor() { }
3887 TypedefDecl *TypedefDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3888 return new (C, ID) TypedefDecl(C, nullptr, SourceLocation(), SourceLocation(),
3892 TypeAliasDecl *TypeAliasDecl::Create(ASTContext &C, DeclContext *DC,
3893 SourceLocation StartLoc,
3894 SourceLocation IdLoc, IdentifierInfo *Id,
3895 TypeSourceInfo *TInfo) {
3896 return new (C, DC) TypeAliasDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
3899 TypeAliasDecl *TypeAliasDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3900 return new (C, ID) TypeAliasDecl(C, nullptr, SourceLocation(),
3901 SourceLocation(), nullptr, nullptr);
3904 SourceRange TypedefDecl::getSourceRange() const {
3905 SourceLocation RangeEnd = getLocation();
3906 if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
3907 if (typeIsPostfix(TInfo->getType()))
3908 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
3910 return SourceRange(getLocStart(), RangeEnd);
3913 SourceRange TypeAliasDecl::getSourceRange() const {
3914 SourceLocation RangeEnd = getLocStart();
3915 if (TypeSourceInfo *TInfo = getTypeSourceInfo())
3916 RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
3917 return SourceRange(getLocStart(), RangeEnd);
3920 void FileScopeAsmDecl::anchor() { }
3922 FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC,
3924 SourceLocation AsmLoc,
3925 SourceLocation RParenLoc) {
3926 return new (C, DC) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc);
3929 FileScopeAsmDecl *FileScopeAsmDecl::CreateDeserialized(ASTContext &C,
3931 return new (C, ID) FileScopeAsmDecl(nullptr, nullptr, SourceLocation(),
3935 void EmptyDecl::anchor() {}
3937 EmptyDecl *EmptyDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
3938 return new (C, DC) EmptyDecl(DC, L);
3941 EmptyDecl *EmptyDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3942 return new (C, ID) EmptyDecl(nullptr, SourceLocation());
3945 //===----------------------------------------------------------------------===//
3946 // ImportDecl Implementation
3947 //===----------------------------------------------------------------------===//
3949 /// \brief Retrieve the number of module identifiers needed to name the given
3951 static unsigned getNumModuleIdentifiers(Module *Mod) {
3952 unsigned Result = 1;
3953 while (Mod->Parent) {
3960 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
3962 ArrayRef<SourceLocation> IdentifierLocs)
3963 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true),
3966 assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size());
3967 SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(this + 1);
3968 memcpy(StoredLocs, IdentifierLocs.data(),
3969 IdentifierLocs.size() * sizeof(SourceLocation));
3972 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
3973 Module *Imported, SourceLocation EndLoc)
3974 : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false),
3977 *reinterpret_cast<SourceLocation *>(this + 1) = EndLoc;
3980 ImportDecl *ImportDecl::Create(ASTContext &C, DeclContext *DC,
3981 SourceLocation StartLoc, Module *Imported,
3982 ArrayRef<SourceLocation> IdentifierLocs) {
3983 return new (C, DC, IdentifierLocs.size() * sizeof(SourceLocation))
3984 ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
3987 ImportDecl *ImportDecl::CreateImplicit(ASTContext &C, DeclContext *DC,
3988 SourceLocation StartLoc,
3990 SourceLocation EndLoc) {
3991 ImportDecl *Import =
3992 new (C, DC, sizeof(SourceLocation)) ImportDecl(DC, StartLoc,
3994 Import->setImplicit();
3998 ImportDecl *ImportDecl::CreateDeserialized(ASTContext &C, unsigned ID,
3999 unsigned NumLocations) {
4000 return new (C, ID, NumLocations * sizeof(SourceLocation))
4001 ImportDecl(EmptyShell());
4004 ArrayRef<SourceLocation> ImportDecl::getIdentifierLocs() const {
4005 if (!ImportedAndComplete.getInt())
4008 const SourceLocation *StoredLocs
4009 = reinterpret_cast<const SourceLocation *>(this + 1);
4010 return llvm::makeArrayRef(StoredLocs,
4011 getNumModuleIdentifiers(getImportedModule()));
4014 SourceRange ImportDecl::getSourceRange() const {
4015 if (!ImportedAndComplete.getInt())
4016 return SourceRange(getLocation(),
4017 *reinterpret_cast<const SourceLocation *>(this + 1));
4019 return SourceRange(getLocation(), getIdentifierLocs().back());