clang  6.0.0svn
Decl.cpp
Go to the documentation of this file.
1 //===--- Decl.cpp - Declaration AST Node Implementation -------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the Decl subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/Decl.h"
15 #include "Linkage.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTLambda.h"
19 #include "clang/AST/Attr.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclOpenMP.h"
23 #include "clang/AST/DeclTemplate.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/Stmt.h"
28 #include "clang/AST/TypeLoc.h"
29 #include "clang/Basic/Builtins.h"
31 #include "clang/Basic/Module.h"
32 #include "clang/Basic/Specifiers.h"
33 #include "clang/Basic/TargetInfo.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include <algorithm>
37 
38 using namespace clang;
39 
41  return D->getASTContext().getPrimaryMergedDecl(D);
42 }
43 
44 // Defined here so that it can be inlined into its direct callers.
45 bool Decl::isOutOfLine() const {
47 }
48 
49 TranslationUnitDecl::TranslationUnitDecl(ASTContext &ctx)
50  : Decl(TranslationUnit, nullptr, SourceLocation()),
51  DeclContext(TranslationUnit), Ctx(ctx), AnonymousNamespace(nullptr) {}
52 
53 //===----------------------------------------------------------------------===//
54 // NamedDecl Implementation
55 //===----------------------------------------------------------------------===//
56 
57 // Visibility rules aren't rigorously externally specified, but here
58 // are the basic principles behind what we implement:
59 //
60 // 1. An explicit visibility attribute is generally a direct expression
61 // of the user's intent and should be honored. Only the innermost
62 // visibility attribute applies. If no visibility attribute applies,
63 // global visibility settings are considered.
64 //
65 // 2. There is one caveat to the above: on or in a template pattern,
66 // an explicit visibility attribute is just a default rule, and
67 // visibility can be decreased by the visibility of template
68 // arguments. But this, too, has an exception: an attribute on an
69 // explicit specialization or instantiation causes all the visibility
70 // restrictions of the template arguments to be ignored.
71 //
72 // 3. A variable that does not otherwise have explicit visibility can
73 // be restricted by the visibility of its type.
74 //
75 // 4. A visibility restriction is explicit if it comes from an
76 // attribute (or something like it), not a global visibility setting.
77 // When emitting a reference to an external symbol, visibility
78 // restrictions are ignored unless they are explicit.
79 //
80 // 5. When computing the visibility of a non-type, including a
81 // non-type member of a class, only non-type visibility restrictions
82 // are considered: the 'visibility' attribute, global value-visibility
83 // settings, and a few special cases like __private_extern.
84 //
85 // 6. When computing the visibility of a type, including a type member
86 // of a class, only type visibility restrictions are considered:
87 // the 'type_visibility' attribute and global type-visibility settings.
88 // However, a 'visibility' attribute counts as a 'type_visibility'
89 // attribute on any declaration that only has the former.
90 //
91 // The visibility of a "secondary" entity, like a template argument,
92 // is computed using the kind of that entity, not the kind of the
93 // primary entity for which we are computing visibility. For example,
94 // the visibility of a specialization of either of these templates:
95 // template <class T, bool (&compare)(T, X)> bool has_match(list<T>, X);
96 // template <class T, bool (&compare)(T, X)> class matcher;
97 // is restricted according to the type visibility of the argument 'T',
98 // the type visibility of 'bool(&)(T,X)', and the value visibility of
99 // the argument function 'compare'. That 'has_match' is a value
100 // and 'matcher' is a type only matters when looking for attributes
101 // and settings from the immediate context.
102 
103 /// Does this computation kind permit us to consider additional
104 /// visibility settings from attributes and the like?
106  return computation.IgnoreExplicitVisibility;
107 }
108 
109 /// Given an LVComputationKind, return one of the same type/value sort
110 /// that records that it already has explicit visibility.
111 static LVComputationKind
113  Kind.IgnoreExplicitVisibility = true;
114  return Kind;
115 }
116 
117 static Optional<Visibility> getExplicitVisibility(const NamedDecl *D,
119  assert(!kind.IgnoreExplicitVisibility &&
120  "asking for explicit visibility when we shouldn't be");
122 }
123 
124 /// Is the given declaration a "type" or a "value" for the purposes of
125 /// visibility computation?
126 static bool usesTypeVisibility(const NamedDecl *D) {
127  return isa<TypeDecl>(D) ||
128  isa<ClassTemplateDecl>(D) ||
129  isa<ObjCInterfaceDecl>(D);
130 }
131 
132 /// Does the given declaration have member specialization information,
133 /// and if so, is it an explicit specialization?
134 template <class T> static typename
135 std::enable_if<!std::is_base_of<RedeclarableTemplateDecl, T>::value, bool>::type
137  if (const MemberSpecializationInfo *member =
138  D->getMemberSpecializationInfo()) {
139  return member->isExplicitSpecialization();
140  }
141  return false;
142 }
143 
144 /// For templates, this question is easier: a member template can't be
145 /// explicitly instantiated, so there's a single bit indicating whether
146 /// or not this is an explicit member specialization.
148  return D->isMemberSpecialization();
149 }
150 
151 /// Given a visibility attribute, return the explicit visibility
152 /// associated with it.
153 template <class T>
154 static Visibility getVisibilityFromAttr(const T *attr) {
155  switch (attr->getVisibility()) {
156  case T::Default:
157  return DefaultVisibility;
158  case T::Hidden:
159  return HiddenVisibility;
160  case T::Protected:
161  return ProtectedVisibility;
162  }
163  llvm_unreachable("bad visibility kind");
164 }
165 
166 /// Return the explicit visibility of the given declaration.
167 static Optional<Visibility> getVisibilityOf(const NamedDecl *D,
169  // If we're ultimately computing the visibility of a type, look for
170  // a 'type_visibility' attribute before looking for 'visibility'.
171  if (kind == NamedDecl::VisibilityForType) {
172  if (const auto *A = D->getAttr<TypeVisibilityAttr>()) {
173  return getVisibilityFromAttr(A);
174  }
175  }
176 
177  // If this declaration has an explicit visibility attribute, use it.
178  if (const auto *A = D->getAttr<VisibilityAttr>()) {
179  return getVisibilityFromAttr(A);
180  }
181 
182  return None;
183 }
184 
185 LinkageInfo LinkageComputer::getLVForType(const Type &T,
186  LVComputationKind computation) {
187  if (computation.IgnoreAllVisibility)
188  return LinkageInfo(T.getLinkage(), DefaultVisibility, true);
189  return getTypeLinkageAndVisibility(&T);
190 }
191 
192 /// \brief Get the most restrictive linkage for the types in the given
193 /// template parameter list. For visibility purposes, template
194 /// parameters are part of the signature of a template.
195 LinkageInfo LinkageComputer::getLVForTemplateParameterList(
196  const TemplateParameterList *Params, LVComputationKind computation) {
197  LinkageInfo LV;
198  for (const NamedDecl *P : *Params) {
199  // Template type parameters are the most common and never
200  // contribute to visibility, pack or not.
201  if (isa<TemplateTypeParmDecl>(P))
202  continue;
203 
204  // Non-type template parameters can be restricted by the value type, e.g.
205  // template <enum X> class A { ... };
206  // We have to be careful here, though, because we can be dealing with
207  // dependent types.
208  if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(P)) {
209  // Handle the non-pack case first.
210  if (!NTTP->isExpandedParameterPack()) {
211  if (!NTTP->getType()->isDependentType()) {
212  LV.merge(getLVForType(*NTTP->getType(), computation));
213  }
214  continue;
215  }
216 
217  // Look at all the types in an expanded pack.
218  for (unsigned i = 0, n = NTTP->getNumExpansionTypes(); i != n; ++i) {
219  QualType type = NTTP->getExpansionType(i);
220  if (!type->isDependentType())
221  LV.merge(getTypeLinkageAndVisibility(type));
222  }
223  continue;
224  }
225 
226  // Template template parameters can be restricted by their
227  // template parameters, recursively.
228  const auto *TTP = cast<TemplateTemplateParmDecl>(P);
229 
230  // Handle the non-pack case first.
231  if (!TTP->isExpandedParameterPack()) {
232  LV.merge(getLVForTemplateParameterList(TTP->getTemplateParameters(),
233  computation));
234  continue;
235  }
236 
237  // Look at all expansions in an expanded pack.
238  for (unsigned i = 0, n = TTP->getNumExpansionTemplateParameters();
239  i != n; ++i) {
240  LV.merge(getLVForTemplateParameterList(
241  TTP->getExpansionTemplateParameters(i), computation));
242  }
243  }
244 
245  return LV;
246 }
247 
248 static const Decl *getOutermostFuncOrBlockContext(const Decl *D) {
249  const Decl *Ret = nullptr;
250  const DeclContext *DC = D->getDeclContext();
251  while (DC->getDeclKind() != Decl::TranslationUnit) {
252  if (isa<FunctionDecl>(DC) || isa<BlockDecl>(DC))
253  Ret = cast<Decl>(DC);
254  DC = DC->getParent();
255  }
256  return Ret;
257 }
258 
259 /// \brief Get the most restrictive linkage for the types and
260 /// declarations in the given template argument list.
261 ///
262 /// Note that we don't take an LVComputationKind because we always
263 /// want to honor the visibility of template arguments in the same way.
265 LinkageComputer::getLVForTemplateArgumentList(ArrayRef<TemplateArgument> Args,
266  LVComputationKind computation) {
267  LinkageInfo LV;
268 
269  for (const TemplateArgument &Arg : Args) {
270  switch (Arg.getKind()) {
274  continue;
275 
277  LV.merge(getLVForType(*Arg.getAsType(), computation));
278  continue;
279 
281  if (const auto *ND = dyn_cast<NamedDecl>(Arg.getAsDecl())) {
282  assert(!usesTypeVisibility(ND));
283  LV.merge(getLVForDecl(ND, computation));
284  }
285  continue;
286 
288  LV.merge(getTypeLinkageAndVisibility(Arg.getNullPtrType()));
289  continue;
290 
293  if (TemplateDecl *Template =
294  Arg.getAsTemplateOrTemplatePattern().getAsTemplateDecl())
295  LV.merge(getLVForDecl(Template, computation));
296  continue;
297 
299  LV.merge(getLVForTemplateArgumentList(Arg.getPackAsArray(), computation));
300  continue;
301  }
302  llvm_unreachable("bad template argument kind");
303  }
304 
305  return LV;
306 }
307 
309 LinkageComputer::getLVForTemplateArgumentList(const TemplateArgumentList &TArgs,
310  LVComputationKind computation) {
311  return getLVForTemplateArgumentList(TArgs.asArray(), computation);
312 }
313 
315  const FunctionTemplateSpecializationInfo *specInfo) {
316  // Include visibility from the template parameters and arguments
317  // only if this is not an explicit instantiation or specialization
318  // with direct explicit visibility. (Implicit instantiations won't
319  // have a direct attribute.)
321  return true;
322 
323  return !fn->hasAttr<VisibilityAttr>();
324 }
325 
326 /// Merge in template-related linkage and visibility for the given
327 /// function template specialization.
328 ///
329 /// We don't need a computation kind here because we can assume
330 /// LVForValue.
331 ///
332 /// \param[out] LV the computation to use for the parent
333 void LinkageComputer::mergeTemplateLV(
334  LinkageInfo &LV, const FunctionDecl *fn,
335  const FunctionTemplateSpecializationInfo *specInfo,
336  LVComputationKind computation) {
337  bool considerVisibility =
338  shouldConsiderTemplateVisibility(fn, specInfo);
339 
340  // Merge information from the template parameters.
341  FunctionTemplateDecl *temp = specInfo->getTemplate();
342  LinkageInfo tempLV =
343  getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
344  LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
345 
346  // Merge information from the template arguments.
347  const TemplateArgumentList &templateArgs = *specInfo->TemplateArguments;
348  LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
349  LV.mergeMaybeWithVisibility(argsLV, considerVisibility);
350 }
351 
352 /// Does the given declaration have a direct visibility attribute
353 /// that would match the given rules?
355  LVComputationKind computation) {
356  if (computation.IgnoreAllVisibility)
357  return false;
358 
359  return (computation.isTypeVisibility() && D->hasAttr<TypeVisibilityAttr>()) ||
360  D->hasAttr<VisibilityAttr>();
361 }
362 
363 /// Should we consider visibility associated with the template
364 /// arguments and parameters of the given class template specialization?
367  LVComputationKind computation) {
368  // Include visibility from the template parameters and arguments
369  // only if this is not an explicit instantiation or specialization
370  // with direct explicit visibility (and note that implicit
371  // instantiations won't have a direct attribute).
372  //
373  // Furthermore, we want to ignore template parameters and arguments
374  // for an explicit specialization when computing the visibility of a
375  // member thereof with explicit visibility.
376  //
377  // This is a bit complex; let's unpack it.
378  //
379  // An explicit class specialization is an independent, top-level
380  // declaration. As such, if it or any of its members has an
381  // explicit visibility attribute, that must directly express the
382  // user's intent, and we should honor it. The same logic applies to
383  // an explicit instantiation of a member of such a thing.
384 
385  // Fast path: if this is not an explicit instantiation or
386  // specialization, we always want to consider template-related
387  // visibility restrictions.
389  return true;
390 
391  // This is the 'member thereof' check.
392  if (spec->isExplicitSpecialization() &&
393  hasExplicitVisibilityAlready(computation))
394  return false;
395 
396  return !hasDirectVisibilityAttribute(spec, computation);
397 }
398 
399 /// Merge in template-related linkage and visibility for the given
400 /// class template specialization.
401 void LinkageComputer::mergeTemplateLV(
403  LVComputationKind computation) {
404  bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
405 
406  // Merge information from the template parameters, but ignore
407  // visibility if we're only considering template arguments.
408 
410  LinkageInfo tempLV =
411  getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
412  LV.mergeMaybeWithVisibility(tempLV,
413  considerVisibility && !hasExplicitVisibilityAlready(computation));
414 
415  // Merge information from the template arguments. We ignore
416  // template-argument visibility if we've got an explicit
417  // instantiation with a visibility attribute.
418  const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
419  LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
420  if (considerVisibility)
421  LV.mergeVisibility(argsLV);
422  LV.mergeExternalVisibility(argsLV);
423 }
424 
425 /// Should we consider visibility associated with the template
426 /// arguments and parameters of the given variable template
427 /// specialization? As usual, follow class template specialization
428 /// logic up to initialization.
430  const VarTemplateSpecializationDecl *spec,
431  LVComputationKind computation) {
432  // Include visibility from the template parameters and arguments
433  // only if this is not an explicit instantiation or specialization
434  // with direct explicit visibility (and note that implicit
435  // instantiations won't have a direct attribute).
437  return true;
438 
439  // An explicit variable specialization is an independent, top-level
440  // declaration. As such, if it has an explicit visibility attribute,
441  // that must directly express the user's intent, and we should honor
442  // it.
443  if (spec->isExplicitSpecialization() &&
444  hasExplicitVisibilityAlready(computation))
445  return false;
446 
447  return !hasDirectVisibilityAttribute(spec, computation);
448 }
449 
450 /// Merge in template-related linkage and visibility for the given
451 /// variable template specialization. As usual, follow class template
452 /// specialization logic up to initialization.
453 void LinkageComputer::mergeTemplateLV(LinkageInfo &LV,
454  const VarTemplateSpecializationDecl *spec,
455  LVComputationKind computation) {
456  bool considerVisibility = shouldConsiderTemplateVisibility(spec, computation);
457 
458  // Merge information from the template parameters, but ignore
459  // visibility if we're only considering template arguments.
460 
461  VarTemplateDecl *temp = spec->getSpecializedTemplate();
462  LinkageInfo tempLV =
463  getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
464  LV.mergeMaybeWithVisibility(tempLV,
465  considerVisibility && !hasExplicitVisibilityAlready(computation));
466 
467  // Merge information from the template arguments. We ignore
468  // template-argument visibility if we've got an explicit
469  // instantiation with a visibility attribute.
470  const TemplateArgumentList &templateArgs = spec->getTemplateArgs();
471  LinkageInfo argsLV = getLVForTemplateArgumentList(templateArgs, computation);
472  if (considerVisibility)
473  LV.mergeVisibility(argsLV);
474  LV.mergeExternalVisibility(argsLV);
475 }
476 
477 static bool useInlineVisibilityHidden(const NamedDecl *D) {
478  // FIXME: we should warn if -fvisibility-inlines-hidden is used with c.
479  const LangOptions &Opts = D->getASTContext().getLangOpts();
480  if (!Opts.CPlusPlus || !Opts.InlineVisibilityHidden)
481  return false;
482 
483  const auto *FD = dyn_cast<FunctionDecl>(D);
484  if (!FD)
485  return false;
486 
489  = FD->getTemplateSpecializationInfo()) {
490  TSK = spec->getTemplateSpecializationKind();
491  } else if (MemberSpecializationInfo *MSI =
492  FD->getMemberSpecializationInfo()) {
493  TSK = MSI->getTemplateSpecializationKind();
494  }
495 
496  const FunctionDecl *Def = nullptr;
497  // InlineVisibilityHidden only applies to definitions, and
498  // isInlined() only gives meaningful answers on definitions
499  // anyway.
500  return TSK != TSK_ExplicitInstantiationDeclaration &&
502  FD->hasBody(Def) && Def->isInlined() && !Def->hasAttr<GNUInlineAttr>();
503 }
504 
505 template <typename T> static bool isFirstInExternCContext(T *D) {
506  const T *First = D->getFirstDecl();
507  return First->isInExternCContext();
508 }
509 
510 static bool isSingleLineLanguageLinkage(const Decl &D) {
511  if (const auto *SD = dyn_cast<LinkageSpecDecl>(D.getDeclContext()))
512  if (!SD->hasBraces())
513  return true;
514  return false;
515 }
516 
518  switch (D->getModuleOwnershipKind()) {
521  return false;
524  if (auto *M = D->getOwningModule())
525  return M->Kind == Module::ModuleInterfaceUnit;
526  }
527  llvm_unreachable("unexpected module ownership kind");
528 }
529 
531  // Internal linkage declarations within a module interface unit are modeled
532  // as "module-internal linkage", which means that they have internal linkage
533  // formally but can be indirectly accessed from outside the module via inline
534  // functions and templates defined within the module.
535  if (auto *M = D->getOwningModule())
536  if (M->Kind == Module::ModuleInterfaceUnit)
538 
539  return LinkageInfo::internal();
540 }
541 
543  // C++ Modules TS [basic.link]/6.8:
544  // - A name declared at namespace scope that does not have internal linkage
545  // by the previous rules and that is introduced by a non-exported
546  // declaration has module linkage.
547  if (auto *M = D->getOwningModule())
548  if (M->Kind == Module::ModuleInterfaceUnit)
551 
552  return LinkageInfo::external();
553 }
554 
556 LinkageComputer::getLVForNamespaceScopeDecl(const NamedDecl *D,
557  LVComputationKind computation,
558  bool IgnoreVarTypeLinkage) {
559  assert(D->getDeclContext()->getRedeclContext()->isFileContext() &&
560  "Not a name having namespace scope");
561  ASTContext &Context = D->getASTContext();
562 
563  // C++ [basic.link]p3:
564  // A name having namespace scope (3.3.6) has internal linkage if it
565  // is the name of
566  // - an object, reference, function or function template that is
567  // explicitly declared static; or,
568  // (This bullet corresponds to C99 6.2.2p3.)
569  if (const auto *Var = dyn_cast<VarDecl>(D)) {
570  // Explicitly declared static.
571  if (Var->getStorageClass() == SC_Static)
572  return getInternalLinkageFor(Var);
573 
574  // - a non-inline, non-volatile object or reference that is explicitly
575  // declared const or constexpr and neither explicitly declared extern
576  // nor previously declared to have external linkage; or (there is no
577  // equivalent in C99)
578  // The C++ modules TS adds "non-exported" to this list.
579  if (Context.getLangOpts().CPlusPlus &&
580  Var->getType().isConstQualified() &&
581  !Var->getType().isVolatileQualified() &&
582  !Var->isInline() &&
584  const VarDecl *PrevVar = Var->getPreviousDecl();
585  if (PrevVar)
586  return getLVForDecl(PrevVar, computation);
587 
588  if (Var->getStorageClass() != SC_Extern &&
589  Var->getStorageClass() != SC_PrivateExtern &&
591  return getInternalLinkageFor(Var);
592  }
593 
594  for (const VarDecl *PrevVar = Var->getPreviousDecl(); PrevVar;
595  PrevVar = PrevVar->getPreviousDecl()) {
596  if (PrevVar->getStorageClass() == SC_PrivateExtern &&
597  Var->getStorageClass() == SC_None)
598  return getDeclLinkageAndVisibility(PrevVar);
599  // Explicitly declared static.
600  if (PrevVar->getStorageClass() == SC_Static)
601  return getInternalLinkageFor(Var);
602  }
603  } else if (const FunctionDecl *Function = D->getAsFunction()) {
604  // C++ [temp]p4:
605  // A non-member function template can have internal linkage; any
606  // other template name shall have external linkage.
607 
608  // Explicitly declared static.
609  if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
610  return getInternalLinkageFor(Function);
611  } else if (const auto *IFD = dyn_cast<IndirectFieldDecl>(D)) {
612  // - a data member of an anonymous union.
613  const VarDecl *VD = IFD->getVarDecl();
614  assert(VD && "Expected a VarDecl in this IndirectFieldDecl!");
615  return getLVForNamespaceScopeDecl(VD, computation, IgnoreVarTypeLinkage);
616  }
617  assert(!isa<FieldDecl>(D) && "Didn't expect a FieldDecl!");
618 
619  if (D->isInAnonymousNamespace()) {
620  const auto *Var = dyn_cast<VarDecl>(D);
621  const auto *Func = dyn_cast<FunctionDecl>(D);
622  // FIXME: The check for extern "C" here is not justified by the standard
623  // wording, but we retain it from the pre-DR1113 model to avoid breaking
624  // code.
625  //
626  // C++11 [basic.link]p4:
627  // An unnamed namespace or a namespace declared directly or indirectly
628  // within an unnamed namespace has internal linkage.
629  if ((!Var || !isFirstInExternCContext(Var)) &&
630  (!Func || !isFirstInExternCContext(Func)))
631  return getInternalLinkageFor(D);
632  }
633 
634  // Set up the defaults.
635 
636  // C99 6.2.2p5:
637  // If the declaration of an identifier for an object has file
638  // scope and no storage-class specifier, its linkage is
639  // external.
641 
642  if (!hasExplicitVisibilityAlready(computation)) {
643  if (Optional<Visibility> Vis = getExplicitVisibility(D, computation)) {
644  LV.mergeVisibility(*Vis, true);
645  } else {
646  // If we're declared in a namespace with a visibility attribute,
647  // use that namespace's visibility, and it still counts as explicit.
648  for (const DeclContext *DC = D->getDeclContext();
649  !isa<TranslationUnitDecl>(DC);
650  DC = DC->getParent()) {
651  const auto *ND = dyn_cast<NamespaceDecl>(DC);
652  if (!ND) continue;
653  if (Optional<Visibility> Vis = getExplicitVisibility(ND, computation)) {
654  LV.mergeVisibility(*Vis, true);
655  break;
656  }
657  }
658  }
659 
660  // Add in global settings if the above didn't give us direct visibility.
661  if (!LV.isVisibilityExplicit()) {
662  // Use global type/value visibility as appropriate.
663  Visibility globalVisibility =
664  computation.isValueVisibility()
665  ? Context.getLangOpts().getValueVisibilityMode()
666  : Context.getLangOpts().getTypeVisibilityMode();
667  LV.mergeVisibility(globalVisibility, /*explicit*/ false);
668 
669  // If we're paying attention to global visibility, apply
670  // -finline-visibility-hidden if this is an inline method.
673  }
674  }
675 
676  // C++ [basic.link]p4:
677 
678  // A name having namespace scope has external linkage if it is the
679  // name of
680  //
681  // - an object or reference, unless it has internal linkage; or
682  if (const auto *Var = dyn_cast<VarDecl>(D)) {
683  // GCC applies the following optimization to variables and static
684  // data members, but not to functions:
685  //
686  // Modify the variable's LV by the LV of its type unless this is
687  // C or extern "C". This follows from [basic.link]p9:
688  // A type without linkage shall not be used as the type of a
689  // variable or function with external linkage unless
690  // - the entity has C language linkage, or
691  // - the entity is declared within an unnamed namespace, or
692  // - the entity is not used or is defined in the same
693  // translation unit.
694  // and [basic.link]p10:
695  // ...the types specified by all declarations referring to a
696  // given variable or function shall be identical...
697  // C does not have an equivalent rule.
698  //
699  // Ignore this if we've got an explicit attribute; the user
700  // probably knows what they're doing.
701  //
702  // Note that we don't want to make the variable non-external
703  // because of this, but unique-external linkage suits us.
704  if (Context.getLangOpts().CPlusPlus && !isFirstInExternCContext(Var) &&
705  !IgnoreVarTypeLinkage) {
706  LinkageInfo TypeLV = getLVForType(*Var->getType(), computation);
707  if (!isExternallyVisible(TypeLV.getLinkage()))
709  if (!LV.isVisibilityExplicit())
710  LV.mergeVisibility(TypeLV);
711  }
712 
713  if (Var->getStorageClass() == SC_PrivateExtern)
715 
716  // Note that Sema::MergeVarDecl already takes care of implementing
717  // C99 6.2.2p4 and propagating the visibility attribute, so we don't have
718  // to do it here.
719 
720  // As per function and class template specializations (below),
721  // consider LV for the template and template arguments. We're at file
722  // scope, so we do not need to worry about nested specializations.
723  if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(Var)) {
724  mergeTemplateLV(LV, spec, computation);
725  }
726 
727  // - a function, unless it has internal linkage; or
728  } else if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
729  // In theory, we can modify the function's LV by the LV of its
730  // type unless it has C linkage (see comment above about variables
731  // for justification). In practice, GCC doesn't do this, so it's
732  // just too painful to make work.
733 
734  if (Function->getStorageClass() == SC_PrivateExtern)
736 
737  // Note that Sema::MergeCompatibleFunctionDecls already takes care of
738  // merging storage classes and visibility attributes, so we don't have to
739  // look at previous decls in here.
740 
741  // In C++, then if the type of the function uses a type with
742  // unique-external linkage, it's not legally usable from outside
743  // this translation unit. However, we should use the C linkage
744  // rules instead for extern "C" declarations.
745  if (Context.getLangOpts().CPlusPlus && !Function->isInExternCContext()) {
746  // Only look at the type-as-written. Otherwise, deducing the return type
747  // of a function could change its linkage.
748  QualType TypeAsWritten = Function->getType();
749  if (TypeSourceInfo *TSI = Function->getTypeSourceInfo())
750  TypeAsWritten = TSI->getType();
751  if (!isExternallyVisible(TypeAsWritten->getLinkage()))
753  }
754 
755  // Consider LV from the template and the template arguments.
756  // We're at file scope, so we do not need to worry about nested
757  // specializations.
759  = Function->getTemplateSpecializationInfo()) {
760  mergeTemplateLV(LV, Function, specInfo, computation);
761  }
762 
763  // - a named class (Clause 9), or an unnamed class defined in a
764  // typedef declaration in which the class has the typedef name
765  // for linkage purposes (7.1.3); or
766  // - a named enumeration (7.2), or an unnamed enumeration
767  // defined in a typedef declaration in which the enumeration
768  // has the typedef name for linkage purposes (7.1.3); or
769  } else if (const auto *Tag = dyn_cast<TagDecl>(D)) {
770  // Unnamed tags have no linkage.
771  if (!Tag->hasNameForLinkage())
772  return LinkageInfo::none();
773 
774  // If this is a class template specialization, consider the
775  // linkage of the template and template arguments. We're at file
776  // scope, so we do not need to worry about nested specializations.
777  if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) {
778  mergeTemplateLV(LV, spec, computation);
779  }
780 
781  // - an enumerator belonging to an enumeration with external linkage;
782  } else if (isa<EnumConstantDecl>(D)) {
783  LinkageInfo EnumLV = getLVForDecl(cast<NamedDecl>(D->getDeclContext()),
784  computation);
785  if (!isExternalFormalLinkage(EnumLV.getLinkage()))
786  return LinkageInfo::none();
787  LV.merge(EnumLV);
788 
789  // - a template, unless it is a function template that has
790  // internal linkage (Clause 14);
791  } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
792  bool considerVisibility = !hasExplicitVisibilityAlready(computation);
793  LinkageInfo tempLV =
794  getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
795  LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
796 
797  // - a namespace (7.3), unless it is declared within an unnamed
798  // namespace.
799  //
800  // We handled names in anonymous namespaces above.
801  } else if (isa<NamespaceDecl>(D)) {
802  return LV;
803 
804  // By extension, we assign external linkage to Objective-C
805  // interfaces.
806  } else if (isa<ObjCInterfaceDecl>(D)) {
807  // fallout
808 
809  } else if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
810  // A typedef declaration has linkage if it gives a type a name for
811  // linkage purposes.
812  if (!TD->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
813  return LinkageInfo::none();
814 
815  // Everything not covered here has no linkage.
816  } else {
817  return LinkageInfo::none();
818  }
819 
820  // If we ended up with non-external linkage, visibility should
821  // always be default.
822  if (LV.getLinkage() != ExternalLinkage)
823  return LinkageInfo(LV.getLinkage(), DefaultVisibility, false);
824 
825  return LV;
826 }
827 
829 LinkageComputer::getLVForClassMember(const NamedDecl *D,
830  LVComputationKind computation,
831  bool IgnoreVarTypeLinkage) {
832  // Only certain class members have linkage. Note that fields don't
833  // really have linkage, but it's convenient to say they do for the
834  // purposes of calculating linkage of pointer-to-data-member
835  // template arguments.
836  //
837  // Templates also don't officially have linkage, but since we ignore
838  // the C++ standard and look at template arguments when determining
839  // linkage and visibility of a template specialization, we might hit
840  // a template template argument that way. If we do, we need to
841  // consider its linkage.
842  if (!(isa<CXXMethodDecl>(D) ||
843  isa<VarDecl>(D) ||
844  isa<FieldDecl>(D) ||
845  isa<IndirectFieldDecl>(D) ||
846  isa<TagDecl>(D) ||
847  isa<TemplateDecl>(D)))
848  return LinkageInfo::none();
849 
850  LinkageInfo LV;
851 
852  // If we have an explicit visibility attribute, merge that in.
853  if (!hasExplicitVisibilityAlready(computation)) {
854  if (Optional<Visibility> Vis = getExplicitVisibility(D, computation))
855  LV.mergeVisibility(*Vis, true);
856  // If we're paying attention to global visibility, apply
857  // -finline-visibility-hidden if this is an inline method.
858  //
859  // Note that we do this before merging information about
860  // the class visibility.
863  }
864 
865  // If this class member has an explicit visibility attribute, the only
866  // thing that can change its visibility is the template arguments, so
867  // only look for them when processing the class.
868  LVComputationKind classComputation = computation;
869  if (LV.isVisibilityExplicit())
870  classComputation = withExplicitVisibilityAlready(computation);
871 
872  LinkageInfo classLV =
873  getLVForDecl(cast<RecordDecl>(D->getDeclContext()), classComputation);
874  // The member has the same linkage as the class. If that's not externally
875  // visible, we don't need to compute anything about the linkage.
876  // FIXME: If we're only computing linkage, can we bail out here?
877  if (!isExternallyVisible(classLV.getLinkage()))
878  return classLV;
879 
880 
881  // Otherwise, don't merge in classLV yet, because in certain cases
882  // we need to completely ignore the visibility from it.
883 
884  // Specifically, if this decl exists and has an explicit attribute.
885  const NamedDecl *explicitSpecSuppressor = nullptr;
886 
887  if (const auto *MD = dyn_cast<CXXMethodDecl>(D)) {
888  // Only look at the type-as-written. Otherwise, deducing the return type
889  // of a function could change its linkage.
890  QualType TypeAsWritten = MD->getType();
891  if (TypeSourceInfo *TSI = MD->getTypeSourceInfo())
892  TypeAsWritten = TSI->getType();
893  if (!isExternallyVisible(TypeAsWritten->getLinkage()))
895 
896  // If this is a method template specialization, use the linkage for
897  // the template parameters and arguments.
899  = MD->getTemplateSpecializationInfo()) {
900  mergeTemplateLV(LV, MD, spec, computation);
901  if (spec->isExplicitSpecialization()) {
902  explicitSpecSuppressor = MD;
903  } else if (isExplicitMemberSpecialization(spec->getTemplate())) {
904  explicitSpecSuppressor = spec->getTemplate()->getTemplatedDecl();
905  }
906  } else if (isExplicitMemberSpecialization(MD)) {
907  explicitSpecSuppressor = MD;
908  }
909 
910  } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
911  if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(RD)) {
912  mergeTemplateLV(LV, spec, computation);
913  if (spec->isExplicitSpecialization()) {
914  explicitSpecSuppressor = spec;
915  } else {
916  const ClassTemplateDecl *temp = spec->getSpecializedTemplate();
917  if (isExplicitMemberSpecialization(temp)) {
918  explicitSpecSuppressor = temp->getTemplatedDecl();
919  }
920  }
921  } else if (isExplicitMemberSpecialization(RD)) {
922  explicitSpecSuppressor = RD;
923  }
924 
925  // Static data members.
926  } else if (const auto *VD = dyn_cast<VarDecl>(D)) {
927  if (const auto *spec = dyn_cast<VarTemplateSpecializationDecl>(VD))
928  mergeTemplateLV(LV, spec, computation);
929 
930  // Modify the variable's linkage by its type, but ignore the
931  // type's visibility unless it's a definition.
932  if (!IgnoreVarTypeLinkage) {
933  LinkageInfo typeLV = getLVForType(*VD->getType(), computation);
934  // FIXME: If the type's linkage is not externally visible, we can
935  // give this static data member UniqueExternalLinkage.
936  if (!LV.isVisibilityExplicit() && !classLV.isVisibilityExplicit())
937  LV.mergeVisibility(typeLV);
938  LV.mergeExternalVisibility(typeLV);
939  }
940 
942  explicitSpecSuppressor = VD;
943  }
944 
945  // Template members.
946  } else if (const auto *temp = dyn_cast<TemplateDecl>(D)) {
947  bool considerVisibility =
948  (!LV.isVisibilityExplicit() &&
949  !classLV.isVisibilityExplicit() &&
950  !hasExplicitVisibilityAlready(computation));
951  LinkageInfo tempLV =
952  getLVForTemplateParameterList(temp->getTemplateParameters(), computation);
953  LV.mergeMaybeWithVisibility(tempLV, considerVisibility);
954 
955  if (const auto *redeclTemp = dyn_cast<RedeclarableTemplateDecl>(temp)) {
956  if (isExplicitMemberSpecialization(redeclTemp)) {
957  explicitSpecSuppressor = temp->getTemplatedDecl();
958  }
959  }
960  }
961 
962  // We should never be looking for an attribute directly on a template.
963  assert(!explicitSpecSuppressor || !isa<TemplateDecl>(explicitSpecSuppressor));
964 
965  // If this member is an explicit member specialization, and it has
966  // an explicit attribute, ignore visibility from the parent.
967  bool considerClassVisibility = true;
968  if (explicitSpecSuppressor &&
969  // optimization: hasDVA() is true only with explicit visibility.
970  LV.isVisibilityExplicit() &&
971  classLV.getVisibility() != DefaultVisibility &&
972  hasDirectVisibilityAttribute(explicitSpecSuppressor, computation)) {
973  considerClassVisibility = false;
974  }
975 
976  // Finally, merge in information from the class.
977  LV.mergeMaybeWithVisibility(classLV, considerClassVisibility);
978  return LV;
979 }
980 
981 void NamedDecl::anchor() { }
982 
984  if (!hasCachedLinkage())
985  return true;
986 
989  .getLinkage();
990  return L == getCachedLinkage();
991 }
992 
994  StringRef name = getName();
995  if (name.empty()) return SFF_None;
996 
997  if (name.front() == 'C')
998  if (name == "CFStringCreateWithFormat" ||
999  name == "CFStringCreateWithFormatAndArguments" ||
1000  name == "CFStringAppendFormat" ||
1001  name == "CFStringAppendFormatAndArguments")
1002  return SFF_CFString;
1003  return SFF_None;
1004 }
1005 
1007  // We don't care about visibility here, so ask for the cheapest
1008  // possible visibility analysis.
1009  return LinkageComputer{}
1011  .getLinkage();
1012 }
1013 
1016 }
1017 
1018 static Optional<Visibility>
1021  bool IsMostRecent) {
1022  assert(!IsMostRecent || ND == ND->getMostRecentDecl());
1023 
1024  // Check the declaration itself first.
1025  if (Optional<Visibility> V = getVisibilityOf(ND, kind))
1026  return V;
1027 
1028  // If this is a member class of a specialization of a class template
1029  // and the corresponding decl has explicit visibility, use that.
1030  if (const auto *RD = dyn_cast<CXXRecordDecl>(ND)) {
1031  CXXRecordDecl *InstantiatedFrom = RD->getInstantiatedFromMemberClass();
1032  if (InstantiatedFrom)
1033  return getVisibilityOf(InstantiatedFrom, kind);
1034  }
1035 
1036  // If there wasn't explicit visibility there, and this is a
1037  // specialization of a class template, check for visibility
1038  // on the pattern.
1039  if (const auto *spec = dyn_cast<ClassTemplateSpecializationDecl>(ND))
1041  kind);
1042 
1043  // Use the most recent declaration.
1044  if (!IsMostRecent && !isa<NamespaceDecl>(ND)) {
1045  const NamedDecl *MostRecent = ND->getMostRecentDecl();
1046  if (MostRecent != ND)
1047  return getExplicitVisibilityAux(MostRecent, kind, true);
1048  }
1049 
1050  if (const auto *Var = dyn_cast<VarDecl>(ND)) {
1051  if (Var->isStaticDataMember()) {
1052  VarDecl *InstantiatedFrom = Var->getInstantiatedFromStaticDataMember();
1053  if (InstantiatedFrom)
1054  return getVisibilityOf(InstantiatedFrom, kind);
1055  }
1056 
1057  if (const auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(Var))
1058  return getVisibilityOf(VTSD->getSpecializedTemplate()->getTemplatedDecl(),
1059  kind);
1060 
1061  return None;
1062  }
1063  // Also handle function template specializations.
1064  if (const auto *fn = dyn_cast<FunctionDecl>(ND)) {
1065  // If the function is a specialization of a template with an
1066  // explicit visibility attribute, use that.
1067  if (FunctionTemplateSpecializationInfo *templateInfo
1069  return getVisibilityOf(templateInfo->getTemplate()->getTemplatedDecl(),
1070  kind);
1071 
1072  // If the function is a member of a specialization of a class template
1073  // and the corresponding decl has explicit visibility, use that.
1074  FunctionDecl *InstantiatedFrom = fn->getInstantiatedFromMemberFunction();
1075  if (InstantiatedFrom)
1076  return getVisibilityOf(InstantiatedFrom, kind);
1077 
1078  return None;
1079  }
1080 
1081  // The visibility of a template is stored in the templated decl.
1082  if (const auto *TD = dyn_cast<TemplateDecl>(ND))
1083  return getVisibilityOf(TD->getTemplatedDecl(), kind);
1084 
1085  return None;
1086 }
1087 
1088 Optional<Visibility>
1090  return getExplicitVisibilityAux(this, kind, false);
1091 }
1092 
1093 LinkageInfo LinkageComputer::getLVForClosure(const DeclContext *DC,
1094  Decl *ContextDecl,
1095  LVComputationKind computation) {
1096  // This lambda has its linkage/visibility determined by its owner.
1097  const NamedDecl *Owner;
1098  if (!ContextDecl)
1099  Owner = dyn_cast<NamedDecl>(DC);
1100  else if (isa<ParmVarDecl>(ContextDecl))
1101  Owner =
1102  dyn_cast<NamedDecl>(ContextDecl->getDeclContext()->getRedeclContext());
1103  else
1104  Owner = cast<NamedDecl>(ContextDecl);
1105 
1106  if (!Owner)
1107  return LinkageInfo::none();
1108 
1109  // If the owner has a deduced type, we need to skip querying the linkage and
1110  // visibility of that type, because it might involve this closure type. The
1111  // only effect of this is that we might give a lambda VisibleNoLinkage rather
1112  // than NoLinkage when we don't strictly need to, which is benign.
1113  auto *VD = dyn_cast<VarDecl>(Owner);
1114  LinkageInfo OwnerLV =
1115  VD && VD->getType()->getContainedDeducedType()
1116  ? computeLVForDecl(Owner, computation, /*IgnoreVarTypeLinkage*/true)
1117  : getLVForDecl(Owner, computation);
1118 
1119  // A lambda never formally has linkage. But if the owner is externally
1120  // visible, then the lambda is too. We apply the same rules to blocks.
1121  if (!isExternallyVisible(OwnerLV.getLinkage()))
1122  return LinkageInfo::none();
1123  return LinkageInfo(VisibleNoLinkage, OwnerLV.getVisibility(),
1124  OwnerLV.isVisibilityExplicit());
1125 }
1126 
1127 LinkageInfo LinkageComputer::getLVForLocalDecl(const NamedDecl *D,
1128  LVComputationKind computation) {
1129  if (const auto *Function = dyn_cast<FunctionDecl>(D)) {
1130  if (Function->isInAnonymousNamespace() &&
1131  !Function->isInExternCContext())
1132  return getInternalLinkageFor(Function);
1133 
1134  // This is a "void f();" which got merged with a file static.
1135  if (Function->getCanonicalDecl()->getStorageClass() == SC_Static)
1136  return getInternalLinkageFor(Function);
1137 
1138  LinkageInfo LV;
1139  if (!hasExplicitVisibilityAlready(computation)) {
1140  if (Optional<Visibility> Vis =
1141  getExplicitVisibility(Function, computation))
1142  LV.mergeVisibility(*Vis, true);
1143  }
1144 
1145  // Note that Sema::MergeCompatibleFunctionDecls already takes care of
1146  // merging storage classes and visibility attributes, so we don't have to
1147  // look at previous decls in here.
1148 
1149  return LV;
1150  }
1151 
1152  if (const auto *Var = dyn_cast<VarDecl>(D)) {
1153  if (Var->hasExternalStorage()) {
1154  if (Var->isInAnonymousNamespace() && !Var->isInExternCContext())
1155  return getInternalLinkageFor(Var);
1156 
1157  LinkageInfo LV;
1158  if (Var->getStorageClass() == SC_PrivateExtern)
1160  else if (!hasExplicitVisibilityAlready(computation)) {
1161  if (Optional<Visibility> Vis = getExplicitVisibility(Var, computation))
1162  LV.mergeVisibility(*Vis, true);
1163  }
1164 
1165  if (const VarDecl *Prev = Var->getPreviousDecl()) {
1166  LinkageInfo PrevLV = getLVForDecl(Prev, computation);
1167  if (PrevLV.getLinkage())
1168  LV.setLinkage(PrevLV.getLinkage());
1169  LV.mergeVisibility(PrevLV);
1170  }
1171 
1172  return LV;
1173  }
1174 
1175  if (!Var->isStaticLocal())
1176  return LinkageInfo::none();
1177  }
1178 
1179  ASTContext &Context = D->getASTContext();
1180  if (!Context.getLangOpts().CPlusPlus)
1181  return LinkageInfo::none();
1182 
1183  const Decl *OuterD = getOutermostFuncOrBlockContext(D);
1184  if (!OuterD || OuterD->isInvalidDecl())
1185  return LinkageInfo::none();
1186 
1187  LinkageInfo LV;
1188  if (const auto *BD = dyn_cast<BlockDecl>(OuterD)) {
1189  if (!BD->getBlockManglingNumber())
1190  return LinkageInfo::none();
1191 
1192  LV = getLVForClosure(BD->getDeclContext()->getRedeclContext(),
1193  BD->getBlockManglingContextDecl(), computation);
1194  } else {
1195  const auto *FD = cast<FunctionDecl>(OuterD);
1196  if (!FD->isInlined() &&
1197  !isTemplateInstantiation(FD->getTemplateSpecializationKind()))
1198  return LinkageInfo::none();
1199 
1200  LV = getLVForDecl(FD, computation);
1201  }
1202  if (!isExternallyVisible(LV.getLinkage()))
1203  return LinkageInfo::none();
1205  LV.isVisibilityExplicit());
1206 }
1207 
1208 static inline const CXXRecordDecl*
1210  const CXXRecordDecl *Ret = Record;
1211  while (Record && Record->isLambda()) {
1212  Ret = Record;
1213  if (!Record->getParent()) break;
1214  // Get the Containing Class of this Lambda Class
1215  Record = dyn_cast_or_null<CXXRecordDecl>(
1216  Record->getParent()->getParent());
1217  }
1218  return Ret;
1219 }
1220 
1222  LVComputationKind computation,
1223  bool IgnoreVarTypeLinkage) {
1224  // Internal_linkage attribute overrides other considerations.
1225  if (D->hasAttr<InternalLinkageAttr>())
1226  return getInternalLinkageFor(D);
1227 
1228  // Objective-C: treat all Objective-C declarations as having external
1229  // linkage.
1230  switch (D->getKind()) {
1231  default:
1232  break;
1233 
1234  // Per C++ [basic.link]p2, only the names of objects, references,
1235  // functions, types, templates, namespaces, and values ever have linkage.
1236  //
1237  // Note that the name of a typedef, namespace alias, using declaration,
1238  // and so on are not the name of the corresponding type, namespace, or
1239  // declaration, so they do *not* have linkage.
1240  case Decl::ImplicitParam:
1241  case Decl::Label:
1242  case Decl::NamespaceAlias:
1243  case Decl::ParmVar:
1244  case Decl::Using:
1245  case Decl::UsingShadow:
1246  case Decl::UsingDirective:
1247  return LinkageInfo::none();
1248 
1249  case Decl::EnumConstant:
1250  // C++ [basic.link]p4: an enumerator has the linkage of its enumeration.
1251  if (D->getASTContext().getLangOpts().CPlusPlus)
1252  return getLVForDecl(cast<EnumDecl>(D->getDeclContext()), computation);
1253  return LinkageInfo::visible_none();
1254 
1255  case Decl::Typedef:
1256  case Decl::TypeAlias:
1257  // A typedef declaration has linkage if it gives a type a name for
1258  // linkage purposes.
1259  if (!cast<TypedefNameDecl>(D)
1260  ->getAnonDeclWithTypedefName(/*AnyRedecl*/true))
1261  return LinkageInfo::none();
1262  break;
1263 
1264  case Decl::TemplateTemplateParm: // count these as external
1265  case Decl::NonTypeTemplateParm:
1266  case Decl::ObjCAtDefsField:
1267  case Decl::ObjCCategory:
1268  case Decl::ObjCCategoryImpl:
1269  case Decl::ObjCCompatibleAlias:
1270  case Decl::ObjCImplementation:
1271  case Decl::ObjCMethod:
1272  case Decl::ObjCProperty:
1273  case Decl::ObjCPropertyImpl:
1274  case Decl::ObjCProtocol:
1275  return getExternalLinkageFor(D);
1276 
1277  case Decl::CXXRecord: {
1278  const auto *Record = cast<CXXRecordDecl>(D);
1279  if (Record->isLambda()) {
1280  if (!Record->getLambdaManglingNumber()) {
1281  // This lambda has no mangling number, so it's internal.
1282  return getInternalLinkageFor(D);
1283  }
1284 
1285  // This lambda has its linkage/visibility determined:
1286  // - either by the outermost lambda if that lambda has no mangling
1287  // number.
1288  // - or by the parent of the outer most lambda
1289  // This prevents infinite recursion in settings such as nested lambdas
1290  // used in NSDMI's, for e.g.
1291  // struct L {
1292  // int t{};
1293  // int t2 = ([](int a) { return [](int b) { return b; };})(t)(t);
1294  // };
1295  const CXXRecordDecl *OuterMostLambda =
1297  if (!OuterMostLambda->getLambdaManglingNumber())
1298  return getInternalLinkageFor(D);
1299 
1300  return getLVForClosure(
1301  OuterMostLambda->getDeclContext()->getRedeclContext(),
1302  OuterMostLambda->getLambdaContextDecl(), computation);
1303  }
1304 
1305  break;
1306  }
1307  }
1308 
1309  // Handle linkage for namespace-scope names.
1311  return getLVForNamespaceScopeDecl(D, computation, IgnoreVarTypeLinkage);
1312 
1313  // C++ [basic.link]p5:
1314  // In addition, a member function, static data member, a named
1315  // class or enumeration of class scope, or an unnamed class or
1316  // enumeration defined in a class-scope typedef declaration such
1317  // that the class or enumeration has the typedef name for linkage
1318  // purposes (7.1.3), has external linkage if the name of the class
1319  // has external linkage.
1320  if (D->getDeclContext()->isRecord())
1321  return getLVForClassMember(D, computation, IgnoreVarTypeLinkage);
1322 
1323  // C++ [basic.link]p6:
1324  // The name of a function declared in block scope and the name of
1325  // an object declared by a block scope extern declaration have
1326  // linkage. If there is a visible declaration of an entity with
1327  // linkage having the same name and type, ignoring entities
1328  // declared outside the innermost enclosing namespace scope, the
1329  // block scope declaration declares that same entity and receives
1330  // the linkage of the previous declaration. If there is more than
1331  // one such matching entity, the program is ill-formed. Otherwise,
1332  // if no matching entity is found, the block scope entity receives
1333  // external linkage.
1334  if (D->getDeclContext()->isFunctionOrMethod())
1335  return getLVForLocalDecl(D, computation);
1336 
1337  // C++ [basic.link]p6:
1338  // Names not covered by these rules have no linkage.
1339  return LinkageInfo::none();
1340 }
1341 
1342 /// getLVForDecl - Get the linkage and visibility for the given declaration.
1344  LVComputationKind computation) {
1345  // Internal_linkage attribute overrides other considerations.
1346  if (D->hasAttr<InternalLinkageAttr>())
1347  return getInternalLinkageFor(D);
1348 
1349  if (computation.IgnoreAllVisibility && D->hasCachedLinkage())
1350  return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
1351 
1352  if (llvm::Optional<LinkageInfo> LI = lookup(D, computation))
1353  return *LI;
1354 
1355  LinkageInfo LV = computeLVForDecl(D, computation);
1356  if (D->hasCachedLinkage())
1357  assert(D->getCachedLinkage() == LV.getLinkage());
1358 
1359  D->setCachedLinkage(LV.getLinkage());
1360  cache(D, computation, LV);
1361 
1362 #ifndef NDEBUG
1363  // In C (because of gnu inline) and in c++ with microsoft extensions an
1364  // static can follow an extern, so we can have two decls with different
1365  // linkages.
1366  const LangOptions &Opts = D->getASTContext().getLangOpts();
1367  if (!Opts.CPlusPlus || Opts.MicrosoftExt)
1368  return LV;
1369 
1370  // We have just computed the linkage for this decl. By induction we know
1371  // that all other computed linkages match, check that the one we just
1372  // computed also does.
1373  NamedDecl *Old = nullptr;
1374  for (auto I : D->redecls()) {
1375  auto *T = cast<NamedDecl>(I);
1376  if (T == D)
1377  continue;
1378  if (!T->isInvalidDecl() && T->hasCachedLinkage()) {
1379  Old = T;
1380  break;
1381  }
1382  }
1383  assert(!Old || Old->getCachedLinkage() == D->getCachedLinkage());
1384 #endif
1385 
1386  return LV;
1387 }
1388 
1390  return getLVForDecl(D,
1394 }
1395 
1397  Module *M = getOwningModule();
1398  if (!M)
1399  return nullptr;
1400 
1401  switch (M->Kind) {
1403  // Module map modules have no special linkage semantics.
1404  return nullptr;
1405 
1407  return M;
1408 
1410  // External linkage declarations in the global module have no owning module
1411  // for linkage purposes. But internal linkage declarations in the global
1412  // module fragment of a particular module are owned by that module for
1413  // linkage purposes.
1414  return hasExternalFormalLinkage() ? nullptr : M->Parent;
1415  }
1416 
1417  llvm_unreachable("unknown module kind");
1418 }
1419 
1420 void NamedDecl::printName(raw_ostream &os) const {
1421  os << Name;
1422 }
1423 
1425  std::string QualName;
1426  llvm::raw_string_ostream OS(QualName);
1427  printQualifiedName(OS, getASTContext().getPrintingPolicy());
1428  return OS.str();
1429 }
1430 
1431 void NamedDecl::printQualifiedName(raw_ostream &OS) const {
1432  printQualifiedName(OS, getASTContext().getPrintingPolicy());
1433 }
1434 
1435 void NamedDecl::printQualifiedName(raw_ostream &OS,
1436  const PrintingPolicy &P) const {
1437  const DeclContext *Ctx = getDeclContext();
1438 
1439  // For ObjC methods, look through categories and use the interface as context.
1440  if (auto *MD = dyn_cast<ObjCMethodDecl>(this))
1441  if (auto *ID = MD->getClassInterface())
1442  Ctx = ID;
1443 
1444  if (Ctx->isFunctionOrMethod()) {
1445  printName(OS);
1446  return;
1447  }
1448 
1449  typedef SmallVector<const DeclContext *, 8> ContextsTy;
1450  ContextsTy Contexts;
1451 
1452  // Collect contexts.
1453  while (Ctx && isa<NamedDecl>(Ctx)) {
1454  Contexts.push_back(Ctx);
1455  Ctx = Ctx->getParent();
1456  }
1457 
1458  for (const DeclContext *DC : reverse(Contexts)) {
1459  if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(DC)) {
1460  OS << Spec->getName();
1461  const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
1463  OS, TemplateArgs.asArray(), P);
1464  } else if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {
1465  if (P.SuppressUnwrittenScope &&
1466  (ND->isAnonymousNamespace() || ND->isInline()))
1467  continue;
1468  if (ND->isAnonymousNamespace()) {
1469  OS << (P.MSVCFormatting ? "`anonymous namespace\'"
1470  : "(anonymous namespace)");
1471  }
1472  else
1473  OS << *ND;
1474  } else if (const auto *RD = dyn_cast<RecordDecl>(DC)) {
1475  if (!RD->getIdentifier())
1476  OS << "(anonymous " << RD->getKindName() << ')';
1477  else
1478  OS << *RD;
1479  } else if (const auto *FD = dyn_cast<FunctionDecl>(DC)) {
1480  const FunctionProtoType *FT = nullptr;
1481  if (FD->hasWrittenPrototype())
1482  FT = dyn_cast<FunctionProtoType>(FD->getType()->castAs<FunctionType>());
1483 
1484  OS << *FD << '(';
1485  if (FT) {
1486  unsigned NumParams = FD->getNumParams();
1487  for (unsigned i = 0; i < NumParams; ++i) {
1488  if (i)
1489  OS << ", ";
1490  OS << FD->getParamDecl(i)->getType().stream(P);
1491  }
1492 
1493  if (FT->isVariadic()) {
1494  if (NumParams > 0)
1495  OS << ", ";
1496  OS << "...";
1497  }
1498  }
1499  OS << ')';
1500  } else if (const auto *ED = dyn_cast<EnumDecl>(DC)) {
1501  // C++ [dcl.enum]p10: Each enum-name and each unscoped
1502  // enumerator is declared in the scope that immediately contains
1503  // the enum-specifier. Each scoped enumerator is declared in the
1504  // scope of the enumeration.
1505  if (ED->isScoped() || ED->getIdentifier())
1506  OS << *ED;
1507  else
1508  continue;
1509  } else {
1510  OS << *cast<NamedDecl>(DC);
1511  }
1512  OS << "::";
1513  }
1514 
1515  if (getDeclName() || isa<DecompositionDecl>(this))
1516  OS << *this;
1517  else
1518  OS << "(anonymous)";
1519 }
1520 
1521 void NamedDecl::getNameForDiagnostic(raw_ostream &OS,
1522  const PrintingPolicy &Policy,
1523  bool Qualified) const {
1524  if (Qualified)
1525  printQualifiedName(OS, Policy);
1526  else
1527  printName(OS);
1528 }
1529 
1530 template<typename T> static bool isRedeclarableImpl(Redeclarable<T> *) {
1531  return true;
1532 }
1533 static bool isRedeclarableImpl(...) { return false; }
1534 static bool isRedeclarable(Decl::Kind K) {
1535  switch (K) {
1536 #define DECL(Type, Base) \
1537  case Decl::Type: \
1538  return isRedeclarableImpl((Type##Decl *)nullptr);
1539 #define ABSTRACT_DECL(DECL)
1540 #include "clang/AST/DeclNodes.inc"
1541  }
1542  llvm_unreachable("unknown decl kind");
1543 }
1544 
1545 bool NamedDecl::declarationReplaces(NamedDecl *OldD, bool IsKnownNewer) const {
1546  assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch");
1547 
1548  // Never replace one imported declaration with another; we need both results
1549  // when re-exporting.
1550  if (OldD->isFromASTFile() && isFromASTFile())
1551  return false;
1552 
1553  // A kind mismatch implies that the declaration is not replaced.
1554  if (OldD->getKind() != getKind())
1555  return false;
1556 
1557  // For method declarations, we never replace. (Why?)
1558  if (isa<ObjCMethodDecl>(this))
1559  return false;
1560 
1561  // For parameters, pick the newer one. This is either an error or (in
1562  // Objective-C) permitted as an extension.
1563  if (isa<ParmVarDecl>(this))
1564  return true;
1565 
1566  // Inline namespaces can give us two declarations with the same
1567  // name and kind in the same scope but different contexts; we should
1568  // keep both declarations in this case.
1569  if (!this->getDeclContext()->getRedeclContext()->Equals(
1570  OldD->getDeclContext()->getRedeclContext()))
1571  return false;
1572 
1573  // Using declarations can be replaced if they import the same name from the
1574  // same context.
1575  if (auto *UD = dyn_cast<UsingDecl>(this)) {
1576  ASTContext &Context = getASTContext();
1577  return Context.getCanonicalNestedNameSpecifier(UD->getQualifier()) ==
1579  cast<UsingDecl>(OldD)->getQualifier());
1580  }
1581  if (auto *UUVD = dyn_cast<UnresolvedUsingValueDecl>(this)) {
1582  ASTContext &Context = getASTContext();
1583  return Context.getCanonicalNestedNameSpecifier(UUVD->getQualifier()) ==
1585  cast<UnresolvedUsingValueDecl>(OldD)->getQualifier());
1586  }
1587 
1588  // UsingDirectiveDecl's are not really NamedDecl's, and all have same name.
1589  // They can be replaced if they nominate the same namespace.
1590  // FIXME: Is this true even if they have different module visibility?
1591  if (auto *UD = dyn_cast<UsingDirectiveDecl>(this))
1592  return UD->getNominatedNamespace()->getOriginalNamespace() ==
1593  cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace()
1594  ->getOriginalNamespace();
1595 
1596  if (isRedeclarable(getKind())) {
1597  if (getCanonicalDecl() != OldD->getCanonicalDecl())
1598  return false;
1599 
1600  if (IsKnownNewer)
1601  return true;
1602 
1603  // Check whether this is actually newer than OldD. We want to keep the
1604  // newer declaration. This loop will usually only iterate once, because
1605  // OldD is usually the previous declaration.
1606  for (auto D : redecls()) {
1607  if (D == OldD)
1608  break;
1609 
1610  // If we reach the canonical declaration, then OldD is not actually older
1611  // than this one.
1612  //
1613  // FIXME: In this case, we should not add this decl to the lookup table.
1614  if (D->isCanonicalDecl())
1615  return false;
1616  }
1617 
1618  // It's a newer declaration of the same kind of declaration in the same
1619  // scope: we want this decl instead of the existing one.
1620  return true;
1621  }
1622 
1623  // In all other cases, we need to keep both declarations in case they have
1624  // different visibility. Any attempt to use the name will result in an
1625  // ambiguity if more than one is visible.
1626  return false;
1627 }
1628 
1630  return getFormalLinkage() != NoLinkage;
1631 }
1632 
1633 NamedDecl *NamedDecl::getUnderlyingDeclImpl() {
1634  NamedDecl *ND = this;
1635  while (auto *UD = dyn_cast<UsingShadowDecl>(ND))
1636  ND = UD->getTargetDecl();
1637 
1638  if (auto *AD = dyn_cast<ObjCCompatibleAliasDecl>(ND))
1639  return AD->getClassInterface();
1640 
1641  if (auto *AD = dyn_cast<NamespaceAliasDecl>(ND))
1642  return AD->getNamespace();
1643 
1644  return ND;
1645 }
1646 
1648  if (!isCXXClassMember())
1649  return false;
1650 
1651  const NamedDecl *D = this;
1652  if (isa<UsingShadowDecl>(D))
1653  D = cast<UsingShadowDecl>(D)->getTargetDecl();
1654 
1655  if (isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D) || isa<MSPropertyDecl>(D))
1656  return true;
1657  if (const auto *MD = dyn_cast_or_null<CXXMethodDecl>(D->getAsFunction()))
1658  return MD->isInstance();
1659  return false;
1660 }
1661 
1662 //===----------------------------------------------------------------------===//
1663 // DeclaratorDecl Implementation
1664 //===----------------------------------------------------------------------===//
1665 
1666 template <typename DeclT>
1668  if (decl->getNumTemplateParameterLists() > 0)
1669  return decl->getTemplateParameterList(0)->getTemplateLoc();
1670  else
1671  return decl->getInnerLocStart();
1672 }
1673 
1675  TypeSourceInfo *TSI = getTypeSourceInfo();
1676  if (TSI) return TSI->getTypeLoc().getBeginLoc();
1677  return SourceLocation();
1678 }
1679 
1681  if (QualifierLoc) {
1682  // Make sure the extended decl info is allocated.
1683  if (!hasExtInfo()) {
1684  // Save (non-extended) type source info pointer.
1685  auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1686  // Allocate external info struct.
1687  DeclInfo = new (getASTContext()) ExtInfo;
1688  // Restore savedTInfo into (extended) decl info.
1689  getExtInfo()->TInfo = savedTInfo;
1690  }
1691  // Set qualifier info.
1692  getExtInfo()->QualifierLoc = QualifierLoc;
1693  } else {
1694  // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
1695  if (hasExtInfo()) {
1696  if (getExtInfo()->NumTemplParamLists == 0) {
1697  // Save type source info pointer.
1698  TypeSourceInfo *savedTInfo = getExtInfo()->TInfo;
1699  // Deallocate the extended decl info.
1700  getASTContext().Deallocate(getExtInfo());
1701  // Restore savedTInfo into (non-extended) decl info.
1702  DeclInfo = savedTInfo;
1703  }
1704  else
1705  getExtInfo()->QualifierLoc = QualifierLoc;
1706  }
1707  }
1708 }
1709 
1711  ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
1712  assert(!TPLists.empty());
1713  // Make sure the extended decl info is allocated.
1714  if (!hasExtInfo()) {
1715  // Save (non-extended) type source info pointer.
1716  auto *savedTInfo = DeclInfo.get<TypeSourceInfo*>();
1717  // Allocate external info struct.
1718  DeclInfo = new (getASTContext()) ExtInfo;
1719  // Restore savedTInfo into (extended) decl info.
1720  getExtInfo()->TInfo = savedTInfo;
1721  }
1722  // Set the template parameter lists info.
1723  getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
1724 }
1725 
1727  return getTemplateOrInnerLocStart(this);
1728 }
1729 
1730 namespace {
1731 
1732 // Helper function: returns true if QT is or contains a type
1733 // having a postfix component.
1734 bool typeIsPostfix(clang::QualType QT) {
1735  while (true) {
1736  const Type* T = QT.getTypePtr();
1737  switch (T->getTypeClass()) {
1738  default:
1739  return false;
1740  case Type::Pointer:
1741  QT = cast<PointerType>(T)->getPointeeType();
1742  break;
1743  case Type::BlockPointer:
1744  QT = cast<BlockPointerType>(T)->getPointeeType();
1745  break;
1746  case Type::MemberPointer:
1747  QT = cast<MemberPointerType>(T)->getPointeeType();
1748  break;
1749  case Type::LValueReference:
1750  case Type::RValueReference:
1751  QT = cast<ReferenceType>(T)->getPointeeType();
1752  break;
1753  case Type::PackExpansion:
1754  QT = cast<PackExpansionType>(T)->getPattern();
1755  break;
1756  case Type::Paren:
1757  case Type::ConstantArray:
1758  case Type::DependentSizedArray:
1759  case Type::IncompleteArray:
1760  case Type::VariableArray:
1761  case Type::FunctionProto:
1762  case Type::FunctionNoProto:
1763  return true;
1764  }
1765  }
1766 }
1767 
1768 } // namespace
1769 
1771  SourceLocation RangeEnd = getLocation();
1772  if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
1773  // If the declaration has no name or the type extends past the name take the
1774  // end location of the type.
1775  if (!getDeclName() || typeIsPostfix(TInfo->getType()))
1776  RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
1777  }
1778  return SourceRange(getOuterLocStart(), RangeEnd);
1779 }
1780 
1782  ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
1783  // Free previous template parameters (if any).
1784  if (NumTemplParamLists > 0) {
1785  Context.Deallocate(TemplParamLists);
1786  TemplParamLists = nullptr;
1787  NumTemplParamLists = 0;
1788  }
1789  // Set info on matched template parameter lists (if any).
1790  if (!TPLists.empty()) {
1791  TemplParamLists = new (Context) TemplateParameterList *[TPLists.size()];
1792  NumTemplParamLists = TPLists.size();
1793  std::copy(TPLists.begin(), TPLists.end(), TemplParamLists);
1794  }
1795 }
1796 
1797 //===----------------------------------------------------------------------===//
1798 // VarDecl Implementation
1799 //===----------------------------------------------------------------------===//
1800 
1802  switch (SC) {
1803  case SC_None: break;
1804  case SC_Auto: return "auto";
1805  case SC_Extern: return "extern";
1806  case SC_PrivateExtern: return "__private_extern__";
1807  case SC_Register: return "register";
1808  case SC_Static: return "static";
1809  }
1810 
1811  llvm_unreachable("Invalid storage class");
1812 }
1813 
1815  SourceLocation StartLoc, SourceLocation IdLoc,
1817  StorageClass SC)
1818  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
1819  redeclarable_base(C), Init() {
1820  static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
1821  "VarDeclBitfields too large!");
1822  static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
1823  "ParmVarDeclBitfields too large!");
1824  static_assert(sizeof(NonParmVarDeclBitfields) <= sizeof(unsigned),
1825  "NonParmVarDeclBitfields too large!");
1826  AllBits = 0;
1827  VarDeclBits.SClass = SC;
1828  // Everything else is implicitly initialized to false.
1829 }
1830 
1832  SourceLocation StartL, SourceLocation IdL,
1834  StorageClass S) {
1835  return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
1836 }
1837 
1839  return new (C, ID)
1840  VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
1841  QualType(), nullptr, SC_None);
1842 }
1843 
1845  assert(isLegalForVariable(SC));
1846  VarDeclBits.SClass = SC;
1847 }
1848 
1850  switch (VarDeclBits.TSCSpec) {
1851  case TSCS_unspecified:
1852  if (!hasAttr<ThreadAttr>() &&
1853  !(getASTContext().getLangOpts().OpenMPUseTLS &&
1854  getASTContext().getTargetInfo().isTLSSupported() &&
1855  hasAttr<OMPThreadPrivateDeclAttr>()))
1856  return TLS_None;
1857  return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
1859  hasAttr<OMPThreadPrivateDeclAttr>())
1860  ? TLS_Dynamic
1861  : TLS_Static;
1862  case TSCS___thread: // Fall through.
1863  case TSCS__Thread_local:
1864  return TLS_Static;
1865  case TSCS_thread_local:
1866  return TLS_Dynamic;
1867  }
1868  llvm_unreachable("Unknown thread storage class specifier!");
1869 }
1870 
1872  if (const Expr *Init = getInit()) {
1873  SourceLocation InitEnd = Init->getLocEnd();
1874  // If Init is implicit, ignore its source range and fallback on
1875  // DeclaratorDecl::getSourceRange() to handle postfix elements.
1876  if (InitEnd.isValid() && InitEnd != getLocation())
1877  return SourceRange(getOuterLocStart(), InitEnd);
1878  }
1880 }
1881 
1882 template<typename T>
1884  // C++ [dcl.link]p1: All function types, function names with external linkage,
1885  // and variable names with external linkage have a language linkage.
1886  if (!D.hasExternalFormalLinkage())
1887  return NoLanguageLinkage;
1888 
1889  // Language linkage is a C++ concept, but saying that everything else in C has
1890  // C language linkage fits the implementation nicely.
1891  ASTContext &Context = D.getASTContext();
1892  if (!Context.getLangOpts().CPlusPlus)
1893  return CLanguageLinkage;
1894 
1895  // C++ [dcl.link]p4: A C language linkage is ignored in determining the
1896  // language linkage of the names of class members and the function type of
1897  // class member functions.
1898  const DeclContext *DC = D.getDeclContext();
1899  if (DC->isRecord())
1900  return CXXLanguageLinkage;
1901 
1902  // If the first decl is in an extern "C" context, any other redeclaration
1903  // will have C language linkage. If the first one is not in an extern "C"
1904  // context, we would have reported an error for any other decl being in one.
1905  if (isFirstInExternCContext(&D))
1906  return CLanguageLinkage;
1907  return CXXLanguageLinkage;
1908 }
1909 
1910 template<typename T>
1911 static bool isDeclExternC(const T &D) {
1912  // Since the context is ignored for class members, they can only have C++
1913  // language linkage or no language linkage.
1914  const DeclContext *DC = D.getDeclContext();
1915  if (DC->isRecord()) {
1916  assert(D.getASTContext().getLangOpts().CPlusPlus);
1917  return false;
1918  }
1919 
1920  return D.getLanguageLinkage() == CLanguageLinkage;
1921 }
1922 
1924  return getDeclLanguageLinkage(*this);
1925 }
1926 
1927 bool VarDecl::isExternC() const {
1928  return isDeclExternC(*this);
1929 }
1930 
1933 }
1934 
1937 }
1938 
1940 
1943  // C++ [basic.def]p2:
1944  // A declaration is a definition unless [...] it contains the 'extern'
1945  // specifier or a linkage-specification and neither an initializer [...],
1946  // it declares a non-inline static data member in a class declaration [...],
1947  // it declares a static data member outside a class definition and the variable
1948  // was defined within the class with the constexpr specifier [...],
1949  // C++1y [temp.expl.spec]p15:
1950  // An explicit specialization of a static data member or an explicit
1951  // specialization of a static data member template is a definition if the
1952  // declaration includes an initializer; otherwise, it is a declaration.
1953  //
1954  // FIXME: How do you declare (but not define) a partial specialization of
1955  // a static data member template outside the containing class?
1957  return DeclarationOnly;
1958 
1959  if (isStaticDataMember()) {
1960  if (isOutOfLine() &&
1961  !(getCanonicalDecl()->isInline() &&
1962  getCanonicalDecl()->isConstexpr()) &&
1963  (hasInit() ||
1964  // If the first declaration is out-of-line, this may be an
1965  // instantiation of an out-of-line partial specialization of a variable
1966  // template for which we have not yet instantiated the initializer.
1971  isa<VarTemplatePartialSpecializationDecl>(this)))
1972  return Definition;
1973  else if (!isOutOfLine() && isInline())
1974  return Definition;
1975  else
1976  return DeclarationOnly;
1977  }
1978  // C99 6.7p5:
1979  // A definition of an identifier is a declaration for that identifier that
1980  // [...] causes storage to be reserved for that object.
1981  // Note: that applies for all non-file-scope objects.
1982  // C99 6.9.2p1:
1983  // If the declaration of an identifier for an object has file scope and an
1984  // initializer, the declaration is an external definition for the identifier
1985  if (hasInit())
1986  return Definition;
1987 
1988  if (hasDefiningAttr())
1989  return Definition;
1990 
1991  if (const auto *SAA = getAttr<SelectAnyAttr>())
1992  if (!SAA->isInherited())
1993  return Definition;
1994 
1995  // A variable template specialization (other than a static data member
1996  // template or an explicit specialization) is a declaration until we
1997  // instantiate its initializer.
1998  if (isa<VarTemplateSpecializationDecl>(this) &&
2000  return DeclarationOnly;
2001 
2002  if (hasExternalStorage())
2003  return DeclarationOnly;
2004 
2005  // [dcl.link] p7:
2006  // A declaration directly contained in a linkage-specification is treated
2007  // as if it contains the extern specifier for the purpose of determining
2008  // the linkage of the declared name and whether it is a definition.
2009  if (isSingleLineLanguageLinkage(*this))
2010  return DeclarationOnly;
2011 
2012  // C99 6.9.2p2:
2013  // A declaration of an object that has file scope without an initializer,
2014  // and without a storage class specifier or the scs 'static', constitutes
2015  // a tentative definition.
2016  // No such thing in C++.
2017  if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
2018  return TentativeDefinition;
2019 
2020  // What's left is (in C, block-scope) declarations without initializers or
2021  // external storage. These are definitions.
2022  return Definition;
2023 }
2024 
2027  if (Kind != TentativeDefinition)
2028  return nullptr;
2029 
2030  VarDecl *LastTentative = nullptr;
2031  VarDecl *First = getFirstDecl();
2032  for (auto I : First->redecls()) {
2033  Kind = I->isThisDeclarationADefinition();
2034  if (Kind == Definition)
2035  return nullptr;
2036  else if (Kind == TentativeDefinition)
2037  LastTentative = I;
2038  }
2039  return LastTentative;
2040 }
2041 
2043  VarDecl *First = getFirstDecl();
2044  for (auto I : First->redecls()) {
2045  if (I->isThisDeclarationADefinition(C) == Definition)
2046  return I;
2047  }
2048  return nullptr;
2049 }
2050 
2053 
2054  const VarDecl *First = getFirstDecl();
2055  for (auto I : First->redecls()) {
2056  Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
2057  if (Kind == Definition)
2058  break;
2059  }
2060 
2061  return Kind;
2062 }
2063 
2064 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
2065  for (auto I : redecls()) {
2066  if (auto Expr = I->getInit()) {
2067  D = I;
2068  return Expr;
2069  }
2070  }
2071  return nullptr;
2072 }
2073 
2074 bool VarDecl::hasInit() const {
2075  if (auto *P = dyn_cast<ParmVarDecl>(this))
2076  if (P->hasUnparsedDefaultArg() || P->hasUninstantiatedDefaultArg())
2077  return false;
2078 
2079  return !Init.isNull();
2080 }
2081 
2083  if (!hasInit())
2084  return nullptr;
2085 
2086  if (auto *S = Init.dyn_cast<Stmt *>())
2087  return cast<Expr>(S);
2088 
2089  return cast_or_null<Expr>(Init.get<EvaluatedStmt *>()->Value);
2090 }
2091 
2093  if (auto *ES = Init.dyn_cast<EvaluatedStmt *>())
2094  return &ES->Value;
2095 
2096  return Init.getAddrOfPtr1();
2097 }
2098 
2099 bool VarDecl::isOutOfLine() const {
2100  if (Decl::isOutOfLine())
2101  return true;
2102 
2103  if (!isStaticDataMember())
2104  return false;
2105 
2106  // If this static data member was instantiated from a static data member of
2107  // a class template, check whether that static data member was defined
2108  // out-of-line.
2110  return VD->isOutOfLine();
2111 
2112  return false;
2113 }
2114 
2116  if (auto *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
2117  Eval->~EvaluatedStmt();
2118  getASTContext().Deallocate(Eval);
2119  }
2120 
2121  Init = I;
2122 }
2123 
2125  const LangOptions &Lang = C.getLangOpts();
2126 
2127  if (!Lang.CPlusPlus)
2128  return false;
2129 
2130  // In C++11, any variable of reference type can be used in a constant
2131  // expression if it is initialized by a constant expression.
2132  if (Lang.CPlusPlus11 && getType()->isReferenceType())
2133  return true;
2134 
2135  // Only const objects can be used in constant expressions in C++. C++98 does
2136  // not require the variable to be non-volatile, but we consider this to be a
2137  // defect.
2138  if (!getType().isConstQualified() || getType().isVolatileQualified())
2139  return false;
2140 
2141  // In C++, const, non-volatile variables of integral or enumeration types
2142  // can be used in constant expressions.
2143  if (getType()->isIntegralOrEnumerationType())
2144  return true;
2145 
2146  // Additionally, in C++11, non-volatile constexpr variables can be used in
2147  // constant expressions.
2148  return Lang.CPlusPlus11 && isConstexpr();
2149 }
2150 
2151 /// Convert the initializer for this declaration to the elaborated EvaluatedStmt
2152 /// form, which contains extra information on the evaluated value of the
2153 /// initializer.
2155  auto *Eval = Init.dyn_cast<EvaluatedStmt *>();
2156  if (!Eval) {
2157  // Note: EvaluatedStmt contains an APValue, which usually holds
2158  // resources not allocated from the ASTContext. We need to do some
2159  // work to avoid leaking those, but we do so in VarDecl::evaluateValue
2160  // where we can detect whether there's anything to clean up or not.
2161  Eval = new (getASTContext()) EvaluatedStmt;
2162  Eval->Value = Init.get<Stmt *>();
2163  Init = Eval;
2164  }
2165  return Eval;
2166 }
2167 
2170  return evaluateValue(Notes);
2171 }
2172 
2174  SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
2176 
2177  // We only produce notes indicating why an initializer is non-constant the
2178  // first time it is evaluated. FIXME: The notes won't always be emitted the
2179  // first time we try evaluation, so might not be produced at all.
2180  if (Eval->WasEvaluated)
2181  return Eval->Evaluated.isUninit() ? nullptr : &Eval->Evaluated;
2182 
2183  const auto *Init = cast<Expr>(Eval->Value);
2184  assert(!Init->isValueDependent());
2185 
2186  if (Eval->IsEvaluating) {
2187  // FIXME: Produce a diagnostic for self-initialization.
2188  Eval->CheckedICE = true;
2189  Eval->IsICE = false;
2190  return nullptr;
2191  }
2192 
2193  Eval->IsEvaluating = true;
2194 
2195  bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, getASTContext(),
2196  this, Notes);
2197 
2198  // Ensure the computed APValue is cleaned up later if evaluation succeeded,
2199  // or that it's empty (so that there's nothing to clean up) if evaluation
2200  // failed.
2201  if (!Result)
2202  Eval->Evaluated = APValue();
2203  else if (Eval->Evaluated.needsCleanup())
2205 
2206  Eval->IsEvaluating = false;
2207  Eval->WasEvaluated = true;
2208 
2209  // In C++11, we have determined whether the initializer was a constant
2210  // expression as a side-effect.
2211  if (getASTContext().getLangOpts().CPlusPlus11 && !Eval->CheckedICE) {
2212  Eval->CheckedICE = true;
2213  Eval->IsICE = Result && Notes.empty();
2214  }
2215 
2216  return Result ? &Eval->Evaluated : nullptr;
2217 }
2218 
2220  if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
2221  if (Eval->WasEvaluated)
2222  return &Eval->Evaluated;
2223 
2224  return nullptr;
2225 }
2226 
2228  if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
2229  return Eval->CheckedICE;
2230 
2231  return false;
2232 }
2233 
2234 bool VarDecl::isInitICE() const {
2235  assert(isInitKnownICE() &&
2236  "Check whether we already know that the initializer is an ICE");
2237  return Init.get<EvaluatedStmt *>()->IsICE;
2238 }
2239 
2241  // Initializers of weak variables are never ICEs.
2242  if (isWeak())
2243  return false;
2244 
2246  if (Eval->CheckedICE)
2247  // We have already checked whether this subexpression is an
2248  // integral constant expression.
2249  return Eval->IsICE;
2250 
2251  const auto *Init = cast<Expr>(Eval->Value);
2252  assert(!Init->isValueDependent());
2253 
2254  // In C++11, evaluate the initializer to check whether it's a constant
2255  // expression.
2256  if (getASTContext().getLangOpts().CPlusPlus11) {
2258  evaluateValue(Notes);
2259  return Eval->IsICE;
2260  }
2261 
2262  // It's an ICE whether or not the definition we found is
2263  // out-of-line. See DR 721 and the discussion in Clang PR
2264  // 6206 for details.
2265 
2266  if (Eval->CheckingICE)
2267  return false;
2268  Eval->CheckingICE = true;
2269 
2270  Eval->IsICE = Init->isIntegerConstantExpr(getASTContext());
2271  Eval->CheckingICE = false;
2272  Eval->CheckedICE = true;
2273  return Eval->IsICE;
2274 }
2275 
2276 template<typename DeclT>
2277 static DeclT *getDefinitionOrSelf(DeclT *D) {
2278  assert(D);
2279  if (auto *Def = D->getDefinition())
2280  return Def;
2281  return D;
2282 }
2283 
2285  // If it's a variable template specialization, find the template or partial
2286  // specialization from which it was instantiated.
2287  if (auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(this)) {
2288  auto From = VDTemplSpec->getInstantiatedFrom();
2289  if (auto *VTD = From.dyn_cast<VarTemplateDecl *>()) {
2290  while (auto *NewVTD = VTD->getInstantiatedFromMemberTemplate()) {
2291  if (NewVTD->isMemberSpecialization())
2292  break;
2293  VTD = NewVTD;
2294  }
2295  return getDefinitionOrSelf(VTD->getTemplatedDecl());
2296  }
2297  if (auto *VTPSD =
2298  From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
2299  while (auto *NewVTPSD = VTPSD->getInstantiatedFromMember()) {
2300  if (NewVTPSD->isMemberSpecialization())
2301  break;
2302  VTPSD = NewVTPSD;
2303  }
2304  return getDefinitionOrSelf<VarDecl>(VTPSD);
2305  }
2306  }
2307 
2309  if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
2311  while (auto *NewVD = VD->getInstantiatedFromStaticDataMember())
2312  VD = NewVD;
2313  return getDefinitionOrSelf(VD);
2314  }
2315  }
2316 
2317  if (VarTemplateDecl *VarTemplate = getDescribedVarTemplate()) {
2318  while (VarTemplate->getInstantiatedFromMemberTemplate()) {
2319  if (VarTemplate->isMemberSpecialization())
2320  break;
2321  VarTemplate = VarTemplate->getInstantiatedFromMemberTemplate();
2322  }
2323 
2324  return getDefinitionOrSelf(VarTemplate->getTemplatedDecl());
2325  }
2326  return nullptr;
2327 }
2328 
2331  return cast<VarDecl>(MSI->getInstantiatedFrom());
2332 
2333  return nullptr;
2334 }
2335 
2337  if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2338  return Spec->getSpecializationKind();
2339 
2341  return MSI->getTemplateSpecializationKind();
2342 
2343  return TSK_Undeclared;
2344 }
2345 
2347  if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2348  return Spec->getPointOfInstantiation();
2349 
2351  return MSI->getPointOfInstantiation();
2352 
2353  return SourceLocation();
2354 }
2355 
2358  .dyn_cast<VarTemplateDecl *>();
2359 }
2360 
2363 }
2364 
2366  if (isStaticDataMember())
2367  // FIXME: Remove ?
2368  // return getASTContext().getInstantiatedFromStaticDataMember(this);
2370  .dyn_cast<MemberSpecializationInfo *>();
2371  return nullptr;
2372 }
2373 
2375  SourceLocation PointOfInstantiation) {
2376  assert((isa<VarTemplateSpecializationDecl>(this) ||
2378  "not a variable or static data member template specialization");
2379 
2380  if (VarTemplateSpecializationDecl *Spec =
2381  dyn_cast<VarTemplateSpecializationDecl>(this)) {
2382  Spec->setSpecializationKind(TSK);
2383  if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2384  Spec->getPointOfInstantiation().isInvalid())
2385  Spec->setPointOfInstantiation(PointOfInstantiation);
2386  }
2387 
2389  MSI->setTemplateSpecializationKind(TSK);
2390  if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2391  MSI->getPointOfInstantiation().isInvalid())
2392  MSI->setPointOfInstantiation(PointOfInstantiation);
2393  }
2394 }
2395 
2396 void
2399  assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
2400  "Previous template or instantiation?");
2402 }
2403 
2404 //===----------------------------------------------------------------------===//
2405 // ParmVarDecl Implementation
2406 //===----------------------------------------------------------------------===//
2407 
2409  SourceLocation StartLoc,
2411  QualType T, TypeSourceInfo *TInfo,
2412  StorageClass S, Expr *DefArg) {
2413  return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
2414  S, DefArg);
2415 }
2416 
2419  QualType T = TSI ? TSI->getType() : getType();
2420  if (const auto *DT = dyn_cast<DecayedType>(T))
2421  return DT->getOriginalType();
2422  return T;
2423 }
2424 
2426  return new (C, ID)
2427  ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
2428  nullptr, QualType(), nullptr, SC_None, nullptr);
2429 }
2430 
2432  if (!hasInheritedDefaultArg()) {
2433  SourceRange ArgRange = getDefaultArgRange();
2434  if (ArgRange.isValid())
2435  return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2436  }
2437 
2438  // DeclaratorDecl considers the range of postfix types as overlapping with the
2439  // declaration name, but this is not the case with parameters in ObjC methods.
2440  if (isa<ObjCMethodDecl>(getDeclContext()))
2442 
2444 }
2445 
2447  assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
2448  assert(!hasUninstantiatedDefaultArg() &&
2449  "Default argument is not yet instantiated!");
2450 
2451  Expr *Arg = getInit();
2452  if (auto *E = dyn_cast_or_null<ExprWithCleanups>(Arg))
2453  return E->getSubExpr();
2454 
2455  return Arg;
2456 }
2457 
2459  ParmVarDeclBits.DefaultArgKind = DAK_Normal;
2460  Init = defarg;
2461 }
2462 
2464  switch (ParmVarDeclBits.DefaultArgKind) {
2465  case DAK_None:
2466  case DAK_Unparsed:
2467  // Nothing we can do here.
2468  return SourceRange();
2469 
2470  case DAK_Uninstantiated:
2471  return getUninstantiatedDefaultArg()->getSourceRange();
2472 
2473  case DAK_Normal:
2474  if (const Expr *E = getInit())
2475  return E->getSourceRange();
2476 
2477  // Missing an actual expression, may be invalid.
2478  return SourceRange();
2479  }
2480  llvm_unreachable("Invalid default argument kind.");
2481 }
2482 
2484  ParmVarDeclBits.DefaultArgKind = DAK_Uninstantiated;
2485  Init = arg;
2486 }
2487 
2489  assert(hasUninstantiatedDefaultArg() &&
2490  "Wrong kind of initialization expression!");
2491  return cast_or_null<Expr>(Init.get<Stmt *>());
2492 }
2493 
2495  // FIXME: We should just return false for DAK_None here once callers are
2496  // prepared for the case that we encountered an invalid default argument and
2497  // were unable to even build an invalid expression.
2498  return hasUnparsedDefaultArg() || hasUninstantiatedDefaultArg() ||
2499  !Init.isNull();
2500 }
2501 
2503  return isa<PackExpansionType>(getType());
2504 }
2505 
2506 void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
2507  getASTContext().setParameterIndex(this, parameterIndex);
2508  ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
2509 }
2510 
2511 unsigned ParmVarDecl::getParameterIndexLarge() const {
2512  return getASTContext().getParameterIndex(this);
2513 }
2514 
2515 //===----------------------------------------------------------------------===//
2516 // FunctionDecl Implementation
2517 //===----------------------------------------------------------------------===//
2518 
2520  raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
2521  NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
2522  const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
2523  if (TemplateArgs)
2525  OS, TemplateArgs->asArray(), Policy);
2526 }
2527 
2529  if (const auto *FT = getType()->getAs<FunctionProtoType>())
2530  return FT->isVariadic();
2531  return false;
2532 }
2533 
2535  for (auto I : redecls()) {
2536  if (I->doesThisDeclarationHaveABody()) {
2537  Definition = I;
2538  return true;
2539  }
2540  }
2541 
2542  return false;
2543 }
2544 
2546 {
2547  Stmt *S = getBody();
2548  if (!S) {
2549  // Since we don't have a body for this function, we don't know if it's
2550  // trivial or not.
2551  return false;
2552  }
2553 
2554  if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
2555  return true;
2556  return false;
2557 }
2558 
2560  for (auto I : redecls()) {
2561  if (I->isThisDeclarationADefinition()) {
2562  Definition = I;
2563  return true;
2564  }
2565  }
2566 
2567  return false;
2568 }
2569 
2571  if (!hasBody(Definition))
2572  return nullptr;
2573 
2574  if (Definition->Body)
2575  return Definition->Body.get(getASTContext().getExternalSource());
2576 
2577  return nullptr;
2578 }
2579 
2581  Body = B;
2582  if (B)
2583  EndRangeLoc = B->getLocEnd();
2584 }
2585 
2587  IsPure = P;
2588  if (P)
2589  if (auto *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
2590  Parent->markedVirtualFunctionPure();
2591 }
2592 
2593 template<std::size_t Len>
2594 static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
2595  IdentifierInfo *II = ND->getIdentifier();
2596  return II && II->isStr(Str);
2597 }
2598 
2599 bool FunctionDecl::isMain() const {
2600  const TranslationUnitDecl *tunit =
2602  return tunit &&
2603  !tunit->getASTContext().getLangOpts().Freestanding &&
2604  isNamed(this, "main");
2605 }
2606 
2608  const TranslationUnitDecl *TUnit =
2610  if (!TUnit)
2611  return false;
2612 
2613  // Even though we aren't really targeting MSVCRT if we are freestanding,
2614  // semantic analysis for these functions remains the same.
2615 
2616  // MSVCRT entry points only exist on MSVCRT targets.
2617  if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
2618  return false;
2619 
2620  // Nameless functions like constructors cannot be entry points.
2621  if (!getIdentifier())
2622  return false;
2623 
2624  return llvm::StringSwitch<bool>(getName())
2625  .Cases("main", // an ANSI console app
2626  "wmain", // a Unicode console App
2627  "WinMain", // an ANSI GUI app
2628  "wWinMain", // a Unicode GUI app
2629  "DllMain", // a DLL
2630  true)
2631  .Default(false);
2632 }
2633 
2635  assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName);
2636  assert(getDeclName().getCXXOverloadedOperator() == OO_New ||
2637  getDeclName().getCXXOverloadedOperator() == OO_Delete ||
2638  getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
2639  getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
2640 
2641  if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2642  return false;
2643 
2644  const auto *proto = getType()->castAs<FunctionProtoType>();
2645  if (proto->getNumParams() != 2 || proto->isVariadic())
2646  return false;
2647 
2648  ASTContext &Context =
2649  cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
2650  ->getASTContext();
2651 
2652  // The result type and first argument type are constant across all
2653  // these operators. The second argument must be exactly void*.
2654  return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
2655 }
2656 
2658  if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
2659  return false;
2660  if (getDeclName().getCXXOverloadedOperator() != OO_New &&
2661  getDeclName().getCXXOverloadedOperator() != OO_Delete &&
2662  getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
2663  getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
2664  return false;
2665 
2666  if (isa<CXXRecordDecl>(getDeclContext()))
2667  return false;
2668 
2669  // This can only fail for an invalid 'operator new' declaration.
2670  if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
2671  return false;
2672 
2673  const auto *FPT = getType()->castAs<FunctionProtoType>();
2674  if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
2675  return false;
2676 
2677  // If this is a single-parameter function, it must be a replaceable global
2678  // allocation or deallocation function.
2679  if (FPT->getNumParams() == 1)
2680  return true;
2681 
2682  unsigned Params = 1;
2683  QualType Ty = FPT->getParamType(Params);
2684  ASTContext &Ctx = getASTContext();
2685 
2686  auto Consume = [&] {
2687  ++Params;
2688  Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) : QualType();
2689  };
2690 
2691  // In C++14, the next parameter can be a 'std::size_t' for sized delete.
2692  bool IsSizedDelete = false;
2693  if (Ctx.getLangOpts().SizedDeallocation &&
2694  (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
2695  getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
2696  Ctx.hasSameType(Ty, Ctx.getSizeType())) {
2697  IsSizedDelete = true;
2698  Consume();
2699  }
2700 
2701  // In C++17, the next parameter can be a 'std::align_val_t' for aligned
2702  // new/delete.
2703  if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
2704  if (IsAligned)
2705  *IsAligned = true;
2706  Consume();
2707  }
2708 
2709  // Finally, if this is not a sized delete, the final parameter can
2710  // be a 'const std::nothrow_t&'.
2711  if (!IsSizedDelete && !Ty.isNull() && Ty->isReferenceType()) {
2712  Ty = Ty->getPointeeType();
2713  if (Ty.getCVRQualifiers() != Qualifiers::Const)
2714  return false;
2715  const CXXRecordDecl *RD = Ty->getAsCXXRecordDecl();
2716  if (RD && isNamed(RD, "nothrow_t") && RD->isInStdNamespace())
2717  Consume();
2718  }
2719 
2720  return Params == FPT->getNumParams();
2721 }
2722 
2724  return getDeclLanguageLinkage(*this);
2725 }
2726 
2728  return isDeclExternC(*this);
2729 }
2730 
2733 }
2734 
2737 }
2738 
2740  if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
2741  return Method->isStatic();
2742 
2744  return false;
2745 
2746  for (const DeclContext *DC = getDeclContext();
2747  DC->isNamespace();
2748  DC = DC->getParent()) {
2749  if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
2750  if (!Namespace->getDeclName())
2751  return false;
2752  break;
2753  }
2754  }
2755 
2756  return true;
2757 }
2758 
2760  if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
2761  hasAttr<C11NoReturnAttr>())
2762  return true;
2763 
2764  if (auto *FnTy = getType()->getAs<FunctionType>())
2765  return FnTy->getNoReturnAttr();
2766 
2767  return false;
2768 }
2769 
2770 void
2773 
2774  if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
2775  FunctionTemplateDecl *PrevFunTmpl
2776  = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
2777  assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
2778  FunTmpl->setPreviousDecl(PrevFunTmpl);
2779  }
2780 
2781  if (PrevDecl && PrevDecl->IsInline)
2782  IsInline = true;
2783 }
2784 
2786 
2787 /// \brief Returns a value indicating whether this function
2788 /// corresponds to a builtin function.
2789 ///
2790 /// The function corresponds to a built-in function if it is
2791 /// declared at translation scope or within an extern "C" block and
2792 /// its name matches with the name of a builtin. The returned value
2793 /// will be 0 for functions that do not correspond to a builtin, a
2794 /// value of type \c Builtin::ID if in the target-independent range
2795 /// \c [1,Builtin::First), or a target-specific builtin value.
2796 unsigned FunctionDecl::getBuiltinID() const {
2797  if (!getIdentifier())
2798  return 0;
2799 
2800  unsigned BuiltinID = getIdentifier()->getBuiltinID();
2801  if (!BuiltinID)
2802  return 0;
2803 
2804  ASTContext &Context = getASTContext();
2805  if (Context.getLangOpts().CPlusPlus) {
2806  const auto *LinkageDecl =
2808  // In C++, the first declaration of a builtin is always inside an implicit
2809  // extern "C".
2810  // FIXME: A recognised library function may not be directly in an extern "C"
2811  // declaration, for instance "extern "C" { namespace std { decl } }".
2812  if (!LinkageDecl) {
2813  if (BuiltinID == Builtin::BI__GetExceptionInfo &&
2814  Context.getTargetInfo().getCXXABI().isMicrosoft())
2815  return Builtin::BI__GetExceptionInfo;
2816  return 0;
2817  }
2818  if (LinkageDecl->getLanguage() != LinkageSpecDecl::lang_c)
2819  return 0;
2820  }
2821 
2822  // If the function is marked "overloadable", it has a different mangled name
2823  // and is not the C library function.
2824  if (hasAttr<OverloadableAttr>())
2825  return 0;
2826 
2827  if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
2828  return BuiltinID;
2829 
2830  // This function has the name of a known C library
2831  // function. Determine whether it actually refers to the C library
2832  // function or whether it just has the same name.
2833 
2834  // If this is a static function, it's not a builtin.
2835  if (getStorageClass() == SC_Static)
2836  return 0;
2837 
2838  // OpenCL v1.2 s6.9.f - The library functions defined in
2839  // the C99 standard headers are not available.
2840  if (Context.getLangOpts().OpenCL &&
2841  Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
2842  return 0;
2843 
2844  return BuiltinID;
2845 }
2846 
2847 
2848 /// getNumParams - Return the number of parameters this function must have
2849 /// based on its FunctionType. This is the length of the ParamInfo array
2850 /// after it has been created.
2851 unsigned FunctionDecl::getNumParams() const {
2852  const auto *FPT = getType()->getAs<FunctionProtoType>();
2853  return FPT ? FPT->getNumParams() : 0;
2854 }
2855 
2856 void FunctionDecl::setParams(ASTContext &C,
2857  ArrayRef<ParmVarDecl *> NewParamInfo) {
2858  assert(!ParamInfo && "Already has param info!");
2859  assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
2860 
2861  // Zero params -> null pointer.
2862  if (!NewParamInfo.empty()) {
2863  ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
2864  std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
2865  }
2866 }
2867 
2868 /// getMinRequiredArguments - Returns the minimum number of arguments
2869 /// needed to call this function. This may be fewer than the number of
2870 /// function parameters, if some of the parameters have default
2871 /// arguments (in C++) or are parameter packs (C++11).
2873  if (!getASTContext().getLangOpts().CPlusPlus)
2874  return getNumParams();
2875 
2876  unsigned NumRequiredArgs = 0;
2877  for (auto *Param : parameters())
2878  if (!Param->isParameterPack() && !Param->hasDefaultArg())
2879  ++NumRequiredArgs;
2880  return NumRequiredArgs;
2881 }
2882 
2883 /// \brief The combination of the extern and inline keywords under MSVC forces
2884 /// the function to be required.
2885 ///
2886 /// Note: This function assumes that we will only get called when isInlined()
2887 /// would return true for this FunctionDecl.
2889  assert(isInlined() && "expected to get called on an inlined function!");
2890 
2891  const ASTContext &Context = getASTContext();
2892  if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
2893  !hasAttr<DLLExportAttr>())
2894  return false;
2895 
2896  for (const FunctionDecl *FD = getMostRecentDecl(); FD;
2897  FD = FD->getPreviousDecl())
2898  if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
2899  return true;
2900 
2901  return false;
2902 }
2903 
2904 static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
2905  if (Redecl->getStorageClass() != SC_Extern)
2906  return false;
2907 
2908  for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
2909  FD = FD->getPreviousDecl())
2910  if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
2911  return false;
2912 
2913  return true;
2914 }
2915 
2916 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
2917  // Only consider file-scope declarations in this test.
2918  if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
2919  return false;
2920 
2921  // Only consider explicit declarations; the presence of a builtin for a
2922  // libcall shouldn't affect whether a definition is externally visible.
2923  if (Redecl->isImplicit())
2924  return false;
2925 
2926  if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
2927  return true; // Not an inline definition
2928 
2929  return false;
2930 }
2931 
2932 /// \brief For a function declaration in C or C++, determine whether this
2933 /// declaration causes the definition to be externally visible.
2934 ///
2935 /// For instance, this determines if adding the current declaration to the set
2936 /// of redeclarations of the given functions causes
2937 /// isInlineDefinitionExternallyVisible to change from false to true.
2939  assert(!doesThisDeclarationHaveABody() &&
2940  "Must have a declaration without a body.");
2941 
2942  ASTContext &Context = getASTContext();
2943 
2944  if (Context.getLangOpts().MSVCCompat) {
2945  const FunctionDecl *Definition;
2946  if (hasBody(Definition) && Definition->isInlined() &&
2947  redeclForcesDefMSVC(this))
2948  return true;
2949  }
2950 
2951  if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
2952  // With GNU inlining, a declaration with 'inline' but not 'extern', forces
2953  // an externally visible definition.
2954  //
2955  // FIXME: What happens if gnu_inline gets added on after the first
2956  // declaration?
2958  return false;
2959 
2960  const FunctionDecl *Prev = this;
2961  bool FoundBody = false;
2962  while ((Prev = Prev->getPreviousDecl())) {
2963  FoundBody |= Prev->Body.isValid();
2964 
2965  if (Prev->Body) {
2966  // If it's not the case that both 'inline' and 'extern' are
2967  // specified on the definition, then it is always externally visible.
2968  if (!Prev->isInlineSpecified() ||
2969  Prev->getStorageClass() != SC_Extern)
2970  return false;
2971  } else if (Prev->isInlineSpecified() &&
2972  Prev->getStorageClass() != SC_Extern) {
2973  return false;
2974  }
2975  }
2976  return FoundBody;
2977  }
2978 
2979  if (Context.getLangOpts().CPlusPlus)
2980  return false;
2981 
2982  // C99 6.7.4p6:
2983  // [...] If all of the file scope declarations for a function in a
2984  // translation unit include the inline function specifier without extern,
2985  // then the definition in that translation unit is an inline definition.
2987  return false;
2988  const FunctionDecl *Prev = this;
2989  bool FoundBody = false;
2990  while ((Prev = Prev->getPreviousDecl())) {
2991  FoundBody |= Prev->Body.isValid();
2992  if (RedeclForcesDefC99(Prev))
2993  return false;
2994  }
2995  return FoundBody;
2996 }
2997 
2999  const TypeSourceInfo *TSI = getTypeSourceInfo();
3000  if (!TSI)
3001  return SourceRange();
3002  FunctionTypeLoc FTL =
3004  if (!FTL)
3005  return SourceRange();
3006 
3007  // Skip self-referential return types.
3009  SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
3010  SourceLocation Boundary = getNameInfo().getLocStart();
3011  if (RTRange.isInvalid() || Boundary.isInvalid() ||
3012  !SM.isBeforeInTranslationUnit(RTRange.getEnd(), Boundary))
3013  return SourceRange();
3014 
3015  return RTRange;
3016 }
3017 
3019  const TypeSourceInfo *TSI = getTypeSourceInfo();
3020  if (!TSI)
3021  return SourceRange();
3022  FunctionTypeLoc FTL =
3024  if (!FTL)
3025  return SourceRange();
3026 
3027  return FTL.getExceptionSpecRange();
3028 }
3029 
3031  QualType RetType = getReturnType();
3032  if (RetType->isRecordType()) {
3033  if (const CXXRecordDecl *Ret = RetType->getAsCXXRecordDecl()) {
3034  if (const auto *R = Ret->getAttr<WarnUnusedResultAttr>())
3035  return R;
3036  }
3037  } else if (const auto *ET = RetType->getAs<EnumType>()) {
3038  if (const EnumDecl *ED = ET->getDecl()) {
3039  if (const auto *R = ED->getAttr<WarnUnusedResultAttr>())
3040  return R;
3041  }
3042  }
3043  return getAttr<WarnUnusedResultAttr>();
3044 }
3045 
3046 /// \brief For an inline function definition in C, or for a gnu_inline function
3047 /// in C++, determine whether the definition will be externally visible.
3048 ///
3049 /// Inline function definitions are always available for inlining optimizations.
3050 /// However, depending on the language dialect, declaration specifiers, and
3051 /// attributes, the definition of an inline function may or may not be
3052 /// "externally" visible to other translation units in the program.
3053 ///
3054 /// In C99, inline definitions are not externally visible by default. However,
3055 /// if even one of the global-scope declarations is marked "extern inline", the
3056 /// inline definition becomes externally visible (C99 6.7.4p6).
3057 ///
3058 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function
3059 /// definition, we use the GNU semantics for inline, which are nearly the
3060 /// opposite of C99 semantics. In particular, "inline" by itself will create
3061 /// an externally visible symbol, but "extern inline" will not create an
3062 /// externally visible symbol.
3064  assert((doesThisDeclarationHaveABody() || willHaveBody()) &&
3065  "Must be a function definition");
3066  assert(isInlined() && "Function must be inline");
3067  ASTContext &Context = getASTContext();
3068 
3069  if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3070  // Note: If you change the logic here, please change
3071  // doesDeclarationForceExternallyVisibleDefinition as well.
3072  //
3073  // If it's not the case that both 'inline' and 'extern' are
3074  // specified on the definition, then this inline definition is
3075  // externally visible.
3076  if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
3077  return true;
3078 
3079  // If any declaration is 'inline' but not 'extern', then this definition
3080  // is externally visible.
3081  for (auto Redecl : redecls()) {
3082  if (Redecl->isInlineSpecified() &&
3083  Redecl->getStorageClass() != SC_Extern)
3084  return true;
3085  }
3086 
3087  return false;
3088  }
3089 
3090  // The rest of this function is C-only.
3091  assert(!Context.getLangOpts().CPlusPlus &&
3092  "should not use C inline rules in C++");
3093 
3094  // C99 6.7.4p6:
3095  // [...] If all of the file scope declarations for a function in a
3096  // translation unit include the inline function specifier without extern,
3097  // then the definition in that translation unit is an inline definition.
3098  for (auto Redecl : redecls()) {
3099  if (RedeclForcesDefC99(Redecl))
3100  return true;
3101  }
3102 
3103  // C99 6.7.4p6:
3104  // An inline definition does not provide an external definition for the
3105  // function, and does not forbid an external definition in another
3106  // translation unit.
3107  return false;
3108 }
3109 
3110 /// getOverloadedOperator - Which C++ overloaded operator this
3111 /// function represents, if any.
3113  if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
3115  else
3116  return OO_None;
3117 }
3118 
3119 /// getLiteralIdentifier - The literal suffix identifier this function
3120 /// represents, if any.
3124  else
3125  return nullptr;
3126 }
3127 
3129  if (TemplateOrSpecialization.isNull())
3130  return TK_NonTemplate;
3131  if (TemplateOrSpecialization.is<FunctionTemplateDecl *>())
3132  return TK_FunctionTemplate;
3133  if (TemplateOrSpecialization.is<MemberSpecializationInfo *>())
3134  return TK_MemberSpecialization;
3135  if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
3136  return TK_FunctionTemplateSpecialization;
3137  if (TemplateOrSpecialization.is
3139  return TK_DependentFunctionTemplateSpecialization;
3140 
3141  llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
3142 }
3143 
3146  return cast<FunctionDecl>(Info->getInstantiatedFrom());
3147 
3148  return nullptr;
3149 }
3150 
3152  return TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>();
3153 }
3154 
3155 void
3156 FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
3157  FunctionDecl *FD,
3159  assert(TemplateOrSpecialization.isNull() &&
3160  "Member function is already a specialization");
3162  = new (C) MemberSpecializationInfo(FD, TSK);
3163  TemplateOrSpecialization = Info;
3164 }
3165 
3167  return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl *>();
3168 }
3169 
3171  TemplateOrSpecialization = Template;
3172 }
3173 
3175  // If the function is invalid, it can't be implicitly instantiated.
3176  if (isInvalidDecl())
3177  return false;
3178 
3179  switch (getTemplateSpecializationKind()) {
3180  case TSK_Undeclared:
3182  return false;
3183 
3185  return true;
3186 
3187  // It is possible to instantiate TSK_ExplicitSpecialization kind
3188  // if the FunctionDecl has a class scope specialization pattern.
3190  return getClassScopeSpecializationPattern() != nullptr;
3191 
3193  // Handled below.
3194  break;
3195  }
3196 
3197  // Find the actual template from which we will instantiate.
3198  const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
3199  bool HasPattern = false;
3200  if (PatternDecl)
3201  HasPattern = PatternDecl->hasBody(PatternDecl);
3202 
3203  // C++0x [temp.explicit]p9:
3204  // Except for inline functions, other explicit instantiation declarations
3205  // have the effect of suppressing the implicit instantiation of the entity
3206  // to which they refer.
3207  if (!HasPattern || !PatternDecl)
3208  return true;
3209 
3210  return PatternDecl->isInlined();
3211 }
3212 
3214  switch (getTemplateSpecializationKind()) {
3215  case TSK_Undeclared:
3217  return false;
3221  return true;
3222  }
3223  llvm_unreachable("All TSK values handled.");
3224 }
3225 
3227  // Handle class scope explicit specialization special case.
3229  if (auto *Spec = getClassScopeSpecializationPattern())
3230  return getDefinitionOrSelf(Spec);
3231  return nullptr;
3232  }
3233 
3234  // If this is a generic lambda call operator specialization, its
3235  // instantiation pattern is always its primary template's pattern
3236  // even if its primary template was instantiated from another
3237  // member template (which happens with nested generic lambdas).
3238  // Since a lambda's call operator's body is transformed eagerly,
3239  // we don't have to go hunting for a prototype definition template
3240  // (i.e. instantiated-from-member-template) to use as an instantiation
3241  // pattern.
3242 
3244  dyn_cast<CXXMethodDecl>(this))) {
3245  assert(getPrimaryTemplate() && "not a generic lambda call operator?");
3246  return getDefinitionOrSelf(getPrimaryTemplate()->getTemplatedDecl());
3247  }
3248 
3249  if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
3250  while (Primary->getInstantiatedFromMemberTemplate()) {
3251  // If we have hit a point where the user provided a specialization of
3252  // this template, we're done looking.
3253  if (Primary->isMemberSpecialization())
3254  break;
3255  Primary = Primary->getInstantiatedFromMemberTemplate();
3256  }
3257 
3258  return getDefinitionOrSelf(Primary->getTemplatedDecl());
3259  }
3260 
3261  if (auto *MFD = getInstantiatedFromMemberFunction())
3262  return getDefinitionOrSelf(MFD);
3263 
3264  return nullptr;
3265 }
3266 
3269  = TemplateOrSpecialization
3270  .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3271  return Info->Template.getPointer();
3272  }
3273  return nullptr;
3274 }
3275 
3278 }
3279 
3282  return TemplateOrSpecialization
3283  .dyn_cast<FunctionTemplateSpecializationInfo *>();
3284 }
3285 
3286 const TemplateArgumentList *
3289  = TemplateOrSpecialization
3290  .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3291  return Info->TemplateArguments;
3292  }
3293  return nullptr;
3294 }
3295 
3299  = TemplateOrSpecialization
3300  .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3301  return Info->TemplateArgumentsAsWritten;
3302  }
3303  return nullptr;
3304 }
3305 
3306 void
3307 FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
3308  FunctionTemplateDecl *Template,
3309  const TemplateArgumentList *TemplateArgs,
3310  void *InsertPos,
3312  const TemplateArgumentListInfo *TemplateArgsAsWritten,
3313  SourceLocation PointOfInstantiation) {
3314  assert(TSK != TSK_Undeclared &&
3315  "Must specify the type of function template specialization");
3317  = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
3318  if (!Info)
3319  Info = FunctionTemplateSpecializationInfo::Create(C, this, Template, TSK,
3320  TemplateArgs,
3321  TemplateArgsAsWritten,
3322  PointOfInstantiation);
3323  TemplateOrSpecialization = Info;
3324  Template->addSpecialization(Info, InsertPos);
3325 }
3326 
3327 void
3329  const UnresolvedSetImpl &Templates,
3330  const TemplateArgumentListInfo &TemplateArgs) {
3331  assert(TemplateOrSpecialization.isNull());
3334  TemplateArgs);
3335  TemplateOrSpecialization = Info;
3336 }
3337 
3340  return TemplateOrSpecialization
3342 }
3343 
3346  ASTContext &Context, const UnresolvedSetImpl &Ts,
3347  const TemplateArgumentListInfo &TArgs) {
3348  void *Buffer = Context.Allocate(
3349  totalSizeToAlloc<TemplateArgumentLoc, FunctionTemplateDecl *>(
3350  TArgs.size(), Ts.size()));
3351  return new (Buffer) DependentFunctionTemplateSpecializationInfo(Ts, TArgs);
3352 }
3353 
3354 DependentFunctionTemplateSpecializationInfo::
3355 DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
3356  const TemplateArgumentListInfo &TArgs)
3357  : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
3358 
3359  NumTemplates = Ts.size();
3360  NumArgs = TArgs.size();
3361 
3362  FunctionTemplateDecl **TsArray = getTrailingObjects<FunctionTemplateDecl *>();
3363  for (unsigned I = 0, E = Ts.size(); I != E; ++I)
3364  TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
3365 
3366  TemplateArgumentLoc *ArgsArray = getTrailingObjects<TemplateArgumentLoc>();
3367  for (unsigned I = 0, E = TArgs.size(); I != E; ++I)
3368  new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]);
3369 }
3370 
3372  // For a function template specialization, query the specialization
3373  // information object.
3375  = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>();
3376  if (FTSInfo)
3377  return FTSInfo->getTemplateSpecializationKind();
3378 
3379  MemberSpecializationInfo *MSInfo
3380  = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
3381  if (MSInfo)
3382  return MSInfo->getTemplateSpecializationKind();
3383 
3384  return TSK_Undeclared;
3385 }
3386 
3387 void
3389  SourceLocation PointOfInstantiation) {
3391  = TemplateOrSpecialization.dyn_cast<
3393  FTSInfo->setTemplateSpecializationKind(TSK);
3394  if (TSK != TSK_ExplicitSpecialization &&
3395  PointOfInstantiation.isValid() &&
3396  FTSInfo->getPointOfInstantiation().isInvalid())
3397  FTSInfo->setPointOfInstantiation(PointOfInstantiation);
3398  } else if (MemberSpecializationInfo *MSInfo
3399  = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) {
3400  MSInfo->setTemplateSpecializationKind(TSK);
3401  if (TSK != TSK_ExplicitSpecialization &&
3402  PointOfInstantiation.isValid() &&
3403  MSInfo->getPointOfInstantiation().isInvalid())
3404  MSInfo->setPointOfInstantiation(PointOfInstantiation);
3405  } else
3406  llvm_unreachable("Function cannot have a template specialization kind");
3407 }
3408 
3411  = TemplateOrSpecialization.dyn_cast<
3413  return FTSInfo->getPointOfInstantiation();
3414  else if (MemberSpecializationInfo *MSInfo
3415  = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>())
3416  return MSInfo->getPointOfInstantiation();
3417 
3418  return SourceLocation();
3419 }
3420 
3422  if (Decl::isOutOfLine())
3423  return true;
3424 
3425  // If this function was instantiated from a member function of a
3426  // class template, check whether that member function was defined out-of-line.
3427  if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) {
3428  const FunctionDecl *Definition;
3429  if (FD->hasBody(Definition))
3430  return Definition->isOutOfLine();
3431  }
3432 
3433  // If this function was instantiated from a function template,
3434  // check whether that function template was defined out-of-line.
3435  if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) {
3436  const FunctionDecl *Definition;
3437  if (FunTmpl->getTemplatedDecl()->hasBody(Definition))
3438  return Definition->isOutOfLine();
3439  }
3440 
3441  return false;
3442 }
3443 
3445  return SourceRange(getOuterLocStart(), EndRangeLoc);
3446 }
3447 
3449  IdentifierInfo *FnInfo = getIdentifier();
3450 
3451  if (!FnInfo)
3452  return 0;
3453 
3454  // Builtin handling.
3455  switch (getBuiltinID()) {
3456  case Builtin::BI__builtin_memset:
3457  case Builtin::BI__builtin___memset_chk:
3458  case Builtin::BImemset:
3459  return Builtin::BImemset;
3460 
3461  case Builtin::BI__builtin_memcpy:
3462  case Builtin::BI__builtin___memcpy_chk:
3463  case Builtin::BImemcpy:
3464  return Builtin::BImemcpy;
3465 
3466  case Builtin::BI__builtin_memmove:
3467  case Builtin::BI__builtin___memmove_chk:
3468  case Builtin::BImemmove:
3469  return Builtin::BImemmove;
3470 
3471  case Builtin::BIstrlcpy:
3472  case Builtin::BI__builtin___strlcpy_chk:
3473  return Builtin::BIstrlcpy;
3474 
3475  case Builtin::BIstrlcat:
3476  case Builtin::BI__builtin___strlcat_chk:
3477  return Builtin::BIstrlcat;
3478 
3479  case Builtin::BI__builtin_memcmp:
3480  case Builtin::BImemcmp:
3481  return Builtin::BImemcmp;
3482 
3483  case Builtin::BI__builtin_strncpy:
3484  case Builtin::BI__builtin___strncpy_chk:
3485  case Builtin::BIstrncpy:
3486  return Builtin::BIstrncpy;
3487 
3488  case Builtin::BI__builtin_strncmp:
3489  case Builtin::BIstrncmp:
3490  return Builtin::BIstrncmp;
3491 
3492  case Builtin::BI__builtin_strncasecmp:
3493  case Builtin::BIstrncasecmp:
3494  return Builtin::BIstrncasecmp;
3495 
3496  case Builtin::BI__builtin_strncat:
3497  case Builtin::BI__builtin___strncat_chk:
3498  case Builtin::BIstrncat:
3499  return Builtin::BIstrncat;
3500 
3501  case Builtin::BI__builtin_strndup:
3502  case Builtin::BIstrndup:
3503  return Builtin::BIstrndup;
3504 
3505  case Builtin::BI__builtin_strlen:
3506  case Builtin::BIstrlen:
3507  return Builtin::BIstrlen;
3508 
3509  case Builtin::BI__builtin_bzero:
3510  case Builtin::BIbzero:
3511  return Builtin::BIbzero;
3512 
3513  default:
3514  if (isExternC()) {
3515  if (FnInfo->isStr("memset"))
3516  return Builtin::BImemset;
3517  else if (FnInfo->isStr("memcpy"))
3518  return Builtin::BImemcpy;
3519  else if (FnInfo->isStr("memmove"))
3520  return Builtin::BImemmove;
3521  else if (FnInfo->isStr("memcmp"))
3522  return Builtin::BImemcmp;
3523  else if (FnInfo->isStr("strncpy"))
3524  return Builtin::BIstrncpy;
3525  else if (FnInfo->isStr("strncmp"))
3526  return Builtin::BIstrncmp;
3527  else if (FnInfo->isStr("strncasecmp"))
3528  return Builtin::BIstrncasecmp;
3529  else if (FnInfo->isStr("strncat"))
3530  return Builtin::BIstrncat;
3531  else if (FnInfo->isStr("strndup"))
3532  return Builtin::BIstrndup;
3533  else if (FnInfo->isStr("strlen"))
3534  return Builtin::BIstrlen;
3535  else if (FnInfo->isStr("bzero"))
3536  return Builtin::BIbzero;
3537  }
3538  break;
3539  }
3540  return 0;
3541 }
3542 
3543 //===----------------------------------------------------------------------===//
3544 // FieldDecl Implementation
3545 //===----------------------------------------------------------------------===//
3546 
3548  SourceLocation StartLoc, SourceLocation IdLoc,
3550  TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
3551  InClassInitStyle InitStyle) {
3552  return new (C, DC) FieldDecl(Decl::Field, DC, StartLoc, IdLoc, Id, T, TInfo,
3553  BW, Mutable, InitStyle);
3554 }
3555 
3557  return new (C, ID) FieldDecl(Field, nullptr, SourceLocation(),
3558  SourceLocation(), nullptr, QualType(), nullptr,
3559  nullptr, false, ICIS_NoInit);
3560 }
3561 
3563  if (!isImplicit() || getDeclName())
3564  return false;
3565 
3566  if (const auto *Record = getType()->getAs<RecordType>())
3567  return Record->getDecl()->isAnonymousStructOrUnion();
3568 
3569  return false;
3570 }
3571 
3572 unsigned FieldDecl::getBitWidthValue(const ASTContext &Ctx) const {
3573  assert(isBitField() && "not a bitfield");
3574  return getBitWidth()->EvaluateKnownConstInt(Ctx).getZExtValue();
3575 }
3576 
3577 unsigned FieldDecl::getFieldIndex() const {
3578  const FieldDecl *Canonical = getCanonicalDecl();
3579  if (Canonical != this)
3580  return Canonical->getFieldIndex();
3581 
3582  if (CachedFieldIndex) return CachedFieldIndex - 1;
3583 
3584  unsigned Index = 0;
3585  const RecordDecl *RD = getParent();
3586 
3587  for (auto *Field : RD->fields()) {
3588  Field->getCanonicalDecl()->CachedFieldIndex = Index + 1;
3589  ++Index;
3590  }
3591 
3592  assert(CachedFieldIndex && "failed to find field in parent");
3593  return CachedFieldIndex - 1;
3594 }
3595 
3597  const Expr *FinalExpr = getInClassInitializer();
3598  if (!FinalExpr)
3599  FinalExpr = getBitWidth();
3600  if (FinalExpr)
3601  return SourceRange(getInnerLocStart(), FinalExpr->getLocEnd());
3603 }
3604 
3606  assert((getParent()->isLambda() || getParent()->isCapturedRecord()) &&
3607  "capturing type in non-lambda or captured record.");
3608  assert(InitStorage.getInt() == ISK_NoInit &&
3609  InitStorage.getPointer() == nullptr &&
3610  "bit width, initializer or captured type already set");
3611  InitStorage.setPointerAndInt(const_cast<VariableArrayType *>(VLAType),
3612  ISK_CapturedVLAType);
3613 }
3614 
3615 //===----------------------------------------------------------------------===//
3616 // TagDecl Implementation
3617 //===----------------------------------------------------------------------===//
3618 
3620  return getTemplateOrInnerLocStart(this);
3621 }
3622 
3624  SourceLocation RBraceLoc = BraceRange.getEnd();
3625  SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
3626  return SourceRange(getOuterLocStart(), E);
3627 }
3628 
3630 
3632  TypedefNameDeclOrQualifier = TDD;
3633  if (const Type *T = getTypeForDecl()) {
3634  (void)T;
3635  assert(T->isLinkageValid());
3636  }
3637  assert(isLinkageValid());
3638 }
3639 
3641  IsBeingDefined = true;
3642 
3643  if (auto *D = dyn_cast<CXXRecordDecl>(this)) {
3644  struct CXXRecordDecl::DefinitionData *Data =
3645  new (getASTContext()) struct CXXRecordDecl::DefinitionData(D);
3646  for (auto I : redecls())
3647  cast<CXXRecordDecl>(I)->DefinitionData = Data;
3648  }
3649 }
3650 
3652  assert((!isa<CXXRecordDecl>(this) ||
3653  cast<CXXRecordDecl>(this)->hasDefinition()) &&
3654  "definition completed but not started");
3655 
3656  IsCompleteDefinition = true;
3657  IsBeingDefined = false;
3658 
3660  L->CompletedTagDefinition(this);
3661 }
3662 
3664  if (isCompleteDefinition())
3665  return const_cast<TagDecl *>(this);
3666 
3667  // If it's possible for us to have an out-of-date definition, check now.
3668  if (MayHaveOutOfDateDef) {
3669  if (IdentifierInfo *II = getIdentifier()) {
3670  if (II->isOutOfDate()) {
3671  updateOutOfDate(*II);
3672  }
3673  }
3674  }
3675 
3676  if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(this))
3677  return CXXRD->getDefinition();
3678 
3679  for (auto R : redecls())
3680  if (R->isCompleteDefinition())
3681  return R;
3682 
3683  return nullptr;
3684 }
3685 
3687  if (QualifierLoc) {
3688  // Make sure the extended qualifier info is allocated.
3689  if (!hasExtInfo())
3690  TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
3691  // Set qualifier info.
3692  getExtInfo()->QualifierLoc = QualifierLoc;
3693  } else {
3694  // Here Qualifier == 0, i.e., we are removing the qualifier (if any).
3695  if (hasExtInfo()) {
3696  if (getExtInfo()->NumTemplParamLists == 0) {
3697  getASTContext().Deallocate(getExtInfo());
3698  TypedefNameDeclOrQualifier = (TypedefNameDecl *)nullptr;
3699  }
3700  else
3701  getExtInfo()->QualifierLoc = QualifierLoc;
3702  }
3703  }
3704 }
3705 
3707  ASTContext &Context, ArrayRef<TemplateParameterList *> TPLists) {
3708  assert(!TPLists.empty());
3709  // Make sure the extended decl info is allocated.
3710  if (!hasExtInfo())
3711  // Allocate external info struct.
3712  TypedefNameDeclOrQualifier = new (getASTContext()) ExtInfo;
3713  // Set the template parameter lists info.
3714  getExtInfo()->setTemplateParameterListsInfo(Context, TPLists);
3715 }
3716 
3717 //===----------------------------------------------------------------------===//
3718 // EnumDecl Implementation
3719 //===----------------------------------------------------------------------===//
3720 
3721 void EnumDecl::anchor() { }
3722 
3724  SourceLocation StartLoc, SourceLocation IdLoc,
3725  IdentifierInfo *Id,
3726  EnumDecl *PrevDecl, bool IsScoped,
3727  bool IsScopedUsingClassTag, bool IsFixed) {
3728  auto *Enum = new (C, DC) EnumDecl(C, DC, StartLoc, IdLoc, Id, PrevDecl,
3729  IsScoped, IsScopedUsingClassTag, IsFixed);
3730  Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3731  C.getTypeDeclType(Enum, PrevDecl);
3732  return Enum;
3733 }
3734 
3736  EnumDecl *Enum =
3737  new (C, ID) EnumDecl(C, nullptr, SourceLocation(), SourceLocation(),
3738  nullptr, nullptr, false, false, false);
3739  Enum->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3740  return Enum;
3741 }
3742 
3744  if (const TypeSourceInfo *TI = getIntegerTypeSourceInfo())
3745  return TI->getTypeLoc().getSourceRange();
3746  return SourceRange();
3747 }
3748 
3750  QualType NewPromotionType,
3751  unsigned NumPositiveBits,
3752  unsigned NumNegativeBits) {
3753  assert(!isCompleteDefinition() && "Cannot redefine enums!");
3754  if (!IntegerType)
3755  IntegerType = NewType.getTypePtr();
3756  PromotionType = NewPromotionType;
3757  setNumPositiveBits(NumPositiveBits);
3758  setNumNegativeBits(NumNegativeBits);
3760 }
3761 
3762 bool EnumDecl::isClosed() const {
3763  if (const auto *A = getAttr<EnumExtensibilityAttr>())
3764  return A->getExtensibility() == EnumExtensibilityAttr::Closed;
3765  return true;
3766 }
3767 
3769  return isClosed() && hasAttr<FlagEnumAttr>();
3770 }
3771 
3773  return isClosed() && !hasAttr<FlagEnumAttr>();
3774 }
3775 
3778  return MSI->getTemplateSpecializationKind();
3779 
3780  return TSK_Undeclared;
3781 }
3782 
3784  SourceLocation PointOfInstantiation) {
3786  assert(MSI && "Not an instantiated member enumeration?");
3788  if (TSK != TSK_ExplicitSpecialization &&
3789  PointOfInstantiation.isValid() &&
3791  MSI->setPointOfInstantiation(PointOfInstantiation);
3792 }
3793 
3796  if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
3797  EnumDecl *ED = getInstantiatedFromMemberEnum();
3798  while (auto *NewED = ED->getInstantiatedFromMemberEnum())
3799  ED = NewED;
3800  return getDefinitionOrSelf(ED);
3801  }
3802  }
3803 
3805  "couldn't find pattern for enum instantiation");
3806  return nullptr;
3807 }
3808 
3810  if (SpecializationInfo)
3811  return cast<EnumDecl>(SpecializationInfo->getInstantiatedFrom());
3812 
3813  return nullptr;
3814 }
3815 
3816 void EnumDecl::setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3818  assert(!SpecializationInfo && "Member enum is already a specialization");
3819  SpecializationInfo = new (C) MemberSpecializationInfo(ED, TSK);
3820 }
3821 
3822 //===----------------------------------------------------------------------===//
3823 // RecordDecl Implementation
3824 //===----------------------------------------------------------------------===//
3825 
3827  DeclContext *DC, SourceLocation StartLoc,
3829  RecordDecl *PrevDecl)
3830  : TagDecl(DK, TK, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
3831  HasFlexibleArrayMember = false;
3832  AnonymousStructOrUnion = false;
3833  HasObjectMember = false;
3834  HasVolatileMember = false;
3835  LoadedFieldsFromExternalStorage = false;
3836  assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!");
3837 }
3838 
3840  SourceLocation StartLoc, SourceLocation IdLoc,
3841  IdentifierInfo *Id, RecordDecl* PrevDecl) {
3842  RecordDecl *R = new (C, DC) RecordDecl(Record, TK, C, DC,
3843  StartLoc, IdLoc, Id, PrevDecl);
3844  R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3845 
3846  C.getTypeDeclType(R, PrevDecl);
3847  return R;
3848 }
3849 
3851  RecordDecl *R =
3852  new (C, ID) RecordDecl(Record, TTK_Struct, C, nullptr, SourceLocation(),
3853  SourceLocation(), nullptr, nullptr);
3854  R->MayHaveOutOfDateDef = C.getLangOpts().Modules;
3855  return R;
3856 }
3857 
3859  return isImplicit() && getDeclName() && getDeclContext()->isRecord() &&
3860  cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName();
3861 }
3862 
3863 bool RecordDecl::isLambda() const {
3864  if (auto RD = dyn_cast<CXXRecordDecl>(this))
3865  return RD->isLambda();
3866  return false;
3867 }
3868 
3870  return hasAttr<CapturedRecordAttr>();
3871 }
3872 
3874  addAttr(CapturedRecordAttr::CreateImplicit(getASTContext()));
3875 }
3876 
3878  if (hasExternalLexicalStorage() && !LoadedFieldsFromExternalStorage)
3879  LoadFieldsFromExternalStorage();
3880 
3882 }
3883 
3884 /// completeDefinition - Notes that the definition of this type is now
3885 /// complete.
3887  assert(!isCompleteDefinition() && "Cannot redefine record!");
3889 }
3890 
3891 /// isMsStruct - Get whether or not this record uses ms_struct layout.
3892 /// This which can be turned on with an attribute, pragma, or the
3893 /// -mms-bitfields command-line option.
3894 bool RecordDecl::isMsStruct(const ASTContext &C) const {
3895  return hasAttr<MSStructAttr>() || C.getLangOpts().MSBitfields == 1;
3896 }
3897 
3898 void RecordDecl::LoadFieldsFromExternalStorage() const {
3900  assert(hasExternalLexicalStorage() && Source && "No external storage?");
3901 
3902  // Notify that we have a RecordDecl doing some initialization.
3903  ExternalASTSource::Deserializing TheFields(Source);
3904 
3905  SmallVector<Decl*, 64> Decls;
3906  LoadedFieldsFromExternalStorage = true;
3907  Source->FindExternalLexicalDecls(this, [](Decl::Kind K) {
3909  }, Decls);
3910 
3911 #ifndef NDEBUG
3912  // Check that all decls we got were FieldDecls.
3913  for (unsigned i=0, e=Decls.size(); i != e; ++i)
3914  assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
3915 #endif
3916 
3917  if (Decls.empty())
3918  return;
3919 
3920  std::tie(FirstDecl, LastDecl) = BuildDeclChain(Decls,
3921  /*FieldsAlreadyLoaded=*/false);
3922 }
3923 
3924 bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
3925  ASTContext &Context = getASTContext();
3926  if (!Context.getLangOpts().Sanitize.hasOneOf(
3927  SanitizerKind::Address | SanitizerKind::KernelAddress) ||
3928  !Context.getLangOpts().SanitizeAddressFieldPadding)
3929  return false;
3930  const auto &Blacklist = Context.getSanitizerBlacklist();
3931  const auto *CXXRD = dyn_cast<CXXRecordDecl>(this);
3932  // We may be able to relax some of these requirements.
3933  int ReasonToReject = -1;
3934  if (!CXXRD || CXXRD->isExternCContext())
3935  ReasonToReject = 0; // is not C++.
3936  else if (CXXRD->hasAttr<PackedAttr>())
3937  ReasonToReject = 1; // is packed.
3938  else if (CXXRD->isUnion())
3939  ReasonToReject = 2; // is a union.
3940  else if (CXXRD->isTriviallyCopyable())
3941  ReasonToReject = 3; // is trivially copyable.
3942  else if (CXXRD->hasTrivialDestructor())
3943  ReasonToReject = 4; // has trivial destructor.
3944  else if (CXXRD->isStandardLayout())
3945  ReasonToReject = 5; // is standard layout.
3946  else if (Blacklist.isBlacklistedLocation(getLocation(), "field-padding"))
3947  ReasonToReject = 6; // is in a blacklisted file.
3948  else if (Blacklist.isBlacklistedType(getQualifiedNameAsString(),
3949  "field-padding"))
3950  ReasonToReject = 7; // is blacklisted.
3951 
3952  if (EmitRemark) {
3953  if (ReasonToReject >= 0)
3954  Context.getDiagnostics().Report(
3955  getLocation(),
3956  diag::remark_sanitize_address_insert_extra_padding_rejected)
3957  << getQualifiedNameAsString() << ReasonToReject;
3958  else
3959  Context.getDiagnostics().Report(
3960  getLocation(),
3961  diag::remark_sanitize_address_insert_extra_padding_accepted)
3963  }
3964  return ReasonToReject < 0;
3965 }
3966 
3968  for (const auto *I : fields()) {
3969  if (I->getIdentifier())
3970  return I;
3971 
3972  if (const auto *RT = I->getType()->getAs<RecordType>())
3973  if (const FieldDecl *NamedDataMember =
3974  RT->getDecl()->findFirstNamedDataMember())
3975  return NamedDataMember;
3976  }
3977 
3978  // We didn't find a named data member.
3979  return nullptr;
3980 }
3981 
3982 
3983 //===----------------------------------------------------------------------===//
3984 // BlockDecl Implementation
3985 //===----------------------------------------------------------------------===//
3986 
3988  assert(!ParamInfo && "Already has param info!");
3989 
3990  // Zero params -> null pointer.
3991  if (!NewParamInfo.empty()) {
3992  NumParams = NewParamInfo.size();
3993  ParamInfo = new (getASTContext()) ParmVarDecl*[NewParamInfo.size()];
3994  std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3995  }
3996 }
3997 
3999  bool CapturesCXXThis) {
4000  this->CapturesCXXThis = CapturesCXXThis;
4001  this->NumCaptures = Captures.size();
4002 
4003  if (Captures.empty()) {
4004  this->Captures = nullptr;
4005  return;
4006  }
4007 
4008  this->Captures = Captures.copy(Context).data();
4009 }
4010 
4011 bool BlockDecl::capturesVariable(const VarDecl *variable) const {
4012  for (const auto &I : captures())
4013  // Only auto vars can be captured, so no redeclaration worries.
4014  if (I.getVariable() == variable)
4015  return true;
4016 
4017  return false;
4018 }
4019 
4021  return SourceRange(getLocation(), Body? Body->getLocEnd() : getLocation());
4022 }
4023 
4024 //===----------------------------------------------------------------------===//
4025 // Other Decl Allocation/Deallocation Method Implementations
4026 //===----------------------------------------------------------------------===//
4027 
4028 void TranslationUnitDecl::anchor() { }
4029 
4031  return new (C, (DeclContext *)nullptr) TranslationUnitDecl(C);
4032 }
4033 
4034 void PragmaCommentDecl::anchor() { }
4035 
4037  TranslationUnitDecl *DC,
4038  SourceLocation CommentLoc,
4039  PragmaMSCommentKind CommentKind,
4040  StringRef Arg) {
4041  PragmaCommentDecl *PCD =
4042  new (C, DC, additionalSizeToAlloc<char>(Arg.size() + 1))
4043  PragmaCommentDecl(DC, CommentLoc, CommentKind);
4044  memcpy(PCD->getTrailingObjects<char>(), Arg.data(), Arg.size());
4045  PCD->getTrailingObjects<char>()[Arg.size()] = '\0';
4046  return PCD;
4047 }
4048 
4050  unsigned ID,
4051  unsigned ArgSize) {
4052  return new (C, ID, additionalSizeToAlloc<char>(ArgSize + 1))
4054 }
4055 
4056 void PragmaDetectMismatchDecl::anchor() { }
4057 
4060  SourceLocation Loc, StringRef Name,
4061  StringRef Value) {
4062  size_t ValueStart = Name.size() + 1;
4063  PragmaDetectMismatchDecl *PDMD =
4064  new (C, DC, additionalSizeToAlloc<char>(ValueStart + Value.size() + 1))
4065  PragmaDetectMismatchDecl(DC, Loc, ValueStart);
4066  memcpy(PDMD->getTrailingObjects<char>(), Name.data(), Name.size());
4067  PDMD->getTrailingObjects<char>()[Name.size()] = '\0';
4068  memcpy(PDMD->getTrailingObjects<char>() + ValueStart, Value.data(),
4069  Value.size());
4070  PDMD->getTrailingObjects<char>()[ValueStart + Value.size()] = '\0';
4071  return PDMD;
4072 }
4073 
4076  unsigned NameValueSize) {
4077  return new (C, ID, additionalSizeToAlloc<char>(NameValueSize + 1))
4079 }
4080 
4081 void ExternCContextDecl::anchor() { }
4082 
4084  TranslationUnitDecl *DC) {
4085  return new (C, DC) ExternCContextDecl(DC);
4086 }
4087 
4088 void LabelDecl::anchor() { }
4089 
4091  SourceLocation IdentL, IdentifierInfo *II) {
4092  return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, IdentL);
4093 }
4094 
4096  SourceLocation IdentL, IdentifierInfo *II,
4097  SourceLocation GnuLabelL) {
4098  assert(GnuLabelL != IdentL && "Use this only for GNU local labels");
4099  return new (C, DC) LabelDecl(DC, IdentL, II, nullptr, GnuLabelL);
4100 }
4101 
4103  return new (C, ID) LabelDecl(nullptr, SourceLocation(), nullptr, nullptr,
4104  SourceLocation());
4105 }
4106 
4107 void LabelDecl::setMSAsmLabel(StringRef Name) {
4108  char *Buffer = new (getASTContext(), 1) char[Name.size() + 1];
4109  memcpy(Buffer, Name.data(), Name.size());
4110  Buffer[Name.size()] = '\0';
4111  MSAsmName = Buffer;
4112 }
4113 
4114 void ValueDecl::anchor() { }
4115 
4116 bool ValueDecl::isWeak() const {
4117  for (const auto *I : attrs())
4118  if (isa<WeakAttr>(I) || isa<WeakRefAttr>(I))
4119  return true;
4120 
4121  return isWeakImported();
4122 }
4123 
4124 void ImplicitParamDecl::anchor() { }
4125 
4127  SourceLocation IdLoc,
4129  ImplicitParamKind ParamKind) {
4130  return new (C, DC) ImplicitParamDecl(C, DC, IdLoc, Id, Type, ParamKind);
4131 }
4132 
4134  ImplicitParamKind ParamKind) {
4135  return new (C, nullptr) ImplicitParamDecl(C, Type, ParamKind);
4136 }
4137 
4139  unsigned ID) {
4140  return new (C, ID) ImplicitParamDecl(C, QualType(), ImplicitParamKind::Other);
4141 }
4142 
4144  SourceLocation StartLoc,
4145  const DeclarationNameInfo &NameInfo,
4146  QualType T, TypeSourceInfo *TInfo,
4147  StorageClass SC,
4148  bool isInlineSpecified,
4149  bool hasWrittenPrototype,
4150  bool isConstexprSpecified) {
4151  FunctionDecl *New =
4152  new (C, DC) FunctionDecl(Function, C, DC, StartLoc, NameInfo, T, TInfo,
4153  SC, isInlineSpecified, isConstexprSpecified);
4154  New->HasWrittenPrototype = hasWrittenPrototype;
4155  return New;
4156 }
4157 
4159  return new (C, ID) FunctionDecl(Function, C, nullptr, SourceLocation(),
4160  DeclarationNameInfo(), QualType(), nullptr,
4161  SC_None, false, false);
4162 }
4163 
4165  return new (C, DC) BlockDecl(DC, L);
4166 }
4167 
4169  return new (C, ID) BlockDecl(nullptr, SourceLocation());
4170 }
4171 
4172 CapturedDecl::CapturedDecl(DeclContext *DC, unsigned NumParams)
4173  : Decl(Captured, DC, SourceLocation()), DeclContext(Captured),
4174  NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr, false) {}
4175 
4177  unsigned NumParams) {
4178  return new (C, DC, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
4179  CapturedDecl(DC, NumParams);
4180 }
4181 
4183  unsigned NumParams) {
4184  return new (C, ID, additionalSizeToAlloc<ImplicitParamDecl *>(NumParams))
4185  CapturedDecl(nullptr, NumParams);
4186 }
4187 
4188 Stmt *CapturedDecl::getBody() const { return BodyAndNothrow.getPointer(); }
4189 void CapturedDecl::setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
4190 
4191 bool CapturedDecl::isNothrow() const { return BodyAndNothrow.getInt(); }
4192 void CapturedDecl::setNothrow(bool Nothrow) { BodyAndNothrow.setInt(Nothrow); }
4193 
4195  SourceLocation L,
4197  Expr *E, const llvm::APSInt &V) {
4198  return new (C, CD) EnumConstantDecl(CD, L, Id, T, E, V);
4199 }
4200 
4203  return new (C, ID) EnumConstantDecl(nullptr, SourceLocation(), nullptr,
4204  QualType(), nullptr, llvm::APSInt());
4205 }
4206 
4207 void IndirectFieldDecl::anchor() { }
4208 
4209 IndirectFieldDecl::IndirectFieldDecl(ASTContext &C, DeclContext *DC,
4211  QualType T,
4213  : ValueDecl(IndirectField, DC, L, N, T), Chaining(CH.data()),
4214  ChainingSize(CH.size()) {
4215  // In C++, indirect field declarations conflict with tag declarations in the
4216  // same scope, so add them to IDNS_Tag so that tag redeclaration finds them.
4217  if (C.getLangOpts().CPlusPlus)
4219 }
4220 
4225  return new (C, DC) IndirectFieldDecl(C, DC, L, Id, T, CH);
4226 }
4227 
4229  unsigned ID) {
4230  return new (C, ID) IndirectFieldDecl(C, nullptr, SourceLocation(),
4231  DeclarationName(), QualType(), None);
4232 }
4233 
4236  if (Init)
4237  End = Init->getLocEnd();
4238  return SourceRange(getLocation(), End);
4239 }
4240 
4241 void TypeDecl::anchor() { }
4242 
4244  SourceLocation StartLoc, SourceLocation IdLoc,
4245  IdentifierInfo *Id, TypeSourceInfo *TInfo) {
4246  return new (C, DC) TypedefDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
4247 }
4248 
4249 void TypedefNameDecl::anchor() { }
4250 
4252  if (auto *TT = getTypeSourceInfo()->getType()->getAs<TagType>()) {
4253  auto *OwningTypedef = TT->getDecl()->getTypedefNameForAnonDecl();
4254  auto *ThisTypedef = this;
4255  if (AnyRedecl && OwningTypedef) {
4256  OwningTypedef = OwningTypedef->getCanonicalDecl();
4257  ThisTypedef = ThisTypedef->getCanonicalDecl();
4258  }
4259  if (OwningTypedef == ThisTypedef)
4260  return TT->getDecl();
4261  }
4262 
4263  return nullptr;
4264 }
4265 
4266 bool TypedefNameDecl::isTransparentTagSlow() const {
4267  auto determineIsTransparent = [&]() {
4268  if (auto *TT = getUnderlyingType()->getAs<TagType>()) {
4269  if (auto *TD = TT->getDecl()) {
4270  if (TD->getName() != getName())
4271  return false;
4272  SourceLocation TTLoc = getLocation();
4273  SourceLocation TDLoc = TD->getLocation();
4274  if (!TTLoc.isMacroID() || !TDLoc.isMacroID())
4275  return false;
4277  return SM.getSpellingLoc(TTLoc) == SM.getSpellingLoc(TDLoc);
4278  }
4279  }
4280  return false;
4281  };
4282 
4283  bool isTransparent = determineIsTransparent();
4284  CacheIsTransparentTag = 1;
4285  if (isTransparent)
4286  CacheIsTransparentTag |= 0x2;
4287  return isTransparent;
4288 }
4289 
4291  return new (C, ID) TypedefDecl(C, nullptr, SourceLocation(), SourceLocation(),
4292  nullptr, nullptr);
4293 }
4294 
4296  SourceLocation StartLoc,
4298  TypeSourceInfo *TInfo) {
4299  return new (C, DC) TypeAliasDecl(C, DC, StartLoc, IdLoc, Id, TInfo);
4300 }
4301 
4303  return new (C, ID) TypeAliasDecl(C, nullptr, SourceLocation(),
4304  SourceLocation(), nullptr, nullptr);
4305 }
4306 
4308  SourceLocation RangeEnd = getLocation();
4309  if (TypeSourceInfo *TInfo = getTypeSourceInfo()) {
4310  if (typeIsPostfix(TInfo->getType()))
4311  RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
4312  }
4313  return SourceRange(getLocStart(), RangeEnd);
4314 }
4315 
4317  SourceLocation RangeEnd = getLocStart();
4318  if (TypeSourceInfo *TInfo = getTypeSourceInfo())
4319  RangeEnd = TInfo->getTypeLoc().getSourceRange().getEnd();
4320  return SourceRange(getLocStart(), RangeEnd);
4321 }
4322 
4323 void FileScopeAsmDecl::anchor() { }
4324 
4326  StringLiteral *Str,
4327  SourceLocation AsmLoc,
4328  SourceLocation RParenLoc) {
4329  return new (C, DC) FileScopeAsmDecl(DC, Str, AsmLoc, RParenLoc);
4330 }
4331 
4333  unsigned ID) {
4334  return new (C, ID) FileScopeAsmDecl(nullptr, nullptr, SourceLocation(),
4335  SourceLocation());
4336 }
4337 
4338 void EmptyDecl::anchor() {}
4339 
4341  return new (C, DC) EmptyDecl(DC, L);
4342 }
4343 
4345  return new (C, ID) EmptyDecl(nullptr, SourceLocation());
4346 }
4347 
4348 //===----------------------------------------------------------------------===//
4349 // ImportDecl Implementation
4350 //===----------------------------------------------------------------------===//
4351 
4352 /// \brief Retrieve the number of module identifiers needed to name the given
4353 /// module.
4354 static unsigned getNumModuleIdentifiers(Module *Mod) {
4355  unsigned Result = 1;
4356  while (Mod->Parent) {
4357  Mod = Mod->Parent;
4358  ++Result;
4359  }
4360  return Result;
4361 }
4362 
4363 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
4364  Module *Imported,
4365  ArrayRef<SourceLocation> IdentifierLocs)
4366  : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, true),
4367  NextLocalImport()
4368 {
4369  assert(getNumModuleIdentifiers(Imported) == IdentifierLocs.size());
4370  auto *StoredLocs = getTrailingObjects<SourceLocation>();
4371  std::uninitialized_copy(IdentifierLocs.begin(), IdentifierLocs.end(),
4372  StoredLocs);
4373 }
4374 
4375 ImportDecl::ImportDecl(DeclContext *DC, SourceLocation StartLoc,
4376  Module *Imported, SourceLocation EndLoc)
4377  : Decl(Import, DC, StartLoc), ImportedAndComplete(Imported, false),
4378  NextLocalImport()
4379 {
4380  *getTrailingObjects<SourceLocation>() = EndLoc;
4381 }
4382 
4384  SourceLocation StartLoc, Module *Imported,
4385  ArrayRef<SourceLocation> IdentifierLocs) {
4386  return new (C, DC,
4387  additionalSizeToAlloc<SourceLocation>(IdentifierLocs.size()))
4388  ImportDecl(DC, StartLoc, Imported, IdentifierLocs);
4389 }
4390 
4392  SourceLocation StartLoc,
4393  Module *Imported,
4394  SourceLocation EndLoc) {
4395  ImportDecl *Import = new (C, DC, additionalSizeToAlloc<SourceLocation>(1))
4396  ImportDecl(DC, StartLoc, Imported, EndLoc);
4397  Import->setImplicit();
4398  return Import;
4399 }
4400 
4402  unsigned NumLocations) {
4403  return new (C, ID, additionalSizeToAlloc<SourceLocation>(NumLocations))
4405 }
4406 
4408  if (!ImportedAndComplete.getInt())
4409  return None;
4410 
4411  const auto *StoredLocs = getTrailingObjects<SourceLocation>();
4412  return llvm::makeArrayRef(StoredLocs,
4413  getNumModuleIdentifiers(getImportedModule()));
4414 }
4415 
4417  if (!ImportedAndComplete.getInt())
4418  return SourceRange(getLocation(), *getTrailingObjects<SourceLocation>());
4419 
4420  return SourceRange(getLocation(), getIdentifierLocs().back());
4421 }
4422 
4423 //===----------------------------------------------------------------------===//
4424 // ExportDecl Implementation
4425 //===----------------------------------------------------------------------===//
4426 
4427 void ExportDecl::anchor() {}
4428 
4430  SourceLocation ExportLoc) {
4431  return new (C, DC) ExportDecl(DC, ExportLoc);
4432 }
4433 
4435  return new (C, ID) ExportDecl(nullptr, SourceLocation());
4436 }
void setLinkage(Linkage L)
Definition: Visibility.h:86
EnumDecl * getTemplateInstantiationPattern() const
Retrieve the enum definition from which this enumeration could be instantiated, if it is an instantia...
Definition: Decl.cpp:3794
VarTemplateDecl * getDescribedVarTemplate() const
Retrieves the variable template that is described by this variable declaration.
Definition: Decl.cpp:2356
bool isNoReturn() const
Determines whether this function is known to be &#39;noreturn&#39;, through an attribute on its declaration o...
Definition: Decl.cpp:2759
Defines the clang::ASTContext interface.
void setTemplateOrSpecializationInfo(VarDecl *Inst, TemplateOrSpecializationInfo TSI)
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4307
ObjCStringFormatFamily
void setImplicit(bool I=true)
Definition: DeclBase.h:538
FunctionDecl - An instance of this class is created to represent a function declaration or definition...
Definition: Decl.h:1629
void setInstantiatedFromStaticDataMember(VarDecl *Inst, VarDecl *Tmpl, TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
Note that the static data member Inst is an instantiation of the static data member template Tmpl of ...
SourceRange getExceptionSpecRange() const
Definition: TypeLoc.h:1407
bool isReservedGlobalPlacementOperator() const
Determines whether this operator new or delete is one of the reserved global placement operators: voi...
Definition: Decl.cpp:2634
FunctionTemplateDecl * getTemplate() const
Retrieve the template from which this function was specialized.
Definition: DeclTemplate.h:537
unsigned getMemoryFunctionKind() const
Identify a memory copying or setting function.
Definition: Decl.cpp:3448
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
Definition: Decl.h:1225
External linkage, which indicates that the entity can be referred to from other translation units...
Definition: Linkage.h:61
bool isPredefinedLibFunction(unsigned ID) const
Determines whether this builtin is a predefined libc/libm function, such as "malloc", where we know the signature a priori.
Definition: Builtins.h:140
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:1923
bool isClosedNonFlag() const
Returns true if this enum is annotated with neither flag_enum nor enum_extensibility(open).
Definition: Decl.cpp:3772
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:737
static ImportDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumLocations)
Create a new, deserialized module import declaration.
Definition: Decl.cpp:4401
CanQualType VoidPtrTy
Definition: ASTContext.h:979
bool isInExternCXXContext() const
Determines whether this function&#39;s context is, or is nested within, a C++ extern "C++" linkage spec...
Definition: Decl.cpp:2735
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
A (possibly-)qualified type.
Definition: Type.h:614
TagDecl * getDefinition() const
getDefinition - Returns the TagDecl that actually defines this struct/union/class/enum.
Definition: Decl.cpp:3663
virtual void FindExternalLexicalDecls(const DeclContext *DC, llvm::function_ref< bool(Decl::Kind)> IsKindWeWant, SmallVectorImpl< Decl *> &Result)
Finds all declarations lexically contained within the given DeclContext, after applying an optional f...
Internal linkage according to the Modules TS, but can be referred to from other translation units ind...
Definition: Linkage.h:51
bool isExternC() const
Determines whether this function is a function with external, C linkage.
Definition: Decl.cpp:2727
RAII class for safely pairing a StartedDeserializing call with FinishedDeserializing.
static VarDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:1838
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4234
This declaration has an owning module, but is only visible to lookups that occur within that module...
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: DeclBase.h:948
static IndirectFieldDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, llvm::MutableArrayRef< NamedDecl *> CH)
Definition: Decl.cpp:4222
Stmt - This represents one statement.
Definition: Stmt.h:60
bool isGenericLambdaCallOperatorSpecialization(const CXXMethodDecl *MD)
Definition: ASTLambda.h:39
void setPreviousDecl(VarDecl *PrevDecl)
Set the previous declaration.
Definition: Decl.h:3993
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:2920
SanitizerSet Sanitize
Set of enabled sanitizers.
Definition: LangOptions.h:100
bool IsICE
Whether this statement is an integral constant expression, or in C++11, whether the statement is a co...
Definition: Decl.h:761
const ASTTemplateArgumentListInfo * getTemplateSpecializationArgsAsWritten() const
Retrieve the template argument list as written in the sources, if any.
Definition: Decl.cpp:3297
VarDecl * getTemplatedDecl() const
Get the underlying variable declarations of the template.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:415
bool isMain() const
Determines whether this function is "main", which is the entry point into an executable program...
Definition: Decl.cpp:2599
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function...
Definition: Decl.cpp:3421
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:781
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2579
No linkage, which means that the entity is unique and can only be referred to from within its scope...
Definition: Linkage.h:28
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:958
void setTypedefNameForAnonDecl(TypedefNameDecl *TDD)
Definition: Decl.cpp:3631
TypedefDecl - Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier...
Definition: Decl.h:2795
bool IsEvaluating
Whether this statement is being evaluated.
Definition: Decl.h:748
static PragmaCommentDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned ArgSize)
Definition: Decl.cpp:4049
The template argument is an expression, and we&#39;ve not resolved it to one of the other forms yet...
Definition: TemplateBase.h:69
bool isRecordType() const
Definition: Type.h:5779
bool isInExternCContext() const
Determines whether this function&#39;s context is, or is nested within, a C++ extern "C" linkage spec...
Definition: Decl.cpp:2731
bool isInitICE() const
Determines whether the initializer is an integral constant expression, or in C++11, whether the initializer is a constant expression.
Definition: Decl.cpp:2234
Defines the clang::Module class, which describes a module in the source code.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:81
bool isVariadic() const
Definition: Type.h:3453
static LinkageInfo getExternalLinkageFor(const NamedDecl *D)
Definition: Decl.cpp:542
bool isNothrow() const
Definition: Decl.cpp:4191
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4416
Defines the C++ template declaration subclasses.
StringRef P
void setPure(bool P=true)
Definition: Decl.cpp:2586
Module * getOwningModuleForLinkage() const
Get the module that owns this declaration for linkage purposes.
Definition: Decl.cpp:1396
bool isBeforeInTranslationUnit(SourceLocation LHS, SourceLocation RHS) const
Determines the order of 2 source locations in the translation unit.
void setPreviousDeclaration(FunctionDecl *PrevDecl)
Definition: Decl.cpp:2771
unsigned getFieldIndex() const
getFieldIndex - Returns the index of this field within its record, as appropriate for passing to ASTR...
Definition: Decl.cpp:3577
static Visibility getVisibilityFromAttr(const T *attr)
Given a visibility attribute, return the explicit visibility associated with it.
Definition: Decl.cpp:154
bool isUninit() const
Definition: APValue.h:182
ImplicitParamKind
Defines the kind of the implicit parameter: is this an implicit parameter with pointer to &#39;this&#39;...
Definition: Decl.h:1400
The base class of the type hierarchy.
Definition: Type.h:1300
Represents an empty-declaration.
Definition: Decl.h:3963
void setParameterIndex(const ParmVarDecl *D, unsigned index)
Used by ParmVarDecl to store on the side the index of the parameter when it exceeds the size of the n...
void setParams(ArrayRef< ParmVarDecl *> NewParamInfo)
Definition: Decl.cpp:3987
DiagnosticsEngine & getDiagnostics() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1205
Declaration of a variable template.
The template argument is a declaration that was provided for a pointer, reference, or pointer to member non-type template parameter.
Definition: TemplateBase.h:51
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:472
static void PrintTemplateArgumentList(raw_ostream &OS, ArrayRef< TemplateArgument > Args, const PrintingPolicy &Policy, bool SkipBrackets=false)
Print a template argument list, including the &#39;<&#39; and &#39;>&#39; enclosing the template arguments.
static std::enable_if<!std::is_base_of< RedeclarableTemplateDecl, T >::value, bool >::type isExplicitMemberSpecialization(const T *D)
Does the given declaration have member specialization information, and if so, is it an explicit speci...
Definition: Decl.cpp:136
virtual void completeDefinition()
completeDefinition - Notes that the definition of this type is now complete.
Definition: Decl.cpp:3886
friend class DeclContext
Definition: Decl.h:3403
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:643
A container of type source information.
Definition: Decl.h:62
Linkage getLinkage() const
Determine the linkage of this type.
Definition: Type.cpp:3437
SourceRange getIntegerTypeRange() const LLVM_READONLY
Retrieve the source range that covers the underlying type if specified.
Definition: Decl.cpp:3743
bool CheckingICE
Whether we are checking whether this statement is an integral constant expression.
Definition: Decl.h:756
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
getNameForDiagnostic - Appends a human-readable name for this declaration into the given stream...
Definition: Decl.cpp:2519
SourceLocation getOuterLocStart() const
getOuterLocStart - Return SourceLocation representing start of source range taking into account any o...
Definition: Decl.cpp:3619
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList *> TPLists)
setTemplateParameterListsInfo - Sets info about "outer" template parameter lists. ...
Definition: Decl.cpp:1781
const Expr * getAnyInitializer() const
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
Definition: Decl.h:1147
bool isImplicitlyInstantiable() const
Determines whether this function is a function template specialization or a member of a class templat...
Definition: Decl.cpp:3174
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:68
static CapturedDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumParams)
Definition: Decl.cpp:4182
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:2985
Represents a #pragma comment line.
Definition: Decl.h:109
LinkageInfo getDeclLinkageAndVisibility(const NamedDecl *D)
Definition: Decl.cpp:1389
void setNothrow(bool Nothrow=true)
Definition: Decl.cpp:4192
This file provides some common utility functions for processing Lambda related AST Constructs...
ExplicitVisibilityKind
Kinds of explicit visibility.
Definition: Decl.h:351
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:769
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:351
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition: Visibility.h:35
bool WasEvaluated
Whether this statement was already evaluated.
Definition: Decl.h:745
Declaration of a redeclarable template.
Definition: DeclTemplate.h:724
static LanguageLinkage getDeclLanguageLinkage(const T &D)
Definition: Decl.cpp:1883
unsigned getNumParams() const
Definition: Type.h:3349
void mergeVisibility(Visibility newVis, bool newExplicit)
Merge in the visibility &#39;newVis&#39;.
Definition: Visibility.h:110
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6052
bool hasDefaultArg() const
hasDefaultArg - Determines whether this parameter has a default argument, either parsed or not...
Definition: Decl.cpp:2494
Visibility getVisibility() const
Definition: Visibility.h:83
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:540
Represents an empty template argument, e.g., one that has not been deduced.
Definition: TemplateBase.h:46
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:191
Represents a variable template specialization, which refers to a variable template with a given set o...
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1060
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:388
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:573
Decl * FirstDecl
FirstDecl - The first declaration stored within this declaration context.
Definition: DeclBase.h:1261
bool isInvalidDecl() const
Definition: DeclBase.h:532
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:50
Not a TLS variable.
Definition: Decl.h:786
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template specialization this is.
Definition: DeclTemplate.h:617
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1445
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
Defines the clang::Expr interface and subclasses for C++ expressions.
LinkageInfo getLVForDecl(const NamedDecl *D, LVComputationKind computation)
getLVForDecl - Get the linkage and visibility for the given declaration.
Definition: Decl.cpp:1343
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:659
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Determines whether this field is a representative for an anonymous struct ...
Definition: Decl.cpp:3562
bool mayInsertExtraPadding(bool EmitRemark=false) const
Whether we are allowed to insert extra padding between fields.
Definition: Decl.cpp:3924
ModuleKind Kind
The kind of this module.
Definition: Module.h:79
SourceRange getReturnTypeSourceRange() const
Attempt to compute an informative source range covering the function return type. ...
Definition: Decl.cpp:2998
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:232
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3379
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the class template specialization.
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:258
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:80
C11 _Thread_local.
Definition: Specifiers.h:199
static bool isRedeclarable(Decl::Kind K)
Definition: Decl.cpp:1534
One of these records is kept for each identifier that is lexed.
Represents a class template specialization, which refers to a class template with a given set of temp...
bool hasBody() const override
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
Definition: Decl.h:1835
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
Definition: TargetInfo.h:850
SourceLocation getOuterLocStart() const
getOuterLocStart - Return SourceLocation representing start of source range taking into account any o...
Definition: Decl.cpp:1726
bool isInAnonymousNamespace() const
Definition: DeclBase.cpp:317
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
bool isCapturedRecord() const
Determine whether this record is a record for captured variables in CapturedStmt construct.
Definition: Decl.cpp:3869
static RecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, RecordDecl *PrevDecl=nullptr)
Definition: Decl.cpp:3839
void setUninstantiatedDefaultArg(Expr *arg)
Definition: Decl.cpp:2483
static IndirectFieldDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4228
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:128
bool hasTrivialBody() const
hasTrivialBody - Returns whether the function has a trivial body that does not require any specific c...
Definition: Decl.cpp:2545
A C++ nested-name-specifier augmented with source location information.
static bool redeclForcesDefMSVC(const FunctionDecl *Redecl)
Definition: Decl.cpp:2904
bool CheckedICE
Whether we already checked whether this statement was an integral constant expression.
Definition: Decl.h:752
The template argument is an integral value stored in an llvm::APSInt that was provided for an integra...
Definition: TemplateBase.h:57
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.
Definition: Sanitizers.h:56
static LinkageInfo internal()
Definition: Visibility.h:69
static bool usesTypeVisibility(const NamedDecl *D)
Is the given declaration a "type" or a "value" for the purposes of visibility computation?
Definition: Decl.cpp:126
field_range fields() const
Definition: Decl.h:3508
static unsigned getNumModuleIdentifiers(Module *Mod)
Retrieve the number of module identifiers needed to name the given module.
Definition: Decl.cpp:4354
static const Decl * getOutermostFuncOrBlockContext(const Decl *D)
Definition: Decl.cpp:248
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2377
friend class DeclContext
Definition: DeclBase.h:234
void completeDefinition()
Completes the definition of this tag declaration.
Definition: Decl.cpp:3651
bool isNamespace() const
Definition: DeclBase.h:1374
const internal::VariadicAllOfMatcher< Decl > decl
Matches declarations.
Definition: ASTMatchers.h:281
void startDefinition()
Starts the definition of this tag declaration.
Definition: Decl.cpp:3640
bool isReferenceType() const
Definition: Type.h:5731
const Attr * getUnusedResultAttr() const
Returns the WarnUnusedResultAttr that is either declared on this function, or its return type declara...
Definition: Decl.cpp:3030
Linkage getFormalLinkage(Linkage L)
Definition: Linkage.h:91
This declaration is definitely a definition.
Definition: Decl.h:1089
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Decl.cpp:983
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1416
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
Describes a module or submodule.
Definition: Module.h:57
static PragmaCommentDecl * Create(const ASTContext &C, TranslationUnitDecl *DC, SourceLocation CommentLoc, PragmaMSCommentKind CommentKind, StringRef Arg)
Definition: Decl.cpp:4036
Objects with "default" visibility are seen by the dynamic linker and act like normal objects...
Definition: Visibility.h:44
virtual bool isDefined() const
Definition: Decl.h:1849
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:494
SourceLocation getPointOfInstantiation() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2346
TypedefNameDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this typedef-name.
Definition: Decl.h:2765
VarDecl * getActingDefinition()
Get the tentative definition that acts as the real definition in a TU.
Definition: Decl.cpp:2025
bool isReplaceableGlobalAllocationFunction(bool *IsAligned=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition: Decl.cpp:2657
const TemplateArgumentList * TemplateArguments
The template arguments used to produce the function template specialization from the function templat...
Definition: DeclTemplate.h:527
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.cpp:4188
Kinds of LV computation.
Definition: Linkage.h:28
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For an enumeration member that was instantiated from a member enumeration of a templated class...
Definition: Decl.cpp:3783
QualType getOriginalType() const
Definition: Decl.cpp:2417
static ExternCContextDecl * Create(const ASTContext &C, TranslationUnitDecl *TU)
Definition: Decl.cpp:4083
A convenient class for passing around template argument information.
Definition: TemplateBase.h:524
const TemplateArgumentList & getTemplateArgs() const
Retrieve the template arguments of the variable template specialization.
TagDecl * getAnonDeclWithTypedefName(bool AnyRedecl=false) const
Retrieves the tag declaration for which this is the typedef name for linkage purposes, if any.
Definition: Decl.cpp:4251
Wrapper for source info for functions.
Definition: TypeLoc.h:1357
ModuleOwnershipKind getModuleOwnershipKind() const
Get the kind of module ownership for this declaration.
Definition: DeclBase.h:757
static EnumConstantDecl * Create(ASTContext &C, EnumDecl *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition: Decl.cpp:4194
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3166
bool isMemberSpecialization() const
Determines whether this template was a specialization of a member template.
Definition: DeclTemplate.h:849
ASTContext & getASTContext() const
Definition: Decl.h:90
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
DefinitionKind hasDefinition() const
Definition: Decl.h:1103
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2336
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:1770
A set of unresolved declarations.
Definition: UnresolvedSet.h:56
Module * Parent
The parent of this module.
Definition: Module.h:83
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1310
FunctionTemplateSpecializationInfo * getTemplateSpecializationInfo() const
If this function is actually a function template specialization, retrieve information about this func...
Definition: Decl.cpp:3281
VarTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:1113
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition: Type.h:5499
field_iterator field_begin() const
Definition: Decl.cpp:3877
unsigned getBitWidthValue(const ASTContext &Ctx) const
Definition: Decl.cpp:3572
static FileScopeAsmDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4332
bool isInlineDefinitionExternallyVisible() const
For an inline function definition in C, or for a gnu_inline function in C++, determine whether the de...
Definition: Decl.cpp:3063
static TypeAliasDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4302
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:796
SourceLocation getSpellingLoc(SourceLocation Loc) const
Given a SourceLocation object, return the spelling location referenced by the ID. ...
static VarDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S)
Definition: Decl.cpp:1831
ArrayRef< SourceLocation > getIdentifierLocs() const
Retrieves the locations of each of the identifiers that make up the complete module name in the impor...
Definition: Decl.cpp:4407
bool needsCleanup() const
Returns whether the object performed allocations.
Definition: APValue.cpp:215
SourceRange getExceptionSpecSourceRange() const
Attempt to compute an informative source range covering the function exception specification, if any.
Definition: Decl.cpp:3018
FunctionDecl * getInstantiatedFromMemberFunction() const
If this function is an instantiation of a member function of a class template specialization, retrieves the function from which it was instantiated.
Definition: Decl.cpp:3144
static FunctionTemplateSpecializationInfo * Create(ASTContext &C, FunctionDecl *FD, FunctionTemplateDecl *Template, TemplateSpecializationKind TSK, const TemplateArgumentList *TemplateArgs, const TemplateArgumentListInfo *TemplateArgsAsWritten, SourceLocation POI)
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3751
Represents a linkage specification.
Definition: DeclCXX.h:2681
static ParmVarDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:2425
SourceLocation getTypeSpecStartLoc() const
Definition: Decl.cpp:1674
CXXRecordDecl * getTemplatedDecl() const
Get the underlying class declarations of the template.
LinkageInfo computeLVForDecl(const NamedDecl *D, LVComputationKind computation, bool IgnoreVarTypeLinkage=false)
Definition: Decl.cpp:1221
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this function is an instantiation of a member function of a class template specialization, retrieves the member specialization information.
Definition: Decl.cpp:3151
Decl * getPrimaryMergedDecl(Decl *D)
Definition: ASTContext.h:920
void setCachedLinkage(Linkage L) const
Definition: DeclBase.h:386
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1791
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:841
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3267
static ImplicitParamDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, ImplicitParamKind ParamKind)
Create implicit parameter.
Definition: Decl.cpp:4126
NodeId Parent
Definition: ASTDiff.cpp:192
bool isExternC() const
Determines whether this variable is a variable with external, C linkage.
Definition: Decl.cpp:1927
bool isInExternCContext() const
Determines whether this variable&#39;s context is, or is nested within, a C++ extern "C" linkage spec...
Definition: Decl.cpp:1931
static ImportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, Module *Imported, ArrayRef< SourceLocation > IdentifierLocs)
Create a new module import declaration.
Definition: Decl.cpp:4383
unsigned getLambdaManglingNumber() const
If this is the closure type of a lambda expression, retrieve the number to be used for name mangling ...
Definition: DeclCXX.h:1783
bool hasAttr() const
Definition: DeclBase.h:521
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:104
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:97
static bool isExportedFromModuleIntefaceUnit(const NamedDecl *D)
Definition: Decl.cpp:517
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2815
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1549
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3126
bool isFileVarDecl() const
isFileVarDecl - Returns true for file scoped variable declaration.
Definition: Decl.h:1131
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2691
bool isUsableInConstantExpressions(ASTContext &C) const
Determine whether this variable&#39;s value can be used in a constant expression, according to the releva...
Definition: Decl.cpp:2124
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any...
Definition: Decl.cpp:3112
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:647
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Stmt.cpp:270
OverloadedOperatorKind getCXXOverloadedOperator() const
getCXXOverloadedOperator - If this name is the name of an overloadable operator in C++ (e...
Module linkage, which indicates that the entity can be referred to from other translation units withi...
Definition: Linkage.h:57
bool isClosed() const
Returns true if this enum is either annotated with enum_extensibility(closed) or isn&#39;t annotated with...
Definition: Decl.cpp:3762
static EmptyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L)
Definition: Decl.cpp:4340
FunctionDecl * getClassScopeSpecializationPattern() const
Retrieve the class scope template pattern that this function template specialization is instantiated ...
Definition: Decl.cpp:3276
bool isInlineSpecified() const
Definition: Decl.h:1295
ID
Defines the address space values used by the address space qualifier of QualType. ...
Definition: AddressSpaces.h:26
Stmt ** getInitAddress()
Retrieve the address of the initializer expression.
Definition: Decl.cpp:2092
bool isMsStruct(const ASTContext &C) const
isMsStrust - Get whether or not this is an ms_struct which can be turned on with an attribute...
Definition: Decl.cpp:3894
SourceLocation getBeginLoc() const
Get the begin source location.
Definition: TypeLoc.cpp:169
unsigned IgnoreExplicitVisibility
Whether explicit visibility attributes should be ignored.
Definition: Linkage.h:34
TemplateParameterList * getTemplateParameters() const
Get the list of template parameters.
Definition: DeclTemplate.h:410
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:847
bool isWeak() const
Determine whether this symbol is weakly-imported, or declared with the weak or weak-ref attr...
Definition: Decl.cpp:4116
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2151
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3582
const FieldDecl * findFirstNamedDataMember() const
Finds the first data member which has a name.
Definition: Decl.cpp:3967
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:591
Expr - This represents one expression.
Definition: Expr.h:106
SourceLocation End
bool isTypeVisibility() const
Definition: Linkage.h:47
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2528
static bool classofKind(Kind K)
Definition: Decl.h:2661
std::string Label
void mergeExternalVisibility(Linkage L)
Definition: Visibility.h:95
int Id
Definition: ASTDiff.cpp:191
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:6115
static bool hasExplicitVisibilityAlready(LVComputationKind computation)
Does this computation kind permit us to consider additional visibility settings from attributes and t...
Definition: Decl.cpp:105
The template argument is a null pointer or null pointer to member that was provided for a non-type te...
Definition: TemplateBase.h:54
ObjCStringFormatFamily getObjCFStringFormattingFamily() const
Definition: Decl.cpp:993
Decl * LastDecl
LastDecl - The last declaration stored within this declaration context.
Definition: DeclBase.h:1267
T getAs() const
Convert to the specified TypeLoc type, returning a null TypeLoc if this TypeLoc is not of the desired...
Definition: TypeLoc.h:64
void setInit(Expr *I)
Definition: Decl.cpp:2115
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:537
const TemplateArgumentList * getTemplateSpecializationArgs() const
Retrieve the template arguments used to produce this function template specialization from the primar...
Definition: Decl.cpp:3287
static Optional< Visibility > getVisibilityOf(const NamedDecl *D, NamedDecl::ExplicitVisibilityKind kind)
Return the explicit visibility of the given declaration.
Definition: Decl.cpp:167
static LVComputationKind withExplicitVisibilityAlready(LVComputationKind Kind)
Given an LVComputationKind, return one of the same type/value sort that records that it already has e...
Definition: Decl.cpp:112
Linkage getLinkage() const
Definition: Visibility.h:82
ClassTemplateDecl * getSpecializedTemplate() const
Retrieve the template that this specialization specializes.
bool isFileContext() const
Definition: DeclBase.h:1362
DeclContext * getDeclContext()
Definition: DeclBase.h:416
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition: Decl.cpp:2723
This declaration is a tentative definition.
Definition: Decl.h:1088
Decl * getPrimaryMergedDecl(Decl *D)
Get the primary declaration for a declaration from an AST file.
Definition: Decl.cpp:40
TLSKind getTLSKind() const
Definition: Decl.cpp:1849
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2147
ArrayRef< TemplateArgument > asArray() const
Produce this as an array ref.
Definition: DeclTemplate.h:247
Defines the clang::TypeLoc interface and its subclasses.
TemplateOrSpecializationInfo getTemplateOrSpecializationInfo(const VarDecl *Var)
DependentFunctionTemplateSpecializationInfo * getDependentSpecializationInfo() const
Definition: Decl.cpp:3339
VarDecl * getTemplateInstantiationPattern() const
Retrieve the variable declaration from which this variable could be instantiated, if it is an instant...
Definition: Decl.cpp:2284
static bool RedeclForcesDefC99(const FunctionDecl *Redecl)
Definition: Decl.cpp:2916
static const CXXRecordDecl * getOutermostEnclosingLambda(const CXXRecordDecl *Record)
Definition: Decl.cpp:1209
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body (definition).
Definition: Decl.cpp:2534
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isInvalid() const
bool isFunctionOrMethod() const
Definition: DeclBase.h:1345
StorageClass
Storage classes.
Definition: Specifiers.h:203
static Optional< Visibility > getExplicitVisibility(const NamedDecl *D, LVComputationKind kind)
Definition: Decl.cpp:117
Objects with "protected" visibility are seen by the dynamic linker but always dynamically resolve to ...
Definition: Visibility.h:40
PragmaMSCommentKind
Definition: PragmaKinds.h:15
unsigned IgnoreAllVisibility
Whether all visibility should be ignored.
Definition: Linkage.h:37
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:226
static CapturedDecl * Create(ASTContext &C, DeclContext *DC, unsigned NumParams)
Definition: Decl.cpp:4176
This declaration has an owning module, and is visible when that module is imported.
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1296
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:87
SourceLocation getEnd() const
specific_decl_iterator< FieldDecl > field_iterator
Definition: Decl.h:3505
bool capturesVariable(const VarDecl *var) const
Definition: Decl.cpp:4011
APValue * evaluateValue() const
Attempt to evaluate the value of the initializer attached to this declaration, and produce notes expl...
Definition: Decl.cpp:2168
bool isValueVisibility() const
Definition: Linkage.h:50
unsigned getParameterIndex(const ParmVarDecl *D) const
Used by ParmVarDecl to retrieve on the side the index of the parameter when it exceeds the size of th...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3596
void printQualifiedName(raw_ostream &OS) const
printQualifiedName - Returns human-readable qualified name for declaration, like A::B::i, for i being member of namespace A::B.
Definition: Decl.cpp:1431
void setStorageClass(StorageClass SC)
Definition: Decl.cpp:1844
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1296
void addDestruction(T *Ptr)
If T isn&#39;t trivially destructible, calls AddDeallocation to register it for destruction.
Definition: ASTContext.h:2545
The result type of a method or function.
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
DefinitionKind isThisDeclarationADefinition() const
Definition: Decl.h:1096
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:681
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:167
static LinkageInfo visible_none()
Definition: Visibility.h:78
const SourceManager & SM
Definition: Format.cpp:1307
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList *> TPLists)
Definition: Decl.cpp:3706
TypeLoc getReturnLoc() const
Definition: TypeLoc.h:1434
static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])
Definition: Decl.cpp:2594
const SanitizerBlacklist & getSanitizerBlacklist() const
Definition: ASTContext.h:661
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:1939
static LinkageInfo external()
Definition: Visibility.h:66
VarDecl * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:209
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:5532
unsigned getBuiltinID() const
Return a value indicating whether this is a builtin function.
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
Definition: DeclBase.h:954
EnumDecl * getInstantiatedFromMemberEnum() const
Returns the enumeration (declared within the template) from which this enumeration type was instantia...
Definition: Decl.cpp:3809
void addAttr(Attr *A)
Definition: DeclBase.h:472
Abstract interface for external sources of AST nodes.
bool isAlignValT() const
Definition: Type.cpp:2308
static PragmaDetectMismatchDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize)
Definition: Decl.cpp:4075
bool isInjectedClassName() const
Determines whether this declaration represents the injected class name.
Definition: Decl.cpp:3858
virtual void printName(raw_ostream &os) const
Definition: Decl.cpp:1420
Represents a C++ Modules TS module export declaration.
Definition: Decl.h:3919
QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case...
Definition: Decl.h:614
APValue * getEvaluatedValue() const
Return the already-evaluated value of this variable&#39;s initializer, or NULL if the value is not yet kn...
Definition: Decl.cpp:2219
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1290
IdentifierInfo * getCXXLiteralIdentifier() const
getCXXLiteralIdentifier - If this name is the name of a literal operator, retrieve the identifier ass...
bool isExplicitInstantiationOrSpecialization() const
True if this declaration is an explicit specialization, explicit instantiation declaration, or explicit instantiation definition.
Definition: DeclTemplate.h:551
This declaration has an owning module, but is globally visible (typically because its owning module i...
static bool classof(const Decl *D)
Definition: Decl.h:3525
The "struct" keyword.
Definition: Type.h:4500
static EnumConstantDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4202
Kind
TypeLoc IgnoreParens() const
Definition: TypeLoc.h:1158
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:2431
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:197
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:200
static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl)
Definition: Decl.cpp:1667
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: Redeclarable.h:289
Encodes a location in the source.
static EmptyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: Decl.cpp:4344
bool isLinkageValid() const
True if the computed linkage is valid.
Definition: Type.cpp:3520
static ExportDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExportLoc)
Definition: Decl.cpp:4429
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of enums...
Definition: Type.h:3820
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2841
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:66
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:347
bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer=true) const
Determine whether this declaration, if known to be well-formed within its context, will replace the declaration OldD if introduced into scope.
Definition: Decl.cpp:1545
static QualType getUnderlyingType(const SubRegion *R)
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:425
void setTemplateParameterListsInfo(ASTContext &Context, ArrayRef< TemplateParameterList *> TPLists)
Definition: Decl.cpp:1710
TemplateSpecializationKind getTemplateSpecializationKind() const
If this enumeration is a member of a specialization of a templated class, determine what kind of temp...
Definition: Decl.cpp:3776
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3629
bool isLegalForVariable(StorageClass SC)
Checks whether the given storage class is legal for variables.
Definition: Specifiers.h:221
bool isLambda() const
Determine whether this record is a class describing a lambda function object.
Definition: Decl.cpp:3863
GNU __thread.
Definition: Specifiers.h:193
This file defines OpenMP nodes for declarative directives.
bool hasCachedLinkage() const
Definition: DeclBase.h:390
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:3623
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
Definition: Decl.cpp:2938
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.cpp:4316
This is a fragment of the global module within some C++ Modules TS module.
Definition: Module.h:75
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:1842
Linkage getCachedLinkage() const
Definition: DeclBase.h:382