204a035130ab45cb9d28f23da3d8778acca95218
[lldb.git] / clang / lib / Sema / SemaDecl.cpp
1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
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 semantic analysis for declarations.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "TypeLocBuilder.h"
14 #include "clang/AST/ASTConsumer.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/ASTLambda.h"
17 #include "clang/AST/CXXInheritance.h"
18 #include "clang/AST/CharUnits.h"
19 #include "clang/AST/CommentDiagnostic.h"
20 #include "clang/AST/DeclCXX.h"
21 #include "clang/AST/DeclObjC.h"
22 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/EvaluatedExprVisitor.h"
24 #include "clang/AST/Expr.h"
25 #include "clang/AST/ExprCXX.h"
26 #include "clang/AST/NonTrivialTypeVisitor.h"
27 #include "clang/AST/StmtCXX.h"
28 #include "clang/Basic/Builtins.h"
29 #include "clang/Basic/PartialDiagnostic.h"
30 #include "clang/Basic/SourceManager.h"
31 #include "clang/Basic/TargetInfo.h"
32 #include "clang/Lex/HeaderSearch.h" // TODO: Sema shouldn't depend on Lex
33 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
34 #include "clang/Lex/ModuleLoader.h" // TODO: Sema shouldn't depend on Lex
35 #include "clang/Lex/Preprocessor.h" // Included for isCodeCompletionEnabled()
36 #include "clang/Sema/CXXFieldCollector.h"
37 #include "clang/Sema/DeclSpec.h"
38 #include "clang/Sema/DelayedDiagnostic.h"
39 #include "clang/Sema/Initialization.h"
40 #include "clang/Sema/Lookup.h"
41 #include "clang/Sema/ParsedTemplate.h"
42 #include "clang/Sema/Scope.h"
43 #include "clang/Sema/ScopeInfo.h"
44 #include "clang/Sema/SemaInternal.h"
45 #include "clang/Sema/Template.h"
46 #include "llvm/ADT/SmallString.h"
47 #include "llvm/ADT/Triple.h"
48 #include <algorithm>
49 #include <cstring>
50 #include <functional>
51 #include <unordered_map>
52
53 using namespace clang;
54 using namespace sema;
55
56 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
57   if (OwnedType) {
58     Decl *Group[2] = { OwnedType, Ptr };
59     return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
60   }
61
62   return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
63 }
64
65 namespace {
66
67 class TypeNameValidatorCCC final : public CorrectionCandidateCallback {
68  public:
69    TypeNameValidatorCCC(bool AllowInvalid, bool WantClass = false,
70                         bool AllowTemplates = false,
71                         bool AllowNonTemplates = true)
72        : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
73          AllowTemplates(AllowTemplates), AllowNonTemplates(AllowNonTemplates) {
74      WantExpressionKeywords = false;
75      WantCXXNamedCasts = false;
76      WantRemainingKeywords = false;
77   }
78
79   bool ValidateCandidate(const TypoCorrection &candidate) override {
80     if (NamedDecl *ND = candidate.getCorrectionDecl()) {
81       if (!AllowInvalidDecl && ND->isInvalidDecl())
82         return false;
83
84       if (getAsTypeTemplateDecl(ND))
85         return AllowTemplates;
86
87       bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
88       if (!IsType)
89         return false;
90
91       if (AllowNonTemplates)
92         return true;
93
94       // An injected-class-name of a class template (specialization) is valid
95       // as a template or as a non-template.
96       if (AllowTemplates) {
97         auto *RD = dyn_cast<CXXRecordDecl>(ND);
98         if (!RD || !RD->isInjectedClassName())
99           return false;
100         RD = cast<CXXRecordDecl>(RD->getDeclContext());
101         return RD->getDescribedClassTemplate() ||
102                isa<ClassTemplateSpecializationDecl>(RD);
103       }
104
105       return false;
106     }
107
108     return !WantClassName && candidate.isKeyword();
109   }
110
111   std::unique_ptr<CorrectionCandidateCallback> clone() override {
112     return std::make_unique<TypeNameValidatorCCC>(*this);
113   }
114
115  private:
116   bool AllowInvalidDecl;
117   bool WantClassName;
118   bool AllowTemplates;
119   bool AllowNonTemplates;
120 };
121
122 } // end anonymous namespace
123
124 /// Determine whether the token kind starts a simple-type-specifier.
125 bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
126   switch (Kind) {
127   // FIXME: Take into account the current language when deciding whether a
128   // token kind is a valid type specifier
129   case tok::kw_short:
130   case tok::kw_long:
131   case tok::kw___int64:
132   case tok::kw___int128:
133   case tok::kw_signed:
134   case tok::kw_unsigned:
135   case tok::kw_void:
136   case tok::kw_char:
137   case tok::kw_int:
138   case tok::kw_half:
139   case tok::kw_float:
140   case tok::kw_double:
141   case tok::kw___bf16:
142   case tok::kw__Float16:
143   case tok::kw___float128:
144   case tok::kw_wchar_t:
145   case tok::kw_bool:
146   case tok::kw___underlying_type:
147   case tok::kw___auto_type:
148     return true;
149
150   case tok::annot_typename:
151   case tok::kw_char16_t:
152   case tok::kw_char32_t:
153   case tok::kw_typeof:
154   case tok::annot_decltype:
155   case tok::kw_decltype:
156     return getLangOpts().CPlusPlus;
157
158   case tok::kw_char8_t:
159     return getLangOpts().Char8;
160
161   default:
162     break;
163   }
164
165   return false;
166 }
167
168 namespace {
169 enum class UnqualifiedTypeNameLookupResult {
170   NotFound,
171   FoundNonType,
172   FoundType
173 };
174 } // end anonymous namespace
175
176 /// Tries to perform unqualified lookup of the type decls in bases for
177 /// dependent class.
178 /// \return \a NotFound if no any decls is found, \a FoundNotType if found not a
179 /// type decl, \a FoundType if only type decls are found.
180 static UnqualifiedTypeNameLookupResult
181 lookupUnqualifiedTypeNameInBase(Sema &S, const IdentifierInfo &II,
182                                 SourceLocation NameLoc,
183                                 const CXXRecordDecl *RD) {
184   if (!RD->hasDefinition())
185     return UnqualifiedTypeNameLookupResult::NotFound;
186   // Look for type decls in base classes.
187   UnqualifiedTypeNameLookupResult FoundTypeDecl =
188       UnqualifiedTypeNameLookupResult::NotFound;
189   for (const auto &Base : RD->bases()) {
190     const CXXRecordDecl *BaseRD = nullptr;
191     if (auto *BaseTT = Base.getType()->getAs<TagType>())
192       BaseRD = BaseTT->getAsCXXRecordDecl();
193     else if (auto *TST = Base.getType()->getAs<TemplateSpecializationType>()) {
194       // Look for type decls in dependent base classes that have known primary
195       // templates.
196       if (!TST || !TST->isDependentType())
197         continue;
198       auto *TD = TST->getTemplateName().getAsTemplateDecl();
199       if (!TD)
200         continue;
201       if (auto *BasePrimaryTemplate =
202           dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl())) {
203         if (BasePrimaryTemplate->getCanonicalDecl() != RD->getCanonicalDecl())
204           BaseRD = BasePrimaryTemplate;
205         else if (auto *CTD = dyn_cast<ClassTemplateDecl>(TD)) {
206           if (const ClassTemplatePartialSpecializationDecl *PS =
207                   CTD->findPartialSpecialization(Base.getType()))
208             if (PS->getCanonicalDecl() != RD->getCanonicalDecl())
209               BaseRD = PS;
210         }
211       }
212     }
213     if (BaseRD) {
214       for (NamedDecl *ND : BaseRD->lookup(&II)) {
215         if (!isa<TypeDecl>(ND))
216           return UnqualifiedTypeNameLookupResult::FoundNonType;
217         FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
218       }
219       if (FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound) {
220         switch (lookupUnqualifiedTypeNameInBase(S, II, NameLoc, BaseRD)) {
221         case UnqualifiedTypeNameLookupResult::FoundNonType:
222           return UnqualifiedTypeNameLookupResult::FoundNonType;
223         case UnqualifiedTypeNameLookupResult::FoundType:
224           FoundTypeDecl = UnqualifiedTypeNameLookupResult::FoundType;
225           break;
226         case UnqualifiedTypeNameLookupResult::NotFound:
227           break;
228         }
229       }
230     }
231   }
232
233   return FoundTypeDecl;
234 }
235
236 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
237                                                       const IdentifierInfo &II,
238                                                       SourceLocation NameLoc) {
239   // Lookup in the parent class template context, if any.
240   const CXXRecordDecl *RD = nullptr;
241   UnqualifiedTypeNameLookupResult FoundTypeDecl =
242       UnqualifiedTypeNameLookupResult::NotFound;
243   for (DeclContext *DC = S.CurContext;
244        DC && FoundTypeDecl == UnqualifiedTypeNameLookupResult::NotFound;
245        DC = DC->getParent()) {
246     // Look for type decls in dependent base classes that have known primary
247     // templates.
248     RD = dyn_cast<CXXRecordDecl>(DC);
249     if (RD && RD->getDescribedClassTemplate())
250       FoundTypeDecl = lookupUnqualifiedTypeNameInBase(S, II, NameLoc, RD);
251   }
252   if (FoundTypeDecl != UnqualifiedTypeNameLookupResult::FoundType)
253     return nullptr;
254
255   // We found some types in dependent base classes.  Recover as if the user
256   // wrote 'typename MyClass::II' instead of 'II'.  We'll fully resolve the
257   // lookup during template instantiation.
258   S.Diag(NameLoc, diag::ext_found_in_dependent_base) << &II;
259
260   ASTContext &Context = S.Context;
261   auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
262                                           cast<Type>(Context.getRecordType(RD)));
263   QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
264
265   CXXScopeSpec SS;
266   SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
267
268   TypeLocBuilder Builder;
269   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
270   DepTL.setNameLoc(NameLoc);
271   DepTL.setElaboratedKeywordLoc(SourceLocation());
272   DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
273   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
274 }
275
276 /// If the identifier refers to a type name within this scope,
277 /// return the declaration of that type.
278 ///
279 /// This routine performs ordinary name lookup of the identifier II
280 /// within the given scope, with optional C++ scope specifier SS, to
281 /// determine whether the name refers to a type. If so, returns an
282 /// opaque pointer (actually a QualType) corresponding to that
283 /// type. Otherwise, returns NULL.
284 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
285                              Scope *S, CXXScopeSpec *SS,
286                              bool isClassName, bool HasTrailingDot,
287                              ParsedType ObjectTypePtr,
288                              bool IsCtorOrDtorName,
289                              bool WantNontrivialTypeSourceInfo,
290                              bool IsClassTemplateDeductionContext,
291                              IdentifierInfo **CorrectedII) {
292   // FIXME: Consider allowing this outside C++1z mode as an extension.
293   bool AllowDeducedTemplate = IsClassTemplateDeductionContext &&
294                               getLangOpts().CPlusPlus17 && !IsCtorOrDtorName &&
295                               !isClassName && !HasTrailingDot;
296
297   // Determine where we will perform name lookup.
298   DeclContext *LookupCtx = nullptr;
299   if (ObjectTypePtr) {
300     QualType ObjectType = ObjectTypePtr.get();
301     if (ObjectType->isRecordType())
302       LookupCtx = computeDeclContext(ObjectType);
303   } else if (SS && SS->isNotEmpty()) {
304     LookupCtx = computeDeclContext(*SS, false);
305
306     if (!LookupCtx) {
307       if (isDependentScopeSpecifier(*SS)) {
308         // C++ [temp.res]p3:
309         //   A qualified-id that refers to a type and in which the
310         //   nested-name-specifier depends on a template-parameter (14.6.2)
311         //   shall be prefixed by the keyword typename to indicate that the
312         //   qualified-id denotes a type, forming an
313         //   elaborated-type-specifier (7.1.5.3).
314         //
315         // We therefore do not perform any name lookup if the result would
316         // refer to a member of an unknown specialization.
317         if (!isClassName && !IsCtorOrDtorName)
318           return nullptr;
319
320         // We know from the grammar that this name refers to a type,
321         // so build a dependent node to describe the type.
322         if (WantNontrivialTypeSourceInfo)
323           return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
324
325         NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
326         QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
327                                        II, NameLoc);
328         return ParsedType::make(T);
329       }
330
331       return nullptr;
332     }
333
334     if (!LookupCtx->isDependentContext() &&
335         RequireCompleteDeclContext(*SS, LookupCtx))
336       return nullptr;
337   }
338
339   // FIXME: LookupNestedNameSpecifierName isn't the right kind of
340   // lookup for class-names.
341   LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
342                                       LookupOrdinaryName;
343   LookupResult Result(*this, &II, NameLoc, Kind);
344   if (LookupCtx) {
345     // Perform "qualified" name lookup into the declaration context we
346     // computed, which is either the type of the base of a member access
347     // expression or the declaration context associated with a prior
348     // nested-name-specifier.
349     LookupQualifiedName(Result, LookupCtx);
350
351     if (ObjectTypePtr && Result.empty()) {
352       // C++ [basic.lookup.classref]p3:
353       //   If the unqualified-id is ~type-name, the type-name is looked up
354       //   in the context of the entire postfix-expression. If the type T of
355       //   the object expression is of a class type C, the type-name is also
356       //   looked up in the scope of class C. At least one of the lookups shall
357       //   find a name that refers to (possibly cv-qualified) T.
358       LookupName(Result, S);
359     }
360   } else {
361     // Perform unqualified name lookup.
362     LookupName(Result, S);
363
364     // For unqualified lookup in a class template in MSVC mode, look into
365     // dependent base classes where the primary class template is known.
366     if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
367       if (ParsedType TypeInBase =
368               recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
369         return TypeInBase;
370     }
371   }
372
373   NamedDecl *IIDecl = nullptr;
374   switch (Result.getResultKind()) {
375   case LookupResult::NotFound:
376   case LookupResult::NotFoundInCurrentInstantiation:
377     if (CorrectedII) {
378       TypeNameValidatorCCC CCC(/*AllowInvalid=*/true, isClassName,
379                                AllowDeducedTemplate);
380       TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(), Kind,
381                                               S, SS, CCC, CTK_ErrorRecovery);
382       IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
383       TemplateTy Template;
384       bool MemberOfUnknownSpecialization;
385       UnqualifiedId TemplateName;
386       TemplateName.setIdentifier(NewII, NameLoc);
387       NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
388       CXXScopeSpec NewSS, *NewSSPtr = SS;
389       if (SS && NNS) {
390         NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
391         NewSSPtr = &NewSS;
392       }
393       if (Correction && (NNS || NewII != &II) &&
394           // Ignore a correction to a template type as the to-be-corrected
395           // identifier is not a template (typo correction for template names
396           // is handled elsewhere).
397           !(getLangOpts().CPlusPlus && NewSSPtr &&
398             isTemplateName(S, *NewSSPtr, false, TemplateName, nullptr, false,
399                            Template, MemberOfUnknownSpecialization))) {
400         ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
401                                     isClassName, HasTrailingDot, ObjectTypePtr,
402                                     IsCtorOrDtorName,
403                                     WantNontrivialTypeSourceInfo,
404                                     IsClassTemplateDeductionContext);
405         if (Ty) {
406           diagnoseTypo(Correction,
407                        PDiag(diag::err_unknown_type_or_class_name_suggest)
408                          << Result.getLookupName() << isClassName);
409           if (SS && NNS)
410             SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
411           *CorrectedII = NewII;
412           return Ty;
413         }
414       }
415     }
416     // If typo correction failed or was not performed, fall through
417     LLVM_FALLTHROUGH;
418   case LookupResult::FoundOverloaded:
419   case LookupResult::FoundUnresolvedValue:
420     Result.suppressDiagnostics();
421     return nullptr;
422
423   case LookupResult::Ambiguous:
424     // Recover from type-hiding ambiguities by hiding the type.  We'll
425     // do the lookup again when looking for an object, and we can
426     // diagnose the error then.  If we don't do this, then the error
427     // about hiding the type will be immediately followed by an error
428     // that only makes sense if the identifier was treated like a type.
429     if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
430       Result.suppressDiagnostics();
431       return nullptr;
432     }
433
434     // Look to see if we have a type anywhere in the list of results.
435     for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
436          Res != ResEnd; ++Res) {
437       if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res) ||
438           (AllowDeducedTemplate && getAsTypeTemplateDecl(*Res))) {
439         if (!IIDecl ||
440             (*Res)->getLocation().getRawEncoding() <
441               IIDecl->getLocation().getRawEncoding())
442           IIDecl = *Res;
443       }
444     }
445
446     if (!IIDecl) {
447       // None of the entities we found is a type, so there is no way
448       // to even assume that the result is a type. In this case, don't
449       // complain about the ambiguity. The parser will either try to
450       // perform this lookup again (e.g., as an object name), which
451       // will produce the ambiguity, or will complain that it expected
452       // a type name.
453       Result.suppressDiagnostics();
454       return nullptr;
455     }
456
457     // We found a type within the ambiguous lookup; diagnose the
458     // ambiguity and then return that type. This might be the right
459     // answer, or it might not be, but it suppresses any attempt to
460     // perform the name lookup again.
461     break;
462
463   case LookupResult::Found:
464     IIDecl = Result.getFoundDecl();
465     break;
466   }
467
468   assert(IIDecl && "Didn't find decl");
469
470   QualType T;
471   if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
472     // C++ [class.qual]p2: A lookup that would find the injected-class-name
473     // instead names the constructors of the class, except when naming a class.
474     // This is ill-formed when we're not actually forming a ctor or dtor name.
475     auto *LookupRD = dyn_cast_or_null<CXXRecordDecl>(LookupCtx);
476     auto *FoundRD = dyn_cast<CXXRecordDecl>(TD);
477     if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD &&
478         FoundRD->isInjectedClassName() &&
479         declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))
480       Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor)
481           << &II << /*Type*/1;
482
483     DiagnoseUseOfDecl(IIDecl, NameLoc);
484
485     T = Context.getTypeDeclType(TD);
486     MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
487   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
488     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
489     if (!HasTrailingDot)
490       T = Context.getObjCInterfaceType(IDecl);
491   } else if (AllowDeducedTemplate) {
492     if (auto *TD = getAsTypeTemplateDecl(IIDecl))
493       T = Context.getDeducedTemplateSpecializationType(TemplateName(TD),
494                                                        QualType(), false);
495   }
496
497   if (T.isNull()) {
498     // If it's not plausibly a type, suppress diagnostics.
499     Result.suppressDiagnostics();
500     return nullptr;
501   }
502
503   // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
504   // constructor or destructor name (in such a case, the scope specifier
505   // will be attached to the enclosing Expr or Decl node).
506   if (SS && SS->isNotEmpty() && !IsCtorOrDtorName &&
507       !isa<ObjCInterfaceDecl>(IIDecl)) {
508     if (WantNontrivialTypeSourceInfo) {
509       // Construct a type with type-source information.
510       TypeLocBuilder Builder;
511       Builder.pushTypeSpec(T).setNameLoc(NameLoc);
512
513       T = getElaboratedType(ETK_None, *SS, T);
514       ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
515       ElabTL.setElaboratedKeywordLoc(SourceLocation());
516       ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
517       return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
518     } else {
519       T = getElaboratedType(ETK_None, *SS, T);
520     }
521   }
522
523   return ParsedType::make(T);
524 }
525
526 // Builds a fake NNS for the given decl context.
527 static NestedNameSpecifier *
528 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
529   for (;; DC = DC->getLookupParent()) {
530     DC = DC->getPrimaryContext();
531     auto *ND = dyn_cast<NamespaceDecl>(DC);
532     if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
533       return NestedNameSpecifier::Create(Context, nullptr, ND);
534     else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
535       return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
536                                          RD->getTypeForDecl());
537     else if (isa<TranslationUnitDecl>(DC))
538       return NestedNameSpecifier::GlobalSpecifier(Context);
539   }
540   llvm_unreachable("something isn't in TU scope?");
541 }
542
543 /// Find the parent class with dependent bases of the innermost enclosing method
544 /// context. Do not look for enclosing CXXRecordDecls directly, or we will end
545 /// up allowing unqualified dependent type names at class-level, which MSVC
546 /// correctly rejects.
547 static const CXXRecordDecl *
548 findRecordWithDependentBasesOfEnclosingMethod(const DeclContext *DC) {
549   for (; DC && DC->isDependentContext(); DC = DC->getLookupParent()) {
550     DC = DC->getPrimaryContext();
551     if (const auto *MD = dyn_cast<CXXMethodDecl>(DC))
552       if (MD->getParent()->hasAnyDependentBases())
553         return MD->getParent();
554   }
555   return nullptr;
556 }
557
558 ParsedType Sema::ActOnMSVCUnknownTypeName(const IdentifierInfo &II,
559                                           SourceLocation NameLoc,
560                                           bool IsTemplateTypeArg) {
561   assert(getLangOpts().MSVCCompat && "shouldn't be called in non-MSVC mode");
562
563   NestedNameSpecifier *NNS = nullptr;
564   if (IsTemplateTypeArg && getCurScope()->isTemplateParamScope()) {
565     // If we weren't able to parse a default template argument, delay lookup
566     // until instantiation time by making a non-dependent DependentTypeName. We
567     // pretend we saw a NestedNameSpecifier referring to the current scope, and
568     // lookup is retried.
569     // FIXME: This hurts our diagnostic quality, since we get errors like "no
570     // type named 'Foo' in 'current_namespace'" when the user didn't write any
571     // name specifiers.
572     NNS = synthesizeCurrentNestedNameSpecifier(Context, CurContext);
573     Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
574   } else if (const CXXRecordDecl *RD =
575                  findRecordWithDependentBasesOfEnclosingMethod(CurContext)) {
576     // Build a DependentNameType that will perform lookup into RD at
577     // instantiation time.
578     NNS = NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
579                                       RD->getTypeForDecl());
580
581     // Diagnose that this identifier was undeclared, and retry the lookup during
582     // template instantiation.
583     Diag(NameLoc, diag::ext_undeclared_unqual_id_with_dependent_base) << &II
584                                                                       << RD;
585   } else {
586     // This is not a situation that we should recover from.
587     return ParsedType();
588   }
589
590   QualType T = Context.getDependentNameType(ETK_None, NNS, &II);
591
592   // Build type location information.  We synthesized the qualifier, so we have
593   // to build a fake NestedNameSpecifierLoc.
594   NestedNameSpecifierLocBuilder NNSLocBuilder;
595   NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
596   NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
597
598   TypeLocBuilder Builder;
599   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
600   DepTL.setNameLoc(NameLoc);
601   DepTL.setElaboratedKeywordLoc(SourceLocation());
602   DepTL.setQualifierLoc(QualifierLoc);
603   return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
604 }
605
606 /// isTagName() - This method is called *for error recovery purposes only*
607 /// to determine if the specified name is a valid tag name ("struct foo").  If
608 /// so, this returns the TST for the tag corresponding to it (TST_enum,
609 /// TST_union, TST_struct, TST_interface, TST_class).  This is used to diagnose
610 /// cases in C where the user forgot to specify the tag.
611 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
612   // Do a tag name lookup in this scope.
613   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
614   LookupName(R, S, false);
615   R.suppressDiagnostics();
616   if (R.getResultKind() == LookupResult::Found)
617     if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
618       switch (TD->getTagKind()) {
619       case TTK_Struct: return DeclSpec::TST_struct;
620       case TTK_Interface: return DeclSpec::TST_interface;
621       case TTK_Union:  return DeclSpec::TST_union;
622       case TTK_Class:  return DeclSpec::TST_class;
623       case TTK_Enum:   return DeclSpec::TST_enum;
624       }
625     }
626
627   return DeclSpec::TST_unspecified;
628 }
629
630 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
631 /// if a CXXScopeSpec's type is equal to the type of one of the base classes
632 /// then downgrade the missing typename error to a warning.
633 /// This is needed for MSVC compatibility; Example:
634 /// @code
635 /// template<class T> class A {
636 /// public:
637 ///   typedef int TYPE;
638 /// };
639 /// template<class T> class B : public A<T> {
640 /// public:
641 ///   A<T>::TYPE a; // no typename required because A<T> is a base class.
642 /// };
643 /// @endcode
644 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
645   if (CurContext->isRecord()) {
646     if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super)
647       return true;
648
649     const Type *Ty = SS->getScopeRep()->getAsType();
650
651     CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
652     for (const auto &Base : RD->bases())
653       if (Ty && Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
654         return true;
655     return S->isFunctionPrototypeScope();
656   }
657   return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
658 }
659
660 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
661                                    SourceLocation IILoc,
662                                    Scope *S,
663                                    CXXScopeSpec *SS,
664                                    ParsedType &SuggestedType,
665                                    bool IsTemplateName) {
666   // Don't report typename errors for editor placeholders.
667   if (II->isEditorPlaceholder())
668     return;
669   // We don't have anything to suggest (yet).
670   SuggestedType = nullptr;
671
672   // There may have been a typo in the name of the type. Look up typo
673   // results, in case we have something that we can suggest.
674   TypeNameValidatorCCC CCC(/*AllowInvalid=*/false, /*WantClass=*/false,
675                            /*AllowTemplates=*/IsTemplateName,
676                            /*AllowNonTemplates=*/!IsTemplateName);
677   if (TypoCorrection Corrected =
678           CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
679                       CCC, CTK_ErrorRecovery)) {
680     // FIXME: Support error recovery for the template-name case.
681     bool CanRecover = !IsTemplateName;
682     if (Corrected.isKeyword()) {
683       // We corrected to a keyword.
684       diagnoseTypo(Corrected,
685                    PDiag(IsTemplateName ? diag::err_no_template_suggest
686                                         : diag::err_unknown_typename_suggest)
687                        << II);
688       II = Corrected.getCorrectionAsIdentifierInfo();
689     } else {
690       // We found a similarly-named type or interface; suggest that.
691       if (!SS || !SS->isSet()) {
692         diagnoseTypo(Corrected,
693                      PDiag(IsTemplateName ? diag::err_no_template_suggest
694                                           : diag::err_unknown_typename_suggest)
695                          << II, CanRecover);
696       } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
697         std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
698         bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
699                                 II->getName().equals(CorrectedStr);
700         diagnoseTypo(Corrected,
701                      PDiag(IsTemplateName
702                                ? diag::err_no_member_template_suggest
703                                : diag::err_unknown_nested_typename_suggest)
704                          << II << DC << DroppedSpecifier << SS->getRange(),
705                      CanRecover);
706       } else {
707         llvm_unreachable("could not have corrected a typo here");
708       }
709
710       if (!CanRecover)
711         return;
712
713       CXXScopeSpec tmpSS;
714       if (Corrected.getCorrectionSpecifier())
715         tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
716                           SourceRange(IILoc));
717       // FIXME: Support class template argument deduction here.
718       SuggestedType =
719           getTypeName(*Corrected.getCorrectionAsIdentifierInfo(), IILoc, S,
720                       tmpSS.isSet() ? &tmpSS : SS, false, false, nullptr,
721                       /*IsCtorOrDtorName=*/false,
722                       /*WantNontrivialTypeSourceInfo=*/true);
723     }
724     return;
725   }
726
727   if (getLangOpts().CPlusPlus && !IsTemplateName) {
728     // See if II is a class template that the user forgot to pass arguments to.
729     UnqualifiedId Name;
730     Name.setIdentifier(II, IILoc);
731     CXXScopeSpec EmptySS;
732     TemplateTy TemplateResult;
733     bool MemberOfUnknownSpecialization;
734     if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
735                        Name, nullptr, true, TemplateResult,
736                        MemberOfUnknownSpecialization) == TNK_Type_template) {
737       diagnoseMissingTemplateArguments(TemplateResult.get(), IILoc);
738       return;
739     }
740   }
741
742   // FIXME: Should we move the logic that tries to recover from a missing tag
743   // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
744
745   if (!SS || (!SS->isSet() && !SS->isInvalid()))
746     Diag(IILoc, IsTemplateName ? diag::err_no_template
747                                : diag::err_unknown_typename)
748         << II;
749   else if (DeclContext *DC = computeDeclContext(*SS, false))
750     Diag(IILoc, IsTemplateName ? diag::err_no_member_template
751                                : diag::err_typename_nested_not_found)
752         << II << DC << SS->getRange();
753   else if (SS->isValid() && SS->getScopeRep()->containsErrors()) {
754     SuggestedType =
755         ActOnTypenameType(S, SourceLocation(), *SS, *II, IILoc).get();
756   } else if (isDependentScopeSpecifier(*SS)) {
757     unsigned DiagID = diag::err_typename_missing;
758     if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
759       DiagID = diag::ext_typename_missing;
760
761     Diag(SS->getRange().getBegin(), DiagID)
762       << SS->getScopeRep() << II->getName()
763       << SourceRange(SS->getRange().getBegin(), IILoc)
764       << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
765     SuggestedType = ActOnTypenameType(S, SourceLocation(),
766                                       *SS, *II, IILoc).get();
767   } else {
768     assert(SS && SS->isInvalid() &&
769            "Invalid scope specifier has already been diagnosed");
770   }
771 }
772
773 /// Determine whether the given result set contains either a type name
774 /// or
775 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
776   bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
777                        NextToken.is(tok::less);
778
779   for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
780     if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
781       return true;
782
783     if (CheckTemplate && isa<TemplateDecl>(*I))
784       return true;
785   }
786
787   return false;
788 }
789
790 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
791                                     Scope *S, CXXScopeSpec &SS,
792                                     IdentifierInfo *&Name,
793                                     SourceLocation NameLoc) {
794   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
795   SemaRef.LookupParsedName(R, S, &SS);
796   if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
797     StringRef FixItTagName;
798     switch (Tag->getTagKind()) {
799       case TTK_Class:
800         FixItTagName = "class ";
801         break;
802
803       case TTK_Enum:
804         FixItTagName = "enum ";
805         break;
806
807       case TTK_Struct:
808         FixItTagName = "struct ";
809         break;
810
811       case TTK_Interface:
812         FixItTagName = "__interface ";
813         break;
814
815       case TTK_Union:
816         FixItTagName = "union ";
817         break;
818     }
819
820     StringRef TagName = FixItTagName.drop_back();
821     SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
822       << Name << TagName << SemaRef.getLangOpts().CPlusPlus
823       << FixItHint::CreateInsertion(NameLoc, FixItTagName);
824
825     for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
826          I != IEnd; ++I)
827       SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
828         << Name << TagName;
829
830     // Replace lookup results with just the tag decl.
831     Result.clear(Sema::LookupTagName);
832     SemaRef.LookupParsedName(Result, S, &SS);
833     return true;
834   }
835
836   return false;
837 }
838
839 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
840 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
841                                   QualType T, SourceLocation NameLoc) {
842   ASTContext &Context = S.Context;
843
844   TypeLocBuilder Builder;
845   Builder.pushTypeSpec(T).setNameLoc(NameLoc);
846
847   T = S.getElaboratedType(ETK_None, SS, T);
848   ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
849   ElabTL.setElaboratedKeywordLoc(SourceLocation());
850   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
851   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
852 }
853
854 Sema::NameClassification Sema::ClassifyName(Scope *S, CXXScopeSpec &SS,
855                                             IdentifierInfo *&Name,
856                                             SourceLocation NameLoc,
857                                             const Token &NextToken,
858                                             CorrectionCandidateCallback *CCC) {
859   DeclarationNameInfo NameInfo(Name, NameLoc);
860   ObjCMethodDecl *CurMethod = getCurMethodDecl();
861
862   assert(NextToken.isNot(tok::coloncolon) &&
863          "parse nested name specifiers before calling ClassifyName");
864   if (getLangOpts().CPlusPlus && SS.isSet() &&
865       isCurrentClassName(*Name, S, &SS)) {
866     // Per [class.qual]p2, this names the constructors of SS, not the
867     // injected-class-name. We don't have a classification for that.
868     // There's not much point caching this result, since the parser
869     // will reject it later.
870     return NameClassification::Unknown();
871   }
872
873   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
874   LookupParsedName(Result, S, &SS, !CurMethod);
875
876   if (SS.isInvalid())
877     return NameClassification::Error();
878
879   // For unqualified lookup in a class template in MSVC mode, look into
880   // dependent base classes where the primary class template is known.
881   if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
882     if (ParsedType TypeInBase =
883             recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
884       return TypeInBase;
885   }
886
887   // Perform lookup for Objective-C instance variables (including automatically
888   // synthesized instance variables), if we're in an Objective-C method.
889   // FIXME: This lookup really, really needs to be folded in to the normal
890   // unqualified lookup mechanism.
891   if (SS.isEmpty() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
892     DeclResult Ivar = LookupIvarInObjCMethod(Result, S, Name);
893     if (Ivar.isInvalid())
894       return NameClassification::Error();
895     if (Ivar.isUsable())
896       return NameClassification::NonType(cast<NamedDecl>(Ivar.get()));
897
898     // We defer builtin creation until after ivar lookup inside ObjC methods.
899     if (Result.empty())
900       LookupBuiltin(Result);
901   }
902
903   bool SecondTry = false;
904   bool IsFilteredTemplateName = false;
905
906 Corrected:
907   switch (Result.getResultKind()) {
908   case LookupResult::NotFound:
909     // If an unqualified-id is followed by a '(', then we have a function
910     // call.
911     if (SS.isEmpty() && NextToken.is(tok::l_paren)) {
912       // In C++, this is an ADL-only call.
913       // FIXME: Reference?
914       if (getLangOpts().CPlusPlus)
915         return NameClassification::UndeclaredNonType();
916
917       // C90 6.3.2.2:
918       //   If the expression that precedes the parenthesized argument list in a
919       //   function call consists solely of an identifier, and if no
920       //   declaration is visible for this identifier, the identifier is
921       //   implicitly declared exactly as if, in the innermost block containing
922       //   the function call, the declaration
923       //
924       //     extern int identifier ();
925       //
926       //   appeared.
927       //
928       // We also allow this in C99 as an extension.
929       if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S))
930         return NameClassification::NonType(D);
931     }
932
933     if (getLangOpts().CPlusPlus20 && SS.isEmpty() && NextToken.is(tok::less)) {
934       // In C++20 onwards, this could be an ADL-only call to a function
935       // template, and we're required to assume that this is a template name.
936       //
937       // FIXME: Find a way to still do typo correction in this case.
938       TemplateName Template =
939           Context.getAssumedTemplateName(NameInfo.getName());
940       return NameClassification::UndeclaredTemplate(Template);
941     }
942
943     // In C, we first see whether there is a tag type by the same name, in
944     // which case it's likely that the user just forgot to write "enum",
945     // "struct", or "union".
946     if (!getLangOpts().CPlusPlus && !SecondTry &&
947         isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
948       break;
949     }
950
951     // Perform typo correction to determine if there is another name that is
952     // close to this name.
953     if (!SecondTry && CCC) {
954       SecondTry = true;
955       if (TypoCorrection Corrected =
956               CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S,
957                           &SS, *CCC, CTK_ErrorRecovery)) {
958         unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
959         unsigned QualifiedDiag = diag::err_no_member_suggest;
960
961         NamedDecl *FirstDecl = Corrected.getFoundDecl();
962         NamedDecl *UnderlyingFirstDecl = Corrected.getCorrectionDecl();
963         if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
964             UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
965           UnqualifiedDiag = diag::err_no_template_suggest;
966           QualifiedDiag = diag::err_no_member_template_suggest;
967         } else if (UnderlyingFirstDecl &&
968                    (isa<TypeDecl>(UnderlyingFirstDecl) ||
969                     isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
970                     isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
971           UnqualifiedDiag = diag::err_unknown_typename_suggest;
972           QualifiedDiag = diag::err_unknown_nested_typename_suggest;
973         }
974
975         if (SS.isEmpty()) {
976           diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
977         } else {// FIXME: is this even reachable? Test it.
978           std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
979           bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
980                                   Name->getName().equals(CorrectedStr);
981           diagnoseTypo(Corrected, PDiag(QualifiedDiag)
982                                     << Name << computeDeclContext(SS, false)
983                                     << DroppedSpecifier << SS.getRange());
984         }
985
986         // Update the name, so that the caller has the new name.
987         Name = Corrected.getCorrectionAsIdentifierInfo();
988
989         // Typo correction corrected to a keyword.
990         if (Corrected.isKeyword())
991           return Name;
992
993         // Also update the LookupResult...
994         // FIXME: This should probably go away at some point
995         Result.clear();
996         Result.setLookupName(Corrected.getCorrection());
997         if (FirstDecl)
998           Result.addDecl(FirstDecl);
999
1000         // If we found an Objective-C instance variable, let
1001         // LookupInObjCMethod build the appropriate expression to
1002         // reference the ivar.
1003         // FIXME: This is a gross hack.
1004         if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
1005           DeclResult R =
1006               LookupIvarInObjCMethod(Result, S, Ivar->getIdentifier());
1007           if (R.isInvalid())
1008             return NameClassification::Error();
1009           if (R.isUsable())
1010             return NameClassification::NonType(Ivar);
1011         }
1012
1013         goto Corrected;
1014       }
1015     }
1016
1017     // We failed to correct; just fall through and let the parser deal with it.
1018     Result.suppressDiagnostics();
1019     return NameClassification::Unknown();
1020
1021   case LookupResult::NotFoundInCurrentInstantiation: {
1022     // We performed name lookup into the current instantiation, and there were
1023     // dependent bases, so we treat this result the same way as any other
1024     // dependent nested-name-specifier.
1025
1026     // C++ [temp.res]p2:
1027     //   A name used in a template declaration or definition and that is
1028     //   dependent on a template-parameter is assumed not to name a type
1029     //   unless the applicable name lookup finds a type name or the name is
1030     //   qualified by the keyword typename.
1031     //
1032     // FIXME: If the next token is '<', we might want to ask the parser to
1033     // perform some heroics to see if we actually have a
1034     // template-argument-list, which would indicate a missing 'template'
1035     // keyword here.
1036     return NameClassification::DependentNonType();
1037   }
1038
1039   case LookupResult::Found:
1040   case LookupResult::FoundOverloaded:
1041   case LookupResult::FoundUnresolvedValue:
1042     break;
1043
1044   case LookupResult::Ambiguous:
1045     if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1046         hasAnyAcceptableTemplateNames(Result, /*AllowFunctionTemplates=*/true,
1047                                       /*AllowDependent=*/false)) {
1048       // C++ [temp.local]p3:
1049       //   A lookup that finds an injected-class-name (10.2) can result in an
1050       //   ambiguity in certain cases (for example, if it is found in more than
1051       //   one base class). If all of the injected-class-names that are found
1052       //   refer to specializations of the same class template, and if the name
1053       //   is followed by a template-argument-list, the reference refers to the
1054       //   class template itself and not a specialization thereof, and is not
1055       //   ambiguous.
1056       //
1057       // This filtering can make an ambiguous result into an unambiguous one,
1058       // so try again after filtering out template names.
1059       FilterAcceptableTemplateNames(Result);
1060       if (!Result.isAmbiguous()) {
1061         IsFilteredTemplateName = true;
1062         break;
1063       }
1064     }
1065
1066     // Diagnose the ambiguity and return an error.
1067     return NameClassification::Error();
1068   }
1069
1070   if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
1071       (IsFilteredTemplateName ||
1072        hasAnyAcceptableTemplateNames(
1073            Result, /*AllowFunctionTemplates=*/true,
1074            /*AllowDependent=*/false,
1075            /*AllowNonTemplateFunctions*/ SS.isEmpty() &&
1076                getLangOpts().CPlusPlus20))) {
1077     // C++ [temp.names]p3:
1078     //   After name lookup (3.4) finds that a name is a template-name or that
1079     //   an operator-function-id or a literal- operator-id refers to a set of
1080     //   overloaded functions any member of which is a function template if
1081     //   this is followed by a <, the < is always taken as the delimiter of a
1082     //   template-argument-list and never as the less-than operator.
1083     // C++2a [temp.names]p2:
1084     //   A name is also considered to refer to a template if it is an
1085     //   unqualified-id followed by a < and name lookup finds either one
1086     //   or more functions or finds nothing.
1087     if (!IsFilteredTemplateName)
1088       FilterAcceptableTemplateNames(Result);
1089
1090     bool IsFunctionTemplate;
1091     bool IsVarTemplate;
1092     TemplateName Template;
1093     if (Result.end() - Result.begin() > 1) {
1094       IsFunctionTemplate = true;
1095       Template = Context.getOverloadedTemplateName(Result.begin(),
1096                                                    Result.end());
1097     } else if (!Result.empty()) {
1098       auto *TD = cast<TemplateDecl>(getAsTemplateNameDecl(
1099           *Result.begin(), /*AllowFunctionTemplates=*/true,
1100           /*AllowDependent=*/false));
1101       IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
1102       IsVarTemplate = isa<VarTemplateDecl>(TD);
1103
1104       if (SS.isNotEmpty())
1105         Template =
1106             Context.getQualifiedTemplateName(SS.getScopeRep(),
1107                                              /*TemplateKeyword=*/false, TD);
1108       else
1109         Template = TemplateName(TD);
1110     } else {
1111       // All results were non-template functions. This is a function template
1112       // name.
1113       IsFunctionTemplate = true;
1114       Template = Context.getAssumedTemplateName(NameInfo.getName());
1115     }
1116
1117     if (IsFunctionTemplate) {
1118       // Function templates always go through overload resolution, at which
1119       // point we'll perform the various checks (e.g., accessibility) we need
1120       // to based on which function we selected.
1121       Result.suppressDiagnostics();
1122
1123       return NameClassification::FunctionTemplate(Template);
1124     }
1125
1126     return IsVarTemplate ? NameClassification::VarTemplate(Template)
1127                          : NameClassification::TypeTemplate(Template);
1128   }
1129
1130   NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
1131   if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
1132     DiagnoseUseOfDecl(Type, NameLoc);
1133     MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
1134     QualType T = Context.getTypeDeclType(Type);
1135     if (SS.isNotEmpty())
1136       return buildNestedType(*this, SS, T, NameLoc);
1137     return ParsedType::make(T);
1138   }
1139
1140   ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
1141   if (!Class) {
1142     // FIXME: It's unfortunate that we don't have a Type node for handling this.
1143     if (ObjCCompatibleAliasDecl *Alias =
1144             dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
1145       Class = Alias->getClassInterface();
1146   }
1147
1148   if (Class) {
1149     DiagnoseUseOfDecl(Class, NameLoc);
1150
1151     if (NextToken.is(tok::period)) {
1152       // Interface. <something> is parsed as a property reference expression.
1153       // Just return "unknown" as a fall-through for now.
1154       Result.suppressDiagnostics();
1155       return NameClassification::Unknown();
1156     }
1157
1158     QualType T = Context.getObjCInterfaceType(Class);
1159     return ParsedType::make(T);
1160   }
1161
1162   if (isa<ConceptDecl>(FirstDecl))
1163     return NameClassification::Concept(
1164         TemplateName(cast<TemplateDecl>(FirstDecl)));
1165
1166   // We can have a type template here if we're classifying a template argument.
1167   if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl) &&
1168       !isa<VarTemplateDecl>(FirstDecl))
1169     return NameClassification::TypeTemplate(
1170         TemplateName(cast<TemplateDecl>(FirstDecl)));
1171
1172   // Check for a tag type hidden by a non-type decl in a few cases where it
1173   // seems likely a type is wanted instead of the non-type that was found.
1174   bool NextIsOp = NextToken.isOneOf(tok::amp, tok::star);
1175   if ((NextToken.is(tok::identifier) ||
1176        (NextIsOp &&
1177         FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
1178       isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
1179     TypeDecl *Type = Result.getAsSingle<TypeDecl>();
1180     DiagnoseUseOfDecl(Type, NameLoc);
1181     QualType T = Context.getTypeDeclType(Type);
1182     if (SS.isNotEmpty())
1183       return buildNestedType(*this, SS, T, NameLoc);
1184     return ParsedType::make(T);
1185   }
1186
1187   // If we already know which single declaration is referenced, just annotate
1188   // that declaration directly. Defer resolving even non-overloaded class
1189   // member accesses, as we need to defer certain access checks until we know
1190   // the context.
1191   bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1192   if (Result.isSingleResult() && !ADL && !FirstDecl->isCXXClassMember())
1193     return NameClassification::NonType(Result.getRepresentativeDecl());
1194
1195   // Otherwise, this is an overload set that we will need to resolve later.
1196   Result.suppressDiagnostics();
1197   return NameClassification::OverloadSet(UnresolvedLookupExpr::Create(
1198       Context, Result.getNamingClass(), SS.getWithLocInContext(Context),
1199       Result.getLookupNameInfo(), ADL, Result.isOverloadedResult(),
1200       Result.begin(), Result.end()));
1201 }
1202
1203 ExprResult
1204 Sema::ActOnNameClassifiedAsUndeclaredNonType(IdentifierInfo *Name,
1205                                              SourceLocation NameLoc) {
1206   assert(getLangOpts().CPlusPlus && "ADL-only call in C?");
1207   CXXScopeSpec SS;
1208   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
1209   return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
1210 }
1211
1212 ExprResult
1213 Sema::ActOnNameClassifiedAsDependentNonType(const CXXScopeSpec &SS,
1214                                             IdentifierInfo *Name,
1215                                             SourceLocation NameLoc,
1216                                             bool IsAddressOfOperand) {
1217   DeclarationNameInfo NameInfo(Name, NameLoc);
1218   return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
1219                                     NameInfo, IsAddressOfOperand,
1220                                     /*TemplateArgs=*/nullptr);
1221 }
1222
1223 ExprResult Sema::ActOnNameClassifiedAsNonType(Scope *S, const CXXScopeSpec &SS,
1224                                               NamedDecl *Found,
1225                                               SourceLocation NameLoc,
1226                                               const Token &NextToken) {
1227   if (getCurMethodDecl() && SS.isEmpty())
1228     if (auto *Ivar = dyn_cast<ObjCIvarDecl>(Found->getUnderlyingDecl()))
1229       return BuildIvarRefExpr(S, NameLoc, Ivar);
1230
1231   // Reconstruct the lookup result.
1232   LookupResult Result(*this, Found->getDeclName(), NameLoc, LookupOrdinaryName);
1233   Result.addDecl(Found);
1234   Result.resolveKind();
1235
1236   bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
1237   return BuildDeclarationNameExpr(SS, Result, ADL);
1238 }
1239
1240 ExprResult Sema::ActOnNameClassifiedAsOverloadSet(Scope *S, Expr *E) {
1241   // For an implicit class member access, transform the result into a member
1242   // access expression if necessary.
1243   auto *ULE = cast<UnresolvedLookupExpr>(E);
1244   if ((*ULE->decls_begin())->isCXXClassMember()) {
1245     CXXScopeSpec SS;
1246     SS.Adopt(ULE->getQualifierLoc());
1247
1248     // Reconstruct the lookup result.
1249     LookupResult Result(*this, ULE->getName(), ULE->getNameLoc(),
1250                         LookupOrdinaryName);
1251     Result.setNamingClass(ULE->getNamingClass());
1252     for (auto I = ULE->decls_begin(), E = ULE->decls_end(); I != E; ++I)
1253       Result.addDecl(*I, I.getAccess());
1254     Result.resolveKind();
1255     return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
1256                                            nullptr, S);
1257   }
1258
1259   // Otherwise, this is already in the form we needed, and no further checks
1260   // are necessary.
1261   return ULE;
1262 }
1263
1264 Sema::TemplateNameKindForDiagnostics
1265 Sema::getTemplateNameKindForDiagnostics(TemplateName Name) {
1266   auto *TD = Name.getAsTemplateDecl();
1267   if (!TD)
1268     return TemplateNameKindForDiagnostics::DependentTemplate;
1269   if (isa<ClassTemplateDecl>(TD))
1270     return TemplateNameKindForDiagnostics::ClassTemplate;
1271   if (isa<FunctionTemplateDecl>(TD))
1272     return TemplateNameKindForDiagnostics::FunctionTemplate;
1273   if (isa<VarTemplateDecl>(TD))
1274     return TemplateNameKindForDiagnostics::VarTemplate;
1275   if (isa<TypeAliasTemplateDecl>(TD))
1276     return TemplateNameKindForDiagnostics::AliasTemplate;
1277   if (isa<TemplateTemplateParmDecl>(TD))
1278     return TemplateNameKindForDiagnostics::TemplateTemplateParam;
1279   if (isa<ConceptDecl>(TD))
1280     return TemplateNameKindForDiagnostics::Concept;
1281   return TemplateNameKindForDiagnostics::DependentTemplate;
1282 }
1283
1284 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
1285   assert(DC->getLexicalParent() == CurContext &&
1286       "The next DeclContext should be lexically contained in the current one.");
1287   CurContext = DC;
1288   S->setEntity(DC);
1289 }
1290
1291 void Sema::PopDeclContext() {
1292   assert(CurContext && "DeclContext imbalance!");
1293
1294   CurContext = CurContext->getLexicalParent();
1295   assert(CurContext && "Popped translation unit!");
1296 }
1297
1298 Sema::SkippedDefinitionContext Sema::ActOnTagStartSkippedDefinition(Scope *S,
1299                                                                     Decl *D) {
1300   // Unlike PushDeclContext, the context to which we return is not necessarily
1301   // the containing DC of TD, because the new context will be some pre-existing
1302   // TagDecl definition instead of a fresh one.
1303   auto Result = static_cast<SkippedDefinitionContext>(CurContext);
1304   CurContext = cast<TagDecl>(D)->getDefinition();
1305   assert(CurContext && "skipping definition of undefined tag");
1306   // Start lookups from the parent of the current context; we don't want to look
1307   // into the pre-existing complete definition.
1308   S->setEntity(CurContext->getLookupParent());
1309   return Result;
1310 }
1311
1312 void Sema::ActOnTagFinishSkippedDefinition(SkippedDefinitionContext Context) {
1313   CurContext = static_cast<decltype(CurContext)>(Context);
1314 }
1315
1316 /// EnterDeclaratorContext - Used when we must lookup names in the context
1317 /// of a declarator's nested name specifier.
1318 ///
1319 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
1320   // C++0x [basic.lookup.unqual]p13:
1321   //   A name used in the definition of a static data member of class
1322   //   X (after the qualified-id of the static member) is looked up as
1323   //   if the name was used in a member function of X.
1324   // C++0x [basic.lookup.unqual]p14:
1325   //   If a variable member of a namespace is defined outside of the
1326   //   scope of its namespace then any name used in the definition of
1327   //   the variable member (after the declarator-id) is looked up as
1328   //   if the definition of the variable member occurred in its
1329   //   namespace.
1330   // Both of these imply that we should push a scope whose context
1331   // is the semantic context of the declaration.  We can't use
1332   // PushDeclContext here because that context is not necessarily
1333   // lexically contained in the current context.  Fortunately,
1334   // the containing scope should have the appropriate information.
1335
1336   assert(!S->getEntity() && "scope already has entity");
1337
1338 #ifndef NDEBUG
1339   Scope *Ancestor = S->getParent();
1340   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1341   assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1342 #endif
1343
1344   CurContext = DC;
1345   S->setEntity(DC);
1346
1347   if (S->getParent()->isTemplateParamScope()) {
1348     // Also set the corresponding entities for all immediately-enclosing
1349     // template parameter scopes.
1350     EnterTemplatedContext(S->getParent(), DC);
1351   }
1352 }
1353
1354 void Sema::ExitDeclaratorContext(Scope *S) {
1355   assert(S->getEntity() == CurContext && "Context imbalance!");
1356
1357   // Switch back to the lexical context.  The safety of this is
1358   // enforced by an assert in EnterDeclaratorContext.
1359   Scope *Ancestor = S->getParent();
1360   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1361   CurContext = Ancestor->getEntity();
1362
1363   // We don't need to do anything with the scope, which is going to
1364   // disappear.
1365 }
1366
1367 void Sema::EnterTemplatedContext(Scope *S, DeclContext *DC) {
1368   assert(S->isTemplateParamScope() &&
1369          "expected to be initializing a template parameter scope");
1370
1371   // C++20 [temp.local]p7:
1372   //   In the definition of a member of a class template that appears outside
1373   //   of the class template definition, the name of a member of the class
1374   //   template hides the name of a template-parameter of any enclosing class
1375   //   templates (but not a template-parameter of the member if the member is a
1376   //   class or function template).
1377   // C++20 [temp.local]p9:
1378   //   In the definition of a class template or in the definition of a member
1379   //   of such a template that appears outside of the template definition, for
1380   //   each non-dependent base class (13.8.2.1), if the name of the base class
1381   //   or the name of a member of the base class is the same as the name of a
1382   //   template-parameter, the base class name or member name hides the
1383   //   template-parameter name (6.4.10).
1384   //
1385   // This means that a template parameter scope should be searched immediately
1386   // after searching the DeclContext for which it is a template parameter
1387   // scope. For example, for
1388   //   template<typename T> template<typename U> template<typename V>
1389   //     void N::A<T>::B<U>::f(...)
1390   // we search V then B<U> (and base classes) then U then A<T> (and base
1391   // classes) then T then N then ::.
1392   unsigned ScopeDepth = getTemplateDepth(S);
1393   for (; S && S->isTemplateParamScope(); S = S->getParent(), --ScopeDepth) {
1394     DeclContext *SearchDCAfterScope = DC;
1395     for (; DC; DC = DC->getLookupParent()) {
1396       if (const TemplateParameterList *TPL =
1397               cast<Decl>(DC)->getDescribedTemplateParams()) {
1398         unsigned DCDepth = TPL->getDepth() + 1;
1399         if (DCDepth > ScopeDepth)
1400           continue;
1401         if (ScopeDepth == DCDepth)
1402           SearchDCAfterScope = DC = DC->getLookupParent();
1403         break;
1404       }
1405     }
1406     S->setLookupEntity(SearchDCAfterScope);
1407   }
1408 }
1409
1410 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
1411   // We assume that the caller has already called
1412   // ActOnReenterTemplateScope so getTemplatedDecl() works.
1413   FunctionDecl *FD = D->getAsFunction();
1414   if (!FD)
1415     return;
1416
1417   // Same implementation as PushDeclContext, but enters the context
1418   // from the lexical parent, rather than the top-level class.
1419   assert(CurContext == FD->getLexicalParent() &&
1420     "The next DeclContext should be lexically contained in the current one.");
1421   CurContext = FD;
1422   S->setEntity(CurContext);
1423
1424   for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1425     ParmVarDecl *Param = FD->getParamDecl(P);
1426     // If the parameter has an identifier, then add it to the scope
1427     if (Param->getIdentifier()) {
1428       S->AddDecl(Param);
1429       IdResolver.AddDecl(Param);
1430     }
1431   }
1432 }
1433
1434 void Sema::ActOnExitFunctionContext() {
1435   // Same implementation as PopDeclContext, but returns to the lexical parent,
1436   // rather than the top-level class.
1437   assert(CurContext && "DeclContext imbalance!");
1438   CurContext = CurContext->getLexicalParent();
1439   assert(CurContext && "Popped translation unit!");
1440 }
1441
1442 /// Determine whether we allow overloading of the function
1443 /// PrevDecl with another declaration.
1444 ///
1445 /// This routine determines whether overloading is possible, not
1446 /// whether some new function is actually an overload. It will return
1447 /// true in C++ (where we can always provide overloads) or, as an
1448 /// extension, in C when the previous function is already an
1449 /// overloaded function declaration or has the "overloadable"
1450 /// attribute.
1451 static bool AllowOverloadingOfFunction(LookupResult &Previous,
1452                                        ASTContext &Context,
1453                                        const FunctionDecl *New) {
1454   if (Context.getLangOpts().CPlusPlus)
1455     return true;
1456
1457   if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1458     return true;
1459
1460   return Previous.getResultKind() == LookupResult::Found &&
1461          (Previous.getFoundDecl()->hasAttr<OverloadableAttr>() ||
1462           New->hasAttr<OverloadableAttr>());
1463 }
1464
1465 /// Add this decl to the scope shadowed decl chains.
1466 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1467   // Move up the scope chain until we find the nearest enclosing
1468   // non-transparent context. The declaration will be introduced into this
1469   // scope.
1470   while (S->getEntity() && S->getEntity()->isTransparentContext())
1471     S = S->getParent();
1472
1473   // Add scoped declarations into their context, so that they can be
1474   // found later. Declarations without a context won't be inserted
1475   // into any context.
1476   if (AddToContext)
1477     CurContext->addDecl(D);
1478
1479   // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1480   // are function-local declarations.
1481   if (getLangOpts().CPlusPlus && D->isOutOfLine() && !S->getFnParent())
1482     return;
1483
1484   // Template instantiations should also not be pushed into scope.
1485   if (isa<FunctionDecl>(D) &&
1486       cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1487     return;
1488
1489   // If this replaces anything in the current scope,
1490   IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1491                                IEnd = IdResolver.end();
1492   for (; I != IEnd; ++I) {
1493     if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1494       S->RemoveDecl(*I);
1495       IdResolver.RemoveDecl(*I);
1496
1497       // Should only need to replace one decl.
1498       break;
1499     }
1500   }
1501
1502   S->AddDecl(D);
1503
1504   if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1505     // Implicitly-generated labels may end up getting generated in an order that
1506     // isn't strictly lexical, which breaks name lookup. Be careful to insert
1507     // the label at the appropriate place in the identifier chain.
1508     for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1509       DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1510       if (IDC == CurContext) {
1511         if (!S->isDeclScope(*I))
1512           continue;
1513       } else if (IDC->Encloses(CurContext))
1514         break;
1515     }
1516
1517     IdResolver.InsertDeclAfter(I, D);
1518   } else {
1519     IdResolver.AddDecl(D);
1520   }
1521 }
1522
1523 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S,
1524                          bool AllowInlineNamespace) {
1525   return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1526 }
1527
1528 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
1529   DeclContext *TargetDC = DC->getPrimaryContext();
1530   do {
1531     if (DeclContext *ScopeDC = S->getEntity())
1532       if (ScopeDC->getPrimaryContext() == TargetDC)
1533         return S;
1534   } while ((S = S->getParent()));
1535
1536   return nullptr;
1537 }
1538
1539 static bool isOutOfScopePreviousDeclaration(NamedDecl *,
1540                                             DeclContext*,
1541                                             ASTContext&);
1542
1543 /// Filters out lookup results that don't fall within the given scope
1544 /// as determined by isDeclInScope.
1545 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
1546                                 bool ConsiderLinkage,
1547                                 bool AllowInlineNamespace) {
1548   LookupResult::Filter F = R.makeFilter();
1549   while (F.hasNext()) {
1550     NamedDecl *D = F.next();
1551
1552     if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1553       continue;
1554
1555     if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1556       continue;
1557
1558     F.erase();
1559   }
1560
1561   F.done();
1562 }
1563
1564 /// We've determined that \p New is a redeclaration of \p Old. Check that they
1565 /// have compatible owning modules.
1566 bool Sema::CheckRedeclarationModuleOwnership(NamedDecl *New, NamedDecl *Old) {
1567   // FIXME: The Modules TS is not clear about how friend declarations are
1568   // to be treated. It's not meaningful to have different owning modules for
1569   // linkage in redeclarations of the same entity, so for now allow the
1570   // redeclaration and change the owning modules to match.
1571   if (New->getFriendObjectKind() &&
1572       Old->getOwningModuleForLinkage() != New->getOwningModuleForLinkage()) {
1573     New->setLocalOwningModule(Old->getOwningModule());
1574     makeMergedDefinitionVisible(New);
1575     return false;
1576   }
1577
1578   Module *NewM = New->getOwningModule();
1579   Module *OldM = Old->getOwningModule();
1580
1581   if (NewM && NewM->Kind == Module::PrivateModuleFragment)
1582     NewM = NewM->Parent;
1583   if (OldM && OldM->Kind == Module::PrivateModuleFragment)
1584     OldM = OldM->Parent;
1585
1586   if (NewM == OldM)
1587     return false;
1588
1589   bool NewIsModuleInterface = NewM && NewM->isModulePurview();
1590   bool OldIsModuleInterface = OldM && OldM->isModulePurview();
1591   if (NewIsModuleInterface || OldIsModuleInterface) {
1592     // C++ Modules TS [basic.def.odr] 6.2/6.7 [sic]:
1593     //   if a declaration of D [...] appears in the purview of a module, all
1594     //   other such declarations shall appear in the purview of the same module
1595     Diag(New->getLocation(), diag::err_mismatched_owning_module)
1596       << New
1597       << NewIsModuleInterface
1598       << (NewIsModuleInterface ? NewM->getFullModuleName() : "")
1599       << OldIsModuleInterface
1600       << (OldIsModuleInterface ? OldM->getFullModuleName() : "");
1601     Diag(Old->getLocation(), diag::note_previous_declaration);
1602     New->setInvalidDecl();
1603     return true;
1604   }
1605
1606   return false;
1607 }
1608
1609 static bool isUsingDecl(NamedDecl *D) {
1610   return isa<UsingShadowDecl>(D) ||
1611          isa<UnresolvedUsingTypenameDecl>(D) ||
1612          isa<UnresolvedUsingValueDecl>(D);
1613 }
1614
1615 /// Removes using shadow declarations from the lookup results.
1616 static void RemoveUsingDecls(LookupResult &R) {
1617   LookupResult::Filter F = R.makeFilter();
1618   while (F.hasNext())
1619     if (isUsingDecl(F.next()))
1620       F.erase();
1621
1622   F.done();
1623 }
1624
1625 /// Check for this common pattern:
1626 /// @code
1627 /// class S {
1628 ///   S(const S&); // DO NOT IMPLEMENT
1629 ///   void operator=(const S&); // DO NOT IMPLEMENT
1630 /// };
1631 /// @endcode
1632 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1633   // FIXME: Should check for private access too but access is set after we get
1634   // the decl here.
1635   if (D->doesThisDeclarationHaveABody())
1636     return false;
1637
1638   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1639     return CD->isCopyConstructor();
1640   return D->isCopyAssignmentOperator();
1641 }
1642
1643 // We need this to handle
1644 //
1645 // typedef struct {
1646 //   void *foo() { return 0; }
1647 // } A;
1648 //
1649 // When we see foo we don't know if after the typedef we will get 'A' or '*A'
1650 // for example. If 'A', foo will have external linkage. If we have '*A',
1651 // foo will have no linkage. Since we can't know until we get to the end
1652 // of the typedef, this function finds out if D might have non-external linkage.
1653 // Callers should verify at the end of the TU if it D has external linkage or
1654 // not.
1655 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1656   const DeclContext *DC = D->getDeclContext();
1657   while (!DC->isTranslationUnit()) {
1658     if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1659       if (!RD->hasNameForLinkage())
1660         return true;
1661     }
1662     DC = DC->getParent();
1663   }
1664
1665   return !D->isExternallyVisible();
1666 }
1667
1668 // FIXME: This needs to be refactored; some other isInMainFile users want
1669 // these semantics.
1670 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1671   if (S.TUKind != TU_Complete)
1672     return false;
1673   return S.SourceMgr.isInMainFile(Loc);
1674 }
1675
1676 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1677   assert(D);
1678
1679   if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1680     return false;
1681
1682   // Ignore all entities declared within templates, and out-of-line definitions
1683   // of members of class templates.
1684   if (D->getDeclContext()->isDependentContext() ||
1685       D->getLexicalDeclContext()->isDependentContext())
1686     return false;
1687
1688   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1689     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1690       return false;
1691     // A non-out-of-line declaration of a member specialization was implicitly
1692     // instantiated; it's the out-of-line declaration that we're interested in.
1693     if (FD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1694         FD->getMemberSpecializationInfo() && !FD->isOutOfLine())
1695       return false;
1696
1697     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1698       if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1699         return false;
1700     } else {
1701       // 'static inline' functions are defined in headers; don't warn.
1702       if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1703         return false;
1704     }
1705
1706     if (FD->doesThisDeclarationHaveABody() &&
1707         Context.DeclMustBeEmitted(FD))
1708       return false;
1709   } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1710     // Constants and utility variables are defined in headers with internal
1711     // linkage; don't warn.  (Unlike functions, there isn't a convenient marker
1712     // like "inline".)
1713     if (!isMainFileLoc(*this, VD->getLocation()))
1714       return false;
1715
1716     if (Context.DeclMustBeEmitted(VD))
1717       return false;
1718
1719     if (VD->isStaticDataMember() &&
1720         VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1721       return false;
1722     if (VD->isStaticDataMember() &&
1723         VD->getTemplateSpecializationKind() == TSK_ExplicitSpecialization &&
1724         VD->getMemberSpecializationInfo() && !VD->isOutOfLine())
1725       return false;
1726
1727     if (VD->isInline() && !isMainFileLoc(*this, VD->getLocation()))
1728       return false;
1729   } else {
1730     return false;
1731   }
1732
1733   // Only warn for unused decls internal to the translation unit.
1734   // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1735   // for inline functions defined in the main source file, for instance.
1736   return mightHaveNonExternalLinkage(D);
1737 }
1738
1739 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
1740   if (!D)
1741     return;
1742
1743   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1744     const FunctionDecl *First = FD->getFirstDecl();
1745     if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1746       return; // First should already be in the vector.
1747   }
1748
1749   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1750     const VarDecl *First = VD->getFirstDecl();
1751     if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1752       return; // First should already be in the vector.
1753   }
1754
1755   if (ShouldWarnIfUnusedFileScopedDecl(D))
1756     UnusedFileScopedDecls.push_back(D);
1757 }
1758
1759 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1760   if (D->isInvalidDecl())
1761     return false;
1762
1763   if (auto *DD = dyn_cast<DecompositionDecl>(D)) {
1764     // For a decomposition declaration, warn if none of the bindings are
1765     // referenced, instead of if the variable itself is referenced (which
1766     // it is, by the bindings' expressions).
1767     for (auto *BD : DD->bindings())
1768       if (BD->isReferenced())
1769         return false;
1770   } else if (!D->getDeclName()) {
1771     return false;
1772   } else if (D->isReferenced() || D->isUsed()) {
1773     return false;
1774   }
1775
1776   if (D->hasAttr<UnusedAttr>() || D->hasAttr<ObjCPreciseLifetimeAttr>())
1777     return false;
1778
1779   if (isa<LabelDecl>(D))
1780     return true;
1781
1782   // Except for labels, we only care about unused decls that are local to
1783   // functions.
1784   bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1785   if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1786     // For dependent types, the diagnostic is deferred.
1787     WithinFunction =
1788         WithinFunction || (R->isLocalClass() && !R->isDependentType());
1789   if (!WithinFunction)
1790     return false;
1791
1792   if (isa<TypedefNameDecl>(D))
1793     return true;
1794
1795   // White-list anything that isn't a local variable.
1796   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1797     return false;
1798
1799   // Types of valid local variables should be complete, so this should succeed.
1800   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1801
1802     // White-list anything with an __attribute__((unused)) type.
1803     const auto *Ty = VD->getType().getTypePtr();
1804
1805     // Only look at the outermost level of typedef.
1806     if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1807       if (TT->getDecl()->hasAttr<UnusedAttr>())
1808         return false;
1809     }
1810
1811     // If we failed to complete the type for some reason, or if the type is
1812     // dependent, don't diagnose the variable.
1813     if (Ty->isIncompleteType() || Ty->isDependentType())
1814       return false;
1815
1816     // Look at the element type to ensure that the warning behaviour is
1817     // consistent for both scalars and arrays.
1818     Ty = Ty->getBaseElementTypeUnsafe();
1819
1820     if (const TagType *TT = Ty->getAs<TagType>()) {
1821       const TagDecl *Tag = TT->getDecl();
1822       if (Tag->hasAttr<UnusedAttr>())
1823         return false;
1824
1825       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1826         if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1827           return false;
1828
1829         if (const Expr *Init = VD->getInit()) {
1830           if (const ExprWithCleanups *Cleanups =
1831                   dyn_cast<ExprWithCleanups>(Init))
1832             Init = Cleanups->getSubExpr();
1833           const CXXConstructExpr *Construct =
1834             dyn_cast<CXXConstructExpr>(Init);
1835           if (Construct && !Construct->isElidable()) {
1836             CXXConstructorDecl *CD = Construct->getConstructor();
1837             if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>() &&
1838                 (VD->getInit()->isValueDependent() || !VD->evaluateValue()))
1839               return false;
1840           }
1841
1842           // Suppress the warning if we don't know how this is constructed, and
1843           // it could possibly be non-trivial constructor.
1844           if (Init->isTypeDependent())
1845             for (const CXXConstructorDecl *Ctor : RD->ctors())
1846               if (!Ctor->isTrivial())
1847                 return false;
1848         }
1849       }
1850     }
1851
1852     // TODO: __attribute__((unused)) templates?
1853   }
1854
1855   return true;
1856 }
1857
1858 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1859                                      FixItHint &Hint) {
1860   if (isa<LabelDecl>(D)) {
1861     SourceLocation AfterColon = Lexer::findLocationAfterToken(
1862         D->getEndLoc(), tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(),
1863         true);
1864     if (AfterColon.isInvalid())
1865       return;
1866     Hint = FixItHint::CreateRemoval(
1867         CharSourceRange::getCharRange(D->getBeginLoc(), AfterColon));
1868   }
1869 }
1870
1871 void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) {
1872   if (D->getTypeForDecl()->isDependentType())
1873     return;
1874
1875   for (auto *TmpD : D->decls()) {
1876     if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1877       DiagnoseUnusedDecl(T);
1878     else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1879       DiagnoseUnusedNestedTypedefs(R);
1880   }
1881 }
1882
1883 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1884 /// unless they are marked attr(unused).
1885 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
1886   if (!ShouldDiagnoseUnusedDecl(D))
1887     return;
1888
1889   if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1890     // typedefs can be referenced later on, so the diagnostics are emitted
1891     // at end-of-translation-unit.
1892     UnusedLocalTypedefNameCandidates.insert(TD);
1893     return;
1894   }
1895
1896   FixItHint Hint;
1897   GenerateFixForUnusedDecl(D, Context, Hint);
1898
1899   unsigned DiagID;
1900   if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1901     DiagID = diag::warn_unused_exception_param;
1902   else if (isa<LabelDecl>(D))
1903     DiagID = diag::warn_unused_label;
1904   else
1905     DiagID = diag::warn_unused_variable;
1906
1907   Diag(D->getLocation(), DiagID) << D << Hint;
1908 }
1909
1910 static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1911   // Verify that we have no forward references left.  If so, there was a goto
1912   // or address of a label taken, but no definition of it.  Label fwd
1913   // definitions are indicated with a null substmt which is also not a resolved
1914   // MS inline assembly label name.
1915   bool Diagnose = false;
1916   if (L->isMSAsmLabel())
1917     Diagnose = !L->isResolvedMSAsmLabel();
1918   else
1919     Diagnose = L->getStmt() == nullptr;
1920   if (Diagnose)
1921     S.Diag(L->getLocation(), diag::err_undeclared_label_use) << L;
1922 }
1923
1924 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
1925   S->mergeNRVOIntoParent();
1926
1927   if (S->decl_empty()) return;
1928   assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1929          "Scope shouldn't contain decls!");
1930
1931   for (auto *TmpD : S->decls()) {
1932     assert(TmpD && "This decl didn't get pushed??");
1933
1934     assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1935     NamedDecl *D = cast<NamedDecl>(TmpD);
1936
1937     // Diagnose unused variables in this scope.
1938     if (!S->hasUnrecoverableErrorOccurred()) {
1939       DiagnoseUnusedDecl(D);
1940       if (const auto *RD = dyn_cast<RecordDecl>(D))
1941         DiagnoseUnusedNestedTypedefs(RD);
1942     }
1943
1944     if (!D->getDeclName()) continue;
1945
1946     // If this was a forward reference to a label, verify it was defined.
1947     if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1948       CheckPoppedLabel(LD, *this);
1949
1950     // Remove this name from our lexical scope, and warn on it if we haven't
1951     // already.
1952     IdResolver.RemoveDecl(D);
1953     auto ShadowI = ShadowingDecls.find(D);
1954     if (ShadowI != ShadowingDecls.end()) {
1955       if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {
1956         Diag(D->getLocation(), diag::warn_ctor_parm_shadows_field)
1957             << D << FD << FD->getParent();
1958         Diag(FD->getLocation(), diag::note_previous_declaration);
1959       }
1960       ShadowingDecls.erase(ShadowI);
1961     }
1962   }
1963 }
1964
1965 /// Look for an Objective-C class in the translation unit.
1966 ///
1967 /// \param Id The name of the Objective-C class we're looking for. If
1968 /// typo-correction fixes this name, the Id will be updated
1969 /// to the fixed name.
1970 ///
1971 /// \param IdLoc The location of the name in the translation unit.
1972 ///
1973 /// \param DoTypoCorrection If true, this routine will attempt typo correction
1974 /// if there is no class with the given name.
1975 ///
1976 /// \returns The declaration of the named Objective-C class, or NULL if the
1977 /// class could not be found.
1978 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
1979                                               SourceLocation IdLoc,
1980                                               bool DoTypoCorrection) {
1981   // The third "scope" argument is 0 since we aren't enabling lazy built-in
1982   // creation from this context.
1983   NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1984
1985   if (!IDecl && DoTypoCorrection) {
1986     // Perform typo correction at the given location, but only if we
1987     // find an Objective-C class name.
1988     DeclFilterCCC<ObjCInterfaceDecl> CCC{};
1989     if (TypoCorrection C =
1990             CorrectTypo(DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName,
1991                         TUScope, nullptr, CCC, CTK_ErrorRecovery)) {
1992       diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1993       IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1994       Id = IDecl->getIdentifier();
1995     }
1996   }
1997   ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1998   // This routine must always return a class definition, if any.
1999   if (Def && Def->getDefinition())
2000       Def = Def->getDefinition();
2001   return Def;
2002 }
2003
2004 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
2005 /// from S, where a non-field would be declared. This routine copes
2006 /// with the difference between C and C++ scoping rules in structs and
2007 /// unions. For example, the following code is well-formed in C but
2008 /// ill-formed in C++:
2009 /// @code
2010 /// struct S6 {
2011 ///   enum { BAR } e;
2012 /// };
2013 ///
2014 /// void test_S6() {
2015 ///   struct S6 a;
2016 ///   a.e = BAR;
2017 /// }
2018 /// @endcode
2019 /// For the declaration of BAR, this routine will return a different
2020 /// scope. The scope S will be the scope of the unnamed enumeration
2021 /// within S6. In C++, this routine will return the scope associated
2022 /// with S6, because the enumeration's scope is a transparent
2023 /// context but structures can contain non-field names. In C, this
2024 /// routine will return the translation unit scope, since the
2025 /// enumeration's scope is a transparent context and structures cannot
2026 /// contain non-field names.
2027 Scope *Sema::getNonFieldDeclScope(Scope *S) {
2028   while (((S->getFlags() & Scope::DeclScope) == 0) ||
2029          (S->getEntity() && S->getEntity()->isTransparentContext()) ||
2030          (S->isClassScope() && !getLangOpts().CPlusPlus))
2031     S = S->getParent();
2032   return S;
2033 }
2034
2035 static StringRef getHeaderName(Builtin::Context &BuiltinInfo, unsigned ID,
2036                                ASTContext::GetBuiltinTypeError Error) {
2037   switch (Error) {
2038   case ASTContext::GE_None:
2039     return "";
2040   case ASTContext::GE_Missing_type:
2041     return BuiltinInfo.getHeaderName(ID);
2042   case ASTContext::GE_Missing_stdio:
2043     return "stdio.h";
2044   case ASTContext::GE_Missing_setjmp:
2045     return "setjmp.h";
2046   case ASTContext::GE_Missing_ucontext:
2047     return "ucontext.h";
2048   }
2049   llvm_unreachable("unhandled error kind");
2050 }
2051
2052 FunctionDecl *Sema::CreateBuiltin(IdentifierInfo *II, QualType Type,
2053                                   unsigned ID, SourceLocation Loc) {
2054   DeclContext *Parent = Context.getTranslationUnitDecl();
2055
2056   if (getLangOpts().CPlusPlus) {
2057     LinkageSpecDecl *CLinkageDecl = LinkageSpecDecl::Create(
2058         Context, Parent, Loc, Loc, LinkageSpecDecl::lang_c, false);
2059     CLinkageDecl->setImplicit();
2060     Parent->addDecl(CLinkageDecl);
2061     Parent = CLinkageDecl;
2062   }
2063
2064   FunctionDecl *New =
2065       FunctionDecl::Create(Context, Parent, Loc, Loc, II, Type,
2066                            /*TInfo=*/nullptr, StorageClass::Extern, false,
2067                            Type->isFunctionProtoType());
2068   New->setImplicit();
2069   New->addAttr(BuiltinAttr::CreateImplicit(Context, ID));
2070
2071   // Create Decl objects for each parameter, adding them to the
2072   // FunctionDecl.
2073   if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(Type)) {
2074     SmallVector<ParmVarDecl *, 16> Params;
2075     for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
2076       ParmVarDecl *parm = ParmVarDecl::Create(
2077           Context, New, SourceLocation(), SourceLocation(), nullptr,
2078           FT->getParamType(i), /*TInfo=*/nullptr, StorageClass::None, nullptr);
2079       parm->setScopeInfo(0, i);
2080       Params.push_back(parm);
2081     }
2082     New->setParams(Params);
2083   }
2084
2085   AddKnownFunctionAttributes(New);
2086   return New;
2087 }
2088
2089 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
2090 /// file scope.  lazily create a decl for it. ForRedeclaration is true
2091 /// if we're creating this built-in in anticipation of redeclaring the
2092 /// built-in.
2093 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
2094                                      Scope *S, bool ForRedeclaration,
2095                                      SourceLocation Loc) {
2096   LookupNecessaryTypesForBuiltin(S, ID);
2097
2098   ASTContext::GetBuiltinTypeError Error;
2099   QualType R = Context.GetBuiltinType(ID, Error);
2100   if (Error) {
2101     if (!ForRedeclaration)
2102       return nullptr;
2103
2104     // If we have a builtin without an associated type we should not emit a
2105     // warning when we were not able to find a type for it.
2106     if (Error == ASTContext::GE_Missing_type ||
2107         Context.BuiltinInfo.allowTypeMismatch(ID))
2108       return nullptr;
2109
2110     // If we could not find a type for setjmp it is because the jmp_buf type was
2111     // not defined prior to the setjmp declaration.
2112     if (Error == ASTContext::GE_Missing_setjmp) {
2113       Diag(Loc, diag::warn_implicit_decl_no_jmp_buf)
2114           << Context.BuiltinInfo.getName(ID);
2115       return nullptr;
2116     }
2117
2118     // Generally, we emit a warning that the declaration requires the
2119     // appropriate header.
2120     Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
2121         << getHeaderName(Context.BuiltinInfo, ID, Error)
2122         << Context.BuiltinInfo.getName(ID);
2123     return nullptr;
2124   }
2125
2126   if (!ForRedeclaration &&
2127       (Context.BuiltinInfo.isPredefinedLibFunction(ID) ||
2128        Context.BuiltinInfo.isHeaderDependentFunction(ID))) {
2129     Diag(Loc, diag::ext_implicit_lib_function_decl)
2130         << Context.BuiltinInfo.getName(ID) << R;
2131     if (const char *Header = Context.BuiltinInfo.getHeaderName(ID))
2132       Diag(Loc, diag::note_include_header_or_declare)
2133           << Header << Context.BuiltinInfo.getName(ID);
2134   }
2135
2136   if (R.isNull())
2137     return nullptr;
2138
2139   FunctionDecl *New = CreateBuiltin(II, R, ID, Loc);
2140   RegisterLocallyScopedExternCDecl(New, S);
2141
2142   // TUScope is the translation-unit scope to insert this function into.
2143   // FIXME: This is hideous. We need to teach PushOnScopeChains to
2144   // relate Scopes to DeclContexts, and probably eliminate CurContext
2145   // entirely, but we're not there yet.
2146   DeclContext *SavedContext = CurContext;
2147   CurContext = New->getDeclContext();
2148   PushOnScopeChains(New, TUScope);
2149   CurContext = SavedContext;
2150   return New;
2151 }
2152
2153 /// Typedef declarations don't have linkage, but they still denote the same
2154 /// entity if their types are the same.
2155 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
2156 /// isSameEntity.
2157 static void filterNonConflictingPreviousTypedefDecls(Sema &S,
2158                                                      TypedefNameDecl *Decl,
2159                                                      LookupResult &Previous) {
2160   // This is only interesting when modules are enabled.
2161   if (!S.getLangOpts().Modules && !S.getLangOpts().ModulesLocalVisibility)
2162     return;
2163
2164   // Empty sets are uninteresting.
2165   if (Previous.empty())
2166     return;
2167
2168   LookupResult::Filter Filter = Previous.makeFilter();
2169   while (Filter.hasNext()) {
2170     NamedDecl *Old = Filter.next();
2171
2172     // Non-hidden declarations are never ignored.
2173     if (S.isVisible(Old))
2174       continue;
2175
2176     // Declarations of the same entity are not ignored, even if they have
2177     // different linkages.
2178     if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2179       if (S.Context.hasSameType(OldTD->getUnderlyingType(),
2180                                 Decl->getUnderlyingType()))
2181         continue;
2182
2183       // If both declarations give a tag declaration a typedef name for linkage
2184       // purposes, then they declare the same entity.
2185       if (OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true) &&
2186           Decl->getAnonDeclWithTypedefName())
2187         continue;
2188     }
2189
2190     Filter.erase();
2191   }
2192
2193   Filter.done();
2194 }
2195
2196 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
2197   QualType OldType;
2198   if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
2199     OldType = OldTypedef->getUnderlyingType();
2200   else
2201     OldType = Context.getTypeDeclType(Old);
2202   QualType NewType = New->getUnderlyingType();
2203
2204   if (NewType->isVariablyModifiedType()) {
2205     // Must not redefine a typedef with a variably-modified type.
2206     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2207     Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
2208       << Kind << NewType;
2209     if (Old->getLocation().isValid())
2210       notePreviousDefinition(Old, New->getLocation());
2211     New->setInvalidDecl();
2212     return true;
2213   }
2214
2215   if (OldType != NewType &&
2216       !OldType->isDependentType() &&
2217       !NewType->isDependentType() &&
2218       !Context.hasSameType(OldType, NewType)) {
2219     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
2220     Diag(New->getLocation(), diag::err_redefinition_different_typedef)
2221       << Kind << NewType << OldType;
2222     if (Old->getLocation().isValid())
2223       notePreviousDefinition(Old, New->getLocation());
2224     New->setInvalidDecl();
2225     return true;
2226   }
2227   return false;
2228 }
2229
2230 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
2231 /// same name and scope as a previous declaration 'Old'.  Figure out
2232 /// how to resolve this situation, merging decls or emitting
2233 /// diagnostics as appropriate. If there was an error, set New to be invalid.
2234 ///
2235 void Sema::MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New,
2236                                 LookupResult &OldDecls) {
2237   // If the new decl is known invalid already, don't bother doing any
2238   // merging checks.
2239   if (New->isInvalidDecl()) return;
2240
2241   // Allow multiple definitions for ObjC built-in typedefs.
2242   // FIXME: Verify the underlying types are equivalent!
2243   if (getLangOpts().ObjC) {
2244     const IdentifierInfo *TypeID = New->getIdentifier();
2245     switch (TypeID->getLength()) {
2246     default: break;
2247     case 2:
2248       {
2249         if (!TypeID->isStr("id"))
2250           break;
2251         QualType T = New->getUnderlyingType();
2252         if (!T->isPointerType())
2253           break;
2254         if (!T->isVoidPointerType()) {
2255           QualType PT = T->castAs<PointerType>()->getPointeeType();
2256           if (!PT->isStructureType())
2257             break;
2258         }
2259         Context.setObjCIdRedefinitionType(T);
2260         // Install the built-in type for 'id', ignoring the current definition.
2261         New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
2262         return;
2263       }
2264     case 5:
2265       if (!TypeID->isStr("Class"))
2266         break;
2267       Context.setObjCClassRedefinitionType(New->getUnderlyingType());
2268       // Install the built-in type for 'Class', ignoring the current definition.
2269       New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
2270       return;
2271     case 3:
2272       if (!TypeID->isStr("SEL"))
2273         break;
2274       Context.setObjCSelRedefinitionType(New->getUnderlyingType());
2275       // Install the built-in type for 'SEL', ignoring the current definition.
2276       New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
2277       return;
2278     }
2279     // Fall through - the typedef name was not a builtin type.
2280   }
2281
2282   // Verify the old decl was also a type.
2283   TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
2284   if (!Old) {
2285     Diag(New->getLocation(), diag::err_redefinition_different_kind)
2286       << New->getDeclName();
2287
2288     NamedDecl *OldD = OldDecls.getRepresentativeDecl();
2289     if (OldD->getLocation().isValid())
2290       notePreviousDefinition(OldD, New->getLocation());
2291
2292     return New->setInvalidDecl();
2293   }
2294
2295   // If the old declaration is invalid, just give up here.
2296   if (Old->isInvalidDecl())
2297     return New->setInvalidDecl();
2298
2299   if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old)) {
2300     auto *OldTag = OldTD->getAnonDeclWithTypedefName(/*AnyRedecl*/true);
2301     auto *NewTag = New->getAnonDeclWithTypedefName();
2302     NamedDecl *Hidden = nullptr;
2303     if (OldTag && NewTag &&
2304         OldTag->getCanonicalDecl() != NewTag->getCanonicalDecl() &&
2305         !hasVisibleDefinition(OldTag, &Hidden)) {
2306       // There is a definition of this tag, but it is not visible. Use it
2307       // instead of our tag.
2308       New->setTypeForDecl(OldTD->getTypeForDecl());
2309       if (OldTD->isModed())
2310         New->setModedTypeSourceInfo(OldTD->getTypeSourceInfo(),
2311                                     OldTD->getUnderlyingType());
2312       else
2313         New->setTypeSourceInfo(OldTD->getTypeSourceInfo());
2314
2315       // Make the old tag definition visible.
2316       makeMergedDefinitionVisible(Hidden);
2317
2318       // If this was an unscoped enumeration, yank all of its enumerators
2319       // out of the scope.
2320       if (isa<EnumDecl>(NewTag)) {
2321         Scope *EnumScope = getNonFieldDeclScope(S);
2322         for (auto *D : NewTag->decls()) {
2323           auto *ED = cast<EnumConstantDecl>(D);
2324           assert(EnumScope->isDeclScope(ED));
2325           EnumScope->RemoveDecl(ED);
2326           IdResolver.RemoveDecl(ED);
2327           ED->getLexicalDeclContext()->removeDecl(ED);
2328         }
2329       }
2330     }
2331   }
2332
2333   // If the typedef types are not identical, reject them in all languages and
2334   // with any extensions enabled.
2335   if (isIncompatibleTypedef(Old, New))
2336     return;
2337
2338   // The types match.  Link up the redeclaration chain and merge attributes if
2339   // the old declaration was a typedef.
2340   if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
2341     New->setPreviousDecl(Typedef);
2342     mergeDeclAttributes(New, Old);
2343   }
2344
2345   if (getLangOpts().MicrosoftExt)
2346     return;
2347
2348   if (getLangOpts().CPlusPlus) {
2349     // C++ [dcl.typedef]p2:
2350     //   In a given non-class scope, a typedef specifier can be used to
2351     //   redefine the name of any type declared in that scope to refer
2352     //   to the type to which it already refers.
2353     if (!isa<CXXRecordDecl>(CurContext))
2354       return;
2355
2356     // C++0x [dcl.typedef]p4:
2357     //   In a given class scope, a typedef specifier can be used to redefine
2358     //   any class-name declared in that scope that is not also a typedef-name
2359     //   to refer to the type to which it already refers.
2360     //
2361     // This wording came in via DR424, which was a correction to the
2362     // wording in DR56, which accidentally banned code like:
2363     //
2364     //   struct S {
2365     //     typedef struct A { } A;
2366     //   };
2367     //
2368     // in the C++03 standard. We implement the C++0x semantics, which
2369     // allow the above but disallow
2370     //
2371     //   struct S {
2372     //     typedef int I;
2373     //     typedef int I;
2374     //   };
2375     //
2376     // since that was the intent of DR56.
2377     if (!isa<TypedefNameDecl>(Old))
2378       return;
2379
2380     Diag(New->getLocation(), diag::err_redefinition)
2381       << New->getDeclName();
2382     notePreviousDefinition(Old, New->getLocation());
2383     return New->setInvalidDecl();
2384   }
2385
2386   // Modules always permit redefinition of typedefs, as does C11.
2387   if (getLangOpts().Modules || getLangOpts().C11)
2388     return;
2389
2390   // If we have a redefinition of a typedef in C, emit a warning.  This warning
2391   // is normally mapped to an error, but can be controlled with
2392   // -Wtypedef-redefinition.  If either the original or the redefinition is
2393   // in a system header, don't emit this for compatibility with GCC.
2394   if (getDiagnostics().getSuppressSystemWarnings() &&
2395       // Some standard types are defined implicitly in Clang (e.g. OpenCL).
2396       (Old->isImplicit() ||
2397        Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
2398        Context.getSourceManager().isInSystemHeader(New->getLocation())))
2399     return;
2400
2401   Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
2402     << New->getDeclName();
2403   notePreviousDefinition(Old, New->getLocation());
2404 }
2405
2406 /// DeclhasAttr - returns true if decl Declaration already has the target
2407 /// attribute.
2408 static bool DeclHasAttr(const Decl *D, const Attr *A) {
2409   const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
2410   const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
2411   for (const auto *i : D->attrs())
2412     if (i->getKind() == A->getKind()) {
2413       if (Ann) {
2414         if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
2415           return true;
2416         continue;
2417       }
2418       // FIXME: Don't hardcode this check
2419       if (OA && isa<OwnershipAttr>(i))
2420         return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
2421       return true;
2422     }
2423
2424   return false;
2425 }
2426
2427 static bool isAttributeTargetADefinition(Decl *D) {
2428   if (VarDecl *VD = dyn_cast<VarDecl>(D))
2429     return VD->isThisDeclarationADefinition();
2430   if (TagDecl *TD = dyn_cast<TagDecl>(D))
2431     return TD->isCompleteDefinition() || TD->isBeingDefined();
2432   return true;
2433 }
2434
2435 /// Merge alignment attributes from \p Old to \p New, taking into account the
2436 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2437 ///
2438 /// \return \c true if any attributes were added to \p New.
2439 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2440   // Look for alignas attributes on Old, and pick out whichever attribute
2441   // specifies the strictest alignment requirement.
2442   AlignedAttr *OldAlignasAttr = nullptr;
2443   AlignedAttr *OldStrictestAlignAttr = nullptr;
2444   unsigned OldAlign = 0;
2445   for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2446     // FIXME: We have no way of representing inherited dependent alignments
2447     // in a case like:
2448     //   template<int A, int B> struct alignas(A) X;
2449     //   template<int A, int B> struct alignas(B) X {};
2450     // For now, we just ignore any alignas attributes which are not on the
2451     // definition in such a case.
2452     if (I->isAlignmentDependent())
2453       return false;
2454
2455     if (I->isAlignas())
2456       OldAlignasAttr = I;
2457
2458     unsigned Align = I->getAlignment(S.Context);
2459     if (Align > OldAlign) {
2460       OldAlign = Align;
2461       OldStrictestAlignAttr = I;
2462     }
2463   }
2464
2465   // Look for alignas attributes on New.
2466   AlignedAttr *NewAlignasAttr = nullptr;
2467   unsigned NewAlign = 0;
2468   for (auto *I : New->specific_attrs<AlignedAttr>()) {
2469     if (I->isAlignmentDependent())
2470       return false;
2471
2472     if (I->isAlignas())
2473       NewAlignasAttr = I;
2474
2475     unsigned Align = I->getAlignment(S.Context);
2476     if (Align > NewAlign)
2477       NewAlign = Align;
2478   }
2479
2480   if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2481     // Both declarations have 'alignas' attributes. We require them to match.
2482     // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2483     // fall short. (If two declarations both have alignas, they must both match
2484     // every definition, and so must match each other if there is a definition.)
2485
2486     // If either declaration only contains 'alignas(0)' specifiers, then it
2487     // specifies the natural alignment for the type.
2488     if (OldAlign == 0 || NewAlign == 0) {
2489       QualType Ty;
2490       if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2491         Ty = VD->getType();
2492       else
2493         Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2494
2495       if (OldAlign == 0)
2496         OldAlign = S.Context.getTypeAlign(Ty);
2497       if (NewAlign == 0)
2498         NewAlign = S.Context.getTypeAlign(Ty);
2499     }
2500
2501     if (OldAlign != NewAlign) {
2502       S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2503         << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2504         << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2505       S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2506     }
2507   }
2508
2509   if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2510     // C++11 [dcl.align]p6:
2511     //   if any declaration of an entity has an alignment-specifier,
2512     //   every defining declaration of that entity shall specify an
2513     //   equivalent alignment.
2514     // C11 6.7.5/7:
2515     //   If the definition of an object does not have an alignment
2516     //   specifier, any other declaration of that object shall also
2517     //   have no alignment specifier.
2518     S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2519       << OldAlignasAttr;
2520     S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2521       << OldAlignasAttr;
2522   }
2523
2524   bool AnyAdded = false;
2525
2526   // Ensure we have an attribute representing the strictest alignment.
2527   if (OldAlign > NewAlign) {
2528     AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2529     Clone->setInherited(true);
2530     New->addAttr(Clone);
2531     AnyAdded = true;
2532   }
2533
2534   // Ensure we have an alignas attribute if the old declaration had one.
2535   if (OldAlignasAttr && !NewAlignasAttr &&
2536       !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2537     AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2538     Clone->setInherited(true);
2539     New->addAttr(Clone);
2540     AnyAdded = true;
2541   }
2542
2543   return AnyAdded;
2544 }
2545
2546 static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2547                                const InheritableAttr *Attr,
2548                                Sema::AvailabilityMergeKind AMK) {
2549   // This function copies an attribute Attr from a previous declaration to the
2550   // new declaration D if the new declaration doesn't itself have that attribute
2551   // yet or if that attribute allows duplicates.
2552   // If you're adding a new attribute that requires logic different from
2553   // "use explicit attribute on decl if present, else use attribute from
2554   // previous decl", for example if the attribute needs to be consistent
2555   // between redeclarations, you need to call a custom merge function here.
2556   InheritableAttr *NewAttr = nullptr;
2557   if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2558     NewAttr = S.mergeAvailabilityAttr(
2559         D, *AA, AA->getPlatform(), AA->isImplicit(), AA->getIntroduced(),
2560         AA->getDeprecated(), AA->getObsoleted(), AA->getUnavailable(),
2561         AA->getMessage(), AA->getStrict(), AA->getReplacement(), AMK,
2562         AA->getPriority());
2563   else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2564     NewAttr = S.mergeVisibilityAttr(D, *VA, VA->getVisibility());
2565   else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2566     NewAttr = S.mergeTypeVisibilityAttr(D, *VA, VA->getVisibility());
2567   else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2568     NewAttr = S.mergeDLLImportAttr(D, *ImportA);
2569   else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2570     NewAttr = S.mergeDLLExportAttr(D, *ExportA);
2571   else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2572     NewAttr = S.mergeFormatAttr(D, *FA, FA->getType(), FA->getFormatIdx(),
2573                                 FA->getFirstArg());
2574   else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2575     NewAttr = S.mergeSectionAttr(D, *SA, SA->getName());
2576   else if (const auto *CSA = dyn_cast<CodeSegAttr>(Attr))
2577     NewAttr = S.mergeCodeSegAttr(D, *CSA, CSA->getName());
2578   else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2579     NewAttr = S.mergeMSInheritanceAttr(D, *IA, IA->getBestCase(),
2580                                        IA->getInheritanceModel());
2581   else if (const auto *AA = dyn_cast<AlwaysInlineAttr>(Attr))
2582     NewAttr = S.mergeAlwaysInlineAttr(D, *AA,
2583                                       &S.Context.Idents.get(AA->getSpelling()));
2584   else if (S.getLangOpts().CUDA && isa<FunctionDecl>(D) &&
2585            (isa<CUDAHostAttr>(Attr) || isa<CUDADeviceAttr>(Attr) ||
2586             isa<CUDAGlobalAttr>(Attr))) {
2587     // CUDA target attributes are part of function signature for
2588     // overloading purposes and must not be merged.
2589     return false;
2590   } else if (const auto *MA = dyn_cast<MinSizeAttr>(Attr))
2591     NewAttr = S.mergeMinSizeAttr(D, *MA);
2592   else if (const auto *SNA = dyn_cast<SwiftNameAttr>(Attr))
2593     NewAttr = S.mergeSwiftNameAttr(D, *SNA, SNA->getName());
2594   else if (const auto *OA = dyn_cast<OptimizeNoneAttr>(Attr))
2595     NewAttr = S.mergeOptimizeNoneAttr(D, *OA);
2596   else if (const auto *InternalLinkageA = dyn_cast<InternalLinkageAttr>(Attr))
2597     NewAttr = S.mergeInternalLinkageAttr(D, *InternalLinkageA);
2598   else if (const auto *CommonA = dyn_cast<CommonAttr>(Attr))
2599     NewAttr = S.mergeCommonAttr(D, *CommonA);
2600   else if (isa<AlignedAttr>(Attr))
2601     // AlignedAttrs are handled separately, because we need to handle all
2602     // such attributes on a declaration at the same time.
2603     NewAttr = nullptr;
2604   else if ((isa<DeprecatedAttr>(Attr) || isa<UnavailableAttr>(Attr)) &&
2605            (AMK == Sema::AMK_Override ||
2606             AMK == Sema::AMK_ProtocolImplementation))
2607     NewAttr = nullptr;
2608   else if (const auto *UA = dyn_cast<UuidAttr>(Attr))
2609     NewAttr = S.mergeUuidAttr(D, *UA, UA->getGuid(), UA->getGuidDecl());
2610   else if (const auto *SLHA = dyn_cast<SpeculativeLoadHardeningAttr>(Attr))
2611     NewAttr = S.mergeSpeculativeLoadHardeningAttr(D, *SLHA);
2612   else if (const auto *SLHA = dyn_cast<NoSpeculativeLoadHardeningAttr>(Attr))
2613     NewAttr = S.mergeNoSpeculativeLoadHardeningAttr(D, *SLHA);
2614   else if (const auto *IMA = dyn_cast<WebAssemblyImportModuleAttr>(Attr))
2615     NewAttr = S.mergeImportModuleAttr(D, *IMA);
2616   else if (const auto *INA = dyn_cast<WebAssemblyImportNameAttr>(Attr))
2617     NewAttr = S.mergeImportNameAttr(D, *INA);
2618   else if (Attr->shouldInheritEvenIfAlreadyPresent() || !DeclHasAttr(D, Attr))
2619     NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2620
2621   if (NewAttr) {
2622     NewAttr->setInherited(true);
2623     D->addAttr(NewAttr);
2624     if (isa<MSInheritanceAttr>(NewAttr))
2625       S.Consumer.AssignInheritanceModel(cast<CXXRecordDecl>(D));
2626     return true;
2627   }
2628
2629   return false;
2630 }
2631
2632 static const NamedDecl *getDefinition(const Decl *D) {
2633   if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2634     return TD->getDefinition();
2635   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2636     const VarDecl *Def = VD->getDefinition();
2637     if (Def)
2638       return Def;
2639     return VD->getActingDefinition();
2640   }
2641   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2642     const FunctionDecl *Def = nullptr;
2643     if (FD->isDefined(Def, true))
2644       return Def;
2645   }
2646   return nullptr;
2647 }
2648
2649 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2650   for (const auto *Attribute : D->attrs())
2651     if (Attribute->getKind() == Kind)
2652       return true;
2653   return false;
2654 }
2655
2656 /// checkNewAttributesAfterDef - If we already have a definition, check that
2657 /// there are no new attributes in this declaration.
2658 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2659   if (!New->hasAttrs())
2660     return;
2661
2662   const NamedDecl *Def = getDefinition(Old);
2663   if (!Def || Def == New)
2664     return;
2665
2666   AttrVec &NewAttributes = New->getAttrs();
2667   for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2668     const Attr *NewAttribute = NewAttributes[I];
2669
2670     if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {
2671       if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {
2672         Sema::SkipBodyInfo SkipBody;
2673         S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def), &SkipBody);
2674
2675         // If we're skipping this definition, drop the "alias" attribute.
2676         if (SkipBody.ShouldSkip) {
2677           NewAttributes.erase(NewAttributes.begin() + I);
2678           --E;
2679           continue;
2680         }
2681       } else {
2682         VarDecl *VD = cast<VarDecl>(New);
2683         unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2684                                 VarDecl::TentativeDefinition
2685                             ? diag::err_alias_after_tentative
2686                             : diag::err_redefinition;
2687         S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2688         if (Diag == diag::err_redefinition)
2689           S.notePreviousDefinition(Def, VD->getLocation());
2690         else
2691           S.Diag(Def->getLocation(), diag::note_previous_definition);
2692         VD->setInvalidDecl();
2693       }
2694       ++I;
2695       continue;
2696     }
2697
2698     if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2699       // Tentative definitions are only interesting for the alias check above.
2700       if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2701         ++I;
2702         continue;
2703       }
2704     }
2705
2706     if (hasAttribute(Def, NewAttribute->getKind())) {
2707       ++I;
2708       continue; // regular attr merging will take care of validating this.
2709     }
2710
2711     if (isa<C11NoReturnAttr>(NewAttribute)) {
2712       // C's _Noreturn is allowed to be added to a function after it is defined.
2713       ++I;
2714       continue;
2715     } else if (isa<UuidAttr>(NewAttribute)) {
2716       // msvc will allow a subsequent definition to add an uuid to a class
2717       ++I;
2718       continue;
2719     } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2720       if (AA->isAlignas()) {
2721         // C++11 [dcl.align]p6:
2722         //   if any declaration of an entity has an alignment-specifier,
2723         //   every defining declaration of that entity shall specify an
2724         //   equivalent alignment.
2725         // C11 6.7.5/7:
2726         //   If the definition of an object does not have an alignment
2727         //   specifier, any other declaration of that object shall also
2728         //   have no alignment specifier.
2729         S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2730           << AA;
2731         S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2732           << AA;
2733         NewAttributes.erase(NewAttributes.begin() + I);
2734         --E;
2735         continue;
2736       }
2737     } else if (isa<LoaderUninitializedAttr>(NewAttribute)) {
2738       // If there is a C definition followed by a redeclaration with this
2739       // attribute then there are two different definitions. In C++, prefer the
2740       // standard diagnostics.
2741       if (!S.getLangOpts().CPlusPlus) {
2742         S.Diag(NewAttribute->getLocation(),
2743                diag::err_loader_uninitialized_redeclaration);
2744         S.Diag(Def->getLocation(), diag::note_previous_definition);
2745         NewAttributes.erase(NewAttributes.begin() + I);
2746         --E;
2747         continue;
2748       }
2749     } else if (isa<SelectAnyAttr>(NewAttribute) &&
2750                cast<VarDecl>(New)->isInline() &&
2751                !cast<VarDecl>(New)->isInlineSpecified()) {
2752       // Don't warn about applying selectany to implicitly inline variables.
2753       // Older compilers and language modes would require the use of selectany
2754       // to make such variables inline, and it would have no effect if we
2755       // honored it.
2756       ++I;
2757       continue;
2758     } else if (isa<OMPDeclareVariantAttr>(NewAttribute)) {
2759       // We allow to add OMP[Begin]DeclareVariantAttr to be added to
2760       // declarations after defintions.
2761       ++I;
2762       continue;
2763     }
2764
2765     S.Diag(NewAttribute->getLocation(),
2766            diag::warn_attribute_precede_definition);
2767     S.Diag(Def->getLocation(), diag::note_previous_definition);
2768     NewAttributes.erase(NewAttributes.begin() + I);
2769     --E;
2770   }
2771 }
2772
2773 static void diagnoseMissingConstinit(Sema &S, const VarDecl *InitDecl,
2774                                      const ConstInitAttr *CIAttr,
2775                                      bool AttrBeforeInit) {
2776   SourceLocation InsertLoc = InitDecl->getInnerLocStart();
2777
2778   // Figure out a good way to write this specifier on the old declaration.
2779   // FIXME: We should just use the spelling of CIAttr, but we don't preserve
2780   // enough of the attribute list spelling information to extract that without
2781   // heroics.
2782   std::string SuitableSpelling;
2783   if (S.getLangOpts().CPlusPlus20)
2784     SuitableSpelling = std::string(
2785         S.PP.getLastMacroWithSpelling(InsertLoc, {tok::kw_constinit}));
2786   if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
2787     SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
2788         InsertLoc, {tok::l_square, tok::l_square,
2789                     S.PP.getIdentifierInfo("clang"), tok::coloncolon,
2790                     S.PP.getIdentifierInfo("require_constant_initialization"),
2791                     tok::r_square, tok::r_square}));
2792   if (SuitableSpelling.empty())
2793     SuitableSpelling = std::string(S.PP.getLastMacroWithSpelling(
2794         InsertLoc, {tok::kw___attribute, tok::l_paren, tok::r_paren,
2795                     S.PP.getIdentifierInfo("require_constant_initialization"),
2796                     tok::r_paren, tok::r_paren}));
2797   if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus20)
2798     SuitableSpelling = "constinit";
2799   if (SuitableSpelling.empty() && S.getLangOpts().CPlusPlus11)
2800     SuitableSpelling = "[[clang::require_constant_initialization]]";
2801   if (SuitableSpelling.empty())
2802     SuitableSpelling = "__attribute__((require_constant_initialization))";
2803   SuitableSpelling += " ";
2804
2805   if (AttrBeforeInit) {
2806     // extern constinit int a;
2807     // int a = 0; // error (missing 'constinit'), accepted as extension
2808     assert(CIAttr->isConstinit() && "should not diagnose this for attribute");
2809     S.Diag(InitDecl->getLocation(), diag::ext_constinit_missing)
2810         << InitDecl << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling);
2811     S.Diag(CIAttr->getLocation(), diag::note_constinit_specified_here);
2812   } else {
2813     // int a = 0;
2814     // constinit extern int a; // error (missing 'constinit')
2815     S.Diag(CIAttr->getLocation(),
2816            CIAttr->isConstinit() ? diag::err_constinit_added_too_late
2817                                  : diag::warn_require_const_init_added_too_late)
2818         << FixItHint::CreateRemoval(SourceRange(CIAttr->getLocation()));
2819     S.Diag(InitDecl->getLocation(), diag::note_constinit_missing_here)
2820         << CIAttr->isConstinit()
2821         << FixItHint::CreateInsertion(InsertLoc, SuitableSpelling);
2822   }
2823 }
2824
2825 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2826 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
2827                                AvailabilityMergeKind AMK) {
2828   if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2829     UsedAttr *NewAttr = OldAttr->clone(Context);
2830     NewAttr->setInherited(true);
2831     New->addAttr(NewAttr);
2832   }
2833
2834   if (!Old->hasAttrs() && !New->hasAttrs())
2835     return;
2836
2837   // [dcl.constinit]p1:
2838   //   If the [constinit] specifier is applied to any declaration of a
2839   //   variable, it shall be applied to the initializing declaration.
2840   const auto *OldConstInit = Old->getAttr<ConstInitAttr>();
2841   const auto *NewConstInit = New->getAttr<ConstInitAttr>();
2842   if (bool(OldConstInit) != bool(NewConstInit)) {
2843     const auto *OldVD = cast<VarDecl>(Old);
2844     auto *NewVD = cast<VarDecl>(New);
2845
2846     // Find the initializing declaration. Note that we might not have linked
2847     // the new declaration into the redeclaration chain yet.
2848     const VarDecl *InitDecl = OldVD->getInitializingDeclaration();
2849     if (!InitDecl &&
2850         (NewVD->hasInit() || NewVD->isThisDeclarationADefinition()))
2851       InitDecl = NewVD;
2852
2853     if (InitDecl == NewVD) {
2854       // This is the initializing declaration. If it would inherit 'constinit',
2855       // that's ill-formed. (Note that we do not apply this to the attribute
2856       // form).
2857       if (OldConstInit && OldConstInit->isConstinit())
2858         diagnoseMissingConstinit(*this, NewVD, OldConstInit,
2859                                  /*AttrBeforeInit=*/true);
2860     } else if (NewConstInit) {
2861       // This is the first time we've been told that this declaration should
2862       // have a constant initializer. If we already saw the initializing
2863       // declaration, this is too late.
2864       if (InitDecl && InitDecl != NewVD) {
2865         diagnoseMissingConstinit(*this, InitDecl, NewConstInit,
2866                                  /*AttrBeforeInit=*/false);
2867         NewVD->dropAttr<ConstInitAttr>();
2868       }
2869     }
2870   }
2871
2872   // Attributes declared post-definition are currently ignored.
2873   checkNewAttributesAfterDef(*this, New, Old);
2874
2875   if (AsmLabelAttr *NewA = New->getAttr<AsmLabelAttr>()) {
2876     if (AsmLabelAttr *OldA = Old->getAttr<AsmLabelAttr>()) {
2877       if (!OldA->isEquivalent(NewA)) {
2878         // This redeclaration changes __asm__ label.
2879         Diag(New->getLocation(), diag::err_different_asm_label);
2880         Diag(OldA->getLocation(), diag::note_previous_declaration);
2881       }
2882     } else if (Old->isUsed()) {
2883       // This redeclaration adds an __asm__ label to a declaration that has
2884       // already been ODR-used.
2885       Diag(New->getLocation(), diag::err_late_asm_label_name)
2886         << isa<FunctionDecl>(Old) << New->getAttr<AsmLabelAttr>()->getRange();
2887     }
2888   }
2889
2890   // Re-declaration cannot add abi_tag's.
2891   if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {
2892     if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {
2893       for (const auto &NewTag : NewAbiTagAttr->tags()) {
2894         if (std::find(OldAbiTagAttr->tags_begin(), OldAbiTagAttr->tags_end(),
2895                       NewTag) == OldAbiTagAttr->tags_end()) {
2896           Diag(NewAbiTagAttr->getLocation(),
2897                diag::err_new_abi_tag_on_redeclaration)
2898               << NewTag;
2899           Diag(OldAbiTagAttr->getLocation(), diag::note_previous_declaration);
2900         }
2901       }
2902     } else {
2903       Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);
2904       Diag(Old->getLocation(), diag::note_previous_declaration);
2905     }
2906   }
2907
2908   // This redeclaration adds a section attribute.
2909   if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {
2910     if (auto *VD = dyn_cast<VarDecl>(New)) {
2911       if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {
2912         Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);
2913         Diag(Old->getLocation(), diag::note_previous_declaration);
2914       }
2915     }
2916   }
2917
2918   // Redeclaration adds code-seg attribute.
2919   const auto *NewCSA = New->getAttr<CodeSegAttr>();
2920   if (NewCSA && !Old->hasAttr<CodeSegAttr>() &&
2921       !NewCSA->isImplicit() && isa<CXXMethodDecl>(New)) {
2922     Diag(New->getLocation(), diag::warn_mismatched_section)
2923          << 0 /*codeseg*/;
2924     Diag(Old->getLocation(), diag::note_previous_declaration);
2925   }
2926
2927   if (!Old->hasAttrs())
2928     return;
2929
2930   bool foundAny = New->hasAttrs();
2931
2932   // Ensure that any moving of objects within the allocated map is done before
2933   // we process them.
2934   if (!foundAny) New->setAttrs(AttrVec());
2935
2936   for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2937     // Ignore deprecated/unavailable/availability attributes if requested.
2938     AvailabilityMergeKind LocalAMK = AMK_None;
2939     if (isa<DeprecatedAttr>(I) ||
2940         isa<UnavailableAttr>(I) ||
2941         isa<AvailabilityAttr>(I)) {
2942       switch (AMK) {
2943       case AMK_None:
2944         continue;
2945
2946       case AMK_Redeclaration:
2947       case AMK_Override:
2948       case AMK_ProtocolImplementation:
2949         LocalAMK = AMK;
2950         break;
2951       }
2952     }
2953
2954     // Already handled.
2955     if (isa<UsedAttr>(I))
2956       continue;
2957
2958     if (mergeDeclAttribute(*this, New, I, LocalAMK))
2959       foundAny = true;
2960   }
2961
2962   if (mergeAlignedAttrs(*this, New, Old))
2963     foundAny = true;
2964
2965   if (!foundAny) New->dropAttrs();
2966 }
2967
2968 /// mergeParamDeclAttributes - Copy attributes from the old parameter
2969 /// to the new one.
2970 static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2971                                      const ParmVarDecl *oldDecl,
2972                                      Sema &S) {
2973   // C++11 [dcl.attr.depend]p2:
2974   //   The first declaration of a function shall specify the
2975   //   carries_dependency attribute for its declarator-id if any declaration
2976   //   of the function specifies the carries_dependency attribute.
2977   const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2978   if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2979     S.Diag(CDA->getLocation(),
2980            diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2981     // Find the first declaration of the parameter.
2982     // FIXME: Should we build redeclaration chains for function parameters?
2983     const FunctionDecl *FirstFD =
2984       cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2985     const ParmVarDecl *FirstVD =
2986       FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2987     S.Diag(FirstVD->getLocation(),
2988            diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2989   }
2990
2991   if (!oldDecl->hasAttrs())
2992     return;
2993
2994   bool foundAny = newDecl->hasAttrs();
2995
2996   // Ensure that any moving of objects within the allocated map is
2997   // done before we process them.
2998   if (!foundAny) newDecl->setAttrs(AttrVec());
2999
3000   for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
3001     if (!DeclHasAttr(newDecl, I)) {
3002       InheritableAttr *newAttr =
3003         cast<InheritableParamAttr>(I->clone(S.Context));
3004       newAttr->setInherited(true);
3005       newDecl->addAttr(newAttr);
3006       foundAny = true;
3007     }
3008   }
3009
3010   if (!foundAny) newDecl->dropAttrs();
3011 }
3012
3013 static void mergeParamDeclTypes(ParmVarDecl *NewParam,
3014                                 const ParmVarDecl *OldParam,
3015                                 Sema &S) {
3016   if (auto Oldnullability = OldParam->getType()->getNullability(S.Context)) {
3017     if (auto Newnullability = NewParam->getType()->getNullability(S.Context)) {
3018       if (*Oldnullability != *Newnullability) {
3019         S.Diag(NewParam->getLocation(), diag::warn_mismatched_nullability_attr)
3020           << DiagNullabilityKind(
3021                *Newnullability,
3022                ((NewParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
3023                 != 0))
3024           << DiagNullabilityKind(
3025                *Oldnullability,
3026                ((OldParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
3027                 != 0));
3028         S.Diag(OldParam->getLocation(), diag::note_previous_declaration);
3029       }
3030     } else {
3031       QualType NewT = NewParam->getType();
3032       NewT = S.Context.getAttributedType(
3033                          AttributedType::getNullabilityAttrKind(*Oldnullability),
3034                          NewT, NewT);
3035       NewParam->setType(NewT);
3036     }
3037   }
3038 }
3039
3040 namespace {
3041
3042 /// Used in MergeFunctionDecl to keep track of function parameters in
3043 /// C.
3044 struct GNUCompatibleParamWarning {
3045   ParmVarDecl *OldParm;
3046   ParmVarDecl *NewParm;
3047   QualType PromotedType;
3048 };
3049
3050 } // end anonymous namespace
3051
3052 // Determine whether the previous declaration was a definition, implicit
3053 // declaration, or a declaration.
3054 template <typename T>
3055 static std::pair<diag::kind, SourceLocation>
3056 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
3057   diag::kind PrevDiag;
3058   SourceLocation OldLocation = Old->getLocation();
3059   if (Old->isThisDeclarationADefinition())
3060     PrevDiag = diag::note_previous_definition;
3061   else if (Old->isImplicit()) {
3062     PrevDiag = diag::note_previous_implicit_declaration;
3063     if (OldLocation.isInvalid())
3064       OldLocation = New->getLocation();
3065   } else
3066     PrevDiag = diag::note_previous_declaration;
3067   return std::make_pair(PrevDiag, OldLocation);
3068 }
3069
3070 /// canRedefineFunction - checks if a function can be redefined. Currently,
3071 /// only extern inline functions can be redefined, and even then only in
3072 /// GNU89 mode.
3073 static bool canRedefineFunction(const FunctionDecl *FD,
3074                                 const LangOptions& LangOpts) {
3075   return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
3076           !LangOpts.CPlusPlus && FD->isInlineSpecified() &&
3077           FD->getStorageClass() == StorageClass::Extern);
3078 }
3079
3080 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
3081   const AttributedType *AT = T->getAs<AttributedType>();
3082   while (AT && !AT->isCallingConv())
3083     AT = AT->getModifiedType()->getAs<AttributedType>();
3084   return AT;
3085 }
3086
3087 template <typename T>
3088 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
3089   const DeclContext *DC = Old->getDeclContext();
3090   if (DC->isRecord())
3091     return false;
3092
3093   LanguageLinkage OldLinkage = Old->getLanguageLinkage();
3094   if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
3095     return true;
3096   if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
3097     return true;
3098   return false;
3099 }
3100
3101 template<typename T> static bool isExternC(T *D) { return D->isExternC(); }
3102 static bool isExternC(VarTemplateDecl *) { return false; }
3103
3104 /// Check whether a redeclaration of an entity introduced by a
3105 /// using-declaration is valid, given that we know it's not an overload
3106 /// (nor a hidden tag declaration).
3107 template<typename ExpectedDecl>
3108 static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS,
3109                                    ExpectedDecl *New) {
3110   // C++11 [basic.scope.declarative]p4:
3111   //   Given a set of declarations in a single declarative region, each of
3112   //   which specifies the same unqualified name,
3113   //   -- they shall all refer to the same entity, or all refer to functions
3114   //      and function templates; or
3115   //   -- exactly one declaration shall declare a class name or enumeration
3116   //      name that is not a typedef name and the other declarations shall all
3117   //      refer to the same variable or enumerator, or all refer to functions
3118   //      and function templates; in this case the class name or enumeration
3119   //      name is hidden (3.3.10).
3120
3121   // C++11 [namespace.udecl]p14:
3122   //   If a function declaration in namespace scope or block scope has the
3123   //   same name and the same parameter-type-list as a function introduced
3124   //   by a using-declaration, and the declarations do not declare the same
3125   //   function, the program is ill-formed.
3126
3127   auto *Old = dyn_cast<ExpectedDecl>(OldS->getTargetDecl());
3128   if (Old &&
3129       !Old->getDeclContext()->getRedeclContext()->Equals(
3130           New->getDeclContext()->getRedeclContext()) &&
3131       !(isExternC(Old) && isExternC(New)))
3132     Old = nullptr;
3133
3134   if (!Old) {
3135     S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
3136     S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);
3137     S.Diag(OldS->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
3138     return true;
3139   }
3140   return false;
3141 }
3142
3143 static bool hasIdenticalPassObjectSizeAttrs(const FunctionDecl *A,
3144                                             const FunctionDecl *B) {
3145   assert(A->getNumParams() == B->getNumParams());
3146
3147   auto AttrEq = [](const ParmVarDecl *A, const ParmVarDecl *B) {
3148     const auto *AttrA = A->getAttr<PassObjectSizeAttr>();
3149     const auto *AttrB = B->getAttr<PassObjectSizeAttr>();
3150     if (AttrA == AttrB)
3151       return true;
3152     return AttrA && AttrB && AttrA->getType() == AttrB->getType() &&
3153            AttrA->isDynamic() == AttrB->isDynamic();
3154   };
3155
3156   return std::equal(A->param_begin(), A->param_end(), B->param_begin(), AttrEq);
3157 }
3158
3159 /// If necessary, adjust the semantic declaration context for a qualified
3160 /// declaration to name the correct inline namespace within the qualifier.
3161 static void adjustDeclContextForDeclaratorDecl(DeclaratorDecl *NewD,
3162                                                DeclaratorDecl *OldD) {
3163   // The only case where we need to update the DeclContext is when
3164   // redeclaration lookup for a qualified name finds a declaration
3165   // in an inline namespace within the context named by the qualifier:
3166   //
3167   //   inline namespace N { int f(); }
3168   //   int ::f(); // Sema DC needs adjusting from :: to N::.
3169   //
3170   // For unqualified declarations, the semantic context *can* change
3171   // along the redeclaration chain (for local extern declarations,
3172   // extern "C" declarations, and friend declarations in particular).
3173   if (!NewD->getQualifier())
3174     return;
3175
3176   // NewD is probably already in the right context.
3177   auto *NamedDC = NewD->getDeclContext()->getRedeclContext();
3178   auto *SemaDC = OldD->getDeclContext()->getRedeclContext();
3179   if (NamedDC->Equals(SemaDC))
3180     return;
3181
3182   assert((NamedDC->InEnclosingNamespaceSetOf(SemaDC) ||
3183           NewD->isInvalidDecl() || OldD->isInvalidDecl()) &&
3184          "unexpected context for redeclaration");
3185
3186   auto *LexDC = NewD->getLexicalDeclContext();
3187   auto FixSemaDC = [=](NamedDecl *D) {
3188     if (!D)
3189       return;
3190     D->setDeclContext(SemaDC);
3191     D->setLexicalDeclContext(LexDC);
3192   };
3193
3194   FixSemaDC(NewD);
3195   if (auto *FD = dyn_cast<FunctionDecl>(NewD))
3196     FixSemaDC(FD->getDescribedFunctionTemplate());
3197   else if (auto *VD = dyn_cast<VarDecl>(NewD))
3198     FixSemaDC(VD->getDescribedVarTemplate());
3199 }
3200
3201 /// MergeFunctionDecl - We just parsed a function 'New' from
3202 /// declarator D which has the same name and scope as a previous
3203 /// declaration 'Old'.  Figure out how to resolve this situation,
3204 /// merging decls or emitting diagnostics as appropriate.
3205 ///
3206 /// In C++, New and Old must be declarations that are not
3207 /// overloaded. Use IsOverload to determine whether New and Old are
3208 /// overloaded, and to select the Old declaration that New should be
3209 /// merged with.
3210 ///
3211 /// Returns true if there was an error, false otherwise.
3212 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
3213                              Scope *S, bool MergeTypeWithOld) {
3214   // Verify the old decl was also a function.
3215   FunctionDecl *Old = OldD->getAsFunction();
3216   if (!Old) {
3217     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
3218       if (New->getFriendObjectKind()) {
3219         Diag(New->getLocation(), diag::err_using_decl_friend);
3220         Diag(Shadow->getTargetDecl()->getLocation(),
3221              diag::note_using_decl_target);
3222         Diag(Shadow->getUsingDecl()->getLocation(),
3223              diag::note_using_decl) << 0;
3224         return true;
3225       }
3226
3227       // Check whether the two declarations might declare the same function.
3228       if (checkUsingShadowRedecl<FunctionDecl>(*this, Shadow, New))
3229         return true;
3230       OldD = Old = cast<FunctionDecl>(Shadow->getTargetDecl());
3231     } else {
3232       Diag(New->getLocation(), diag::err_redefinition_different_kind)
3233         << New->getDeclName();
3234       notePreviousDefinition(OldD, New->getLocation());
3235       return true;
3236     }
3237   }
3238
3239   // If the old declaration is invalid, just give up here.
3240   if (Old->isInvalidDecl())
3241     return true;
3242
3243   // Disallow redeclaration of some builtins.
3244   if (!getASTContext().canBuiltinBeRedeclared(Old)) {
3245     Diag(New->getLocation(), diag::err_builtin_redeclare) << Old->getDeclName();
3246     Diag(Old->getLocation(), diag::note_previous_builtin_declaration)
3247         << Old << Old->getType();
3248     return true;
3249   }
3250
3251   diag::kind PrevDiag;
3252   SourceLocation OldLocation;
3253   std::tie(PrevDiag, OldLocation) =
3254       getNoteDiagForInvalidRedeclaration(Old, New);
3255
3256   // Don't complain about this if we're in GNU89 mode and the old function
3257   // is an extern inline function.
3258   // Don't complain about specializations. They are not supposed to have
3259   // storage classes.
3260   if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
3261       New->getStorageClass() == StorageClass::Static &&
3262       Old->hasExternalFormalLinkage() &&
3263       !New->getTemplateSpecializationInfo() &&
3264       !canRedefineFunction(Old, getLangOpts())) {
3265     if (getLangOpts().MicrosoftExt) {
3266       Diag(New->getLocation(), diag::ext_static_non_static) << New;
3267       Diag(OldLocation, PrevDiag);
3268     } else {
3269       Diag(New->getLocation(), diag::err_static_non_static) << New;
3270       Diag(OldLocation, PrevDiag);
3271       return true;
3272     }
3273   }
3274
3275   if (New->hasAttr<InternalLinkageAttr>() &&
3276       !Old->hasAttr<InternalLinkageAttr>()) {
3277     Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
3278         << New->getDeclName();
3279     notePreviousDefinition(Old, New->getLocation());
3280     New->dropAttr<InternalLinkageAttr>();
3281   }
3282
3283   if (CheckRedeclarationModuleOwnership(New, Old))
3284     return true;
3285
3286   if (!getLangOpts().CPlusPlus) {
3287     bool OldOvl = Old->hasAttr<OverloadableAttr>();
3288     if (OldOvl != New->hasAttr<OverloadableAttr>() && !Old->isImplicit()) {
3289       Diag(New->getLocation(), diag::err_attribute_overloadable_mismatch)
3290         << New << OldOvl;
3291
3292       // Try our best to find a decl that actually has the overloadable
3293       // attribute for the note. In most cases (e.g. programs with only one
3294       // broken declaration/definition), this won't matter.
3295       //
3296       // FIXME: We could do this if we juggled some extra state in
3297       // OverloadableAttr, rather than just removing it.
3298       const Decl *DiagOld = Old;
3299       if (OldOvl) {
3300         auto OldIter = llvm::find_if(Old->redecls(), [](const Decl *D) {
3301           const auto *A = D->getAttr<OverloadableAttr>();
3302           return A && !A->isImplicit();
3303         });
3304         // If we've implicitly added *all* of the overloadable attrs to this
3305         // chain, emitting a "previous redecl" note is pointless.
3306         DiagOld = OldIter == Old->redecls_end() ? nullptr : *OldIter;
3307       }
3308
3309       if (DiagOld)
3310         Diag(DiagOld->getLocation(),
3311              diag::note_attribute_overloadable_prev_overload)
3312           << OldOvl;
3313
3314       if (OldOvl)
3315         New->addAttr(OverloadableAttr::CreateImplicit(Context));
3316       else
3317         New->dropAttr<OverloadableAttr>();
3318     }
3319   }
3320
3321   // If a function is first declared with a calling convention, but is later
3322   // declared or defined without one, all following decls assume the calling
3323   // convention of the first.
3324   //
3325   // It's OK if a function is first declared without a calling convention,
3326   // but is later declared or defined with the default calling convention.
3327   //
3328   // To test if either decl has an explicit calling convention, we look for
3329   // AttributedType sugar nodes on the type as written.  If they are missing or
3330   // were canonicalized away, we assume the calling convention was implicit.
3331   //
3332   // Note also that we DO NOT return at this point, because we still have
3333   // other tests to run.
3334   QualType OldQType = Context.getCanonicalType(Old->getType());
3335   QualType NewQType = Context.getCanonicalType(New->getType());
3336   const FunctionType *OldType = cast<FunctionType>(OldQType);
3337   const FunctionType *NewType = cast<FunctionType>(NewQType);
3338   FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
3339   FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
3340   bool RequiresAdjustment = false;
3341
3342   if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
3343     FunctionDecl *First = Old->getFirstDecl();
3344     const FunctionType *FT =
3345         First->getType().getCanonicalType()->castAs<FunctionType>();
3346     FunctionType::ExtInfo FI = FT->getExtInfo();
3347     bool NewCCExplicit = getCallingConvAttributedType(New->getType());
3348     if (!NewCCExplicit) {
3349       // Inherit the CC from the previous declaration if it was specified
3350       // there but not here.
3351       NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
3352       RequiresAdjustment = true;
3353     } else if (Old->getBuiltinID()) {
3354       // Builtin attribute isn't propagated to the new one yet at this point,
3355       // so we check if the old one is a builtin.
3356
3357       // Calling Conventions on a Builtin aren't really useful and setting a
3358       // default calling convention and cdecl'ing some builtin redeclarations is
3359       // common, so warn and ignore the calling convention on the redeclaration.
3360       Diag(New->getLocation(), diag::warn_cconv_unsupported)
3361           << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
3362           << (int)CallingConventionIgnoredReason::BuiltinFunction;
3363       NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
3364       RequiresAdjustment = true;
3365     } else {
3366       // Calling conventions aren't compatible, so complain.
3367       bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
3368       Diag(New->getLocation(), diag::err_cconv_change)
3369         << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
3370         << !FirstCCExplicit
3371         << (!FirstCCExplicit ? "" :
3372             FunctionType::getNameForCallConv(FI.getCC()));
3373
3374       // Put the note on the first decl, since it is the one that matters.
3375       Diag(First->getLocation(), diag::note_previous_declaration);
3376       return true;
3377     }
3378   }
3379
3380   // FIXME: diagnose the other way around?
3381   if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
3382     NewTypeInfo = NewTypeInfo.withNoReturn(true);
3383     RequiresAdjustment = true;
3384   }
3385
3386   // Merge regparm attribute.
3387   if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
3388       OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
3389     if (NewTypeInfo.getHasRegParm()) {
3390       Diag(New->getLocation(), diag::err_regparm_mismatch)
3391         << NewType->getRegParmType()
3392         << OldType->getRegParmType();
3393       Diag(OldLocation, diag::note_previous_declaration);
3394       return true;
3395     }
3396
3397     NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
3398     RequiresAdjustment = true;
3399   }
3400
3401   // Merge ns_returns_retained attribute.
3402   if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
3403     if (NewTypeInfo.getProducesResult()) {
3404       Diag(New->getLocation(), diag::err_function_attribute_mismatch)
3405           << "'ns_returns_retained'";
3406       Diag(OldLocation, diag::note_previous_declaration);
3407       return true;
3408     }
3409
3410     NewTypeInfo = NewTypeInfo.withProducesResult(true);
3411     RequiresAdjustment = true;
3412   }
3413
3414   if (OldTypeInfo.getNoCallerSavedRegs() !=
3415       NewTypeInfo.getNoCallerSavedRegs()) {
3416     if (NewTypeInfo.getNoCallerSavedRegs()) {
3417       AnyX86NoCallerSavedRegistersAttr *Attr =
3418         New->getAttr<AnyX86NoCallerSavedRegistersAttr>();
3419       Diag(New->getLocation(), diag::err_function_attribute_mismatch) << Attr;
3420       Diag(OldLocation, diag::note_previous_declaration);
3421       return true;
3422     }
3423
3424     NewTypeInfo = NewTypeInfo.withNoCallerSavedRegs(true);
3425     RequiresAdjustment = true;
3426   }
3427
3428   if (RequiresAdjustment) {
3429     const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
3430     AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
3431     New->setType(QualType(AdjustedType, 0));
3432     NewQType = Context.getCanonicalType(New->getType());
3433   }
3434
3435   // If this redeclaration makes the function inline, we may need to add it to
3436   // UndefinedButUsed.
3437   if (!Old->isInlined() && New->isInlined() &&
3438       !New->hasAttr<GNUInlineAttr>() &&
3439       !getLangOpts().GNUInline &&
3440       Old->isUsed(false) &&
3441       !Old->isDefined() && !New->isThisDeclarationADefinition())
3442     UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
3443                                            SourceLocation()));
3444
3445   // If this redeclaration makes it newly gnu_inline, we don't want to warn
3446   // about it.
3447   if (New->hasAttr<GNUInlineAttr>() &&
3448       Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
3449     UndefinedButUsed.erase(Old->getCanonicalDecl());
3450   }
3451
3452   // If pass_object_size params don't match up perfectly, this isn't a valid
3453   // redeclaration.
3454   if (Old->getNumParams() > 0 && Old->getNumParams() == New->getNumParams() &&
3455       !hasIdenticalPassObjectSizeAttrs(Old, New)) {
3456     Diag(New->getLocation(), diag::err_different_pass_object_size_params)
3457         << New->getDeclName();
3458     Diag(OldLocation, PrevDiag) << Old << Old->getType();
3459     return true;
3460   }
3461
3462   if (getLangOpts().CPlusPlus) {
3463     // C++1z [over.load]p2
3464     //   Certain function declarations cannot be overloaded:
3465     //     -- Function declarations that differ only in the return type,
3466     //        the exception specification, or both cannot be overloaded.
3467
3468     // Check the exception specifications match. This may recompute the type of
3469     // both Old and New if it resolved exception specifications, so grab the
3470     // types again after this. Because this updates the type, we do this before
3471     // any of the other checks below, which may update the "de facto" NewQType
3472     // but do not necessarily update the type of New.
3473     if (CheckEquivalentExceptionSpec(Old, New))
3474       return true;
3475     OldQType = Context.getCanonicalType(Old->getType());
3476     NewQType = Context.getCanonicalType(New->getType());
3477
3478     // Go back to the type source info to compare the declared return types,
3479     // per C++1y [dcl.type.auto]p13:
3480     //   Redeclarations or specializations of a function or function template
3481     //   with a declared return type that uses a placeholder type shall also
3482     //   use that placeholder, not a deduced type.
3483     QualType OldDeclaredReturnType = Old->getDeclaredReturnType();
3484     QualType NewDeclaredReturnType = New->getDeclaredReturnType();
3485     if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
3486         canFullyTypeCheckRedeclaration(New, Old, NewDeclaredReturnType,
3487                                        OldDeclaredReturnType)) {
3488       QualType ResQT;
3489       if (NewDeclaredReturnType->isObjCObjectPointerType() &&
3490           OldDeclaredReturnType->isObjCObjectPointerType())
3491         // FIXME: This does the wrong thing for a deduced return type.
3492         ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
3493       if (ResQT.isNull()) {
3494         if (New->isCXXClassMember() && New->isOutOfLine())
3495           Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
3496               << New << New->getReturnTypeSourceRange();
3497         else
3498           Diag(New->getLocation(), diag::err_ovl_diff_return_type)
3499               << New->getReturnTypeSourceRange();
3500         Diag(OldLocation, PrevDiag) << Old << Old->getType()
3501                                     << Old->getReturnTypeSourceRange();
3502         return true;
3503       }
3504       else
3505         NewQType = ResQT;
3506     }
3507
3508     QualType OldReturnType = OldType->getReturnType();
3509     QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
3510     if (OldReturnType != NewReturnType) {
3511       // If this function has a deduced return type and has already been
3512       // defined, copy the deduced value from the old declaration.
3513       AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
3514       if (OldAT && OldAT->isDeduced()) {
3515         New->setType(
3516             SubstAutoType(New->getType(),
3517                           OldAT->isDependentType() ? Context.DependentTy
3518                                                    : OldAT->getDeducedType()));
3519         NewQType = Context.getCanonicalType(
3520             SubstAutoType(NewQType,
3521                           OldAT->isDependentType() ? Context.DependentTy
3522                                                    : OldAT->getDeducedType()));
3523       }
3524     }
3525
3526     const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
3527     CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
3528     if (OldMethod && NewMethod) {
3529       // Preserve triviality.
3530       NewMethod->setTrivial(OldMethod->isTrivial());
3531
3532       // MSVC allows explicit template specialization at class scope:
3533       // 2 CXXMethodDecls referring to the same function will be injected.
3534       // We don't want a redeclaration error.
3535       bool IsClassScopeExplicitSpecialization =
3536                               OldMethod->isFunctionTemplateSpecialization() &&
3537                               NewMethod->isFunctionTemplateSpecialization();
3538       bool isFriend = NewMethod->getFriendObjectKind();
3539
3540       if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
3541           !IsClassScopeExplicitSpecialization) {
3542         //    -- Member function declarations with the same name and the
3543         //       same parameter types cannot be overloaded if any of them
3544         //       is a static member function declaration.
3545         if (OldMethod->isStatic() != NewMethod->isStatic()) {
3546           Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
3547           Diag(OldLocation, PrevDiag) << Old << Old->getType();
3548           return true;
3549         }
3550
3551         // C++ [class.mem]p1:
3552         //   [...] A member shall not be declared twice in the
3553         //   member-specification, except that a nested class or member
3554         //   class template can be declared and then later defined.
3555         if (!inTemplateInstantiation()) {
3556           unsigned NewDiag;
3557           if (isa<CXXConstructorDecl>(OldMethod))
3558             NewDiag = diag::err_constructor_redeclared;
3559           else if (isa<CXXDestructorDecl>(NewMethod))
3560             NewDiag = diag::err_destructor_redeclared;
3561           else if (isa<CXXConversionDecl>(NewMethod))
3562             NewDiag = diag::err_conv_function_redeclared;
3563           else
3564             NewDiag = diag::err_member_redeclared;
3565
3566           Diag(New->getLocation(), NewDiag);
3567         } else {
3568           Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
3569             << New << New->getType();
3570         }
3571         Diag(OldLocation, PrevDiag) << Old << Old->getType();
3572         return true;
3573
3574       // Complain if this is an explicit declaration of a special
3575       // member that was initially declared implicitly.
3576       //
3577       // As an exception, it's okay to befriend such methods in order
3578       // to permit the implicit constructor/destructor/operator calls.
3579       } else if (OldMethod->isImplicit()) {
3580         if (isFriend) {
3581           NewMethod->setImplicit();
3582         } else {
3583           Diag(NewMethod->getLocation(),
3584                diag::err_definition_of_implicitly_declared_member)
3585             << New << getSpecialMember(OldMethod);
3586           return true;
3587         }
3588       } else if (OldMethod->getFirstDecl()->isExplicitlyDefaulted() && !isFriend) {
3589         Diag(NewMethod->getLocation(),
3590              diag::err_definition_of_explicitly_defaulted_member)
3591           << getSpecialMember(OldMethod);
3592         return true;
3593       }
3594     }
3595
3596     // C++11 [dcl.attr.noreturn]p1:
3597     //   The first declaration of a function shall specify the noreturn
3598     //   attribute if any declaration of that function specifies the noreturn
3599     //   attribute.
3600     const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
3601     if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
3602       Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
3603       Diag(Old->getFirstDecl()->getLocation(),
3604            diag::note_noreturn_missing_first_decl);
3605     }
3606
3607     // C++11 [dcl.attr.depend]p2:
3608     //   The first declaration of a function shall specify the
3609     //   carries_dependency attribute for its declarator-id if any declaration
3610     //   of the function specifies the carries_dependency attribute.
3611     const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
3612     if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
3613       Diag(CDA->getLocation(),
3614            diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
3615       Diag(Old->getFirstDecl()->getLocation(),
3616            diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
3617     }
3618
3619     // (C++98 8.3.5p3):
3620     //   All declarations for a function shall agree exactly in both the
3621     //   return type and the parameter-type-list.
3622     // We also want to respect all the extended bits except noreturn.
3623
3624     // noreturn should now match unless the old type info didn't have it.
3625     QualType OldQTypeForComparison = OldQType;
3626     if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
3627       auto *OldType = OldQType->castAs<FunctionProtoType>();
3628       const FunctionType *OldTypeForComparison
3629         = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
3630       OldQTypeForComparison = QualType(OldTypeForComparison, 0);
3631       assert(OldQTypeForComparison.isCanonical());
3632     }
3633
3634     if (haveIncompatibleLanguageLinkages(Old, New)) {
3635       // As a special case, retain the language linkage from previous
3636       // declarations of a friend function as an extension.
3637       //
3638       // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
3639       // and is useful because there's otherwise no way to specify language
3640       // linkage within class scope.
3641       //
3642       // Check cautiously as the friend object kind isn't yet complete.
3643       if (New->getFriendObjectKind() != Decl::FOK_None) {
3644         Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
3645         Diag(OldLocation, PrevDiag);
3646       } else {
3647         Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3648         Diag(OldLocation, PrevDiag);
3649         return true;
3650       }
3651     }
3652
3653     // If the function types are compatible, merge the declarations. Ignore the
3654     // exception specifier because it was already checked above in
3655     // CheckEquivalentExceptionSpec, and we don't want follow-on diagnostics
3656     // about incompatible types under -fms-compatibility.
3657     if (Context.hasSameFunctionTypeIgnoringExceptionSpec(OldQTypeForComparison,
3658                                                          NewQType))
3659       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3660
3661     // If the types are imprecise (due to dependent constructs in friends or
3662     // local extern declarations), it's OK if they differ. We'll check again
3663     // during instantiation.
3664     if (!canFullyTypeCheckRedeclaration(New, Old, NewQType, OldQType))
3665       return false;
3666
3667     // Fall through for conflicting redeclarations and redefinitions.
3668   }
3669
3670   // C: Function types need to be compatible, not identical. This handles
3671   // duplicate function decls like "void f(int); void f(enum X);" properly.
3672   if (!getLangOpts().CPlusPlus &&
3673       Context.typesAreCompatible(OldQType, NewQType)) {
3674     const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
3675     const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
3676     const FunctionProtoType *OldProto = nullptr;
3677     if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
3678         (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
3679       // The old declaration provided a function prototype, but the
3680       // new declaration does not. Merge in the prototype.
3681       assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
3682       SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
3683       NewQType =
3684           Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
3685                                   OldProto->getExtProtoInfo());
3686       New->setType(NewQType);
3687       New->setHasInheritedPrototype();
3688
3689       // Synthesize parameters with the same types.
3690       SmallVector<ParmVarDecl*, 16> Params;
3691       for (const auto &ParamType : OldProto->param_types()) {
3692         ParmVarDecl *Param = ParmVarDecl::Create(
3693             Context, New, SourceLocation(), SourceLocation(), nullptr,
3694             ParamType, /*TInfo=*/nullptr, StorageClass::None, nullptr);
3695         Param->setScopeInfo(0, Params.size());
3696         Param->setImplicit();
3697         Params.push_back(Param);
3698       }
3699
3700       New->setParams(Params);
3701     }
3702
3703     return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3704   }
3705
3706   // Check if the function types are compatible when pointer size address
3707   // spaces are ignored.
3708   if (Context.hasSameFunctionTypeIgnoringPtrSizes(OldQType, NewQType))
3709     return false;
3710
3711   // GNU C permits a K&R definition to follow a prototype declaration
3712   // if the declared types of the parameters in the K&R definition
3713   // match the types in the prototype declaration, even when the
3714   // promoted types of the parameters from the K&R definition differ
3715   // from the types in the prototype. GCC then keeps the types from
3716   // the prototype.
3717   //
3718   // If a variadic prototype is followed by a non-variadic K&R definition,
3719   // the K&R definition becomes variadic.  This is sort of an edge case, but
3720   // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
3721   // C99 6.9.1p8.
3722   if (!getLangOpts().CPlusPlus &&
3723       Old->hasPrototype() && !New->hasPrototype() &&
3724       New->getType()->getAs<FunctionProtoType>() &&
3725       Old->getNumParams() == New->getNumParams()) {
3726     SmallVector<QualType, 16> ArgTypes;
3727     SmallVector<GNUCompatibleParamWarning, 16> Warnings;
3728     const FunctionProtoType *OldProto
3729       = Old->getType()->getAs<FunctionProtoType>();
3730     const FunctionProtoType *NewProto
3731       = New->getType()->getAs<FunctionProtoType>();
3732
3733     // Determine whether this is the GNU C extension.
3734     QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
3735                                                NewProto->getReturnType());
3736     bool LooseCompatible = !MergedReturn.isNull();
3737     for (unsigned Idx = 0, End = Old->getNumParams();
3738          LooseCompatible && Idx != End; ++Idx) {
3739       ParmVarDecl *OldParm = Old->getParamDecl(Idx);
3740       ParmVarDecl *NewParm = New->getParamDecl(Idx);
3741       if (Context.typesAreCompatible(OldParm->getType(),
3742                                      NewProto->getParamType(Idx))) {
3743         ArgTypes.push_back(NewParm->getType());
3744       } else if (Context.typesAreCompatible(OldParm->getType(),
3745                                             NewParm->getType(),
3746                                             /*CompareUnqualified=*/true)) {
3747         GNUCompatibleParamWarning Warn = { OldParm, NewParm,
3748                                            NewProto->getParamType(Idx) };
3749         Warnings.push_back(Warn);
3750         ArgTypes.push_back(NewParm->getType());
3751       } else
3752         LooseCompatible = false;
3753     }
3754
3755     if (LooseCompatible) {
3756       for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
3757         Diag(Warnings[Warn].NewParm->getLocation(),
3758              diag::ext_param_promoted_not_compatible_with_prototype)
3759           << Warnings[Warn].PromotedType
3760           << Warnings[Warn].OldParm->getType();
3761         if (Warnings[Warn].OldParm->getLocation().isValid())
3762           Diag(Warnings[Warn].OldParm->getLocation(),
3763                diag::note_previous_declaration);
3764       }
3765
3766       if (MergeTypeWithOld)
3767         New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
3768                                              OldProto->getExtProtoInfo()));
3769       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
3770     }
3771
3772     // Fall through to diagnose conflicting types.
3773   }
3774
3775   // A function that has already been declared has been redeclared or
3776   // defined with a different type; show an appropriate diagnostic.
3777
3778   // If the previous declaration was an implicitly-generated builtin
3779   // declaration, then at the very least we should use a specialized note.
3780   unsigned BuiltinID;
3781   if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
3782     // If it's actually a library-defined builtin function like 'malloc'
3783     // or 'printf', just warn about the incompatible redeclaration.
3784     if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
3785       Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
3786       Diag(OldLocation, diag::note_previous_builtin_declaration)
3787         << Old << Old->getType();
3788       return false;
3789     }
3790
3791     PrevDiag = diag::note_previous_builtin_declaration;
3792   }
3793
3794   Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
3795   Diag(OldLocation, PrevDiag) << Old << Old->getType();
3796   return true;
3797 }
3798
3799 /// Completes the merge of two function declarations that are
3800 /// known to be compatible.
3801 ///
3802 /// This routine handles the merging of attributes and other
3803 /// properties of function declarations from the old declaration to
3804 /// the new declaration, once we know that New is in fact a
3805 /// redeclaration of Old.
3806 ///
3807 /// \returns false
3808 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
3809                                         Scope *S, bool MergeTypeWithOld) {
3810   // Merge the attributes
3811   mergeDeclAttributes(New, Old);
3812
3813   // Merge "pure" flag.
3814   if (Old->isPure())
3815     New->setPure();
3816
3817   // Merge "used" flag.
3818   if (Old->getMostRecentDecl()->isUsed(false))
3819     New->setIsUsed();
3820
3821   // Merge attributes from the parameters.  These can mismatch with K&R
3822   // declarations.
3823   if (New->getNumParams() == Old->getNumParams())
3824       for (unsigned i = 0, e = New->getNumParams(); i != e; ++i) {
3825         ParmVarDecl *NewParam = New->getParamDecl(i);
3826         ParmVarDecl *OldParam = Old->getParamDecl(i);
3827         mergeParamDeclAttributes(NewParam, OldParam, *this);
3828         mergeParamDeclTypes(NewParam, OldParam, *this);
3829       }
3830
3831   if (getLangOpts().CPlusPlus)
3832     return MergeCXXFunctionDecl(New, Old, S);
3833
3834   // Merge the function types so the we get the composite types for the return
3835   // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3836   // was visible.
3837   QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3838   if (!Merged.isNull() && MergeTypeWithOld)
3839     New->setType(Merged);
3840
3841   return false;
3842 }
3843
3844 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
3845                                 ObjCMethodDecl *oldMethod) {
3846   // Merge the attributes, including deprecated/unavailable
3847   AvailabilityMergeKind MergeKind =
3848     isa<ObjCProtocolDecl>(oldMethod->getDeclContext())
3849       ? AMK_ProtocolImplementation
3850       : isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3851                                                        : AMK_Override;
3852
3853   mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3854
3855   // Merge attributes from the parameters.
3856   ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
3857                                        oe = oldMethod->param_end();
3858   for (ObjCMethodDecl::param_iterator
3859          ni = newMethod->param_begin(), ne = newMethod->param_end();
3860        ni != ne && oi != oe; ++ni, ++oi)
3861     mergeParamDeclAttributes(*ni, *oi, *this);
3862
3863   CheckObjCMethodOverride(newMethod, oldMethod);
3864 }
3865
3866 static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl* Old) {
3867   assert(!S.Context.hasSameType(New->getType(), Old->getType()));
3868
3869   S.Diag(New->getLocation(), New->isThisDeclarationADefinition()
3870          ? diag::err_redefinition_different_type
3871          : diag::err_redeclaration_different_type)
3872     << New->getDeclName() << New->getType() << Old->getType();
3873
3874   diag::kind PrevDiag;
3875   SourceLocation OldLocation;
3876   std::tie(PrevDiag, OldLocation)
3877     = getNoteDiagForInvalidRedeclaration(Old, New);
3878   S.Diag(OldLocation, PrevDiag);
3879   New->setInvalidDecl();
3880 }
3881
3882 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3883 /// scope as a previous declaration 'Old'.  Figure out how to merge their types,
3884 /// emitting diagnostics as appropriate.
3885 ///
3886 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3887 /// to here in AddInitializerToDecl. We can't check them before the initializer
3888 /// is attached.
3889 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old,
3890                              bool MergeTypeWithOld) {
3891   if (New->isInvalidDecl() || Old->isInvalidDecl())
3892     return;
3893
3894   QualType MergedT;
3895   if (getLangOpts().CPlusPlus) {
3896     if (New->getType()->isUndeducedType()) {
3897       // We don't know what the new type is until the initializer is attached.
3898       return;
3899     } else if (Context.hasSameType(New->getType(), Old->getType())) {
3900       // These could still be something that needs exception specs checked.
3901       return MergeVarDeclExceptionSpecs(New, Old);
3902     }
3903     // C++ [basic.link]p10:
3904     //   [...] the types specified by all declarations referring to a given
3905     //   object or function shall be identical, except that declarations for an
3906     //   array object can specify array types that differ by the presence or
3907     //   absence of a major array bound (8.3.4).
3908     else if (Old->getType()->isArrayType() && New->getType()->isArrayType()) {
3909       const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3910       const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3911
3912       // We are merging a variable declaration New into Old. If it has an array
3913       // bound, and that bound differs from Old's bound, we should diagnose the
3914       // mismatch.
3915       if (!NewArray->isIncompleteArrayType() && !NewArray->isDependentType()) {
3916         for (VarDecl *PrevVD = Old->getMostRecentDecl(); PrevVD;
3917              PrevVD = PrevVD->getPreviousDecl()) {
3918           QualType PrevVDTy = PrevVD->getType();
3919           if (PrevVDTy->isIncompleteArrayType() || PrevVDTy->isDependentType())
3920             continue;
3921
3922           if (!Context.hasSameType(New->getType(), PrevVDTy))
3923             return diagnoseVarDeclTypeMismatch(*this, New, PrevVD);
3924         }
3925       }
3926
3927       if (OldArray->isIncompleteArrayType() && NewArray->isArrayType()) {
3928         if (Context.hasSameType(OldArray->getElementType(),
3929                                 NewArray->getElementType()))
3930           MergedT = New->getType();
3931       }
3932       // FIXME: Check visibility. New is hidden but has a complete type. If New
3933       // has no array bound, it should not inherit one from Old, if Old is not
3934       // visible.
3935       else if (OldArray->isArrayType() && NewArray->isIncompleteArrayType()) {
3936         if (Context.hasSameType(OldArray->getElementType(),
3937                                 NewArray->getElementType()))
3938           MergedT = Old->getType();
3939       }
3940     }
3941     else if (New->getType()->isObjCObjectPointerType() &&
3942                Old->getType()->isObjCObjectPointerType()) {
3943       MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3944                                               Old->getType());
3945     }
3946   } else {
3947     // C 6.2.7p2:
3948     //   All declarations that refer to the same object or function shall have
3949     //   compatible type.
3950     MergedT = Context.mergeTypes(New->getType(), Old->getType());
3951   }
3952   if (MergedT.isNull()) {
3953     // It's OK if we couldn't merge types if either type is dependent, for a
3954     // block-scope variable. In other cases (static data members of class
3955     // templates, variable templates, ...), we require the types to be
3956     // equivalent.
3957     // FIXME: The C++ standard doesn't say anything about this.
3958     if ((New->getType()->isDependentType() ||
3959          Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3960       // If the old type was dependent, we can't merge with it, so the new type
3961       // becomes dependent for now. We'll reproduce the original type when we
3962       // instantiate the TypeSourceInfo for the variable.
3963       if (!New->getType()->isDependentType() && MergeTypeWithOld)
3964         New->setType(Context.DependentTy);
3965       return;
3966     }
3967     return diagnoseVarDeclTypeMismatch(*this, New, Old);
3968   }
3969
3970   // Don't actually update the type on the new declaration if the old
3971   // declaration was an extern declaration in a different scope.
3972   if (MergeTypeWithOld)
3973     New->setType(MergedT);
3974 }
3975
3976 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3977                                   LookupResult &Previous) {
3978   // C11 6.2.7p4:
3979   //   For an identifier with internal or external linkage declared
3980   //   in a scope in which a prior declaration of that identifier is
3981   //   visible, if the prior declaration specifies internal or
3982   //   external linkage, the type of the identifier at the later
3983   //   declaration becomes the composite type.
3984   //
3985   // If the variable isn't visible, we do not merge with its type.
3986   if (Previous.isShadowed())
3987     return false;
3988
3989   if (S.getLangOpts().CPlusPlus) {
3990     // C++11 [dcl.array]p3:
3991     //   If there is a preceding declaration of the entity in the same
3992     //   scope in which the bound was specified, an omitted array bound
3993     //   is taken to be the same as in that earlier declaration.
3994     return NewVD->isPreviousDeclInSameBlockScope() ||
3995            (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3996             !NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3997   } else {
3998     // If the old declaration was function-local, don't merge with its
3999     // type unless we're in the same function.
4000     return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
4001            OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
4002   }
4003 }
4004
4005 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
4006 /// and scope as a previous declaration 'Old'.  Figure out how to resolve this
4007 /// situation, merging decls or emitting diagnostics as appropriate.
4008 ///
4009 /// Tentative definition rules (C99 6.9.2p2) are checked by
4010 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
4011 /// definitions here, since the initializer hasn't been attached.
4012 ///
4013 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
4014   // If the new decl is already invalid, don't do any other checking.
4015   if (New->isInvalidDecl())
4016     return;
4017
4018   if (!shouldLinkPossiblyHiddenDecl(Previous, New))
4019     return;
4020
4021   VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
4022
4023   // Verify the old decl was also a variable or variable template.
4024   VarDecl *Old = nullptr;
4025   VarTemplateDecl *OldTemplate = nullptr;
4026   if (Previous.isSingleResult()) {
4027     if (NewTemplate) {
4028       OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
4029       Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
4030
4031       if (auto *Shadow =
4032               dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
4033         if (checkUsingShadowRedecl<VarTemplateDecl>(*this, Shadow, NewTemplate))
4034           return New->setInvalidDecl();
4035     } else {
4036       Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
4037
4038       if (auto *Shadow =
4039               dyn_cast<UsingShadowDecl>(Previous.getRepresentativeDecl()))
4040         if (checkUsingShadowRedecl<VarDecl>(*this, Shadow, New))
4041           return New->setInvalidDecl();
4042     }
4043   }
4044   if (!Old) {
4045     Diag(New->getLocation(), diag::err_redefinition_different_kind)
4046         << New->getDeclName();
4047     notePreviousDefinition(Previous.getRepresentativeDecl(),
4048                            New->getLocation());
4049     return New->setInvalidDecl();
4050   }
4051
4052   // Ensure the template parameters are compatible.
4053   if (NewTemplate &&
4054       !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
4055                                       OldTemplate->getTemplateParameters(),
4056                                       /*Complain=*/true, TPL_TemplateMatch))
4057     return New->setInvalidDecl();
4058
4059   // C++ [class.mem]p1:
4060   //   A member shall not be declared twice in the member-specification [...]
4061   //
4062   // Here, we need only consider static data members.
4063   if (Old->isStaticDataMember() && !New->isOutOfLine()) {
4064     Diag(New->getLocation(), diag::err_duplicate_member)
4065       << New->getIdentifier();
4066     Diag(Old->getLocation(), diag::note_previous_declaration);
4067     New->setInvalidDecl();
4068   }
4069
4070   mergeDeclAttributes(New, Old);
4071   // Warn if an already-declared variable is made a weak_import in a subsequent
4072   // declaration
4073   if (New->hasAttr<WeakImportAttr>() &&
4074       Old->getStorageClass() == StorageClass::None &&
4075       !Old->hasAttr<WeakImportAttr>()) {
4076     Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
4077     notePreviousDefinition(Old, New->getLocation());
4078     // Remove weak_import attribute on new declaration.
4079     New->dropAttr<WeakImportAttr>();
4080   }
4081
4082   if (New->hasAttr<InternalLinkageAttr>() &&
4083       !Old->hasAttr<InternalLinkageAttr>()) {
4084     Diag(New->getLocation(), diag::err_internal_linkage_redeclaration)
4085         << New->getDeclName();
4086     notePreviousDefinition(Old, New->getLocation());
4087     New->dropAttr<InternalLinkageAttr>();
4088   }
4089
4090   // Merge the types.
4091   VarDecl *MostRecent = Old->getMostRecentDecl();
4092   if (MostRecent != Old) {
4093     MergeVarDeclTypes(New, MostRecent,
4094                       mergeTypeWithPrevious(*this, New, MostRecent, Previous));
4095     if (New->isInvalidDecl())
4096       return;
4097   }
4098
4099   MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
4100   if (New->isInvalidDecl())
4101     return;
4102
4103   diag::kind PrevDiag;
4104   SourceLocation OldLocation;
4105   std::tie(PrevDiag, OldLocation) =
4106       getNoteDiagForInvalidRedeclaration(Old, New);
4107
4108   // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
4109   if (New->getStorageClass() == StorageClass::Static &&
4110       !New->isStaticDataMember() && Old->hasExternalFormalLinkage()) {
4111     if (getLangOpts().MicrosoftExt) {
4112       Diag(New->getLocation(), diag::ext_static_non_static)
4113           << New->getDeclName();
4114       Diag(OldLocation, PrevDiag);
4115     } else {
4116       Diag(New->getLocation(), diag::err_static_non_static)
4117           << New->getDeclName();
4118       Diag(OldLocation, PrevDiag);
4119       return New->setInvalidDecl();
4120     }
4121   }
4122   // C99 6.2.2p4:
4123   //   For an identifier declared with the storage-class specifier
4124   //   extern in a scope in which a prior declaration of that
4125   //   identifier is visible,23) if the prior declaration specifies
4126   //   internal or external linkage, the linkage of the identifier at
4127   //   the later declaration is the same as the linkage specified at
4128   //   the prior declaration. If no prior declaration is visible, or
4129   //   if the prior declaration specifies no linkage, then the
4130   //   identifier has external linkage.
4131   if (New->hasExternalStorage() && Old->hasLinkage())
4132     /* Okay */;
4133   else if (New->getCanonicalDecl()->getStorageClass() != StorageClass::Static &&
4134            !New->isStaticDataMember() &&
4135            Old->getCanonicalDecl()->getStorageClass() == StorageClass::Static) {
4136     Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
4137     Diag(OldLocation, PrevDiag);
4138     return New->setInvalidDecl();
4139   }
4140
4141   // Check if extern is followed by non-extern and vice-versa.
4142   if (New->hasExternalStorage() &&
4143       !Old->hasLinkage() && Old->isLocalVarDeclOrParm()) {
4144     Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
4145     Diag(OldLocation, PrevDiag);
4146     return New->setInvalidDecl();
4147   }
4148   if (Old->hasLinkage() && New->isLocalVarDeclOrParm() &&
4149       !New->hasExternalStorage()) {
4150     Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
4151     Diag(OldLocation, PrevDiag);
4152     return New->setInvalidDecl();
4153   }
4154
4155   if (CheckRedeclarationModuleOwnership(New, Old))
4156     return;
4157
4158   // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
4159
4160   // FIXME: The test for external storage here seems wrong? We still
4161   // need to check for mismatches.
4162   if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
4163       // Don't complain about out-of-line definitions of static members.
4164       !(Old->getLexicalDeclContext()->isRecord() &&
4165         !New->getLexicalDeclContext()->isRecord())) {
4166     Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
4167     Diag(OldLocation, PrevDiag);
4168     return New->setInvalidDecl();
4169   }
4170
4171   if (New->isInline() && !Old->getMostRecentDecl()->isInline()) {
4172     if (VarDecl *Def = Old->getDefinition()) {
4173       // C++1z [dcl.fcn.spec]p4:
4174       //   If the definition of a variable appears in a translation unit before
4175       //   its first declaration as inline, the program is ill-formed.
4176       Diag(New->getLocation(), diag::err_inline_decl_follows_def) << New;
4177       Diag(Def->getLocation(), diag::note_previous_definition);
4178     }
4179   }
4180
4181   // If this redeclaration makes the variable inline, we may need to add it to
4182   // UndefinedButUsed.
4183   if (!Old->isInline() && New->isInline() && Old->isUsed(false) &&
4184       !Old->getDefinition() && !New->isThisDeclarationADefinition())
4185     UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
4186                                            SourceLocation()));
4187
4188   if (New->getTLSKind() != Old->getTLSKind()) {
4189     if (!Old->getTLSKind()) {
4190       Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
4191       Diag(OldLocation, PrevDiag);
4192     } else if (!New->getTLSKind()) {
4193       Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
4194       Diag(OldLocation, PrevDiag);
4195     } else {
4196       // Do not allow redeclaration to change the variable between requiring
4197       // static and dynamic initialization.
4198       // FIXME: GCC allows this, but uses the TLS keyword on the first
4199       // declaration to determine the kind. Do we need to be compatible here?
4200       Diag(New->getLocation(), diag::err_thread_thread_different_kind)
4201         << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
4202