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