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