Revert "[NFC, Refactor] Modernize StorageClass from Specifiers.h to a scoped enum...
[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 SC_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()) == SC_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() != SC_Extern &&
664           Var->getStorageClass() != SC_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() == SC_PrivateExtern &&
672           Var->getStorageClass() == SC_None)
673         return getDeclLinkageAndVisibility(PrevVar);
674       // Explicitly declared static.
675       if (PrevVar->getStorageClass() == SC_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() == SC_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() == SC_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() == SC_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() == SC_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 SC_None:                 break;
1966   case SC_Auto:                 return "auto";
1967   case SC_Extern:               return "extern";
1968   case SC_PrivateExtern:        return "__private_extern__";
1969   case SC_Register:             return "register";
1970   case SC_Static:               return "static";
1971   }
1972
1973   llvm_unreachable("Invalid storage class");
1974 }
1975
1976 VarDecl::VarDecl(Kind DK, ASTContext &C, DeclContext *DC,
1977                  SourceLocation StartLoc, SourceLocation IdLoc,
1978                  IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1979                  StorageClass SC)
1980     : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
1981       redeclarable_base(C) {
1982   static_assert(sizeof(VarDeclBitfields) <= sizeof(unsigned),
1983                 "VarDeclBitfields too large!");
1984   static_assert(sizeof(ParmVarDeclBitfields) <= sizeof(unsigned),
1985                 "ParmVarDeclBitfields too large!");
1986   static_assert(sizeof(NonParmVarDeclBitfields) <= sizeof(unsigned),
1987                 "NonParmVarDeclBitfields too large!");
1988   AllBits = 0;
1989   VarDeclBits.SClass = SC;
1990   // Everything else is implicitly initialized to false.
1991 }
1992
1993 VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC,
1994                          SourceLocation StartL, SourceLocation IdL,
1995                          IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1996                          StorageClass S) {
1997   return new (C, DC) VarDecl(Var, C, DC, StartL, IdL, Id, T, TInfo, S);
1998 }
1999
2000 VarDecl *VarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2001   return new (C, ID)
2002       VarDecl(Var, C, nullptr, SourceLocation(), SourceLocation(), nullptr,
2003               QualType(), nullptr, SC_None);
2004 }
2005
2006 void VarDecl::setStorageClass(StorageClass SC) {
2007   assert(isLegalForVariable(SC));
2008   VarDeclBits.SClass = SC;
2009 }
2010
2011 VarDecl::TLSKind VarDecl::getTLSKind() const {
2012   switch (VarDeclBits.TSCSpec) {
2013   case TSCS_unspecified:
2014     if (!hasAttr<ThreadAttr>() &&
2015         !(getASTContext().getLangOpts().OpenMPUseTLS &&
2016           getASTContext().getTargetInfo().isTLSSupported() &&
2017           hasAttr<OMPThreadPrivateDeclAttr>()))
2018       return TLS_None;
2019     return ((getASTContext().getLangOpts().isCompatibleWithMSVC(
2020                 LangOptions::MSVC2015)) ||
2021             hasAttr<OMPThreadPrivateDeclAttr>())
2022                ? TLS_Dynamic
2023                : TLS_Static;
2024   case TSCS___thread: // Fall through.
2025   case TSCS__Thread_local:
2026     return TLS_Static;
2027   case TSCS_thread_local:
2028     return TLS_Dynamic;
2029   }
2030   llvm_unreachable("Unknown thread storage class specifier!");
2031 }
2032
2033 SourceRange VarDecl::getSourceRange() const {
2034   if (const Expr *Init = getInit()) {
2035     SourceLocation InitEnd = Init->getEndLoc();
2036     // If Init is implicit, ignore its source range and fallback on
2037     // DeclaratorDecl::getSourceRange() to handle postfix elements.
2038     if (InitEnd.isValid() && InitEnd != getLocation())
2039       return SourceRange(getOuterLocStart(), InitEnd);
2040   }
2041   return DeclaratorDecl::getSourceRange();
2042 }
2043
2044 template<typename T>
2045 static LanguageLinkage getDeclLanguageLinkage(const T &D) {
2046   // C++ [dcl.link]p1: All function types, function names with external linkage,
2047   // and variable names with external linkage have a language linkage.
2048   if (!D.hasExternalFormalLinkage())
2049     return NoLanguageLinkage;
2050
2051   // Language linkage is a C++ concept, but saying that everything else in C has
2052   // C language linkage fits the implementation nicely.
2053   ASTContext &Context = D.getASTContext();
2054   if (!Context.getLangOpts().CPlusPlus)
2055     return CLanguageLinkage;
2056
2057   // C++ [dcl.link]p4: A C language linkage is ignored in determining the
2058   // language linkage of the names of class members and the function type of
2059   // class member functions.
2060   const DeclContext *DC = D.getDeclContext();
2061   if (DC->isRecord())
2062     return CXXLanguageLinkage;
2063
2064   // If the first decl is in an extern "C" context, any other redeclaration
2065   // will have C language linkage. If the first one is not in an extern "C"
2066   // context, we would have reported an error for any other decl being in one.
2067   if (isFirstInExternCContext(&D))
2068     return CLanguageLinkage;
2069   return CXXLanguageLinkage;
2070 }
2071
2072 template<typename T>
2073 static bool isDeclExternC(const T &D) {
2074   // Since the context is ignored for class members, they can only have C++
2075   // language linkage or no language linkage.
2076   const DeclContext *DC = D.getDeclContext();
2077   if (DC->isRecord()) {
2078     assert(D.getASTContext().getLangOpts().CPlusPlus);
2079     return false;
2080   }
2081
2082   return D.getLanguageLinkage() == CLanguageLinkage;
2083 }
2084
2085 LanguageLinkage VarDecl::getLanguageLinkage() const {
2086   return getDeclLanguageLinkage(*this);
2087 }
2088
2089 bool VarDecl::isExternC() const {
2090   return isDeclExternC(*this);
2091 }
2092
2093 bool VarDecl::isInExternCContext() const {
2094   return getLexicalDeclContext()->isExternCContext();
2095 }
2096
2097 bool VarDecl::isInExternCXXContext() const {
2098   return getLexicalDeclContext()->isExternCXXContext();
2099 }
2100
2101 VarDecl *VarDecl::getCanonicalDecl() { return getFirstDecl(); }
2102
2103 VarDecl::DefinitionKind
2104 VarDecl::isThisDeclarationADefinition(ASTContext &C) const {
2105   if (isThisDeclarationADemotedDefinition())
2106     return DeclarationOnly;
2107
2108   // C++ [basic.def]p2:
2109   //   A declaration is a definition unless [...] it contains the 'extern'
2110   //   specifier or a linkage-specification and neither an initializer [...],
2111   //   it declares a non-inline static data member in a class declaration [...],
2112   //   it declares a static data member outside a class definition and the variable
2113   //   was defined within the class with the constexpr specifier [...],
2114   // C++1y [temp.expl.spec]p15:
2115   //   An explicit specialization of a static data member or an explicit
2116   //   specialization of a static data member template is a definition if the
2117   //   declaration includes an initializer; otherwise, it is a declaration.
2118   //
2119   // FIXME: How do you declare (but not define) a partial specialization of
2120   // a static data member template outside the containing class?
2121   if (isStaticDataMember()) {
2122     if (isOutOfLine() &&
2123         !(getCanonicalDecl()->isInline() &&
2124           getCanonicalDecl()->isConstexpr()) &&
2125         (hasInit() ||
2126          // If the first declaration is out-of-line, this may be an
2127          // instantiation of an out-of-line partial specialization of a variable
2128          // template for which we have not yet instantiated the initializer.
2129          (getFirstDecl()->isOutOfLine()
2130               ? getTemplateSpecializationKind() == TSK_Undeclared
2131               : getTemplateSpecializationKind() !=
2132                     TSK_ExplicitSpecialization) ||
2133          isa<VarTemplatePartialSpecializationDecl>(this)))
2134       return Definition;
2135     else if (!isOutOfLine() && isInline())
2136       return Definition;
2137     else
2138       return DeclarationOnly;
2139   }
2140   // C99 6.7p5:
2141   //   A definition of an identifier is a declaration for that identifier that
2142   //   [...] causes storage to be reserved for that object.
2143   // Note: that applies for all non-file-scope objects.
2144   // C99 6.9.2p1:
2145   //   If the declaration of an identifier for an object has file scope and an
2146   //   initializer, the declaration is an external definition for the identifier
2147   if (hasInit())
2148     return Definition;
2149
2150   if (hasDefiningAttr())
2151     return Definition;
2152
2153   if (const auto *SAA = getAttr<SelectAnyAttr>())
2154     if (!SAA->isInherited())
2155       return Definition;
2156
2157   // A variable template specialization (other than a static data member
2158   // template or an explicit specialization) is a declaration until we
2159   // instantiate its initializer.
2160   if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(this)) {
2161     if (VTSD->getTemplateSpecializationKind() != TSK_ExplicitSpecialization &&
2162         !isa<VarTemplatePartialSpecializationDecl>(VTSD) &&
2163         !VTSD->IsCompleteDefinition)
2164       return DeclarationOnly;
2165   }
2166
2167   if (hasExternalStorage())
2168     return DeclarationOnly;
2169
2170   // [dcl.link] p7:
2171   //   A declaration directly contained in a linkage-specification is treated
2172   //   as if it contains the extern specifier for the purpose of determining
2173   //   the linkage of the declared name and whether it is a definition.
2174   if (isSingleLineLanguageLinkage(*this))
2175     return DeclarationOnly;
2176
2177   // C99 6.9.2p2:
2178   //   A declaration of an object that has file scope without an initializer,
2179   //   and without a storage class specifier or the scs 'static', constitutes
2180   //   a tentative definition.
2181   // No such thing in C++.
2182   if (!C.getLangOpts().CPlusPlus && isFileVarDecl())
2183     return TentativeDefinition;
2184
2185   // What's left is (in C, block-scope) declarations without initializers or
2186   // external storage. These are definitions.
2187   return Definition;
2188 }
2189
2190 VarDecl *VarDecl::getActingDefinition() {
2191   DefinitionKind Kind = isThisDeclarationADefinition();
2192   if (Kind != TentativeDefinition)
2193     return nullptr;
2194
2195   VarDecl *LastTentative = nullptr;
2196   VarDecl *First = getFirstDecl();
2197   for (auto I : First->redecls()) {
2198     Kind = I->isThisDeclarationADefinition();
2199     if (Kind == Definition)
2200       return nullptr;
2201     else if (Kind == TentativeDefinition)
2202       LastTentative = I;
2203   }
2204   return LastTentative;
2205 }
2206
2207 VarDecl *VarDecl::getDefinition(ASTContext &C) {
2208   VarDecl *First = getFirstDecl();
2209   for (auto I : First->redecls()) {
2210     if (I->isThisDeclarationADefinition(C) == Definition)
2211       return I;
2212   }
2213   return nullptr;
2214 }
2215
2216 VarDecl::DefinitionKind VarDecl::hasDefinition(ASTContext &C) const {
2217   DefinitionKind Kind = DeclarationOnly;
2218
2219   const VarDecl *First = getFirstDecl();
2220   for (auto I : First->redecls()) {
2221     Kind = std::max(Kind, I->isThisDeclarationADefinition(C));
2222     if (Kind == Definition)
2223       break;
2224   }
2225
2226   return Kind;
2227 }
2228
2229 const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const {
2230   for (auto I : redecls()) {
2231     if (auto Expr = I->getInit()) {
2232       D = I;
2233       return Expr;
2234     }
2235   }
2236   return nullptr;
2237 }
2238
2239 bool VarDecl::hasInit() const {
2240   if (auto *P = dyn_cast<ParmVarDecl>(this))
2241     if (P->hasUnparsedDefaultArg() || P->hasUninstantiatedDefaultArg())
2242       return false;
2243
2244   return !Init.isNull();
2245 }
2246
2247 Expr *VarDecl::getInit() {
2248   if (!hasInit())
2249     return nullptr;
2250
2251   if (auto *S = Init.dyn_cast<Stmt *>())
2252     return cast<Expr>(S);
2253
2254   return cast_or_null<Expr>(Init.get<EvaluatedStmt *>()->Value);
2255 }
2256
2257 Stmt **VarDecl::getInitAddress() {
2258   if (auto *ES = Init.dyn_cast<EvaluatedStmt *>())
2259     return &ES->Value;
2260
2261   return Init.getAddrOfPtr1();
2262 }
2263
2264 VarDecl *VarDecl::getInitializingDeclaration() {
2265   VarDecl *Def = nullptr;
2266   for (auto I : redecls()) {
2267     if (I->hasInit())
2268       return I;
2269
2270     if (I->isThisDeclarationADefinition()) {
2271       if (isStaticDataMember())
2272         return I;
2273       else
2274         Def = I;
2275     }
2276   }
2277   return Def;
2278 }
2279
2280 bool VarDecl::isOutOfLine() const {
2281   if (Decl::isOutOfLine())
2282     return true;
2283
2284   if (!isStaticDataMember())
2285     return false;
2286
2287   // If this static data member was instantiated from a static data member of
2288   // a class template, check whether that static data member was defined
2289   // out-of-line.
2290   if (VarDecl *VD = getInstantiatedFromStaticDataMember())
2291     return VD->isOutOfLine();
2292
2293   return false;
2294 }
2295
2296 void VarDecl::setInit(Expr *I) {
2297   if (auto *Eval = Init.dyn_cast<EvaluatedStmt *>()) {
2298     Eval->~EvaluatedStmt();
2299     getASTContext().Deallocate(Eval);
2300   }
2301
2302   Init = I;
2303 }
2304
2305 bool VarDecl::mightBeUsableInConstantExpressions(const ASTContext &C) const {
2306   const LangOptions &Lang = C.getLangOpts();
2307
2308   // OpenCL permits const integral variables to be used in constant
2309   // expressions, like in C++98.
2310   if (!Lang.CPlusPlus && !Lang.OpenCL)
2311     return false;
2312
2313   // Function parameters are never usable in constant expressions.
2314   if (isa<ParmVarDecl>(this))
2315     return false;
2316
2317   // The values of weak variables are never usable in constant expressions.
2318   if (isWeak())
2319     return false;
2320
2321   // In C++11, any variable of reference type can be used in a constant
2322   // expression if it is initialized by a constant expression.
2323   if (Lang.CPlusPlus11 && getType()->isReferenceType())
2324     return true;
2325
2326   // Only const objects can be used in constant expressions in C++. C++98 does
2327   // not require the variable to be non-volatile, but we consider this to be a
2328   // defect.
2329   if (!getType().isConstant(C) || getType().isVolatileQualified())
2330     return false;
2331
2332   // In C++, const, non-volatile variables of integral or enumeration types
2333   // can be used in constant expressions.
2334   if (getType()->isIntegralOrEnumerationType())
2335     return true;
2336
2337   // Additionally, in C++11, non-volatile constexpr variables can be used in
2338   // constant expressions.
2339   return Lang.CPlusPlus11 && isConstexpr();
2340 }
2341
2342 bool VarDecl::isUsableInConstantExpressions(const ASTContext &Context) const {
2343   // C++2a [expr.const]p3:
2344   //   A variable is usable in constant expressions after its initializing
2345   //   declaration is encountered...
2346   const VarDecl *DefVD = nullptr;
2347   const Expr *Init = getAnyInitializer(DefVD);
2348   if (!Init || Init->isValueDependent() || getType()->isDependentType())
2349     return false;
2350   //   ... if it is a constexpr variable, or it is of reference type or of
2351   //   const-qualified integral or enumeration type, ...
2352   if (!DefVD->mightBeUsableInConstantExpressions(Context))
2353     return false;
2354   //   ... and its initializer is a constant initializer.
2355   if (Context.getLangOpts().CPlusPlus && !DefVD->hasConstantInitialization())
2356     return false;
2357   // C++98 [expr.const]p1:
2358   //   An integral constant-expression can involve only [...] const variables
2359   //   or static data members of integral or enumeration types initialized with
2360   //   [integer] constant expressions (dcl.init)
2361   if ((Context.getLangOpts().CPlusPlus || Context.getLangOpts().OpenCL) &&
2362       !Context.getLangOpts().CPlusPlus11 && !DefVD->hasICEInitializer(Context))
2363     return false;
2364   return true;
2365 }
2366
2367 /// Convert the initializer for this declaration to the elaborated EvaluatedStmt
2368 /// form, which contains extra information on the evaluated value of the
2369 /// initializer.
2370 EvaluatedStmt *VarDecl::ensureEvaluatedStmt() const {
2371   auto *Eval = Init.dyn_cast<EvaluatedStmt *>();
2372   if (!Eval) {
2373     // Note: EvaluatedStmt contains an APValue, which usually holds
2374     // resources not allocated from the ASTContext.  We need to do some
2375     // work to avoid leaking those, but we do so in VarDecl::evaluateValue
2376     // where we can detect whether there's anything to clean up or not.
2377     Eval = new (getASTContext()) EvaluatedStmt;
2378     Eval->Value = Init.get<Stmt *>();
2379     Init = Eval;
2380   }
2381   return Eval;
2382 }
2383
2384 EvaluatedStmt *VarDecl::getEvaluatedStmt() const {
2385   return Init.dyn_cast<EvaluatedStmt *>();
2386 }
2387
2388 APValue *VarDecl::evaluateValue() const {
2389   SmallVector<PartialDiagnosticAt, 8> Notes;
2390   return evaluateValueImpl(Notes, hasConstantInitialization());
2391 }
2392
2393 APValue *VarDecl::evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
2394                                     bool IsConstantInitialization) const {
2395   EvaluatedStmt *Eval = ensureEvaluatedStmt();
2396
2397   const auto *Init = cast<Expr>(Eval->Value);
2398   assert(!Init->isValueDependent());
2399
2400   // We only produce notes indicating why an initializer is non-constant the
2401   // first time it is evaluated. FIXME: The notes won't always be emitted the
2402   // first time we try evaluation, so might not be produced at all.
2403   if (Eval->WasEvaluated)
2404     return Eval->Evaluated.isAbsent() ? nullptr : &Eval->Evaluated;
2405
2406   if (Eval->IsEvaluating) {
2407     // FIXME: Produce a diagnostic for self-initialization.
2408     return nullptr;
2409   }
2410
2411   Eval->IsEvaluating = true;
2412
2413   ASTContext &Ctx = getASTContext();
2414   bool Result = Init->EvaluateAsInitializer(Eval->Evaluated, Ctx, this, Notes,
2415                                             IsConstantInitialization);
2416
2417   // In C++11, this isn't a constant initializer if we produced notes. In that
2418   // case, we can't keep the result, because it may only be correct under the
2419   // assumption that the initializer is a constant context.
2420   if (IsConstantInitialization && Ctx.getLangOpts().CPlusPlus11 &&
2421       !Notes.empty())
2422     Result = false;
2423
2424   // Ensure the computed APValue is cleaned up later if evaluation succeeded,
2425   // or that it's empty (so that there's nothing to clean up) if evaluation
2426   // failed.
2427   if (!Result)
2428     Eval->Evaluated = APValue();
2429   else if (Eval->Evaluated.needsCleanup())
2430     Ctx.addDestruction(&Eval->Evaluated);
2431
2432   Eval->IsEvaluating = false;
2433   Eval->WasEvaluated = true;
2434
2435   return Result ? &Eval->Evaluated : nullptr;
2436 }
2437
2438 APValue *VarDecl::getEvaluatedValue() const {
2439   if (EvaluatedStmt *Eval = getEvaluatedStmt())
2440     if (Eval->WasEvaluated)
2441       return &Eval->Evaluated;
2442
2443   return nullptr;
2444 }
2445
2446 bool VarDecl::hasICEInitializer(const ASTContext &Context) const {
2447   const Expr *Init = getInit();
2448   assert(Init && "no initializer");
2449
2450   EvaluatedStmt *Eval = ensureEvaluatedStmt();
2451   if (!Eval->CheckedForICEInit) {
2452     Eval->CheckedForICEInit = true;
2453     Eval->HasICEInit = Init->isIntegerConstantExpr(Context);
2454   }
2455   return Eval->HasICEInit;
2456 }
2457
2458 bool VarDecl::hasConstantInitialization() const {
2459   // In C, all globals (and only globals) have constant initialization.
2460   if (hasGlobalStorage() && !getASTContext().getLangOpts().CPlusPlus)
2461     return true;
2462
2463   // In C++, it depends on whether the evaluation at the point of definition
2464   // was evaluatable as a constant initializer.
2465   if (EvaluatedStmt *Eval = getEvaluatedStmt())
2466     return Eval->HasConstantInitialization;
2467
2468   return false;
2469 }
2470
2471 bool VarDecl::checkForConstantInitialization(
2472     SmallVectorImpl<PartialDiagnosticAt> &Notes) const {
2473   EvaluatedStmt *Eval = ensureEvaluatedStmt();
2474   // If we ask for the value before we know whether we have a constant
2475   // initializer, we can compute the wrong value (for example, due to
2476   // std::is_constant_evaluated()).
2477   assert(!Eval->WasEvaluated &&
2478          "already evaluated var value before checking for constant init");
2479   assert(getASTContext().getLangOpts().CPlusPlus && "only meaningful in C++");
2480
2481   assert(!cast<Expr>(Eval->Value)->isValueDependent());
2482
2483   // Evaluate the initializer to check whether it's a constant expression.
2484   Eval->HasConstantInitialization =
2485       evaluateValueImpl(Notes, true) && Notes.empty();
2486
2487   // If evaluation as a constant initializer failed, allow re-evaluation as a
2488   // non-constant initializer if we later find we want the value.
2489   if (!Eval->HasConstantInitialization)
2490     Eval->WasEvaluated = false;
2491
2492   return Eval->HasConstantInitialization;
2493 }
2494
2495 bool VarDecl::isParameterPack() const {
2496   return isa<PackExpansionType>(getType());
2497 }
2498
2499 template<typename DeclT>
2500 static DeclT *getDefinitionOrSelf(DeclT *D) {
2501   assert(D);
2502   if (auto *Def = D->getDefinition())
2503     return Def;
2504   return D;
2505 }
2506
2507 bool VarDecl::isEscapingByref() const {
2508   return hasAttr<BlocksAttr>() && NonParmVarDeclBits.EscapingByref;
2509 }
2510
2511 bool VarDecl::isNonEscapingByref() const {
2512   return hasAttr<BlocksAttr>() && !NonParmVarDeclBits.EscapingByref;
2513 }
2514
2515 VarDecl *VarDecl::getTemplateInstantiationPattern() const {
2516   const VarDecl *VD = this;
2517
2518   // If this is an instantiated member, walk back to the template from which
2519   // it was instantiated.
2520   if (MemberSpecializationInfo *MSInfo = VD->getMemberSpecializationInfo()) {
2521     if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
2522       VD = VD->getInstantiatedFromStaticDataMember();
2523       while (auto *NewVD = VD->getInstantiatedFromStaticDataMember())
2524         VD = NewVD;
2525     }
2526   }
2527
2528   // If it's an instantiated variable template specialization, find the
2529   // template or partial specialization from which it was instantiated.
2530   if (auto *VDTemplSpec = dyn_cast<VarTemplateSpecializationDecl>(VD)) {
2531     if (isTemplateInstantiation(VDTemplSpec->getTemplateSpecializationKind())) {
2532       auto From = VDTemplSpec->getInstantiatedFrom();
2533       if (auto *VTD = From.dyn_cast<VarTemplateDecl *>()) {
2534         while (!VTD->isMemberSpecialization()) {
2535           auto *NewVTD = VTD->getInstantiatedFromMemberTemplate();
2536           if (!NewVTD)
2537             break;
2538           VTD = NewVTD;
2539         }
2540         return getDefinitionOrSelf(VTD->getTemplatedDecl());
2541       }
2542       if (auto *VTPSD =
2543               From.dyn_cast<VarTemplatePartialSpecializationDecl *>()) {
2544         while (!VTPSD->isMemberSpecialization()) {
2545           auto *NewVTPSD = VTPSD->getInstantiatedFromMember();
2546           if (!NewVTPSD)
2547             break;
2548           VTPSD = NewVTPSD;
2549         }
2550         return getDefinitionOrSelf<VarDecl>(VTPSD);
2551       }
2552     }
2553   }
2554
2555   // If this is the pattern of a variable template, find where it was
2556   // instantiated from. FIXME: Is this necessary?
2557   if (VarTemplateDecl *VarTemplate = VD->getDescribedVarTemplate()) {
2558     while (!VarTemplate->isMemberSpecialization()) {
2559       auto *NewVT = VarTemplate->getInstantiatedFromMemberTemplate();
2560       if (!NewVT)
2561         break;
2562       VarTemplate = NewVT;
2563     }
2564
2565     return getDefinitionOrSelf(VarTemplate->getTemplatedDecl());
2566   }
2567
2568   if (VD == this)
2569     return nullptr;
2570   return getDefinitionOrSelf(const_cast<VarDecl*>(VD));
2571 }
2572
2573 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
2574   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2575     return cast<VarDecl>(MSI->getInstantiatedFrom());
2576
2577   return nullptr;
2578 }
2579
2580 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
2581   if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2582     return Spec->getSpecializationKind();
2583
2584   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2585     return MSI->getTemplateSpecializationKind();
2586
2587   return TSK_Undeclared;
2588 }
2589
2590 TemplateSpecializationKind
2591 VarDecl::getTemplateSpecializationKindForInstantiation() const {
2592   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2593     return MSI->getTemplateSpecializationKind();
2594
2595   if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2596     return Spec->getSpecializationKind();
2597
2598   return TSK_Undeclared;
2599 }
2600
2601 SourceLocation VarDecl::getPointOfInstantiation() const {
2602   if (const auto *Spec = dyn_cast<VarTemplateSpecializationDecl>(this))
2603     return Spec->getPointOfInstantiation();
2604
2605   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
2606     return MSI->getPointOfInstantiation();
2607
2608   return SourceLocation();
2609 }
2610
2611 VarTemplateDecl *VarDecl::getDescribedVarTemplate() const {
2612   return getASTContext().getTemplateOrSpecializationInfo(this)
2613       .dyn_cast<VarTemplateDecl *>();
2614 }
2615
2616 void VarDecl::setDescribedVarTemplate(VarTemplateDecl *Template) {
2617   getASTContext().setTemplateOrSpecializationInfo(this, Template);
2618 }
2619
2620 bool VarDecl::isKnownToBeDefined() const {
2621   const auto &LangOpts = getASTContext().getLangOpts();
2622   // In CUDA mode without relocatable device code, variables of form 'extern
2623   // __shared__ Foo foo[]' are pointers to the base of the GPU core's shared
2624   // memory pool.  These are never undefined variables, even if they appear
2625   // inside of an anon namespace or static function.
2626   //
2627   // With CUDA relocatable device code enabled, these variables don't get
2628   // special handling; they're treated like regular extern variables.
2629   if (LangOpts.CUDA && !LangOpts.GPURelocatableDeviceCode &&
2630       hasExternalStorage() && hasAttr<CUDASharedAttr>() &&
2631       isa<IncompleteArrayType>(getType()))
2632     return true;
2633
2634   return hasDefinition();
2635 }
2636
2637 bool VarDecl::isNoDestroy(const ASTContext &Ctx) const {
2638   return hasGlobalStorage() && (hasAttr<NoDestroyAttr>() ||
2639                                 (!Ctx.getLangOpts().RegisterStaticDestructors &&
2640                                  !hasAttr<AlwaysDestroyAttr>()));
2641 }
2642
2643 QualType::DestructionKind
2644 VarDecl::needsDestruction(const ASTContext &Ctx) const {
2645   if (EvaluatedStmt *Eval = getEvaluatedStmt())
2646     if (Eval->HasConstantDestruction)
2647       return QualType::DK_none;
2648
2649   if (isNoDestroy(Ctx))
2650     return QualType::DK_none;
2651
2652   return getType().isDestructedType();
2653 }
2654
2655 MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
2656   if (isStaticDataMember())
2657     // FIXME: Remove ?
2658     // return getASTContext().getInstantiatedFromStaticDataMember(this);
2659     return getASTContext().getTemplateOrSpecializationInfo(this)
2660         .dyn_cast<MemberSpecializationInfo *>();
2661   return nullptr;
2662 }
2663
2664 void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2665                                          SourceLocation PointOfInstantiation) {
2666   assert((isa<VarTemplateSpecializationDecl>(this) ||
2667           getMemberSpecializationInfo()) &&
2668          "not a variable or static data member template specialization");
2669
2670   if (VarTemplateSpecializationDecl *Spec =
2671           dyn_cast<VarTemplateSpecializationDecl>(this)) {
2672     Spec->setSpecializationKind(TSK);
2673     if (TSK != TSK_ExplicitSpecialization &&
2674         PointOfInstantiation.isValid() &&
2675         Spec->getPointOfInstantiation().isInvalid()) {
2676       Spec->setPointOfInstantiation(PointOfInstantiation);
2677       if (ASTMutationListener *L = getASTContext().getASTMutationListener())
2678         L->InstantiationRequested(this);
2679     }
2680   } else if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) {
2681     MSI->setTemplateSpecializationKind(TSK);
2682     if (TSK != TSK_ExplicitSpecialization && PointOfInstantiation.isValid() &&
2683         MSI->getPointOfInstantiation().isInvalid()) {
2684       MSI->setPointOfInstantiation(PointOfInstantiation);
2685       if (ASTMutationListener *L = getASTContext().getASTMutationListener())
2686         L->InstantiationRequested(this);
2687     }
2688   }
2689 }
2690
2691 void
2692 VarDecl::setInstantiationOfStaticDataMember(VarDecl *VD,
2693                                             TemplateSpecializationKind TSK) {
2694   assert(getASTContext().getTemplateOrSpecializationInfo(this).isNull() &&
2695          "Previous template or instantiation?");
2696   getASTContext().setInstantiatedFromStaticDataMember(this, VD, TSK);
2697 }
2698
2699 //===----------------------------------------------------------------------===//
2700 // ParmVarDecl Implementation
2701 //===----------------------------------------------------------------------===//
2702
2703 ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC,
2704                                  SourceLocation StartLoc,
2705                                  SourceLocation IdLoc, IdentifierInfo *Id,
2706                                  QualType T, TypeSourceInfo *TInfo,
2707                                  StorageClass S, Expr *DefArg) {
2708   return new (C, DC) ParmVarDecl(ParmVar, C, DC, StartLoc, IdLoc, Id, T, TInfo,
2709                                  S, DefArg);
2710 }
2711
2712 QualType ParmVarDecl::getOriginalType() const {
2713   TypeSourceInfo *TSI = getTypeSourceInfo();
2714   QualType T = TSI ? TSI->getType() : getType();
2715   if (const auto *DT = dyn_cast<DecayedType>(T))
2716     return DT->getOriginalType();
2717   return T;
2718 }
2719
2720 ParmVarDecl *ParmVarDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
2721   return new (C, ID)
2722       ParmVarDecl(ParmVar, C, nullptr, SourceLocation(), SourceLocation(),
2723                   nullptr, QualType(), nullptr, SC_None, nullptr);
2724 }
2725
2726 SourceRange ParmVarDecl::getSourceRange() const {
2727   if (!hasInheritedDefaultArg()) {
2728     SourceRange ArgRange = getDefaultArgRange();
2729     if (ArgRange.isValid())
2730       return SourceRange(getOuterLocStart(), ArgRange.getEnd());
2731   }
2732
2733   // DeclaratorDecl considers the range of postfix types as overlapping with the
2734   // declaration name, but this is not the case with parameters in ObjC methods.
2735   if (isa<ObjCMethodDecl>(getDeclContext()))
2736     return SourceRange(DeclaratorDecl::getBeginLoc(), getLocation());
2737
2738   return DeclaratorDecl::getSourceRange();
2739 }
2740
2741 bool ParmVarDecl::isDestroyedInCallee() const {
2742   if (hasAttr<NSConsumedAttr>())
2743     return true;
2744
2745   auto *RT = getType()->getAs<RecordType>();
2746   if (RT && RT->getDecl()->isParamDestroyedInCallee())
2747     return true;
2748
2749   return false;
2750 }
2751
2752 Expr *ParmVarDecl::getDefaultArg() {
2753   assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!");
2754   assert(!hasUninstantiatedDefaultArg() &&
2755          "Default argument is not yet instantiated!");
2756
2757   Expr *Arg = getInit();
2758   if (auto *E = dyn_cast_or_null<FullExpr>(Arg))
2759     return E->getSubExpr();
2760
2761   return Arg;
2762 }
2763
2764 void ParmVarDecl::setDefaultArg(Expr *defarg) {
2765   ParmVarDeclBits.DefaultArgKind = DAK_Normal;
2766   Init = defarg;
2767 }
2768
2769 SourceRange ParmVarDecl::getDefaultArgRange() const {
2770   switch (ParmVarDeclBits.DefaultArgKind) {
2771   case DAK_None:
2772   case DAK_Unparsed:
2773     // Nothing we can do here.
2774     return SourceRange();
2775
2776   case DAK_Uninstantiated:
2777     return getUninstantiatedDefaultArg()->getSourceRange();
2778
2779   case DAK_Normal:
2780     if (const Expr *E = getInit())
2781       return E->getSourceRange();
2782
2783     // Missing an actual expression, may be invalid.
2784     return SourceRange();
2785   }
2786   llvm_unreachable("Invalid default argument kind.");
2787 }
2788
2789 void ParmVarDecl::setUninstantiatedDefaultArg(Expr *arg) {
2790   ParmVarDeclBits.DefaultArgKind = DAK_Uninstantiated;
2791   Init = arg;
2792 }
2793
2794 Expr *ParmVarDecl::getUninstantiatedDefaultArg() {
2795   assert(hasUninstantiatedDefaultArg() &&
2796          "Wrong kind of initialization expression!");
2797   return cast_or_null<Expr>(Init.get<Stmt *>());
2798 }
2799
2800 bool ParmVarDecl::hasDefaultArg() const {
2801   // FIXME: We should just return false for DAK_None here once callers are
2802   // prepared for the case that we encountered an invalid default argument and
2803   // were unable to even build an invalid expression.
2804   return hasUnparsedDefaultArg() || hasUninstantiatedDefaultArg() ||
2805          !Init.isNull();
2806 }
2807
2808 void ParmVarDecl::setParameterIndexLarge(unsigned parameterIndex) {
2809   getASTContext().setParameterIndex(this, parameterIndex);
2810   ParmVarDeclBits.ParameterIndex = ParameterIndexSentinel;
2811 }
2812
2813 unsigned ParmVarDecl::getParameterIndexLarge() const {
2814   return getASTContext().getParameterIndex(this);
2815 }
2816
2817 //===----------------------------------------------------------------------===//
2818 // FunctionDecl Implementation
2819 //===----------------------------------------------------------------------===//
2820
2821 FunctionDecl::FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC,
2822                            SourceLocation StartLoc,
2823                            const DeclarationNameInfo &NameInfo, QualType T,
2824                            TypeSourceInfo *TInfo, StorageClass S,
2825                            bool isInlineSpecified,
2826                            ConstexprSpecKind ConstexprKind,
2827                            Expr *TrailingRequiresClause)
2828     : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
2829                      StartLoc),
2830       DeclContext(DK), redeclarable_base(C), Body(), ODRHash(0),
2831       EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {
2832   assert(T.isNull() || T->isFunctionType());
2833   FunctionDeclBits.SClass = S;
2834   FunctionDeclBits.IsInline = isInlineSpecified;
2835   FunctionDeclBits.IsInlineSpecified = isInlineSpecified;
2836   FunctionDeclBits.IsVirtualAsWritten = false;
2837   FunctionDeclBits.IsPure = false;
2838   FunctionDeclBits.HasInheritedPrototype = false;
2839   FunctionDeclBits.HasWrittenPrototype = true;
2840   FunctionDeclBits.IsDeleted = false;
2841   FunctionDeclBits.IsTrivial = false;
2842   FunctionDeclBits.IsTrivialForCall = false;
2843   FunctionDeclBits.IsDefaulted = false;
2844   FunctionDeclBits.IsExplicitlyDefaulted = false;
2845   FunctionDeclBits.HasDefaultedFunctionInfo = false;
2846   FunctionDeclBits.HasImplicitReturnZero = false;
2847   FunctionDeclBits.IsLateTemplateParsed = false;
2848   FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(ConstexprKind);
2849   FunctionDeclBits.InstantiationIsPending = false;
2850   FunctionDeclBits.UsesSEHTry = false;
2851   FunctionDeclBits.UsesFPIntrin = false;
2852   FunctionDeclBits.HasSkippedBody = false;
2853   FunctionDeclBits.WillHaveBody = false;
2854   FunctionDeclBits.IsMultiVersion = false;
2855   FunctionDeclBits.IsCopyDeductionCandidate = false;
2856   FunctionDeclBits.HasODRHash = false;
2857   if (TrailingRequiresClause)
2858     setTrailingRequiresClause(TrailingRequiresClause);
2859 }
2860
2861 void FunctionDecl::getNameForDiagnostic(
2862     raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const {
2863   NamedDecl::getNameForDiagnostic(OS, Policy, Qualified);
2864   const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs();
2865   if (TemplateArgs)
2866     printTemplateArgumentList(OS, TemplateArgs->asArray(), Policy);
2867 }
2868
2869 bool FunctionDecl::isVariadic() const {
2870   if (const auto *FT = getType()->getAs<FunctionProtoType>())
2871     return FT->isVariadic();
2872   return false;
2873 }
2874
2875 FunctionDecl::DefaultedFunctionInfo *
2876 FunctionDecl::DefaultedFunctionInfo::Create(ASTContext &Context,
2877                                             ArrayRef<DeclAccessPair> Lookups) {
2878   DefaultedFunctionInfo *Info = new (Context.Allocate(
2879       totalSizeToAlloc<DeclAccessPair>(Lookups.size()),
2880       std::max(alignof(DefaultedFunctionInfo), alignof(DeclAccessPair))))
2881       DefaultedFunctionInfo;
2882   Info->NumLookups = Lookups.size();
2883   std::uninitialized_copy(Lookups.begin(), Lookups.end(),
2884                           Info->getTrailingObjects<DeclAccessPair>());
2885   return Info;
2886 }
2887
2888 void FunctionDecl::setDefaultedFunctionInfo(DefaultedFunctionInfo *Info) {
2889   assert(!FunctionDeclBits.HasDefaultedFunctionInfo && "already have this");
2890   assert(!Body && "can't replace function body with defaulted function info");
2891
2892   FunctionDeclBits.HasDefaultedFunctionInfo = true;
2893   DefaultedInfo = Info;
2894 }
2895
2896 FunctionDecl::DefaultedFunctionInfo *
2897 FunctionDecl::getDefaultedFunctionInfo() const {
2898   return FunctionDeclBits.HasDefaultedFunctionInfo ? DefaultedInfo : nullptr;
2899 }
2900
2901 bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const {
2902   for (auto I : redecls()) {
2903     if (I->doesThisDeclarationHaveABody()) {
2904       Definition = I;
2905       return true;
2906     }
2907   }
2908
2909   return false;
2910 }
2911
2912 bool FunctionDecl::hasTrivialBody() const {
2913   Stmt *S = getBody();
2914   if (!S) {
2915     // Since we don't have a body for this function, we don't know if it's
2916     // trivial or not.
2917     return false;
2918   }
2919
2920   if (isa<CompoundStmt>(S) && cast<CompoundStmt>(S)->body_empty())
2921     return true;
2922   return false;
2923 }
2924
2925 bool FunctionDecl::isThisDeclarationInstantiatedFromAFriendDefinition() const {
2926   if (!getFriendObjectKind())
2927     return false;
2928
2929   // Check for a friend function instantiated from a friend function
2930   // definition in a templated class.
2931   if (const FunctionDecl *InstantiatedFrom =
2932           getInstantiatedFromMemberFunction())
2933     return InstantiatedFrom->getFriendObjectKind() &&
2934            InstantiatedFrom->isThisDeclarationADefinition();
2935
2936   // Check for a friend function template instantiated from a friend
2937   // function template definition in a templated class.
2938   if (const FunctionTemplateDecl *Template = getDescribedFunctionTemplate()) {
2939     if (const FunctionTemplateDecl *InstantiatedFrom =
2940             Template->getInstantiatedFromMemberTemplate())
2941       return InstantiatedFrom->getFriendObjectKind() &&
2942              InstantiatedFrom->isThisDeclarationADefinition();
2943   }
2944
2945   return false;
2946 }
2947
2948 bool FunctionDecl::isDefined(const FunctionDecl *&Definition,
2949                              bool CheckForPendingFriendDefinition) const {
2950   for (const FunctionDecl *FD : redecls()) {
2951     if (FD->isThisDeclarationADefinition()) {
2952       Definition = FD;
2953       return true;
2954     }
2955
2956     // If this is a friend function defined in a class template, it does not
2957     // have a body until it is used, nevertheless it is a definition, see
2958     // [temp.inst]p2:
2959     //
2960     // ... for the purpose of determining whether an instantiated redeclaration
2961     // is valid according to [basic.def.odr] and [class.mem], a declaration that
2962     // corresponds to a definition in the template is considered to be a
2963     // definition.
2964     //
2965     // The following code must produce redefinition error:
2966     //
2967     //     template<typename T> struct C20 { friend void func_20() {} };
2968     //     C20<int> c20i;
2969     //     void func_20() {}
2970     //
2971     if (CheckForPendingFriendDefinition &&
2972         FD->isThisDeclarationInstantiatedFromAFriendDefinition()) {
2973       Definition = FD;
2974       return true;
2975     }
2976   }
2977
2978   return false;
2979 }
2980
2981 Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const {
2982   if (!hasBody(Definition))
2983     return nullptr;
2984
2985   assert(!Definition->FunctionDeclBits.HasDefaultedFunctionInfo &&
2986          "definition should not have a body");
2987   if (Definition->Body)
2988     return Definition->Body.get(getASTContext().getExternalSource());
2989
2990   return nullptr;
2991 }
2992
2993 void FunctionDecl::setBody(Stmt *B) {
2994   FunctionDeclBits.HasDefaultedFunctionInfo = false;
2995   Body = LazyDeclStmtPtr(B);
2996   if (B)
2997     EndRangeLoc = B->getEndLoc();
2998 }
2999
3000 void FunctionDecl::setPure(bool P) {
3001   FunctionDeclBits.IsPure = P;
3002   if (P)
3003     if (auto *Parent = dyn_cast<CXXRecordDecl>(getDeclContext()))
3004       Parent->markedVirtualFunctionPure();
3005 }
3006
3007 template<std::size_t Len>
3008 static bool isNamed(const NamedDecl *ND, const char (&Str)[Len]) {
3009   IdentifierInfo *II = ND->getIdentifier();
3010   return II && II->isStr(Str);
3011 }
3012
3013 bool FunctionDecl::isMain() const {
3014   const TranslationUnitDecl *tunit =
3015     dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
3016   return tunit &&
3017          !tunit->getASTContext().getLangOpts().Freestanding &&
3018          isNamed(this, "main");
3019 }
3020
3021 bool FunctionDecl::isMSVCRTEntryPoint() const {
3022   const TranslationUnitDecl *TUnit =
3023       dyn_cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext());
3024   if (!TUnit)
3025     return false;
3026
3027   // Even though we aren't really targeting MSVCRT if we are freestanding,
3028   // semantic analysis for these functions remains the same.
3029
3030   // MSVCRT entry points only exist on MSVCRT targets.
3031   if (!TUnit->getASTContext().getTargetInfo().getTriple().isOSMSVCRT())
3032     return false;
3033
3034   // Nameless functions like constructors cannot be entry points.
3035   if (!getIdentifier())
3036     return false;
3037
3038   return llvm::StringSwitch<bool>(getName())
3039       .Cases("main",     // an ANSI console app
3040              "wmain",    // a Unicode console App
3041              "WinMain",  // an ANSI GUI app
3042              "wWinMain", // a Unicode GUI app
3043              "DllMain",  // a DLL
3044              true)
3045       .Default(false);
3046 }
3047
3048 bool FunctionDecl::isReservedGlobalPlacementOperator() const {
3049   assert(getDeclName().getNameKind() == DeclarationName::CXXOperatorName);
3050   assert(getDeclName().getCXXOverloadedOperator() == OO_New ||
3051          getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3052          getDeclName().getCXXOverloadedOperator() == OO_Array_New ||
3053          getDeclName().getCXXOverloadedOperator() == OO_Array_Delete);
3054
3055   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
3056     return false;
3057
3058   const auto *proto = getType()->castAs<FunctionProtoType>();
3059   if (proto->getNumParams() != 2 || proto->isVariadic())
3060     return false;
3061
3062   ASTContext &Context =
3063     cast<TranslationUnitDecl>(getDeclContext()->getRedeclContext())
3064       ->getASTContext();
3065
3066   // The result type and first argument type are constant across all
3067   // these operators.  The second argument must be exactly void*.
3068   return (proto->getParamType(1).getCanonicalType() == Context.VoidPtrTy);
3069 }
3070
3071 bool FunctionDecl::isReplaceableGlobalAllocationFunction(
3072     Optional<unsigned> *AlignmentParam, bool *IsNothrow) const {
3073   if (getDeclName().getNameKind() != DeclarationName::CXXOperatorName)
3074     return false;
3075   if (getDeclName().getCXXOverloadedOperator() != OO_New &&
3076       getDeclName().getCXXOverloadedOperator() != OO_Delete &&
3077       getDeclName().getCXXOverloadedOperator() != OO_Array_New &&
3078       getDeclName().getCXXOverloadedOperator() != OO_Array_Delete)
3079     return false;
3080
3081   if (isa<CXXRecordDecl>(getDeclContext()))
3082     return false;
3083
3084   // This can only fail for an invalid 'operator new' declaration.
3085   if (!getDeclContext()->getRedeclContext()->isTranslationUnit())
3086     return false;
3087
3088   const auto *FPT = getType()->castAs<FunctionProtoType>();
3089   if (FPT->getNumParams() == 0 || FPT->getNumParams() > 3 || FPT->isVariadic())
3090     return false;
3091
3092   // If this is a single-parameter function, it must be a replaceable global
3093   // allocation or deallocation function.
3094   if (FPT->getNumParams() == 1)
3095     return true;
3096
3097   unsigned Params = 1;
3098   QualType Ty = FPT->getParamType(Params);
3099   ASTContext &Ctx = getASTContext();
3100
3101   auto Consume = [&] {
3102     ++Params;
3103     Ty = Params < FPT->getNumParams() ? FPT->getParamType(Params) : QualType();
3104   };
3105
3106   // In C++14, the next parameter can be a 'std::size_t' for sized delete.
3107   bool IsSizedDelete = false;
3108   if (Ctx.getLangOpts().SizedDeallocation &&
3109       (getDeclName().getCXXOverloadedOperator() == OO_Delete ||
3110        getDeclName().getCXXOverloadedOperator() == OO_Array_Delete) &&
3111       Ctx.hasSameType(Ty, Ctx.getSizeType())) {
3112     IsSizedDelete = true;
3113     Consume();
3114   }
3115
3116   // In C++17, the next parameter can be a 'std::align_val_t' for aligned
3117   // new/delete.
3118   if (Ctx.getLangOpts().AlignedAllocation && !Ty.isNull() && Ty->isAlignValT()) {
3119     Consume();
3120     if (AlignmentParam)
3121       *AlignmentParam = Params;
3122   }
3123
3124   // Finally, if this is not a sized delete, the final parameter can
3125   // be a 'const std::nothrow_t&'.
3126   if (!IsSizedDelete && !Ty.isNull() && Ty->isReferenceType()) {
3127     Ty = Ty->getPointeeType();
3128     if (Ty.getCVRQualifiers() != Qualifiers::Const)
3129       return false;
3130     if (Ty->isNothrowT()) {
3131       if (IsNothrow)
3132         *IsNothrow = true;
3133       Consume();
3134     }
3135   }
3136
3137   return Params == FPT->getNumParams();
3138 }
3139
3140 bool FunctionDecl::isInlineBuiltinDeclaration() const {
3141   if (!getBuiltinID())
3142     return false;
3143
3144   const FunctionDecl *Definition;
3145   return hasBody(Definition) && Definition->isInlineSpecified();
3146 }
3147
3148 bool FunctionDecl::isDestroyingOperatorDelete() const {
3149   // C++ P0722:
3150   //   Within a class C, a single object deallocation function with signature
3151   //     (T, std::destroying_delete_t, <more params>)
3152   //   is a destroying operator delete.
3153   if (!isa<CXXMethodDecl>(this) || getOverloadedOperator() != OO_Delete ||
3154       getNumParams() < 2)
3155     return false;
3156
3157   auto *RD = getParamDecl(1)->getType()->getAsCXXRecordDecl();
3158   return RD && RD->isInStdNamespace() && RD->getIdentifier() &&
3159          RD->getIdentifier()->isStr("destroying_delete_t");
3160 }
3161
3162 LanguageLinkage FunctionDecl::getLanguageLinkage() const {
3163   return getDeclLanguageLinkage(*this);
3164 }
3165
3166 bool FunctionDecl::isExternC() const {
3167   return isDeclExternC(*this);
3168 }
3169
3170 bool FunctionDecl::isInExternCContext() const {
3171   if (hasAttr<OpenCLKernelAttr>())
3172     return true;
3173   return getLexicalDeclContext()->isExternCContext();
3174 }
3175
3176 bool FunctionDecl::isInExternCXXContext() const {
3177   return getLexicalDeclContext()->isExternCXXContext();
3178 }
3179
3180 bool FunctionDecl::isGlobal() const {
3181   if (const auto *Method = dyn_cast<CXXMethodDecl>(this))
3182     return Method->isStatic();
3183
3184   if (getCanonicalDecl()->getStorageClass() == SC_Static)
3185     return false;
3186
3187   for (const DeclContext *DC = getDeclContext();
3188        DC->isNamespace();
3189        DC = DC->getParent()) {
3190     if (const auto *Namespace = cast<NamespaceDecl>(DC)) {
3191       if (!Namespace->getDeclName())
3192         return false;
3193       break;
3194     }
3195   }
3196
3197   return true;
3198 }
3199
3200 bool FunctionDecl::isNoReturn() const {
3201   if (hasAttr<NoReturnAttr>() || hasAttr<CXX11NoReturnAttr>() ||
3202       hasAttr<C11NoReturnAttr>())
3203     return true;
3204
3205   if (auto *FnTy = getType()->getAs<FunctionType>())
3206     return FnTy->getNoReturnAttr();
3207
3208   return false;
3209 }
3210
3211
3212 MultiVersionKind FunctionDecl::getMultiVersionKind() const {
3213   if (hasAttr<TargetAttr>())
3214     return MultiVersionKind::Target;
3215   if (hasAttr<CPUDispatchAttr>())
3216     return MultiVersionKind::CPUDispatch;
3217   if (hasAttr<CPUSpecificAttr>())
3218     return MultiVersionKind::CPUSpecific;
3219   return MultiVersionKind::None;
3220 }
3221
3222 bool FunctionDecl::isCPUDispatchMultiVersion() const {
3223   return isMultiVersion() && hasAttr<CPUDispatchAttr>();
3224 }
3225
3226 bool FunctionDecl::isCPUSpecificMultiVersion() const {
3227   return isMultiVersion() && hasAttr<CPUSpecificAttr>();
3228 }
3229
3230 bool FunctionDecl::isTargetMultiVersion() const {
3231   return isMultiVersion() && hasAttr<TargetAttr>();
3232 }
3233
3234 void
3235 FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) {
3236   redeclarable_base::setPreviousDecl(PrevDecl);
3237
3238   if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) {
3239     FunctionTemplateDecl *PrevFunTmpl
3240       = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : nullptr;
3241     assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch");
3242     FunTmpl->setPreviousDecl(PrevFunTmpl);
3243   }
3244
3245   if (PrevDecl && PrevDecl->isInlined())
3246     setImplicitlyInline(true);
3247 }
3248
3249 FunctionDecl *FunctionDecl::getCanonicalDecl() { return getFirstDecl(); }
3250
3251 /// Returns a value indicating whether this function corresponds to a builtin
3252 /// function.
3253 ///
3254 /// The function corresponds to a built-in function if it is declared at
3255 /// translation scope or within an extern "C" block and its name matches with
3256 /// the name of a builtin. The returned value will be 0 for functions that do
3257 /// not correspond to a builtin, a value of type \c Builtin::ID if in the
3258 /// target-independent range \c [1,Builtin::First), or a target-specific builtin
3259 /// value.
3260 ///
3261 /// \param ConsiderWrapperFunctions If true, we should consider wrapper
3262 /// functions as their wrapped builtins. This shouldn't be done in general, but
3263 /// it's useful in Sema to diagnose calls to wrappers based on their semantics.
3264 unsigned FunctionDecl::getBuiltinID(bool ConsiderWrapperFunctions) const {
3265   unsigned BuiltinID = 0;
3266
3267   if (const auto *ABAA = getAttr<ArmBuiltinAliasAttr>()) {
3268     BuiltinID = ABAA->getBuiltinName()->getBuiltinID();
3269   } else if (const auto *A = getAttr<BuiltinAttr>()) {
3270     BuiltinID = A->getID();
3271   }
3272
3273   if (!BuiltinID)
3274     return 0;
3275
3276   // If the function is marked "overloadable", it has a different mangled name
3277   // and is not the C library function.
3278   if (!ConsiderWrapperFunctions && hasAttr<OverloadableAttr>() &&
3279       !hasAttr<ArmBuiltinAliasAttr>())
3280     return 0;
3281
3282   ASTContext &Context = getASTContext();
3283   if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3284     return BuiltinID;
3285
3286   // This function has the name of a known C library
3287   // function. Determine whether it actually refers to the C library
3288   // function or whether it just has the same name.
3289
3290   // If this is a static function, it's not a builtin.
3291   if (!ConsiderWrapperFunctions && getStorageClass() == SC_Static)
3292     return 0;
3293
3294   // OpenCL v1.2 s6.9.f - The library functions defined in
3295   // the C99 standard headers are not available.
3296   if (Context.getLangOpts().OpenCL &&
3297       Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
3298     return 0;
3299
3300   // CUDA does not have device-side standard library. printf and malloc are the
3301   // only special cases that are supported by device-side runtime.
3302   if (Context.getLangOpts().CUDA && hasAttr<CUDADeviceAttr>() &&
3303       !hasAttr<CUDAHostAttr>() &&
3304       !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3305     return 0;
3306
3307   // As AMDGCN implementation of OpenMP does not have a device-side standard
3308   // library, none of the predefined library functions except printf and malloc
3309   // should be treated as a builtin i.e. 0 should be returned for them.
3310   if (Context.getTargetInfo().getTriple().isAMDGCN() &&
3311       Context.getLangOpts().OpenMPIsDevice &&
3312       Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
3313       !(BuiltinID == Builtin::BIprintf || BuiltinID == Builtin::BImalloc))
3314     return 0;
3315
3316   return BuiltinID;
3317 }
3318
3319 /// getNumParams - Return the number of parameters this function must have
3320 /// based on its FunctionType.  This is the length of the ParamInfo array
3321 /// after it has been created.
3322 unsigned FunctionDecl::getNumParams() const {
3323   const auto *FPT = getType()->getAs<FunctionProtoType>();
3324   return FPT ? FPT->getNumParams() : 0;
3325 }
3326
3327 void FunctionDecl::setParams(ASTContext &C,
3328                              ArrayRef<ParmVarDecl *> NewParamInfo) {
3329   assert(!ParamInfo && "Already has param info!");
3330   assert(NewParamInfo.size() == getNumParams() && "Parameter count mismatch!");
3331
3332   // Zero params -> null pointer.
3333   if (!NewParamInfo.empty()) {
3334     ParamInfo = new (C) ParmVarDecl*[NewParamInfo.size()];
3335     std::copy(NewParamInfo.begin(), NewParamInfo.end(), ParamInfo);
3336   }
3337 }
3338
3339 /// getMinRequiredArguments - Returns the minimum number of arguments
3340 /// needed to call this function. This may be fewer than the number of
3341 /// function parameters, if some of the parameters have default
3342 /// arguments (in C++) or are parameter packs (C++11).
3343 unsigned FunctionDecl::getMinRequiredArguments() const {
3344   if (!getASTContext().getLangOpts().CPlusPlus)
3345     return getNumParams();
3346
3347   // Note that it is possible for a parameter with no default argument to
3348   // follow a parameter with a default argument.
3349   unsigned NumRequiredArgs = 0;
3350   unsigned MinParamsSoFar = 0;
3351   for (auto *Param : parameters()) {
3352     if (!Param->isParameterPack()) {
3353       ++MinParamsSoFar;
3354       if (!Param->hasDefaultArg())
3355         NumRequiredArgs = MinParamsSoFar;
3356     }
3357   }
3358   return NumRequiredArgs;
3359 }
3360
3361 bool FunctionDecl::hasOneParamOrDefaultArgs() const {
3362   return getNumParams() == 1 ||
3363          (getNumParams() > 1 &&
3364           std::all_of(param_begin() + 1, param_end(),
3365                       [](ParmVarDecl *P) { return P->hasDefaultArg(); }));
3366 }
3367
3368 /// The combination of the extern and inline keywords under MSVC forces
3369 /// the function to be required.
3370 ///
3371 /// Note: This function assumes that we will only get called when isInlined()
3372 /// would return true for this FunctionDecl.
3373 bool FunctionDecl::isMSExternInline() const {
3374   assert(isInlined() && "expected to get called on an inlined function!");
3375
3376   const ASTContext &Context = getASTContext();
3377   if (!Context.getTargetInfo().getCXXABI().isMicrosoft() &&
3378       !hasAttr<DLLExportAttr>())
3379     return false;
3380
3381   for (const FunctionDecl *FD = getMostRecentDecl(); FD;
3382        FD = FD->getPreviousDecl())
3383     if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3384       return true;
3385
3386   return false;
3387 }
3388
3389 static bool redeclForcesDefMSVC(const FunctionDecl *Redecl) {
3390   if (Redecl->getStorageClass() != SC_Extern)
3391     return false;
3392
3393   for (const FunctionDecl *FD = Redecl->getPreviousDecl(); FD;
3394        FD = FD->getPreviousDecl())
3395     if (!FD->isImplicit() && FD->getStorageClass() == SC_Extern)
3396       return false;
3397
3398   return true;
3399 }
3400
3401 static bool RedeclForcesDefC99(const FunctionDecl *Redecl) {
3402   // Only consider file-scope declarations in this test.
3403   if (!Redecl->getLexicalDeclContext()->isTranslationUnit())
3404     return false;
3405
3406   // Only consider explicit declarations; the presence of a builtin for a
3407   // libcall shouldn't affect whether a definition is externally visible.
3408   if (Redecl->isImplicit())
3409     return false;
3410
3411   if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == SC_Extern)
3412     return true; // Not an inline definition
3413
3414   return false;
3415 }
3416
3417 /// For a function declaration in C or C++, determine whether this
3418 /// declaration causes the definition to be externally visible.
3419 ///
3420 /// For instance, this determines if adding the current declaration to the set
3421 /// of redeclarations of the given functions causes
3422 /// isInlineDefinitionExternallyVisible to change from false to true.
3423 bool FunctionDecl::doesDeclarationForceExternallyVisibleDefinition() const {
3424   assert(!doesThisDeclarationHaveABody() &&
3425          "Must have a declaration without a body.");
3426
3427   ASTContext &Context = getASTContext();
3428
3429   if (Context.getLangOpts().MSVCCompat) {
3430     const FunctionDecl *Definition;
3431     if (hasBody(Definition) && Definition->isInlined() &&
3432         redeclForcesDefMSVC(this))
3433       return true;
3434   }
3435
3436   if (Context.getLangOpts().CPlusPlus)
3437     return false;
3438
3439   if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3440     // With GNU inlining, a declaration with 'inline' but not 'extern', forces
3441     // an externally visible definition.
3442     //
3443     // FIXME: What happens if gnu_inline gets added on after the first
3444     // declaration?
3445     if (!isInlineSpecified() || getStorageClass() == SC_Extern)
3446       return false;
3447
3448     const FunctionDecl *Prev = this;
3449     bool FoundBody = false;
3450     while ((Prev = Prev->getPreviousDecl())) {
3451       FoundBody |= Prev->doesThisDeclarationHaveABody();
3452
3453       if (Prev->doesThisDeclarationHaveABody()) {
3454         // If it's not the case that both 'inline' and 'extern' are
3455         // specified on the definition, then it is always externally visible.
3456         if (!Prev->isInlineSpecified() ||
3457             Prev->getStorageClass() != SC_Extern)
3458           return false;
3459       } else if (Prev->isInlineSpecified() &&
3460                  Prev->getStorageClass() != SC_Extern) {
3461         return false;
3462       }
3463     }
3464     return FoundBody;
3465   }
3466
3467   // C99 6.7.4p6:
3468   //   [...] If all of the file scope declarations for a function in a
3469   //   translation unit include the inline function specifier without extern,
3470   //   then the definition in that translation unit is an inline definition.
3471   if (isInlineSpecified() && getStorageClass() != SC_Extern)
3472     return false;
3473   const FunctionDecl *Prev = this;
3474   bool FoundBody = false;
3475   while ((Prev = Prev->getPreviousDecl())) {
3476     FoundBody |= Prev->doesThisDeclarationHaveABody();
3477     if (RedeclForcesDefC99(Prev))
3478       return false;
3479   }
3480   return FoundBody;
3481 }
3482
3483 FunctionTypeLoc FunctionDecl::getFunctionTypeLoc() const {
3484   const TypeSourceInfo *TSI = getTypeSourceInfo();
3485   return TSI ? TSI->getTypeLoc().IgnoreParens().getAs<FunctionTypeLoc>()
3486              : FunctionTypeLoc();
3487 }
3488
3489 SourceRange FunctionDecl::getReturnTypeSourceRange() const {
3490   FunctionTypeLoc FTL = getFunctionTypeLoc();
3491   if (!FTL)
3492     return SourceRange();
3493
3494   // Skip self-referential return types.
3495   const SourceManager &SM = getASTContext().getSourceManager();
3496   SourceRange RTRange = FTL.getReturnLoc().getSourceRange();
3497   SourceLocation Boundary = getNameInfo().getBeginLoc();
3498   if (RTRange.isInvalid() || Boundary.isInvalid() ||
3499       !SM.isBeforeInTranslationUnit(RTRange.getEnd(), Boundary))
3500     return SourceRange();
3501
3502   return RTRange;
3503 }
3504
3505 SourceRange FunctionDecl::getParametersSourceRange() const {
3506   unsigned NP = getNumParams();
3507   SourceLocation EllipsisLoc = getEllipsisLoc();
3508
3509   if (NP == 0 && EllipsisLoc.isInvalid())
3510     return SourceRange();
3511
3512   SourceLocation Begin =
3513       NP > 0 ? ParamInfo[0]->getSourceRange().getBegin() : EllipsisLoc;
3514   SourceLocation End = EllipsisLoc.isValid()
3515                            ? EllipsisLoc
3516                            : ParamInfo[NP - 1]->getSourceRange().getEnd();
3517
3518   return SourceRange(Begin, End);
3519 }
3520
3521 SourceRange FunctionDecl::getExceptionSpecSourceRange() const {
3522   FunctionTypeLoc FTL = getFunctionTypeLoc();
3523   return FTL ? FTL.getExceptionSpecRange() : SourceRange();
3524 }
3525
3526 /// For an inline function definition in C, or for a gnu_inline function
3527 /// in C++, determine whether the definition will be externally visible.
3528 ///
3529 /// Inline function definitions are always available for inlining optimizations.
3530 /// However, depending on the language dialect, declaration specifiers, and
3531 /// attributes, the definition of an inline function may or may not be
3532 /// "externally" visible to other translation units in the program.
3533 ///
3534 /// In C99, inline definitions are not externally visible by default. However,
3535 /// if even one of the global-scope declarations is marked "extern inline", the
3536 /// inline definition becomes externally visible (C99 6.7.4p6).
3537 ///
3538 /// In GNU89 mode, or if the gnu_inline attribute is attached to the function
3539 /// definition, we use the GNU semantics for inline, which are nearly the
3540 /// opposite of C99 semantics. In particular, "inline" by itself will create
3541 /// an externally visible symbol, but "extern inline" will not create an
3542 /// externally visible symbol.
3543 bool FunctionDecl::isInlineDefinitionExternallyVisible() const {
3544   assert((doesThisDeclarationHaveABody() || willHaveBody() ||
3545           hasAttr<AliasAttr>()) &&
3546          "Must be a function definition");
3547   assert(isInlined() && "Function must be inline");
3548   ASTContext &Context = getASTContext();
3549
3550   if (Context.getLangOpts().GNUInline || hasAttr<GNUInlineAttr>()) {
3551     // Note: If you change the logic here, please change
3552     // doesDeclarationForceExternallyVisibleDefinition as well.
3553     //
3554     // If it's not the case that both 'inline' and 'extern' are
3555     // specified on the definition, then this inline definition is
3556     // externally visible.
3557     if (Context.getLangOpts().CPlusPlus)
3558       return false;
3559     if (!(isInlineSpecified() && getStorageClass() == SC_Extern))
3560       return true;
3561
3562     // If any declaration is 'inline' but not 'extern', then this definition
3563     // is externally visible.
3564     for (auto Redecl : redecls()) {
3565       if (Redecl->isInlineSpecified() &&
3566           Redecl->getStorageClass() != SC_Extern)
3567         return true;
3568     }
3569
3570     return false;
3571   }
3572
3573   // The rest of this function is C-only.
3574   assert(!Context.getLangOpts().CPlusPlus &&
3575          "should not use C inline rules in C++");
3576
3577   // C99 6.7.4p6:
3578   //   [...] If all of the file scope declarations for a function in a
3579   //   translation unit include the inline function specifier without extern,
3580   //   then the definition in that translation unit is an inline definition.
3581   for (auto Redecl : redecls()) {
3582     if (RedeclForcesDefC99(Redecl))
3583       return true;
3584   }
3585
3586   // C99 6.7.4p6:
3587   //   An inline definition does not provide an external definition for the
3588   //   function, and does not forbid an external definition in another
3589   //   translation unit.
3590   return false;
3591 }
3592
3593 /// getOverloadedOperator - Which C++ overloaded operator this
3594 /// function represents, if any.
3595 OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const {
3596   if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
3597     return getDeclName().getCXXOverloadedOperator();
3598   else
3599     return OO_None;
3600 }
3601
3602 /// getLiteralIdentifier - The literal suffix identifier this function
3603 /// represents, if any.
3604 const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
3605   if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
3606     return getDeclName().getCXXLiteralIdentifier();
3607   else
3608     return nullptr;
3609 }
3610
3611 FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const {
3612   if (TemplateOrSpecialization.isNull())
3613     return TK_NonTemplate;
3614   if (TemplateOrSpecialization.is<FunctionTemplateDecl *>())
3615     return TK_FunctionTemplate;
3616   if (TemplateOrSpecialization.is<MemberSpecializationInfo *>())
3617     return TK_MemberSpecialization;
3618   if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>())
3619     return TK_FunctionTemplateSpecialization;
3620   if (TemplateOrSpecialization.is
3621                                <DependentFunctionTemplateSpecializationInfo*>())
3622     return TK_DependentFunctionTemplateSpecialization;
3623
3624   llvm_unreachable("Did we miss a TemplateOrSpecialization type?");
3625 }
3626
3627 FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
3628   if (MemberSpecializationInfo *Info = getMemberSpecializationInfo())
3629     return cast<FunctionDecl>(Info->getInstantiatedFrom());
3630
3631   return nullptr;
3632 }
3633
3634 MemberSpecializationInfo *FunctionDecl::getMemberSpecializationInfo() const {
3635   if (auto *MSI =
3636           TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo *>())
3637     return MSI;
3638   if (auto *FTSI = TemplateOrSpecialization
3639                        .dyn_cast<FunctionTemplateSpecializationInfo *>())
3640     return FTSI->getMemberSpecializationInfo();
3641   return nullptr;
3642 }
3643
3644 void
3645 FunctionDecl::setInstantiationOfMemberFunction(ASTContext &C,
3646                                                FunctionDecl *FD,
3647                                                TemplateSpecializationKind TSK) {
3648   assert(TemplateOrSpecialization.isNull() &&
3649          "Member function is already a specialization");
3650   MemberSpecializationInfo *Info
3651     = new (C) MemberSpecializationInfo(FD, TSK);
3652   TemplateOrSpecialization = Info;
3653 }
3654
3655 FunctionTemplateDecl *FunctionDecl::getDescribedFunctionTemplate() const {
3656   return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl *>();
3657 }
3658
3659 void FunctionDecl::setDescribedFunctionTemplate(FunctionTemplateDecl *Template) {
3660   assert(TemplateOrSpecialization.isNull() &&
3661          "Member function is already a specialization");
3662   TemplateOrSpecialization = Template;
3663 }
3664
3665 bool FunctionDecl::isImplicitlyInstantiable() const {
3666   // If the function is invalid, it can't be implicitly instantiated.
3667   if (isInvalidDecl())
3668     return false;
3669
3670   switch (getTemplateSpecializationKindForInstantiation()) {
3671   case TSK_Undeclared:
3672   case TSK_ExplicitInstantiationDefinition:
3673   case TSK_ExplicitSpecialization:
3674     return false;
3675
3676   case TSK_ImplicitInstantiation:
3677     return true;
3678
3679   case TSK_ExplicitInstantiationDeclaration:
3680     // Handled below.
3681     break;
3682   }
3683
3684   // Find the actual template from which we will instantiate.
3685   const FunctionDecl *PatternDecl = getTemplateInstantiationPattern();
3686   bool HasPattern = false;
3687   if (PatternDecl)
3688     HasPattern = PatternDecl->hasBody(PatternDecl);
3689
3690   // C++0x [temp.explicit]p9:
3691   //   Except for inline functions, other explicit instantiation declarations
3692   //   have the effect of suppressing the implicit instantiation of the entity
3693   //   to which they refer.
3694   if (!HasPattern || !PatternDecl)
3695     return true;
3696
3697   return PatternDecl->isInlined();
3698 }
3699
3700 bool FunctionDecl::isTemplateInstantiation() const {
3701   // FIXME: Remove this, it's not clear what it means. (Which template
3702   // specialization kind?)
3703   return clang::isTemplateInstantiation(getTemplateSpecializationKind());
3704 }
3705
3706 FunctionDecl *
3707 FunctionDecl::getTemplateInstantiationPattern(bool ForDefinition) const {
3708   // If this is a generic lambda call operator specialization, its
3709   // instantiation pattern is always its primary template's pattern
3710   // even if its primary template was instantiated from another
3711   // member template (which happens with nested generic lambdas).
3712   // Since a lambda's call operator's body is transformed eagerly,
3713   // we don't have to go hunting for a prototype definition template
3714   // (i.e. instantiated-from-member-template) to use as an instantiation
3715   // pattern.
3716
3717   if (isGenericLambdaCallOperatorSpecialization(
3718           dyn_cast<CXXMethodDecl>(this))) {
3719     assert(getPrimaryTemplate() && "not a generic lambda call operator?");
3720     return getDefinitionOrSelf(getPrimaryTemplate()->getTemplatedDecl());
3721   }
3722
3723   // Check for a declaration of this function that was instantiated from a
3724   // friend definition.
3725   const FunctionDecl *FD = nullptr;
3726   if (!isDefined(FD, /*CheckForPendingFriendDefinition=*/true))
3727     FD = this;
3728
3729   if (MemberSpecializationInfo *Info = FD->getMemberSpecializationInfo()) {
3730     if (ForDefinition &&
3731         !clang::isTemplateInstantiation(Info->getTemplateSpecializationKind()))
3732       return nullptr;
3733     return getDefinitionOrSelf(cast<FunctionDecl>(Info->getInstantiatedFrom()));
3734   }
3735
3736   if (ForDefinition &&
3737       !clang::isTemplateInstantiation(getTemplateSpecializationKind()))
3738     return nullptr;
3739
3740   if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) {
3741     // If we hit a point where the user provided a specialization of this
3742     // template, we're done looking.
3743     while (!ForDefinition || !Primary->isMemberSpecialization()) {
3744       auto *NewPrimary = Primary->getInstantiatedFromMemberTemplate();
3745       if (!NewPrimary)
3746         break;
3747       Primary = NewPrimary;
3748     }
3749
3750     return getDefinitionOrSelf(Primary->getTemplatedDecl());
3751   }
3752
3753   return nullptr;
3754 }
3755
3756 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
3757   if (FunctionTemplateSpecializationInfo *Info
3758         = TemplateOrSpecialization
3759             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3760     return Info->getTemplate();
3761   }
3762   return nullptr;
3763 }
3764
3765 FunctionTemplateSpecializationInfo *
3766 FunctionDecl::getTemplateSpecializationInfo() const {
3767   return TemplateOrSpecialization
3768       .dyn_cast<FunctionTemplateSpecializationInfo *>();
3769 }
3770
3771 const TemplateArgumentList *
3772 FunctionDecl::getTemplateSpecializationArgs() const {
3773   if (FunctionTemplateSpecializationInfo *Info
3774         = TemplateOrSpecialization
3775             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3776     return Info->TemplateArguments;
3777   }
3778   return nullptr;
3779 }
3780
3781 const ASTTemplateArgumentListInfo *
3782 FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
3783   if (FunctionTemplateSpecializationInfo *Info
3784         = TemplateOrSpecialization
3785             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
3786     return Info->TemplateArgumentsAsWritten;
3787   }
3788   return nullptr;
3789 }
3790
3791 void
3792 FunctionDecl::setFunctionTemplateSpecialization(ASTContext &C,
3793                                                 FunctionTemplateDecl *Template,
3794                                      const TemplateArgumentList *TemplateArgs,
3795                                                 void *InsertPos,
3796                                                 TemplateSpecializationKind TSK,
3797                         const TemplateArgumentListInfo *TemplateArgsAsWritten,
3798                                           SourceLocation PointOfInstantiation) {
3799   assert((TemplateOrSpecialization.isNull() ||
3800           TemplateOrSpecialization.is<MemberSpecializationInfo *>()) &&
3801          "Member function is already a specialization");