1 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 //  This file implements semantic analysis for declarations.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/Sema/SemaInternal.h"
15 #include "TypeLocBuilder.h"
16 #include "clang/AST/ASTConsumer.h"
17 #include "clang/AST/ASTContext.h"
18 #include "clang/AST/ASTLambda.h"
19 #include "clang/AST/CXXInheritance.h"
20 #include "clang/AST/CharUnits.h"
21 #include "clang/AST/CommentDiagnostic.h"
22 #include "clang/AST/DeclCXX.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/AST/DeclTemplate.h"
25 #include "clang/AST/EvaluatedExprVisitor.h"
26 #include "clang/AST/ExprCXX.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/Parse/ParseDiagnostic.h"
37 #include "clang/Sema/CXXFieldCollector.h"
38 #include "clang/Sema/DeclSpec.h"
39 #include "clang/Sema/DelayedDiagnostic.h"
40 #include "clang/Sema/Initialization.h"
41 #include "clang/Sema/Lookup.h"
42 #include "clang/Sema/ParsedTemplate.h"
43 #include "clang/Sema/Scope.h"
44 #include "clang/Sema/ScopeInfo.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 using namespace clang;
52 using namespace sema;
53 
54 Sema::DeclGroupPtrTy Sema::ConvertDeclToDeclGroup(Decl *Ptr, Decl *OwnedType) {
55   if (OwnedType) {
56     Decl *Group[2] = { OwnedType, Ptr };
57     return DeclGroupPtrTy::make(DeclGroupRef::Create(Context, Group, 2));
58   }
59 
60   return DeclGroupPtrTy::make(DeclGroupRef(Ptr));
61 }
62 
63 namespace {
64 
65 class TypeNameValidatorCCC : public CorrectionCandidateCallback {
66  public:
67   TypeNameValidatorCCC(bool AllowInvalid, bool WantClass=false,
68                        bool AllowTemplates=false)
69       : AllowInvalidDecl(AllowInvalid), WantClassName(WantClass),
70         AllowClassTemplates(AllowTemplates) {
71     WantExpressionKeywords = false;
72     WantCXXNamedCasts = false;
73     WantRemainingKeywords = false;
74   }
75 
76   bool ValidateCandidate(const TypoCorrection &candidate) override {
77     if (NamedDecl *ND = candidate.getCorrectionDecl()) {
78       bool IsType = isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND);
79       bool AllowedTemplate = AllowClassTemplates && isa<ClassTemplateDecl>(ND);
80       return (IsType || AllowedTemplate) &&
81              (AllowInvalidDecl || !ND->isInvalidDecl());
82     }
83     return !WantClassName && candidate.isKeyword();
84   }
85 
86  private:
87   bool AllowInvalidDecl;
88   bool WantClassName;
89   bool AllowClassTemplates;
90 };
91 
92 }
93 
94 /// \brief Determine whether the token kind starts a simple-type-specifier.
95 bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
96   switch (Kind) {
97   // FIXME: Take into account the current language when deciding whether a
98   // token kind is a valid type specifier
99   case tok::kw_short:
100   case tok::kw_long:
101   case tok::kw___int64:
102   case tok::kw___int128:
103   case tok::kw_signed:
104   case tok::kw_unsigned:
105   case tok::kw_void:
106   case tok::kw_char:
107   case tok::kw_int:
108   case tok::kw_half:
109   case tok::kw_float:
110   case tok::kw_double:
111   case tok::kw_wchar_t:
112   case tok::kw_bool:
113   case tok::kw___underlying_type:
114     return true;
115 
116   case tok::annot_typename:
117   case tok::kw_char16_t:
118   case tok::kw_char32_t:
119   case tok::kw_typeof:
120   case tok::annot_decltype:
121   case tok::kw_decltype:
122     return getLangOpts().CPlusPlus;
123 
124   default:
125     break;
126   }
127 
128   return false;
129 }
130 
131 static ParsedType recoverFromTypeInKnownDependentBase(Sema &S,
132                                                       const IdentifierInfo &II,
133                                                       SourceLocation NameLoc) {
134   // Find the first parent class template context, if any.
135   // FIXME: Perform the lookup in all enclosing class templates.
136   const CXXRecordDecl *RD = nullptr;
137   for (DeclContext *DC = S.CurContext; DC; DC = DC->getParent()) {
138     RD = dyn_cast<CXXRecordDecl>(DC);
139     if (RD && RD->getDescribedClassTemplate())
140       break;
141   }
142   if (!RD)
143     return ParsedType();
144 
145   // Look for type decls in dependent base classes that have known primary
146   // templates.
147   bool FoundTypeDecl = false;
148   for (const auto &Base : RD->bases()) {
149     auto *TST = Base.getType()->getAs<TemplateSpecializationType>();
150     if (!TST || !TST->isDependentType())
151       continue;
152     auto *TD = TST->getTemplateName().getAsTemplateDecl();
153     if (!TD)
154       continue;
155     auto *BasePrimaryTemplate =
156         dyn_cast_or_null<CXXRecordDecl>(TD->getTemplatedDecl());
157     if (!BasePrimaryTemplate)
158       continue;
159     // FIXME: Allow lookup into non-dependent bases of dependent bases, possibly
160     // by calling or integrating with the main LookupQualifiedName mechanism.
161     for (NamedDecl *ND : BasePrimaryTemplate->lookup(&II)) {
162       if (FoundTypeDecl)
163         return ParsedType();
164       FoundTypeDecl = isa<TypeDecl>(ND);
165       if (!FoundTypeDecl)
166         return ParsedType();
167     }
168   }
169   if (!FoundTypeDecl)
170     return ParsedType();
171 
172   // We found some types in dependent base classes.  Recover as if the user
173   // wrote 'typename MyClass::II' instead of 'II'.  We'll fully resolve the
174   // lookup during template instantiation.
175   S.Diag(NameLoc, diag::ext_found_via_dependent_bases_lookup) << &II;
176 
177   ASTContext &Context = S.Context;
178   auto *NNS = NestedNameSpecifier::Create(Context, nullptr, false,
179                                           cast<Type>(Context.getRecordType(RD)));
180   QualType T = Context.getDependentNameType(ETK_Typename, NNS, &II);
181 
182   CXXScopeSpec SS;
183   SS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
184 
185   TypeLocBuilder Builder;
186   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
187   DepTL.setNameLoc(NameLoc);
188   DepTL.setElaboratedKeywordLoc(SourceLocation());
189   DepTL.setQualifierLoc(SS.getWithLocInContext(Context));
190   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
191 }
192 
193 /// \brief If the identifier refers to a type name within this scope,
194 /// return the declaration of that type.
195 ///
196 /// This routine performs ordinary name lookup of the identifier II
197 /// within the given scope, with optional C++ scope specifier SS, to
198 /// determine whether the name refers to a type. If so, returns an
199 /// opaque pointer (actually a QualType) corresponding to that
200 /// type. Otherwise, returns NULL.
201 ParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc,
202                              Scope *S, CXXScopeSpec *SS,
203                              bool isClassName, bool HasTrailingDot,
204                              ParsedType ObjectTypePtr,
205                              bool IsCtorOrDtorName,
206                              bool WantNontrivialTypeSourceInfo,
207                              IdentifierInfo **CorrectedII) {
208   // Determine where we will perform name lookup.
209   DeclContext *LookupCtx = nullptr;
210   if (ObjectTypePtr) {
211     QualType ObjectType = ObjectTypePtr.get();
212     if (ObjectType->isRecordType())
213       LookupCtx = computeDeclContext(ObjectType);
214   } else if (SS && SS->isNotEmpty()) {
215     LookupCtx = computeDeclContext(*SS, false);
216 
217     if (!LookupCtx) {
218       if (isDependentScopeSpecifier(*SS)) {
219         // C++ [temp.res]p3:
220         //   A qualified-id that refers to a type and in which the
221         //   nested-name-specifier depends on a template-parameter (14.6.2)
222         //   shall be prefixed by the keyword typename to indicate that the
223         //   qualified-id denotes a type, forming an
224         //   elaborated-type-specifier (7.1.5.3).
225         //
226         // We therefore do not perform any name lookup if the result would
227         // refer to a member of an unknown specialization.
228         if (!isClassName && !IsCtorOrDtorName)
229           return ParsedType();
230 
231         // We know from the grammar that this name refers to a type,
232         // so build a dependent node to describe the type.
233         if (WantNontrivialTypeSourceInfo)
234           return ActOnTypenameType(S, SourceLocation(), *SS, II, NameLoc).get();
235 
236         NestedNameSpecifierLoc QualifierLoc = SS->getWithLocInContext(Context);
237         QualType T = CheckTypenameType(ETK_None, SourceLocation(), QualifierLoc,
238                                        II, NameLoc);
239         return ParsedType::make(T);
240       }
241 
242       return ParsedType();
243     }
244 
245     if (!LookupCtx->isDependentContext() &&
246         RequireCompleteDeclContext(*SS, LookupCtx))
247       return ParsedType();
248   }
249 
250   // FIXME: LookupNestedNameSpecifierName isn't the right kind of
251   // lookup for class-names.
252   LookupNameKind Kind = isClassName ? LookupNestedNameSpecifierName :
253                                       LookupOrdinaryName;
254   LookupResult Result(*this, &II, NameLoc, Kind);
255   if (LookupCtx) {
256     // Perform "qualified" name lookup into the declaration context we
257     // computed, which is either the type of the base of a member access
258     // expression or the declaration context associated with a prior
259     // nested-name-specifier.
260     LookupQualifiedName(Result, LookupCtx);
261 
262     if (ObjectTypePtr && Result.empty()) {
263       // C++ [basic.lookup.classref]p3:
264       //   If the unqualified-id is ~type-name, the type-name is looked up
265       //   in the context of the entire postfix-expression. If the type T of
266       //   the object expression is of a class type C, the type-name is also
267       //   looked up in the scope of class C. At least one of the lookups shall
268       //   find a name that refers to (possibly cv-qualified) T.
269       LookupName(Result, S);
270     }
271   } else {
272     // Perform unqualified name lookup.
273     LookupName(Result, S);
274 
275     // For unqualified lookup in a class template in MSVC mode, look into
276     // dependent base classes where the primary class template is known.
277     if (Result.empty() && getLangOpts().MSVCCompat && (!SS || SS->isEmpty())) {
278       if (ParsedType TypeInBase =
279               recoverFromTypeInKnownDependentBase(*this, II, NameLoc))
280         return TypeInBase;
281     }
282   }
283 
284   NamedDecl *IIDecl = nullptr;
285   switch (Result.getResultKind()) {
286   case LookupResult::NotFound:
287   case LookupResult::NotFoundInCurrentInstantiation:
288     if (CorrectedII) {
289       TypoCorrection Correction = CorrectTypo(
290           Result.getLookupNameInfo(), Kind, S, SS,
291           llvm::make_unique<TypeNameValidatorCCC>(true, isClassName),
292           CTK_ErrorRecovery);
293       IdentifierInfo *NewII = Correction.getCorrectionAsIdentifierInfo();
294       TemplateTy Template;
295       bool MemberOfUnknownSpecialization;
296       UnqualifiedId TemplateName;
297       TemplateName.setIdentifier(NewII, NameLoc);
298       NestedNameSpecifier *NNS = Correction.getCorrectionSpecifier();
299       CXXScopeSpec NewSS, *NewSSPtr = SS;
300       if (SS && NNS) {
301         NewSS.MakeTrivial(Context, NNS, SourceRange(NameLoc));
302         NewSSPtr = &NewSS;
303       }
304       if (Correction && (NNS || NewII != &II) &&
305           // Ignore a correction to a template type as the to-be-corrected
306           // identifier is not a template (typo correction for template names
307           // is handled elsewhere).
308           !(getLangOpts().CPlusPlus && NewSSPtr &&
309             isTemplateName(S, *NewSSPtr, false, TemplateName, ParsedType(),
310                            false, Template, MemberOfUnknownSpecialization))) {
311         ParsedType Ty = getTypeName(*NewII, NameLoc, S, NewSSPtr,
312                                     isClassName, HasTrailingDot, ObjectTypePtr,
313                                     IsCtorOrDtorName,
314                                     WantNontrivialTypeSourceInfo);
315         if (Ty) {
316           diagnoseTypo(Correction,
317                        PDiag(diag::err_unknown_type_or_class_name_suggest)
318                          << Result.getLookupName() << isClassName);
319           if (SS && NNS)
320             SS->MakeTrivial(Context, NNS, SourceRange(NameLoc));
321           *CorrectedII = NewII;
322           return Ty;
323         }
324       }
325     }
326     // If typo correction failed or was not performed, fall through
327   case LookupResult::FoundOverloaded:
328   case LookupResult::FoundUnresolvedValue:
329     Result.suppressDiagnostics();
330     return ParsedType();
331 
332   case LookupResult::Ambiguous:
333     // Recover from type-hiding ambiguities by hiding the type.  We'll
334     // do the lookup again when looking for an object, and we can
335     // diagnose the error then.  If we don't do this, then the error
336     // about hiding the type will be immediately followed by an error
337     // that only makes sense if the identifier was treated like a type.
338     if (Result.getAmbiguityKind() == LookupResult::AmbiguousTagHiding) {
339       Result.suppressDiagnostics();
340       return ParsedType();
341     }
342 
343     // Look to see if we have a type anywhere in the list of results.
344     for (LookupResult::iterator Res = Result.begin(), ResEnd = Result.end();
345          Res != ResEnd; ++Res) {
346       if (isa<TypeDecl>(*Res) || isa<ObjCInterfaceDecl>(*Res)) {
347         if (!IIDecl ||
348             (*Res)->getLocation().getRawEncoding() <
349               IIDecl->getLocation().getRawEncoding())
350           IIDecl = *Res;
351       }
352     }
353 
354     if (!IIDecl) {
355       // None of the entities we found is a type, so there is no way
356       // to even assume that the result is a type. In this case, don't
357       // complain about the ambiguity. The parser will either try to
358       // perform this lookup again (e.g., as an object name), which
359       // will produce the ambiguity, or will complain that it expected
360       // a type name.
361       Result.suppressDiagnostics();
362       return ParsedType();
363     }
364 
365     // We found a type within the ambiguous lookup; diagnose the
366     // ambiguity and then return that type. This might be the right
367     // answer, or it might not be, but it suppresses any attempt to
368     // perform the name lookup again.
369     break;
370 
371   case LookupResult::Found:
372     IIDecl = Result.getFoundDecl();
373     break;
374   }
375 
376   assert(IIDecl && "Didn't find decl");
377 
378   QualType T;
379   if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {
380     DiagnoseUseOfDecl(IIDecl, NameLoc);
381 
382     T = Context.getTypeDeclType(TD);
383     MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
384 
385     // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
386     // constructor or destructor name (in such a case, the scope specifier
387     // will be attached to the enclosing Expr or Decl node).
388     if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
389       if (WantNontrivialTypeSourceInfo) {
390         // Construct a type with type-source information.
391         TypeLocBuilder Builder;
392         Builder.pushTypeSpec(T).setNameLoc(NameLoc);
393 
394         T = getElaboratedType(ETK_None, *SS, T);
395         ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
396         ElabTL.setElaboratedKeywordLoc(SourceLocation());
397         ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
398         return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
399       } else {
400         T = getElaboratedType(ETK_None, *SS, T);
401       }
402     }
403   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
404     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
405     if (!HasTrailingDot)
406       T = Context.getObjCInterfaceType(IDecl);
407   }
408 
409   if (T.isNull()) {
410     // If it's not plausibly a type, suppress diagnostics.
411     Result.suppressDiagnostics();
412     return ParsedType();
413   }
414   return ParsedType::make(T);
415 }
416 
417 // Builds a fake NNS for the given decl context.
418 static NestedNameSpecifier *
419 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
420   for (;; DC = DC->getLookupParent()) {
421     DC = DC->getPrimaryContext();
422     auto *ND = dyn_cast<NamespaceDecl>(DC);
423     if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
424       return NestedNameSpecifier::Create(Context, nullptr, ND);
425     else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
426       return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
427                                          RD->getTypeForDecl());
428     else if (isa<TranslationUnitDecl>(DC))
429       return NestedNameSpecifier::GlobalSpecifier(Context);
430   }
431   llvm_unreachable("something isn't in TU scope?");
432 }
433 
434 ParsedType Sema::ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II,
435                                                 SourceLocation NameLoc) {
436   // Accepting an undeclared identifier as a default argument for a template
437   // type parameter is a Microsoft extension.
438   Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
439 
440   // Build a fake DependentNameType that will perform lookup into CurContext at
441   // instantiation time.  The name specifier isn't dependent, so template
442   // instantiation won't transform it.  It will retry the lookup, however.
443   NestedNameSpecifier *NNS =
444       synthesizeCurrentNestedNameSpecifier(Context, CurContext);
445   QualType T = Context.getDependentNameType(ETK_None, NNS, &II);
446 
447   // Build type location information.  We synthesized the qualifier, so we have
448   // to build a fake NestedNameSpecifierLoc.
449   NestedNameSpecifierLocBuilder NNSLocBuilder;
450   NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
451   NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
452 
453   TypeLocBuilder Builder;
454   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
455   DepTL.setNameLoc(NameLoc);
456   DepTL.setElaboratedKeywordLoc(SourceLocation());
457   DepTL.setQualifierLoc(QualifierLoc);
458   return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
459 }
460 
461 /// isTagName() - This method is called *for error recovery purposes only*
462 /// to determine if the specified name is a valid tag name ("struct foo").  If
463 /// so, this returns the TST for the tag corresponding to it (TST_enum,
464 /// TST_union, TST_struct, TST_interface, TST_class).  This is used to diagnose
465 /// cases in C where the user forgot to specify the tag.
466 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
467   // Do a tag name lookup in this scope.
468   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
469   LookupName(R, S, false);
470   R.suppressDiagnostics();
471   if (R.getResultKind() == LookupResult::Found)
472     if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
473       switch (TD->getTagKind()) {
474       case TTK_Struct: return DeclSpec::TST_struct;
475       case TTK_Interface: return DeclSpec::TST_interface;
476       case TTK_Union:  return DeclSpec::TST_union;
477       case TTK_Class:  return DeclSpec::TST_class;
478       case TTK_Enum:   return DeclSpec::TST_enum;
479       }
480     }
481 
482   return DeclSpec::TST_unspecified;
483 }
484 
485 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
486 /// if a CXXScopeSpec's type is equal to the type of one of the base classes
487 /// then downgrade the missing typename error to a warning.
488 /// This is needed for MSVC compatibility; Example:
489 /// @code
490 /// template<class T> class A {
491 /// public:
492 ///   typedef int TYPE;
493 /// };
494 /// template<class T> class B : public A<T> {
495 /// public:
496 ///   A<T>::TYPE a; // no typename required because A<T> is a base class.
497 /// };
498 /// @endcode
499 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
500   if (CurContext->isRecord()) {
501     if (SS->getScopeRep()->getKind() == NestedNameSpecifier::Super)
502       return true;
503 
504     const Type *Ty = SS->getScopeRep()->getAsType();
505 
506     CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
507     for (const auto &Base : RD->bases())
508       if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
509         return true;
510     return S->isFunctionPrototypeScope();
511   }
512   return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
513 }
514 
515 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
516                                    SourceLocation IILoc,
517                                    Scope *S,
518                                    CXXScopeSpec *SS,
519                                    ParsedType &SuggestedType,
520                                    bool AllowClassTemplates) {
521   // We don't have anything to suggest (yet).
522   SuggestedType = ParsedType();
523 
524   // There may have been a typo in the name of the type. Look up typo
525   // results, in case we have something that we can suggest.
526   if (TypoCorrection Corrected =
527           CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS,
528                       llvm::make_unique<TypeNameValidatorCCC>(
529                           false, false, AllowClassTemplates),
530                       CTK_ErrorRecovery)) {
531     if (Corrected.isKeyword()) {
532       // We corrected to a keyword.
533       diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II);
534       II = Corrected.getCorrectionAsIdentifierInfo();
535     } else {
536       // We found a similarly-named type or interface; suggest that.
537       if (!SS || !SS->isSet()) {
538         diagnoseTypo(Corrected,
539                      PDiag(diag::err_unknown_typename_suggest) << II);
540       } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
541         std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
542         bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
543                                 II->getName().equals(CorrectedStr);
544         diagnoseTypo(Corrected,
545                      PDiag(diag::err_unknown_nested_typename_suggest)
546                        << II << DC << DroppedSpecifier << SS->getRange());
547       } else {
548         llvm_unreachable("could not have corrected a typo here");
549       }
550 
551       CXXScopeSpec tmpSS;
552       if (Corrected.getCorrectionSpecifier())
553         tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
554                           SourceRange(IILoc));
555       SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(),
556                                   IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false,
557                                   false, ParsedType(),
558                                   /*IsCtorOrDtorName=*/false,
559                                   /*NonTrivialTypeSourceInfo=*/true);
560     }
561     return;
562   }
563 
564   if (getLangOpts().CPlusPlus) {
565     // See if II is a class template that the user forgot to pass arguments to.
566     UnqualifiedId Name;
567     Name.setIdentifier(II, IILoc);
568     CXXScopeSpec EmptySS;
569     TemplateTy TemplateResult;
570     bool MemberOfUnknownSpecialization;
571     if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
572                        Name, ParsedType(), true, TemplateResult,
573                        MemberOfUnknownSpecialization) == TNK_Type_template) {
574       TemplateName TplName = TemplateResult.get();
575       Diag(IILoc, diag::err_template_missing_args) << TplName;
576       if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
577         Diag(TplDecl->getLocation(), diag::note_template_decl_here)
578           << TplDecl->getTemplateParameters()->getSourceRange();
579       }
580       return;
581     }
582   }
583 
584   // FIXME: Should we move the logic that tries to recover from a missing tag
585   // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
586 
587   if (!SS || (!SS->isSet() && !SS->isInvalid()))
588     Diag(IILoc, diag::err_unknown_typename) << II;
589   else if (DeclContext *DC = computeDeclContext(*SS, false))
590     Diag(IILoc, diag::err_typename_nested_not_found)
591       << II << DC << SS->getRange();
592   else if (isDependentScopeSpecifier(*SS)) {
593     unsigned DiagID = diag::err_typename_missing;
594     if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
595       DiagID = diag::ext_typename_missing;
596 
597     Diag(SS->getRange().getBegin(), DiagID)
598       << SS->getScopeRep() << II->getName()
599       << SourceRange(SS->getRange().getBegin(), IILoc)
600       << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
601     SuggestedType = ActOnTypenameType(S, SourceLocation(),
602                                       *SS, *II, IILoc).get();
603   } else {
604     assert(SS && SS->isInvalid() &&
605            "Invalid scope specifier has already been diagnosed");
606   }
607 }
608 
609 /// \brief Determine whether the given result set contains either a type name
610 /// or
611 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
612   bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
613                        NextToken.is(tok::less);
614 
615   for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
616     if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
617       return true;
618 
619     if (CheckTemplate && isa<TemplateDecl>(*I))
620       return true;
621   }
622 
623   return false;
624 }
625 
626 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
627                                     Scope *S, CXXScopeSpec &SS,
628                                     IdentifierInfo *&Name,
629                                     SourceLocation NameLoc) {
630   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
631   SemaRef.LookupParsedName(R, S, &SS);
632   if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
633     StringRef FixItTagName;
634     switch (Tag->getTagKind()) {
635       case TTK_Class:
636         FixItTagName = "class ";
637         break;
638 
639       case TTK_Enum:
640         FixItTagName = "enum ";
641         break;
642 
643       case TTK_Struct:
644         FixItTagName = "struct ";
645         break;
646 
647       case TTK_Interface:
648         FixItTagName = "__interface ";
649         break;
650 
651       case TTK_Union:
652         FixItTagName = "union ";
653         break;
654     }
655 
656     StringRef TagName = FixItTagName.drop_back();
657     SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
658       << Name << TagName << SemaRef.getLangOpts().CPlusPlus
659       << FixItHint::CreateInsertion(NameLoc, FixItTagName);
660 
661     for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
662          I != IEnd; ++I)
663       SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
664         << Name << TagName;
665 
666     // Replace lookup results with just the tag decl.
667     Result.clear(Sema::LookupTagName);
668     SemaRef.LookupParsedName(Result, S, &SS);
669     return true;
670   }
671 
672   return false;
673 }
674 
675 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
676 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
677                                   QualType T, SourceLocation NameLoc) {
678   ASTContext &Context = S.Context;
679 
680   TypeLocBuilder Builder;
681   Builder.pushTypeSpec(T).setNameLoc(NameLoc);
682 
683   T = S.getElaboratedType(ETK_None, SS, T);
684   ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
685   ElabTL.setElaboratedKeywordLoc(SourceLocation());
686   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
687   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
688 }
689 
690 Sema::NameClassification
691 Sema::ClassifyName(Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name,
692                    SourceLocation NameLoc, const Token &NextToken,
693                    bool IsAddressOfOperand,
694                    std::unique_ptr<CorrectionCandidateCallback> CCC) {
695   DeclarationNameInfo NameInfo(Name, NameLoc);
696   ObjCMethodDecl *CurMethod = getCurMethodDecl();
697 
698   if (NextToken.is(tok::coloncolon)) {
699     BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
700                                 QualType(), false, SS, nullptr, false);
701   }
702 
703   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
704   LookupParsedName(Result, S, &SS, !CurMethod);
705 
706   // For unqualified lookup in a class template in MSVC mode, look into
707   // dependent base classes where the primary class template is known.
708   if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
709     if (ParsedType TypeInBase =
710             recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
711       return TypeInBase;
712   }
713 
714   // Perform lookup for Objective-C instance variables (including automatically
715   // synthesized instance variables), if we're in an Objective-C method.
716   // FIXME: This lookup really, really needs to be folded in to the normal
717   // unqualified lookup mechanism.
718   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
719     ExprResult E = LookupInObjCMethod(Result, S, Name, true);
720     if (E.get() || E.isInvalid())
721       return E;
722   }
723 
724   bool SecondTry = false;
725   bool IsFilteredTemplateName = false;
726 
727 Corrected:
728   switch (Result.getResultKind()) {
729   case LookupResult::NotFound:
730     // If an unqualified-id is followed by a '(', then we have a function
731     // call.
732     if (!SS.isSet() && NextToken.is(tok::l_paren)) {
733       // In C++, this is an ADL-only call.
734       // FIXME: Reference?
735       if (getLangOpts().CPlusPlus)
736         return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
737 
738       // C90 6.3.2.2:
739       //   If the expression that precedes the parenthesized argument list in a
740       //   function call consists solely of an identifier, and if no
741       //   declaration is visible for this identifier, the identifier is
742       //   implicitly declared exactly as if, in the innermost block containing
743       //   the function call, the declaration
744       //
745       //     extern int identifier ();
746       //
747       //   appeared.
748       //
749       // We also allow this in C99 as an extension.
750       if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
751         Result.addDecl(D);
752         Result.resolveKind();
753         return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
754       }
755     }
756 
757     // In C, we first see whether there is a tag type by the same name, in
758     // which case it's likely that the user just forget to write "enum",
759     // "struct", or "union".
760     if (!getLangOpts().CPlusPlus && !SecondTry &&
761         isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
762       break;
763     }
764 
765     // Perform typo correction to determine if there is another name that is
766     // close to this name.
767     if (!SecondTry && CCC) {
768       SecondTry = true;
769       if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
770                                                  Result.getLookupKind(), S,
771                                                  &SS, std::move(CCC),
772                                                  CTK_ErrorRecovery)) {
773         unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
774         unsigned QualifiedDiag = diag::err_no_member_suggest;
775 
776         NamedDecl *FirstDecl = Corrected.getCorrectionDecl();
777         NamedDecl *UnderlyingFirstDecl
778           = FirstDecl? FirstDecl->getUnderlyingDecl() : nullptr;
779         if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
780             UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
781           UnqualifiedDiag = diag::err_no_template_suggest;
782           QualifiedDiag = diag::err_no_member_template_suggest;
783         } else if (UnderlyingFirstDecl &&
784                    (isa<TypeDecl>(UnderlyingFirstDecl) ||
785                     isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
786                     isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
787           UnqualifiedDiag = diag::err_unknown_typename_suggest;
788           QualifiedDiag = diag::err_unknown_nested_typename_suggest;
789         }
790 
791         if (SS.isEmpty()) {
792           diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
793         } else {// FIXME: is this even reachable? Test it.
794           std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
795           bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
796                                   Name->getName().equals(CorrectedStr);
797           diagnoseTypo(Corrected, PDiag(QualifiedDiag)
798                                     << Name << computeDeclContext(SS, false)
799                                     << DroppedSpecifier << SS.getRange());
800         }
801 
802         // Update the name, so that the caller has the new name.
803         Name = Corrected.getCorrectionAsIdentifierInfo();
804 
805         // Typo correction corrected to a keyword.
806         if (Corrected.isKeyword())
807           return Name;
808 
809         // Also update the LookupResult...
810         // FIXME: This should probably go away at some point
811         Result.clear();
812         Result.setLookupName(Corrected.getCorrection());
813         if (FirstDecl)
814           Result.addDecl(FirstDecl);
815 
816         // If we found an Objective-C instance variable, let
817         // LookupInObjCMethod build the appropriate expression to
818         // reference the ivar.
819         // FIXME: This is a gross hack.
820         if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
821           Result.clear();
822           ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
823           return E;
824         }
825 
826         goto Corrected;
827       }
828     }
829 
830     // We failed to correct; just fall through and let the parser deal with it.
831     Result.suppressDiagnostics();
832     return NameClassification::Unknown();
833 
834   case LookupResult::NotFoundInCurrentInstantiation: {
835     // We performed name lookup into the current instantiation, and there were
836     // dependent bases, so we treat this result the same way as any other
837     // dependent nested-name-specifier.
838 
839     // C++ [temp.res]p2:
840     //   A name used in a template declaration or definition and that is
841     //   dependent on a template-parameter is assumed not to name a type
842     //   unless the applicable name lookup finds a type name or the name is
843     //   qualified by the keyword typename.
844     //
845     // FIXME: If the next token is '<', we might want to ask the parser to
846     // perform some heroics to see if we actually have a
847     // template-argument-list, which would indicate a missing 'template'
848     // keyword here.
849     return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
850                                       NameInfo, IsAddressOfOperand,
851                                       /*TemplateArgs=*/nullptr);
852   }
853 
854   case LookupResult::Found:
855   case LookupResult::FoundOverloaded:
856   case LookupResult::FoundUnresolvedValue:
857     break;
858 
859   case LookupResult::Ambiguous:
860     if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
861         hasAnyAcceptableTemplateNames(Result)) {
862       // C++ [temp.local]p3:
863       //   A lookup that finds an injected-class-name (10.2) can result in an
864       //   ambiguity in certain cases (for example, if it is found in more than
865       //   one base class). If all of the injected-class-names that are found
866       //   refer to specializations of the same class template, and if the name
867       //   is followed by a template-argument-list, the reference refers to the
868       //   class template itself and not a specialization thereof, and is not
869       //   ambiguous.
870       //
871       // This filtering can make an ambiguous result into an unambiguous one,
872       // so try again after filtering out template names.
873       FilterAcceptableTemplateNames(Result);
874       if (!Result.isAmbiguous()) {
875         IsFilteredTemplateName = true;
876         break;
877       }
878     }
879 
880     // Diagnose the ambiguity and return an error.
881     return NameClassification::Error();
882   }
883 
884   if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
885       (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
886     // C++ [temp.names]p3:
887     //   After name lookup (3.4) finds that a name is a template-name or that
888     //   an operator-function-id or a literal- operator-id refers to a set of
889     //   overloaded functions any member of which is a function template if
890     //   this is followed by a <, the < is always taken as the delimiter of a
891     //   template-argument-list and never as the less-than operator.
892     if (!IsFilteredTemplateName)
893       FilterAcceptableTemplateNames(Result);
894 
895     if (!Result.empty()) {
896       bool IsFunctionTemplate;
897       bool IsVarTemplate;
898       TemplateName Template;
899       if (Result.end() - Result.begin() > 1) {
900         IsFunctionTemplate = true;
901         Template = Context.getOverloadedTemplateName(Result.begin(),
902                                                      Result.end());
903       } else {
904         TemplateDecl *TD
905           = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
906         IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
907         IsVarTemplate = isa<VarTemplateDecl>(TD);
908 
909         if (SS.isSet() && !SS.isInvalid())
910           Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
911                                                     /*TemplateKeyword=*/false,
912                                                       TD);
913         else
914           Template = TemplateName(TD);
915       }
916 
917       if (IsFunctionTemplate) {
918         // Function templates always go through overload resolution, at which
919         // point we'll perform the various checks (e.g., accessibility) we need
920         // to based on which function we selected.
921         Result.suppressDiagnostics();
922 
923         return NameClassification::FunctionTemplate(Template);
924       }
925 
926       return IsVarTemplate ? NameClassification::VarTemplate(Template)
927                            : NameClassification::TypeTemplate(Template);
928     }
929   }
930 
931   NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
932   if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
933     DiagnoseUseOfDecl(Type, NameLoc);
934     MarkAnyDeclReferenced(Type->getLocation(), Type, /*OdrUse=*/false);
935     QualType T = Context.getTypeDeclType(Type);
936     if (SS.isNotEmpty())
937       return buildNestedType(*this, SS, T, NameLoc);
938     return ParsedType::make(T);
939   }
940 
941   ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
942   if (!Class) {
943     // FIXME: It's unfortunate that we don't have a Type node for handling this.
944     if (ObjCCompatibleAliasDecl *Alias =
945             dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
946       Class = Alias->getClassInterface();
947   }
948 
949   if (Class) {
950     DiagnoseUseOfDecl(Class, NameLoc);
951 
952     if (NextToken.is(tok::period)) {
953       // Interface. <something> is parsed as a property reference expression.
954       // Just return "unknown" as a fall-through for now.
955       Result.suppressDiagnostics();
956       return NameClassification::Unknown();
957     }
958 
959     QualType T = Context.getObjCInterfaceType(Class);
960     return ParsedType::make(T);
961   }
962 
963   // We can have a type template here if we're classifying a template argument.
964   if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
965     return NameClassification::TypeTemplate(
966         TemplateName(cast<TemplateDecl>(FirstDecl)));
967 
968   // Check for a tag type hidden by a non-type decl in a few cases where it
969   // seems likely a type is wanted instead of the non-type that was found.
970   bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star);
971   if ((NextToken.is(tok::identifier) ||
972        (NextIsOp &&
973         FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
974       isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
975     TypeDecl *Type = Result.getAsSingle<TypeDecl>();
976     DiagnoseUseOfDecl(Type, NameLoc);
977     QualType T = Context.getTypeDeclType(Type);
978     if (SS.isNotEmpty())
979       return buildNestedType(*this, SS, T, NameLoc);
980     return ParsedType::make(T);
981   }
982 
983   if (FirstDecl->isCXXClassMember())
984     return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
985                                            nullptr);
986 
987   bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
988   return BuildDeclarationNameExpr(SS, Result, ADL);
989 }
990 
991 // Determines the context to return to after temporarily entering a
992 // context.  This depends in an unnecessarily complicated way on the
993 // exact ordering of callbacks from the parser.
994 DeclContext *Sema::getContainingDC(DeclContext *DC) {
995 
996   // Functions defined inline within classes aren't parsed until we've
997   // finished parsing the top-level class, so the top-level class is
998   // the context we'll need to return to.
999   // A Lambda call operator whose parent is a class must not be treated
1000   // as an inline member function.  A Lambda can be used legally
1001   // either as an in-class member initializer or a default argument.  These
1002   // are parsed once the class has been marked complete and so the containing
1003   // context would be the nested class (when the lambda is defined in one);
1004   // If the class is not complete, then the lambda is being used in an
1005   // ill-formed fashion (such as to specify the width of a bit-field, or
1006   // in an array-bound) - in which case we still want to return the
1007   // lexically containing DC (which could be a nested class).
1008   if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
1009     DC = DC->getLexicalParent();
1010 
1011     // A function not defined within a class will always return to its
1012     // lexical context.
1013     if (!isa<CXXRecordDecl>(DC))
1014       return DC;
1015 
1016     // A C++ inline method/friend is parsed *after* the topmost class
1017     // it was declared in is fully parsed ("complete");  the topmost
1018     // class is the context we need to return to.
1019     while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
1020       DC = RD;
1021 
1022     // Return the declaration context of the topmost class the inline method is
1023     // declared in.
1024     return DC;
1025   }
1026 
1027   return DC->getLexicalParent();
1028 }
1029 
1030 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
1031   assert(getContainingDC(DC) == CurContext &&
1032       "The next DeclContext should be lexically contained in the current one.");
1033   CurContext = DC;
1034   S->setEntity(DC);
1035 }
1036 
1037 void Sema::PopDeclContext() {
1038   assert(CurContext && "DeclContext imbalance!");
1039 
1040   CurContext = getContainingDC(CurContext);
1041   assert(CurContext && "Popped translation unit!");
1042 }
1043 
1044 /// EnterDeclaratorContext - Used when we must lookup names in the context
1045 /// of a declarator's nested name specifier.
1046 ///
1047 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
1048   // C++0x [basic.lookup.unqual]p13:
1049   //   A name used in the definition of a static data member of class
1050   //   X (after the qualified-id of the static member) is looked up as
1051   //   if the name was used in a member function of X.
1052   // C++0x [basic.lookup.unqual]p14:
1053   //   If a variable member of a namespace is defined outside of the
1054   //   scope of its namespace then any name used in the definition of
1055   //   the variable member (after the declarator-id) is looked up as
1056   //   if the definition of the variable member occurred in its
1057   //   namespace.
1058   // Both of these imply that we should push a scope whose context
1059   // is the semantic context of the declaration.  We can't use
1060   // PushDeclContext here because that context is not necessarily
1061   // lexically contained in the current context.  Fortunately,
1062   // the containing scope should have the appropriate information.
1063 
1064   assert(!S->getEntity() && "scope already has entity");
1065 
1066 #ifndef NDEBUG
1067   Scope *Ancestor = S->getParent();
1068   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1069   assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1070 #endif
1071 
1072   CurContext = DC;
1073   S->setEntity(DC);
1074 }
1075 
1076 void Sema::ExitDeclaratorContext(Scope *S) {
1077   assert(S->getEntity() == CurContext && "Context imbalance!");
1078 
1079   // Switch back to the lexical context.  The safety of this is
1080   // enforced by an assert in EnterDeclaratorContext.
1081   Scope *Ancestor = S->getParent();
1082   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1083   CurContext = Ancestor->getEntity();
1084 
1085   // We don't need to do anything with the scope, which is going to
1086   // disappear.
1087 }
1088 
1089 
1090 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
1091   // We assume that the caller has already called
1092   // ActOnReenterTemplateScope so getTemplatedDecl() works.
1093   FunctionDecl *FD = D->getAsFunction();
1094   if (!FD)
1095     return;
1096 
1097   // Same implementation as PushDeclContext, but enters the context
1098   // from the lexical parent, rather than the top-level class.
1099   assert(CurContext == FD->getLexicalParent() &&
1100     "The next DeclContext should be lexically contained in the current one.");
1101   CurContext = FD;
1102   S->setEntity(CurContext);
1103 
1104   for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1105     ParmVarDecl *Param = FD->getParamDecl(P);
1106     // If the parameter has an identifier, then add it to the scope
1107     if (Param->getIdentifier()) {
1108       S->AddDecl(Param);
1109       IdResolver.AddDecl(Param);
1110     }
1111   }
1112 }
1113 
1114 
1115 void Sema::ActOnExitFunctionContext() {
1116   // Same implementation as PopDeclContext, but returns to the lexical parent,
1117   // rather than the top-level class.
1118   assert(CurContext && "DeclContext imbalance!");
1119   CurContext = CurContext->getLexicalParent();
1120   assert(CurContext && "Popped translation unit!");
1121 }
1122 
1123 
1124 /// \brief Determine whether we allow overloading of the function
1125 /// PrevDecl with another declaration.
1126 ///
1127 /// This routine determines whether overloading is possible, not
1128 /// whether some new function is actually an overload. It will return
1129 /// true in C++ (where we can always provide overloads) or, as an
1130 /// extension, in C when the previous function is already an
1131 /// overloaded function declaration or has the "overloadable"
1132 /// attribute.
1133 static bool AllowOverloadingOfFunction(LookupResult &Previous,
1134                                        ASTContext &Context) {
1135   if (Context.getLangOpts().CPlusPlus)
1136     return true;
1137 
1138   if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1139     return true;
1140 
1141   return (Previous.getResultKind() == LookupResult::Found
1142           && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
1143 }
1144 
1145 /// Add this decl to the scope shadowed decl chains.
1146 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1147   // Move up the scope chain until we find the nearest enclosing
1148   // non-transparent context. The declaration will be introduced into this
1149   // scope.
1150   while (S->getEntity() && S->getEntity()->isTransparentContext())
1151     S = S->getParent();
1152 
1153   // Add scoped declarations into their context, so that they can be
1154   // found later. Declarations without a context won't be inserted
1155   // into any context.
1156   if (AddToContext)
1157     CurContext->addDecl(D);
1158 
1159   // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1160   // are function-local declarations.
1161   if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
1162       !D->getDeclContext()->getRedeclContext()->Equals(
1163         D->getLexicalDeclContext()->getRedeclContext()) &&
1164       !D->getLexicalDeclContext()->isFunctionOrMethod())
1165     return;
1166 
1167   // Template instantiations should also not be pushed into scope.
1168   if (isa<FunctionDecl>(D) &&
1169       cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1170     return;
1171 
1172   // If this replaces anything in the current scope,
1173   IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1174                                IEnd = IdResolver.end();
1175   for (; I != IEnd; ++I) {
1176     if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1177       S->RemoveDecl(*I);
1178       IdResolver.RemoveDecl(*I);
1179 
1180       // Should only need to replace one decl.
1181       break;
1182     }
1183   }
1184 
1185   S->AddDecl(D);
1186 
1187   if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1188     // Implicitly-generated labels may end up getting generated in an order that
1189     // isn't strictly lexical, which breaks name lookup. Be careful to insert
1190     // the label at the appropriate place in the identifier chain.
1191     for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1192       DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1193       if (IDC == CurContext) {
1194         if (!S->isDeclScope(*I))
1195           continue;
1196       } else if (IDC->Encloses(CurContext))
1197         break;
1198     }
1199 
1200     IdResolver.InsertDeclAfter(I, D);
1201   } else {
1202     IdResolver.AddDecl(D);
1203   }
1204 }
1205 
1206 void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
1207   if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1208     TUScope->AddDecl(D);
1209 }
1210 
1211 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S,
1212                          bool AllowInlineNamespace) {
1213   return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1214 }
1215 
1216 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
1217   DeclContext *TargetDC = DC->getPrimaryContext();
1218   do {
1219     if (DeclContext *ScopeDC = S->getEntity())
1220       if (ScopeDC->getPrimaryContext() == TargetDC)
1221         return S;
1222   } while ((S = S->getParent()));
1223 
1224   return nullptr;
1225 }
1226 
1227 static bool isOutOfScopePreviousDeclaration(NamedDecl *,
1228                                             DeclContext*,
1229                                             ASTContext&);
1230 
1231 /// Filters out lookup results that don't fall within the given scope
1232 /// as determined by isDeclInScope.
1233 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
1234                                 bool ConsiderLinkage,
1235                                 bool AllowInlineNamespace) {
1236   LookupResult::Filter F = R.makeFilter();
1237   while (F.hasNext()) {
1238     NamedDecl *D = F.next();
1239 
1240     if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1241       continue;
1242 
1243     if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1244       continue;
1245 
1246     F.erase();
1247   }
1248 
1249   F.done();
1250 }
1251 
1252 static bool isUsingDecl(NamedDecl *D) {
1253   return isa<UsingShadowDecl>(D) ||
1254          isa<UnresolvedUsingTypenameDecl>(D) ||
1255          isa<UnresolvedUsingValueDecl>(D);
1256 }
1257 
1258 /// Removes using shadow declarations from the lookup results.
1259 static void RemoveUsingDecls(LookupResult &R) {
1260   LookupResult::Filter F = R.makeFilter();
1261   while (F.hasNext())
1262     if (isUsingDecl(F.next()))
1263       F.erase();
1264 
1265   F.done();
1266 }
1267 
1268 /// \brief Check for this common pattern:
1269 /// @code
1270 /// class S {
1271 ///   S(const S&); // DO NOT IMPLEMENT
1272 ///   void operator=(const S&); // DO NOT IMPLEMENT
1273 /// };
1274 /// @endcode
1275 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1276   // FIXME: Should check for private access too but access is set after we get
1277   // the decl here.
1278   if (D->doesThisDeclarationHaveABody())
1279     return false;
1280 
1281   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1282     return CD->isCopyConstructor();
1283   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1284     return Method->isCopyAssignmentOperator();
1285   return false;
1286 }
1287 
1288 // We need this to handle
1289 //
1290 // typedef struct {
1291 //   void *foo() { return 0; }
1292 // } A;
1293 //
1294 // When we see foo we don't know if after the typedef we will get 'A' or '*A'
1295 // for example. If 'A', foo will have external linkage. If we have '*A',
1296 // foo will have no linkage. Since we can't know until we get to the end
1297 // of the typedef, this function finds out if D might have non-external linkage.
1298 // Callers should verify at the end of the TU if it D has external linkage or
1299 // not.
1300 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1301   const DeclContext *DC = D->getDeclContext();
1302   while (!DC->isTranslationUnit()) {
1303     if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1304       if (!RD->hasNameForLinkage())
1305         return true;
1306     }
1307     DC = DC->getParent();
1308   }
1309 
1310   return !D->isExternallyVisible();
1311 }
1312 
1313 // FIXME: This needs to be refactored; some other isInMainFile users want
1314 // these semantics.
1315 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1316   if (S.TUKind != TU_Complete)
1317     return false;
1318   return S.SourceMgr.isInMainFile(Loc);
1319 }
1320 
1321 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1322   assert(D);
1323 
1324   if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1325     return false;
1326 
1327   // Ignore all entities declared within templates, and out-of-line definitions
1328   // of members of class templates.
1329   if (D->getDeclContext()->isDependentContext() ||
1330       D->getLexicalDeclContext()->isDependentContext())
1331     return false;
1332 
1333   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1334     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1335       return false;
1336 
1337     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1338       if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1339         return false;
1340     } else {
1341       // 'static inline' functions are defined in headers; don't warn.
1342       if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1343         return false;
1344     }
1345 
1346     if (FD->doesThisDeclarationHaveABody() &&
1347         Context.DeclMustBeEmitted(FD))
1348       return false;
1349   } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1350     // Constants and utility variables are defined in headers with internal
1351     // linkage; don't warn.  (Unlike functions, there isn't a convenient marker
1352     // like "inline".)
1353     if (!isMainFileLoc(*this, VD->getLocation()))
1354       return false;
1355 
1356     if (Context.DeclMustBeEmitted(VD))
1357       return false;
1358 
1359     if (VD->isStaticDataMember() &&
1360         VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1361       return false;
1362   } else {
1363     return false;
1364   }
1365 
1366   // Only warn for unused decls internal to the translation unit.
1367   // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1368   // for inline functions defined in the main source file, for instance.
1369   return mightHaveNonExternalLinkage(D);
1370 }
1371 
1372 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
1373   if (!D)
1374     return;
1375 
1376   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1377     const FunctionDecl *First = FD->getFirstDecl();
1378     if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1379       return; // First should already be in the vector.
1380   }
1381 
1382   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1383     const VarDecl *First = VD->getFirstDecl();
1384     if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1385       return; // First should already be in the vector.
1386   }
1387 
1388   if (ShouldWarnIfUnusedFileScopedDecl(D))
1389     UnusedFileScopedDecls.push_back(D);
1390 }
1391 
1392 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1393   if (D->isInvalidDecl())
1394     return false;
1395 
1396   if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() ||
1397       D->hasAttr<ObjCPreciseLifetimeAttr>())
1398     return false;
1399 
1400   if (isa<LabelDecl>(D))
1401     return true;
1402 
1403   // Except for labels, we only care about unused decls that are local to
1404   // functions.
1405   bool WithinFunction = D->getDeclContext()->isFunctionOrMethod();
1406   if (const auto *R = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
1407     // For dependent types, the diagnostic is deferred.
1408     WithinFunction =
1409         WithinFunction || (R->isLocalClass() && !R->isDependentType());
1410   if (!WithinFunction)
1411     return false;
1412 
1413   if (isa<TypedefNameDecl>(D))
1414     return true;
1415 
1416   // White-list anything that isn't a local variable.
1417   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D))
1418     return false;
1419 
1420   // Types of valid local variables should be complete, so this should succeed.
1421   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1422 
1423     // White-list anything with an __attribute__((unused)) type.
1424     QualType Ty = VD->getType();
1425 
1426     // Only look at the outermost level of typedef.
1427     if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1428       if (TT->getDecl()->hasAttr<UnusedAttr>())
1429         return false;
1430     }
1431 
1432     // If we failed to complete the type for some reason, or if the type is
1433     // dependent, don't diagnose the variable.
1434     if (Ty->isIncompleteType() || Ty->isDependentType())
1435       return false;
1436 
1437     if (const TagType *TT = Ty->getAs<TagType>()) {
1438       const TagDecl *Tag = TT->getDecl();
1439       if (Tag->hasAttr<UnusedAttr>())
1440         return false;
1441 
1442       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1443         if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1444           return false;
1445 
1446         if (const Expr *Init = VD->getInit()) {
1447           if (const ExprWithCleanups *Cleanups =
1448                   dyn_cast<ExprWithCleanups>(Init))
1449             Init = Cleanups->getSubExpr();
1450           const CXXConstructExpr *Construct =
1451             dyn_cast<CXXConstructExpr>(Init);
1452           if (Construct && !Construct->isElidable()) {
1453             CXXConstructorDecl *CD = Construct->getConstructor();
1454             if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
1455               return false;
1456           }
1457         }
1458       }
1459     }
1460 
1461     // TODO: __attribute__((unused)) templates?
1462   }
1463 
1464   return true;
1465 }
1466 
1467 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1468                                      FixItHint &Hint) {
1469   if (isa<LabelDecl>(D)) {
1470     SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
1471                 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
1472     if (AfterColon.isInvalid())
1473       return;
1474     Hint = FixItHint::CreateRemoval(CharSourceRange::
1475                                     getCharRange(D->getLocStart(), AfterColon));
1476   }
1477   return;
1478 }
1479 
1480 void Sema::DiagnoseUnusedNestedTypedefs(const RecordDecl *D) {
1481   if (D->getTypeForDecl()->isDependentType())
1482     return;
1483 
1484   for (auto *TmpD : D->decls()) {
1485     if (const auto *T = dyn_cast<TypedefNameDecl>(TmpD))
1486       DiagnoseUnusedDecl(T);
1487     else if(const auto *R = dyn_cast<RecordDecl>(TmpD))
1488       DiagnoseUnusedNestedTypedefs(R);
1489   }
1490 }
1491 
1492 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1493 /// unless they are marked attr(unused).
1494 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
1495   if (!ShouldDiagnoseUnusedDecl(D))
1496     return;
1497 
1498   if (auto *TD = dyn_cast<TypedefNameDecl>(D)) {
1499     // typedefs can be referenced later on, so the diagnostics are emitted
1500     // at end-of-translation-unit.
1501     UnusedLocalTypedefNameCandidates.insert(TD);
1502     return;
1503   }
1504 
1505   FixItHint Hint;
1506   GenerateFixForUnusedDecl(D, Context, Hint);
1507 
1508   unsigned DiagID;
1509   if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1510     DiagID = diag::warn_unused_exception_param;
1511   else if (isa<LabelDecl>(D))
1512     DiagID = diag::warn_unused_label;
1513   else
1514     DiagID = diag::warn_unused_variable;
1515 
1516   Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
1517 }
1518 
1519 static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1520   // Verify that we have no forward references left.  If so, there was a goto
1521   // or address of a label taken, but no definition of it.  Label fwd
1522   // definitions are indicated with a null substmt which is also not a resolved
1523   // MS inline assembly label name.
1524   bool Diagnose = false;
1525   if (L->isMSAsmLabel())
1526     Diagnose = !L->isResolvedMSAsmLabel();
1527   else
1528     Diagnose = L->getStmt() == nullptr;
1529   if (Diagnose)
1530     S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1531 }
1532 
1533 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
1534   S->mergeNRVOIntoParent();
1535 
1536   if (S->decl_empty()) return;
1537   assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1538          "Scope shouldn't contain decls!");
1539 
1540   for (auto *TmpD : S->decls()) {
1541     assert(TmpD && "This decl didn't get pushed??");
1542 
1543     assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1544     NamedDecl *D = cast<NamedDecl>(TmpD);
1545 
1546     if (!D->getDeclName()) continue;
1547 
1548     // Diagnose unused variables in this scope.
1549     if (!S->hasUnrecoverableErrorOccurred()) {
1550       DiagnoseUnusedDecl(D);
1551       if (const auto *RD = dyn_cast<RecordDecl>(D))
1552         DiagnoseUnusedNestedTypedefs(RD);
1553     }
1554 
1555     // If this was a forward reference to a label, verify it was defined.
1556     if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1557       CheckPoppedLabel(LD, *this);
1558 
1559     // Remove this name from our lexical scope.
1560     IdResolver.RemoveDecl(D);
1561   }
1562 }
1563 
1564 /// \brief Look for an Objective-C class in the translation unit.
1565 ///
1566 /// \param Id The name of the Objective-C class we're looking for. If
1567 /// typo-correction fixes this name, the Id will be updated
1568 /// to the fixed name.
1569 ///
1570 /// \param IdLoc The location of the name in the translation unit.
1571 ///
1572 /// \param DoTypoCorrection If true, this routine will attempt typo correction
1573 /// if there is no class with the given name.
1574 ///
1575 /// \returns The declaration of the named Objective-C class, or NULL if the
1576 /// class could not be found.
1577 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
1578                                               SourceLocation IdLoc,
1579                                               bool DoTypoCorrection) {
1580   // The third "scope" argument is 0 since we aren't enabling lazy built-in
1581   // creation from this context.
1582   NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1583 
1584   if (!IDecl && DoTypoCorrection) {
1585     // Perform typo correction at the given location, but only if we
1586     // find an Objective-C class name.
1587     if (TypoCorrection C = CorrectTypo(
1588             DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr,
1589             llvm::make_unique<DeclFilterCCC<ObjCInterfaceDecl>>(),
1590             CTK_ErrorRecovery)) {
1591       diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1592       IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1593       Id = IDecl->getIdentifier();
1594     }
1595   }
1596   ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1597   // This routine must always return a class definition, if any.
1598   if (Def && Def->getDefinition())
1599       Def = Def->getDefinition();
1600   return Def;
1601 }
1602 
1603 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
1604 /// from S, where a non-field would be declared. This routine copes
1605 /// with the difference between C and C++ scoping rules in structs and
1606 /// unions. For example, the following code is well-formed in C but
1607 /// ill-formed in C++:
1608 /// @code
1609 /// struct S6 {
1610 ///   enum { BAR } e;
1611 /// };
1612 ///
1613 /// void test_S6() {
1614 ///   struct S6 a;
1615 ///   a.e = BAR;
1616 /// }
1617 /// @endcode
1618 /// For the declaration of BAR, this routine will return a different
1619 /// scope. The scope S will be the scope of the unnamed enumeration
1620 /// within S6. In C++, this routine will return the scope associated
1621 /// with S6, because the enumeration's scope is a transparent
1622 /// context but structures can contain non-field names. In C, this
1623 /// routine will return the translation unit scope, since the
1624 /// enumeration's scope is a transparent context and structures cannot
1625 /// contain non-field names.
1626 Scope *Sema::getNonFieldDeclScope(Scope *S) {
1627   while (((S->getFlags() & Scope::DeclScope) == 0) ||
1628          (S->getEntity() && S->getEntity()->isTransparentContext()) ||
1629          (S->isClassScope() && !getLangOpts().CPlusPlus))
1630     S = S->getParent();
1631   return S;
1632 }
1633 
1634 /// \brief Looks up the declaration of "struct objc_super" and
1635 /// saves it for later use in building builtin declaration of
1636 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1637 /// pre-existing declaration exists no action takes place.
1638 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1639                                         IdentifierInfo *II) {
1640   if (!II->isStr("objc_msgSendSuper"))
1641     return;
1642   ASTContext &Context = ThisSema.Context;
1643 
1644   LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1645                       SourceLocation(), Sema::LookupTagName);
1646   ThisSema.LookupName(Result, S);
1647   if (Result.getResultKind() == LookupResult::Found)
1648     if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1649       Context.setObjCSuperType(Context.getTagDeclType(TD));
1650 }
1651 
1652 static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) {
1653   switch (Error) {
1654   case ASTContext::GE_None:
1655     return "";
1656   case ASTContext::GE_Missing_stdio:
1657     return "stdio.h";
1658   case ASTContext::GE_Missing_setjmp:
1659     return "setjmp.h";
1660   case ASTContext::GE_Missing_ucontext:
1661     return "ucontext.h";
1662   }
1663   llvm_unreachable("unhandled error kind");
1664 }
1665 
1666 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1667 /// file scope.  lazily create a decl for it. ForRedeclaration is true
1668 /// if we're creating this built-in in anticipation of redeclaring the
1669 /// built-in.
1670 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID,
1671                                      Scope *S, bool ForRedeclaration,
1672                                      SourceLocation Loc) {
1673   LookupPredefedObjCSuperType(*this, S, II);
1674 
1675   ASTContext::GetBuiltinTypeError Error;
1676   QualType R = Context.GetBuiltinType(ID, Error);
1677   if (Error) {
1678     if (ForRedeclaration)
1679       Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1680           << getHeaderName(Error)
1681           << Context.BuiltinInfo.GetName(ID);
1682     return nullptr;
1683   }
1684 
1685   if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(ID)) {
1686     Diag(Loc, diag::ext_implicit_lib_function_decl)
1687       << Context.BuiltinInfo.GetName(ID)
1688       << R;
1689     if (Context.BuiltinInfo.getHeaderName(ID) &&
1690         !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
1691       Diag(Loc, diag::note_include_header_or_declare)
1692           << Context.BuiltinInfo.getHeaderName(ID)
1693           << Context.BuiltinInfo.GetName(ID);
1694   }
1695 
1696   DeclContext *Parent = Context.getTranslationUnitDecl();
1697   if (getLangOpts().CPlusPlus) {
1698     LinkageSpecDecl *CLinkageDecl =
1699         LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1700                                 LinkageSpecDecl::lang_c, false);
1701     CLinkageDecl->setImplicit();
1702     Parent->addDecl(CLinkageDecl);
1703     Parent = CLinkageDecl;
1704   }
1705 
1706   FunctionDecl *New = FunctionDecl::Create(Context,
1707                                            Parent,
1708                                            Loc, Loc, II, R, /*TInfo=*/nullptr,
1709                                            SC_Extern,
1710                                            false,
1711                                            /*hasPrototype=*/true);
1712   New->setImplicit();
1713 
1714   // Create Decl objects for each parameter, adding them to the
1715   // FunctionDecl.
1716   if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
1717     SmallVector<ParmVarDecl*, 16> Params;
1718     for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1719       ParmVarDecl *parm =
1720           ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(),
1721                               nullptr, FT->getParamType(i), /*TInfo=*/nullptr,
1722                               SC_None, nullptr);
1723       parm->setScopeInfo(0, i);
1724       Params.push_back(parm);
1725     }
1726     New->setParams(Params);
1727   }
1728 
1729   AddKnownFunctionAttributes(New);
1730   RegisterLocallyScopedExternCDecl(New, S);
1731 
1732   // TUScope is the translation-unit scope to insert this function into.
1733   // FIXME: This is hideous. We need to teach PushOnScopeChains to
1734   // relate Scopes to DeclContexts, and probably eliminate CurContext
1735   // entirely, but we're not there yet.
1736   DeclContext *SavedContext = CurContext;
1737   CurContext = Parent;
1738   PushOnScopeChains(New, TUScope);
1739   CurContext = SavedContext;
1740   return New;
1741 }
1742 
1743 /// \brief Filter out any previous declarations that the given declaration
1744 /// should not consider because they are not permitted to conflict, e.g.,
1745 /// because they come from hidden sub-modules and do not refer to the same
1746 /// entity.
1747 static void filterNonConflictingPreviousDecls(ASTContext &context,
1748                                               NamedDecl *decl,
1749                                               LookupResult &previous){
1750   // This is only interesting when modules are enabled.
1751   if (!context.getLangOpts().Modules)
1752     return;
1753 
1754   // Empty sets are uninteresting.
1755   if (previous.empty())
1756     return;
1757 
1758   LookupResult::Filter filter = previous.makeFilter();
1759   while (filter.hasNext()) {
1760     NamedDecl *old = filter.next();
1761 
1762     // Non-hidden declarations are never ignored.
1763     if (!old->isHidden())
1764       continue;
1765 
1766     if (!old->isExternallyVisible())
1767       filter.erase();
1768   }
1769 
1770   filter.done();
1771 }
1772 
1773 /// Typedef declarations don't have linkage, but they still denote the same
1774 /// entity if their types are the same.
1775 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1776 /// isSameEntity.
1777 static void filterNonConflictingPreviousTypedefDecls(ASTContext &Context,
1778                                                      TypedefNameDecl *Decl,
1779                                                      LookupResult &Previous) {
1780   // This is only interesting when modules are enabled.
1781   if (!Context.getLangOpts().Modules)
1782     return;
1783 
1784   // Empty sets are uninteresting.
1785   if (Previous.empty())
1786     return;
1787 
1788   LookupResult::Filter Filter = Previous.makeFilter();
1789   while (Filter.hasNext()) {
1790     NamedDecl *Old = Filter.next();
1791 
1792     // Non-hidden declarations are never ignored.
1793     if (!Old->isHidden())
1794       continue;
1795 
1796     // Declarations of the same entity are not ignored, even if they have
1797     // different linkages.
1798     if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old))
1799       if (Context.hasSameType(OldTD->getUnderlyingType(),
1800                               Decl->getUnderlyingType()))
1801         continue;
1802 
1803     if (!Old->isExternallyVisible())
1804       Filter.erase();
1805   }
1806 
1807   Filter.done();
1808 }
1809 
1810 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
1811   QualType OldType;
1812   if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1813     OldType = OldTypedef->getUnderlyingType();
1814   else
1815     OldType = Context.getTypeDeclType(Old);
1816   QualType NewType = New->getUnderlyingType();
1817 
1818   if (NewType->isVariablyModifiedType()) {
1819     // Must not redefine a typedef with a variably-modified type.
1820     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1821     Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1822       << Kind << NewType;
1823     if (Old->getLocation().isValid())
1824       Diag(Old->getLocation(), diag::note_previous_definition);
1825     New->setInvalidDecl();
1826     return true;
1827   }
1828 
1829   if (OldType != NewType &&
1830       !OldType->isDependentType() &&
1831       !NewType->isDependentType() &&
1832       !Context.hasSameType(OldType, NewType)) {
1833     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1834     Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1835       << Kind << NewType << OldType;
1836     if (Old->getLocation().isValid())
1837       Diag(Old->getLocation(), diag::note_previous_definition);
1838     New->setInvalidDecl();
1839     return true;
1840   }
1841   return false;
1842 }
1843 
1844 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
1845 /// same name and scope as a previous declaration 'Old'.  Figure out
1846 /// how to resolve this situation, merging decls or emitting
1847 /// diagnostics as appropriate. If there was an error, set New to be invalid.
1848 ///
1849 void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
1850   // If the new decl is known invalid already, don't bother doing any
1851   // merging checks.
1852   if (New->isInvalidDecl()) return;
1853 
1854   // Allow multiple definitions for ObjC built-in typedefs.
1855   // FIXME: Verify the underlying types are equivalent!
1856   if (getLangOpts().ObjC1) {
1857     const IdentifierInfo *TypeID = New->getIdentifier();
1858     switch (TypeID->getLength()) {
1859     default: break;
1860     case 2:
1861       {
1862         if (!TypeID->isStr("id"))
1863           break;
1864         QualType T = New->getUnderlyingType();
1865         if (!T->isPointerType())
1866           break;
1867         if (!T->isVoidPointerType()) {
1868           QualType PT = T->getAs<PointerType>()->getPointeeType();
1869           if (!PT->isStructureType())
1870             break;
1871         }
1872         Context.setObjCIdRedefinitionType(T);
1873         // Install the built-in type for 'id', ignoring the current definition.
1874         New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
1875         return;
1876       }
1877     case 5:
1878       if (!TypeID->isStr("Class"))
1879         break;
1880       Context.setObjCClassRedefinitionType(New->getUnderlyingType());
1881       // Install the built-in type for 'Class', ignoring the current definition.
1882       New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
1883       return;
1884     case 3:
1885       if (!TypeID->isStr("SEL"))
1886         break;
1887       Context.setObjCSelRedefinitionType(New->getUnderlyingType());
1888       // Install the built-in type for 'SEL', ignoring the current definition.
1889       New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
1890       return;
1891     }
1892     // Fall through - the typedef name was not a builtin type.
1893   }
1894 
1895   // Verify the old decl was also a type.
1896   TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1897   if (!Old) {
1898     Diag(New->getLocation(), diag::err_redefinition_different_kind)
1899       << New->getDeclName();
1900 
1901     NamedDecl *OldD = OldDecls.getRepresentativeDecl();
1902     if (OldD->getLocation().isValid())
1903       Diag(OldD->getLocation(), diag::note_previous_definition);
1904 
1905     return New->setInvalidDecl();
1906   }
1907 
1908   // If the old declaration is invalid, just give up here.
1909   if (Old->isInvalidDecl())
1910     return New->setInvalidDecl();
1911 
1912   // If the typedef types are not identical, reject them in all languages and
1913   // with any extensions enabled.
1914   if (isIncompatibleTypedef(Old, New))
1915     return;
1916 
1917   // The types match.  Link up the redeclaration chain and merge attributes if
1918   // the old declaration was a typedef.
1919   if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
1920     New->setPreviousDecl(Typedef);
1921     mergeDeclAttributes(New, Old);
1922   }
1923 
1924   if (getLangOpts().MicrosoftExt)
1925     return;
1926 
1927   if (getLangOpts().CPlusPlus) {
1928     // C++ [dcl.typedef]p2:
1929     //   In a given non-class scope, a typedef specifier can be used to
1930     //   redefine the name of any type declared in that scope to refer
1931     //   to the type to which it already refers.
1932     if (!isa<CXXRecordDecl>(CurContext))
1933       return;
1934 
1935     // C++0x [dcl.typedef]p4:
1936     //   In a given class scope, a typedef specifier can be used to redefine
1937     //   any class-name declared in that scope that is not also a typedef-name
1938     //   to refer to the type to which it already refers.
1939     //
1940     // This wording came in via DR424, which was a correction to the
1941     // wording in DR56, which accidentally banned code like:
1942     //
1943     //   struct S {
1944     //     typedef struct A { } A;
1945     //   };
1946     //
1947     // in the C++03 standard. We implement the C++0x semantics, which
1948     // allow the above but disallow
1949     //
1950     //   struct S {
1951     //     typedef int I;
1952     //     typedef int I;
1953     //   };
1954     //
1955     // since that was the intent of DR56.
1956     if (!isa<TypedefNameDecl>(Old))
1957       return;
1958 
1959     Diag(New->getLocation(), diag::err_redefinition)
1960       << New->getDeclName();
1961     Diag(Old->getLocation(), diag::note_previous_definition);
1962     return New->setInvalidDecl();
1963   }
1964 
1965   // Modules always permit redefinition of typedefs, as does C11.
1966   if (getLangOpts().Modules || getLangOpts().C11)
1967     return;
1968 
1969   // If we have a redefinition of a typedef in C, emit a warning.  This warning
1970   // is normally mapped to an error, but can be controlled with
1971   // -Wtypedef-redefinition.  If either the original or the redefinition is
1972   // in a system header, don't emit this for compatibility with GCC.
1973   if (getDiagnostics().getSuppressSystemWarnings() &&
1974       (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
1975        Context.getSourceManager().isInSystemHeader(New->getLocation())))
1976     return;
1977 
1978   Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
1979     << New->getDeclName();
1980   Diag(Old->getLocation(), diag::note_previous_definition);
1981   return;
1982 }
1983 
1984 /// DeclhasAttr - returns true if decl Declaration already has the target
1985 /// attribute.
1986 static bool DeclHasAttr(const Decl *D, const Attr *A) {
1987   const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
1988   const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
1989   for (const auto *i : D->attrs())
1990     if (i->getKind() == A->getKind()) {
1991       if (Ann) {
1992         if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
1993           return true;
1994         continue;
1995       }
1996       // FIXME: Don't hardcode this check
1997       if (OA && isa<OwnershipAttr>(i))
1998         return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
1999       return true;
2000     }
2001 
2002   return false;
2003 }
2004 
2005 static bool isAttributeTargetADefinition(Decl *D) {
2006   if (VarDecl *VD = dyn_cast<VarDecl>(D))
2007     return VD->isThisDeclarationADefinition();
2008   if (TagDecl *TD = dyn_cast<TagDecl>(D))
2009     return TD->isCompleteDefinition() || TD->isBeingDefined();
2010   return true;
2011 }
2012 
2013 /// Merge alignment attributes from \p Old to \p New, taking into account the
2014 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
2015 ///
2016 /// \return \c true if any attributes were added to \p New.
2017 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
2018   // Look for alignas attributes on Old, and pick out whichever attribute
2019   // specifies the strictest alignment requirement.
2020   AlignedAttr *OldAlignasAttr = nullptr;
2021   AlignedAttr *OldStrictestAlignAttr = nullptr;
2022   unsigned OldAlign = 0;
2023   for (auto *I : Old->specific_attrs<AlignedAttr>()) {
2024     // FIXME: We have no way of representing inherited dependent alignments
2025     // in a case like:
2026     //   template<int A, int B> struct alignas(A) X;
2027     //   template<int A, int B> struct alignas(B) X {};
2028     // For now, we just ignore any alignas attributes which are not on the
2029     // definition in such a case.
2030     if (I->isAlignmentDependent())
2031       return false;
2032 
2033     if (I->isAlignas())
2034       OldAlignasAttr = I;
2035 
2036     unsigned Align = I->getAlignment(S.Context);
2037     if (Align > OldAlign) {
2038       OldAlign = Align;
2039       OldStrictestAlignAttr = I;
2040     }
2041   }
2042 
2043   // Look for alignas attributes on New.
2044   AlignedAttr *NewAlignasAttr = nullptr;
2045   unsigned NewAlign = 0;
2046   for (auto *I : New->specific_attrs<AlignedAttr>()) {
2047     if (I->isAlignmentDependent())
2048       return false;
2049 
2050     if (I->isAlignas())
2051       NewAlignasAttr = I;
2052 
2053     unsigned Align = I->getAlignment(S.Context);
2054     if (Align > NewAlign)
2055       NewAlign = Align;
2056   }
2057 
2058   if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2059     // Both declarations have 'alignas' attributes. We require them to match.
2060     // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2061     // fall short. (If two declarations both have alignas, they must both match
2062     // every definition, and so must match each other if there is a definition.)
2063 
2064     // If either declaration only contains 'alignas(0)' specifiers, then it
2065     // specifies the natural alignment for the type.
2066     if (OldAlign == 0 || NewAlign == 0) {
2067       QualType Ty;
2068       if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2069         Ty = VD->getType();
2070       else
2071         Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2072 
2073       if (OldAlign == 0)
2074         OldAlign = S.Context.getTypeAlign(Ty);
2075       if (NewAlign == 0)
2076         NewAlign = S.Context.getTypeAlign(Ty);
2077     }
2078 
2079     if (OldAlign != NewAlign) {
2080       S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2081         << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2082         << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2083       S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2084     }
2085   }
2086 
2087   if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2088     // C++11 [dcl.align]p6:
2089     //   if any declaration of an entity has an alignment-specifier,
2090     //   every defining declaration of that entity shall specify an
2091     //   equivalent alignment.
2092     // C11 6.7.5/7:
2093     //   If the definition of an object does not have an alignment
2094     //   specifier, any other declaration of that object shall also
2095     //   have no alignment specifier.
2096     S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2097       << OldAlignasAttr;
2098     S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2099       << OldAlignasAttr;
2100   }
2101 
2102   bool AnyAdded = false;
2103 
2104   // Ensure we have an attribute representing the strictest alignment.
2105   if (OldAlign > NewAlign) {
2106     AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2107     Clone->setInherited(true);
2108     New->addAttr(Clone);
2109     AnyAdded = true;
2110   }
2111 
2112   // Ensure we have an alignas attribute if the old declaration had one.
2113   if (OldAlignasAttr && !NewAlignasAttr &&
2114       !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2115     AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2116     Clone->setInherited(true);
2117     New->addAttr(Clone);
2118     AnyAdded = true;
2119   }
2120 
2121   return AnyAdded;
2122 }
2123 
2124 static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2125                                const InheritableAttr *Attr, bool Override) {
2126   InheritableAttr *NewAttr = nullptr;
2127   unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
2128   if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2129     NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2130                                       AA->getIntroduced(), AA->getDeprecated(),
2131                                       AA->getObsoleted(), AA->getUnavailable(),
2132                                       AA->getMessage(), Override,
2133                                       AttrSpellingListIndex);
2134   else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2135     NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2136                                     AttrSpellingListIndex);
2137   else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2138     NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2139                                         AttrSpellingListIndex);
2140   else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2141     NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2142                                    AttrSpellingListIndex);
2143   else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2144     NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2145                                    AttrSpellingListIndex);
2146   else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2147     NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2148                                 FA->getFormatIdx(), FA->getFirstArg(),
2149                                 AttrSpellingListIndex);
2150   else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2151     NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2152                                  AttrSpellingListIndex);
2153   else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2154     NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2155                                        AttrSpellingListIndex,
2156                                        IA->getSemanticSpelling());
2157   else if (isa<AlignedAttr>(Attr))
2158     // AlignedAttrs are handled separately, because we need to handle all
2159     // such attributes on a declaration at the same time.
2160     NewAttr = nullptr;
2161   else if (isa<DeprecatedAttr>(Attr) && Override)
2162     NewAttr = nullptr;
2163   else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
2164     NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2165 
2166   if (NewAttr) {
2167     NewAttr->setInherited(true);
2168     D->addAttr(NewAttr);
2169     return true;
2170   }
2171 
2172   return false;
2173 }
2174 
2175 static const Decl *getDefinition(const Decl *D) {
2176   if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2177     return TD->getDefinition();
2178   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2179     const VarDecl *Def = VD->getDefinition();
2180     if (Def)
2181       return Def;
2182     return VD->getActingDefinition();
2183   }
2184   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2185     const FunctionDecl* Def;
2186     if (FD->isDefined(Def))
2187       return Def;
2188   }
2189   return nullptr;
2190 }
2191 
2192 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2193   for (const auto *Attribute : D->attrs())
2194     if (Attribute->getKind() == Kind)
2195       return true;
2196   return false;
2197 }
2198 
2199 /// checkNewAttributesAfterDef - If we already have a definition, check that
2200 /// there are no new attributes in this declaration.
2201 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2202   if (!New->hasAttrs())
2203     return;
2204 
2205   const Decl *Def = getDefinition(Old);
2206   if (!Def || Def == New)
2207     return;
2208 
2209   AttrVec &NewAttributes = New->getAttrs();
2210   for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2211     const Attr *NewAttribute = NewAttributes[I];
2212 
2213     if (isa<AliasAttr>(NewAttribute)) {
2214       if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New))
2215         S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def));
2216       else {
2217         VarDecl *VD = cast<VarDecl>(New);
2218         unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2219                                 VarDecl::TentativeDefinition
2220                             ? diag::err_alias_after_tentative
2221                             : diag::err_redefinition;
2222         S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2223         S.Diag(Def->getLocation(), diag::note_previous_definition);
2224         VD->setInvalidDecl();
2225       }
2226       ++I;
2227       continue;
2228     }
2229 
2230     if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2231       // Tentative definitions are only interesting for the alias check above.
2232       if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2233         ++I;
2234         continue;
2235       }
2236     }
2237 
2238     if (hasAttribute(Def, NewAttribute->getKind())) {
2239       ++I;
2240       continue; // regular attr merging will take care of validating this.
2241     }
2242 
2243     if (isa<C11NoReturnAttr>(NewAttribute)) {
2244       // C's _Noreturn is allowed to be added to a function after it is defined.
2245       ++I;
2246       continue;
2247     } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2248       if (AA->isAlignas()) {
2249         // C++11 [dcl.align]p6:
2250         //   if any declaration of an entity has an alignment-specifier,
2251         //   every defining declaration of that entity shall specify an
2252         //   equivalent alignment.
2253         // C11 6.7.5/7:
2254         //   If the definition of an object does not have an alignment
2255         //   specifier, any other declaration of that object shall also
2256         //   have no alignment specifier.
2257         S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2258           << AA;
2259         S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2260           << AA;
2261         NewAttributes.erase(NewAttributes.begin() + I);
2262         --E;
2263         continue;
2264       }
2265     }
2266 
2267     S.Diag(NewAttribute->getLocation(),
2268            diag::warn_attribute_precede_definition);
2269     S.Diag(Def->getLocation(), diag::note_previous_definition);
2270     NewAttributes.erase(NewAttributes.begin() + I);
2271     --E;
2272   }
2273 }
2274 
2275 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2276 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
2277                                AvailabilityMergeKind AMK) {
2278   if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2279     UsedAttr *NewAttr = OldAttr->clone(Context);
2280     NewAttr->setInherited(true);
2281     New->addAttr(NewAttr);
2282   }
2283 
2284   if (!Old->hasAttrs() && !New->hasAttrs())
2285     return;
2286 
2287   // attributes declared post-definition are currently ignored
2288   checkNewAttributesAfterDef(*this, New, Old);
2289 
2290   if (!Old->hasAttrs())
2291     return;
2292 
2293   bool foundAny = New->hasAttrs();
2294 
2295   // Ensure that any moving of objects within the allocated map is done before
2296   // we process them.
2297   if (!foundAny) New->setAttrs(AttrVec());
2298 
2299   for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2300     bool Override = false;
2301     // Ignore deprecated/unavailable/availability attributes if requested.
2302     if (isa<DeprecatedAttr>(I) ||
2303         isa<UnavailableAttr>(I) ||
2304         isa<AvailabilityAttr>(I)) {
2305       switch (AMK) {
2306       case AMK_None:
2307         continue;
2308 
2309       case AMK_Redeclaration:
2310         break;
2311 
2312       case AMK_Override:
2313         Override = true;
2314         break;
2315       }
2316     }
2317 
2318     // Already handled.
2319     if (isa<UsedAttr>(I))
2320       continue;
2321 
2322     if (mergeDeclAttribute(*this, New, I, Override))
2323       foundAny = true;
2324   }
2325 
2326   if (mergeAlignedAttrs(*this, New, Old))
2327     foundAny = true;
2328 
2329   if (!foundAny) New->dropAttrs();
2330 }
2331 
2332 /// mergeParamDeclAttributes - Copy attributes from the old parameter
2333 /// to the new one.
2334 static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2335                                      const ParmVarDecl *oldDecl,
2336                                      Sema &S) {
2337   // C++11 [dcl.attr.depend]p2:
2338   //   The first declaration of a function shall specify the
2339   //   carries_dependency attribute for its declarator-id if any declaration
2340   //   of the function specifies the carries_dependency attribute.
2341   const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2342   if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2343     S.Diag(CDA->getLocation(),
2344            diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2345     // Find the first declaration of the parameter.
2346     // FIXME: Should we build redeclaration chains for function parameters?
2347     const FunctionDecl *FirstFD =
2348       cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2349     const ParmVarDecl *FirstVD =
2350       FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2351     S.Diag(FirstVD->getLocation(),
2352            diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2353   }
2354 
2355   if (!oldDecl->hasAttrs())
2356     return;
2357 
2358   bool foundAny = newDecl->hasAttrs();
2359 
2360   // Ensure that any moving of objects within the allocated map is
2361   // done before we process them.
2362   if (!foundAny) newDecl->setAttrs(AttrVec());
2363 
2364   for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2365     if (!DeclHasAttr(newDecl, I)) {
2366       InheritableAttr *newAttr =
2367         cast<InheritableParamAttr>(I->clone(S.Context));
2368       newAttr->setInherited(true);
2369       newDecl->addAttr(newAttr);
2370       foundAny = true;
2371     }
2372   }
2373 
2374   if (!foundAny) newDecl->dropAttrs();
2375 }
2376 
2377 namespace {
2378 
2379 /// Used in MergeFunctionDecl to keep track of function parameters in
2380 /// C.
2381 struct GNUCompatibleParamWarning {
2382   ParmVarDecl *OldParm;
2383   ParmVarDecl *NewParm;
2384   QualType PromotedType;
2385 };
2386 
2387 }
2388 
2389 /// getSpecialMember - get the special member enum for a method.
2390 Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
2391   if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
2392     if (Ctor->isDefaultConstructor())
2393       return Sema::CXXDefaultConstructor;
2394 
2395     if (Ctor->isCopyConstructor())
2396       return Sema::CXXCopyConstructor;
2397 
2398     if (Ctor->isMoveConstructor())
2399       return Sema::CXXMoveConstructor;
2400   } else if (isa<CXXDestructorDecl>(MD)) {
2401     return Sema::CXXDestructor;
2402   } else if (MD->isCopyAssignmentOperator()) {
2403     return Sema::CXXCopyAssignment;
2404   } else if (MD->isMoveAssignmentOperator()) {
2405     return Sema::CXXMoveAssignment;
2406   }
2407 
2408   return Sema::CXXInvalid;
2409 }
2410 
2411 // Determine whether the previous declaration was a definition, implicit
2412 // declaration, or a declaration.
2413 template <typename T>
2414 static std::pair<diag::kind, SourceLocation>
2415 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2416   diag::kind PrevDiag;
2417   SourceLocation OldLocation = Old->getLocation();
2418   if (Old->isThisDeclarationADefinition())
2419     PrevDiag = diag::note_previous_definition;
2420   else if (Old->isImplicit()) {
2421     PrevDiag = diag::note_previous_implicit_declaration;
2422     if (OldLocation.isInvalid())
2423       OldLocation = New->getLocation();
2424   } else
2425     PrevDiag = diag::note_previous_declaration;
2426   return std::make_pair(PrevDiag, OldLocation);
2427 }
2428 
2429 /// canRedefineFunction - checks if a function can be redefined. Currently,
2430 /// only extern inline functions can be redefined, and even then only in
2431 /// GNU89 mode.
2432 static bool canRedefineFunction(const FunctionDecl *FD,
2433                                 const LangOptions& LangOpts) {
2434   return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2435           !LangOpts.CPlusPlus &&
2436           FD->isInlineSpecified() &&
2437           FD->getStorageClass() == SC_Extern);
2438 }
2439 
2440 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
2441   const AttributedType *AT = T->getAs<AttributedType>();
2442   while (AT && !AT->isCallingConv())
2443     AT = AT->getModifiedType()->getAs<AttributedType>();
2444   return AT;
2445 }
2446 
2447 template <typename T>
2448 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
2449   const DeclContext *DC = Old->getDeclContext();
2450   if (DC->isRecord())
2451     return false;
2452 
2453   LanguageLinkage OldLinkage = Old->getLanguageLinkage();
2454   if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
2455     return true;
2456   if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
2457     return true;
2458   return false;
2459 }
2460 
2461 /// MergeFunctionDecl - We just parsed a function 'New' from
2462 /// declarator D which has the same name and scope as a previous
2463 /// declaration 'Old'.  Figure out how to resolve this situation,
2464 /// merging decls or emitting diagnostics as appropriate.
2465 ///
2466 /// In C++, New and Old must be declarations that are not
2467 /// overloaded. Use IsOverload to determine whether New and Old are
2468 /// overloaded, and to select the Old declaration that New should be
2469 /// merged with.
2470 ///
2471 /// Returns true if there was an error, false otherwise.
2472 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
2473                              Scope *S, bool MergeTypeWithOld) {
2474   // Verify the old decl was also a function.
2475   FunctionDecl *Old = OldD->getAsFunction();
2476   if (!Old) {
2477     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
2478       if (New->getFriendObjectKind()) {
2479         Diag(New->getLocation(), diag::err_using_decl_friend);
2480         Diag(Shadow->getTargetDecl()->getLocation(),
2481              diag::note_using_decl_target);
2482         Diag(Shadow->getUsingDecl()->getLocation(),
2483              diag::note_using_decl) << 0;
2484         return true;
2485       }
2486 
2487       // C++11 [namespace.udecl]p14:
2488       //   If a function declaration in namespace scope or block scope has the
2489       //   same name and the same parameter-type-list as a function introduced
2490       //   by a using-declaration, and the declarations do not declare the same
2491       //   function, the program is ill-formed.
2492 
2493       // Check whether the two declarations might declare the same function.
2494       Old = dyn_cast<FunctionDecl>(Shadow->getTargetDecl());
2495       if (Old &&
2496           !Old->getDeclContext()->getRedeclContext()->Equals(
2497               New->getDeclContext()->getRedeclContext()) &&
2498           !(Old->isExternC() && New->isExternC()))
2499         Old = nullptr;
2500 
2501       if (!Old) {
2502         Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2503         Diag(Shadow->getTargetDecl()->getLocation(),
2504              diag::note_using_decl_target);
2505         Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2506         return true;
2507       }
2508       OldD = Old;
2509     } else {
2510       Diag(New->getLocation(), diag::err_redefinition_different_kind)
2511         << New->getDeclName();
2512       Diag(OldD->getLocation(), diag::note_previous_definition);
2513       return true;
2514     }
2515   }
2516 
2517   // If the old declaration is invalid, just give up here.
2518   if (Old->isInvalidDecl())
2519     return true;
2520 
2521   diag::kind PrevDiag;
2522   SourceLocation OldLocation;
2523   std::tie(PrevDiag, OldLocation) =
2524       getNoteDiagForInvalidRedeclaration(Old, New);
2525 
2526   // Don't complain about this if we're in GNU89 mode and the old function
2527   // is an extern inline function.
2528   // Don't complain about specializations. They are not supposed to have
2529   // storage classes.
2530   if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
2531       New->getStorageClass() == SC_Static &&
2532       Old->hasExternalFormalLinkage() &&
2533       !New->getTemplateSpecializationInfo() &&
2534       !canRedefineFunction(Old, getLangOpts())) {
2535     if (getLangOpts().MicrosoftExt) {
2536       Diag(New->getLocation(), diag::ext_static_non_static) << New;
2537       Diag(OldLocation, PrevDiag);
2538     } else {
2539       Diag(New->getLocation(), diag::err_static_non_static) << New;
2540       Diag(OldLocation, PrevDiag);
2541       return true;
2542     }
2543   }
2544 
2545 
2546   // If a function is first declared with a calling convention, but is later
2547   // declared or defined without one, all following decls assume the calling
2548   // convention of the first.
2549   //
2550   // It's OK if a function is first declared without a calling convention,
2551   // but is later declared or defined with the default calling convention.
2552   //
2553   // To test if either decl has an explicit calling convention, we look for
2554   // AttributedType sugar nodes on the type as written.  If they are missing or
2555   // were canonicalized away, we assume the calling convention was implicit.
2556   //
2557   // Note also that we DO NOT return at this point, because we still have
2558   // other tests to run.
2559   QualType OldQType = Context.getCanonicalType(Old->getType());
2560   QualType NewQType = Context.getCanonicalType(New->getType());
2561   const FunctionType *OldType = cast<FunctionType>(OldQType);
2562   const FunctionType *NewType = cast<FunctionType>(NewQType);
2563   FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2564   FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2565   bool RequiresAdjustment = false;
2566 
2567   if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
2568     FunctionDecl *First = Old->getFirstDecl();
2569     const FunctionType *FT =
2570         First->getType().getCanonicalType()->castAs<FunctionType>();
2571     FunctionType::ExtInfo FI = FT->getExtInfo();
2572     bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2573     if (!NewCCExplicit) {
2574       // Inherit the CC from the previous declaration if it was specified
2575       // there but not here.
2576       NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2577       RequiresAdjustment = true;
2578     } else {
2579       // Calling conventions aren't compatible, so complain.
2580       bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2581       Diag(New->getLocation(), diag::err_cconv_change)
2582         << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2583         << !FirstCCExplicit
2584         << (!FirstCCExplicit ? "" :
2585             FunctionType::getNameForCallConv(FI.getCC()));
2586 
2587       // Put the note on the first decl, since it is the one that matters.
2588       Diag(First->getLocation(), diag::note_previous_declaration);
2589       return true;
2590     }
2591   }
2592 
2593   // FIXME: diagnose the other way around?
2594   if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2595     NewTypeInfo = NewTypeInfo.withNoReturn(true);
2596     RequiresAdjustment = true;
2597   }
2598 
2599   // Merge regparm attribute.
2600   if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2601       OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2602     if (NewTypeInfo.getHasRegParm()) {
2603       Diag(New->getLocation(), diag::err_regparm_mismatch)
2604         << NewType->getRegParmType()
2605         << OldType->getRegParmType();
2606       Diag(OldLocation, diag::note_previous_declaration);
2607       return true;
2608     }
2609 
2610     NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2611     RequiresAdjustment = true;
2612   }
2613 
2614   // Merge ns_returns_retained attribute.
2615   if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2616     if (NewTypeInfo.getProducesResult()) {
2617       Diag(New->getLocation(), diag::err_returns_retained_mismatch);
2618       Diag(OldLocation, diag::note_previous_declaration);
2619       return true;
2620     }
2621 
2622     NewTypeInfo = NewTypeInfo.withProducesResult(true);
2623     RequiresAdjustment = true;
2624   }
2625 
2626   if (RequiresAdjustment) {
2627     const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2628     AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2629     New->setType(QualType(AdjustedType, 0));
2630     NewQType = Context.getCanonicalType(New->getType());
2631     NewType = cast<FunctionType>(NewQType);
2632   }
2633 
2634   // If this redeclaration makes the function inline, we may need to add it to
2635   // UndefinedButUsed.
2636   if (!Old->isInlined() && New->isInlined() &&
2637       !New->hasAttr<GNUInlineAttr>() &&
2638       (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) &&
2639       Old->isUsed(false) &&
2640       !Old->isDefined() && !New->isThisDeclarationADefinition())
2641     UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2642                                            SourceLocation()));
2643 
2644   // If this redeclaration makes it newly gnu_inline, we don't want to warn
2645   // about it.
2646   if (New->hasAttr<GNUInlineAttr>() &&
2647       Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2648     UndefinedButUsed.erase(Old->getCanonicalDecl());
2649   }
2650 
2651   if (getLangOpts().CPlusPlus) {
2652     // (C++98 13.1p2):
2653     //   Certain function declarations cannot be overloaded:
2654     //     -- Function declarations that differ only in the return type
2655     //        cannot be overloaded.
2656 
2657     // Go back to the type source info to compare the declared return types,
2658     // per C++1y [dcl.type.auto]p13:
2659     //   Redeclarations or specializations of a function or function template
2660     //   with a declared return type that uses a placeholder type shall also
2661     //   use that placeholder, not a deduced type.
2662     QualType OldDeclaredReturnType =
2663         (Old->getTypeSourceInfo()
2664              ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2665              : OldType)->getReturnType();
2666     QualType NewDeclaredReturnType =
2667         (New->getTypeSourceInfo()
2668              ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2669              : NewType)->getReturnType();
2670     QualType ResQT;
2671     if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2672         !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2673           New->isLocalExternDecl())) {
2674       if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2675           OldDeclaredReturnType->isObjCObjectPointerType())
2676         ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2677       if (ResQT.isNull()) {
2678         if (New->isCXXClassMember() && New->isOutOfLine())
2679           Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2680               << New << New->getReturnTypeSourceRange();
2681         else
2682           Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2683               << New->getReturnTypeSourceRange();
2684         Diag(OldLocation, PrevDiag) << Old << Old->getType()
2685                                     << Old->getReturnTypeSourceRange();
2686         return true;
2687       }
2688       else
2689         NewQType = ResQT;
2690     }
2691 
2692     QualType OldReturnType = OldType->getReturnType();
2693     QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
2694     if (OldReturnType != NewReturnType) {
2695       // If this function has a deduced return type and has already been
2696       // defined, copy the deduced value from the old declaration.
2697       AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
2698       if (OldAT && OldAT->isDeduced()) {
2699         New->setType(
2700             SubstAutoType(New->getType(),
2701                           OldAT->isDependentType() ? Context.DependentTy
2702                                                    : OldAT->getDeducedType()));
2703         NewQType = Context.getCanonicalType(
2704             SubstAutoType(NewQType,
2705                           OldAT->isDependentType() ? Context.DependentTy
2706                                                    : OldAT->getDeducedType()));
2707       }
2708     }
2709 
2710     const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2711     CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
2712     if (OldMethod && NewMethod) {
2713       // Preserve triviality.
2714       NewMethod->setTrivial(OldMethod->isTrivial());
2715 
2716       // MSVC allows explicit template specialization at class scope:
2717       // 2 CXXMethodDecls referring to the same function will be injected.
2718       // We don't want a redeclaration error.
2719       bool IsClassScopeExplicitSpecialization =
2720                               OldMethod->isFunctionTemplateSpecialization() &&
2721                               NewMethod->isFunctionTemplateSpecialization();
2722       bool isFriend = NewMethod->getFriendObjectKind();
2723 
2724       if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2725           !IsClassScopeExplicitSpecialization) {
2726         //    -- Member function declarations with the same name and the
2727         //       same parameter types cannot be overloaded if any of them
2728         //       is a static member function declaration.
2729         if (OldMethod->isStatic() != NewMethod->isStatic()) {
2730           Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
2731           Diag(OldLocation, PrevDiag) << Old << Old->getType();
2732           return true;
2733         }
2734 
2735         // C++ [class.mem]p1:
2736         //   [...] A member shall not be declared twice in the
2737         //   member-specification, except that a nested class or member
2738         //   class template can be declared and then later defined.
2739         if (ActiveTemplateInstantiations.empty()) {
2740           unsigned NewDiag;
2741           if (isa<CXXConstructorDecl>(OldMethod))
2742             NewDiag = diag::err_constructor_redeclared;
2743           else if (isa<CXXDestructorDecl>(NewMethod))
2744             NewDiag = diag::err_destructor_redeclared;
2745           else if (isa<CXXConversionDecl>(NewMethod))
2746             NewDiag = diag::err_conv_function_redeclared;
2747           else
2748             NewDiag = diag::err_member_redeclared;
2749 
2750           Diag(New->getLocation(), NewDiag);
2751         } else {
2752           Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
2753             << New << New->getType();
2754         }
2755         Diag(OldLocation, PrevDiag) << Old << Old->getType();
2756 
2757       // Complain if this is an explicit declaration of a special
2758       // member that was initially declared implicitly.
2759       //
2760       // As an exception, it's okay to befriend such methods in order
2761       // to permit the implicit constructor/destructor/operator calls.
2762       } else if (OldMethod->isImplicit()) {
2763         if (isFriend) {
2764           NewMethod->setImplicit();
2765         } else {
2766           Diag(NewMethod->getLocation(),
2767                diag::err_definition_of_implicitly_declared_member)
2768             << New << getSpecialMember(OldMethod);
2769           return true;
2770         }
2771       } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
2772         Diag(NewMethod->getLocation(),
2773              diag::err_definition_of_explicitly_defaulted_member)
2774           << getSpecialMember(OldMethod);
2775         return true;
2776       }
2777     }
2778 
2779     // C++11 [dcl.attr.noreturn]p1:
2780     //   The first declaration of a function shall specify the noreturn
2781     //   attribute if any declaration of that function specifies the noreturn
2782     //   attribute.
2783     const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
2784     if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
2785       Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
2786       Diag(Old->getFirstDecl()->getLocation(),
2787            diag::note_noreturn_missing_first_decl);
2788     }
2789 
2790     // C++11 [dcl.attr.depend]p2:
2791     //   The first declaration of a function shall specify the
2792     //   carries_dependency attribute for its declarator-id if any declaration
2793     //   of the function specifies the carries_dependency attribute.
2794     const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
2795     if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
2796       Diag(CDA->getLocation(),
2797            diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
2798       Diag(Old->getFirstDecl()->getLocation(),
2799            diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
2800     }
2801 
2802     // (C++98 8.3.5p3):
2803     //   All declarations for a function shall agree exactly in both the
2804     //   return type and the parameter-type-list.
2805     // We also want to respect all the extended bits except noreturn.
2806 
2807     // noreturn should now match unless the old type info didn't have it.
2808     QualType OldQTypeForComparison = OldQType;
2809     if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
2810       assert(OldQType == QualType(OldType, 0));
2811       const FunctionType *OldTypeForComparison
2812         = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
2813       OldQTypeForComparison = QualType(OldTypeForComparison, 0);
2814       assert(OldQTypeForComparison.isCanonical());
2815     }
2816 
2817     if (haveIncompatibleLanguageLinkages(Old, New)) {
2818       // As a special case, retain the language linkage from previous
2819       // declarations of a friend function as an extension.
2820       //
2821       // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
2822       // and is useful because there's otherwise no way to specify language
2823       // linkage within class scope.
2824       //
2825       // Check cautiously as the friend object kind isn't yet complete.
2826       if (New->getFriendObjectKind() != Decl::FOK_None) {
2827         Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
2828         Diag(OldLocation, PrevDiag);
2829       } else {
2830         Diag(New->getLocation(), diag::err_different_language_linkage) << New;
2831         Diag(OldLocation, PrevDiag);
2832         return true;
2833       }
2834     }
2835 
2836     if (OldQTypeForComparison == NewQType)
2837       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2838 
2839     if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
2840         New->isLocalExternDecl()) {
2841       // It's OK if we couldn't merge types for a local function declaraton
2842       // if either the old or new type is dependent. We'll merge the types
2843       // when we instantiate the function.
2844       return false;
2845     }
2846 
2847     // Fall through for conflicting redeclarations and redefinitions.
2848   }
2849 
2850   // C: Function types need to be compatible, not identical. This handles
2851   // duplicate function decls like "void f(int); void f(enum X);" properly.
2852   if (!getLangOpts().CPlusPlus &&
2853       Context.typesAreCompatible(OldQType, NewQType)) {
2854     const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
2855     const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
2856     const FunctionProtoType *OldProto = nullptr;
2857     if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
2858         (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
2859       // The old declaration provided a function prototype, but the
2860       // new declaration does not. Merge in the prototype.
2861       assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
2862       SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
2863       NewQType =
2864           Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
2865                                   OldProto->getExtProtoInfo());
2866       New->setType(NewQType);
2867       New->setHasInheritedPrototype();
2868 
2869       // Synthesize parameters with the same types.
2870       SmallVector<ParmVarDecl*, 16> Params;
2871       for (const auto &ParamType : OldProto->param_types()) {
2872         ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
2873                                                  SourceLocation(), nullptr,
2874                                                  ParamType, /*TInfo=*/nullptr,
2875                                                  SC_None, nullptr);
2876         Param->setScopeInfo(0, Params.size());
2877         Param->setImplicit();
2878         Params.push_back(Param);
2879       }
2880 
2881       New->setParams(Params);
2882     }
2883 
2884     return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2885   }
2886 
2887   // GNU C permits a K&R definition to follow a prototype declaration
2888   // if the declared types of the parameters in the K&R definition
2889   // match the types in the prototype declaration, even when the
2890   // promoted types of the parameters from the K&R definition differ
2891   // from the types in the prototype. GCC then keeps the types from
2892   // the prototype.
2893   //
2894   // If a variadic prototype is followed by a non-variadic K&R definition,
2895   // the K&R definition becomes variadic.  This is sort of an edge case, but
2896   // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
2897   // C99 6.9.1p8.
2898   if (!getLangOpts().CPlusPlus &&
2899       Old->hasPrototype() && !New->hasPrototype() &&
2900       New->getType()->getAs<FunctionProtoType>() &&
2901       Old->getNumParams() == New->getNumParams()) {
2902     SmallVector<QualType, 16> ArgTypes;
2903     SmallVector<GNUCompatibleParamWarning, 16> Warnings;
2904     const FunctionProtoType *OldProto
2905       = Old->getType()->getAs<FunctionProtoType>();
2906     const FunctionProtoType *NewProto
2907       = New->getType()->getAs<FunctionProtoType>();
2908 
2909     // Determine whether this is the GNU C extension.
2910     QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
2911                                                NewProto->getReturnType());
2912     bool LooseCompatible = !MergedReturn.isNull();
2913     for (unsigned Idx = 0, End = Old->getNumParams();
2914          LooseCompatible && Idx != End; ++Idx) {
2915       ParmVarDecl *OldParm = Old->getParamDecl(Idx);
2916       ParmVarDecl *NewParm = New->getParamDecl(Idx);
2917       if (Context.typesAreCompatible(OldParm->getType(),
2918                                      NewProto->getParamType(Idx))) {
2919         ArgTypes.push_back(NewParm->getType());
2920       } else if (Context.typesAreCompatible(OldParm->getType(),
2921                                             NewParm->getType(),
2922                                             /*CompareUnqualified=*/true)) {
2923         GNUCompatibleParamWarning Warn = { OldParm, NewParm,
2924                                            NewProto->getParamType(Idx) };
2925         Warnings.push_back(Warn);
2926         ArgTypes.push_back(NewParm->getType());
2927       } else
2928         LooseCompatible = false;
2929     }
2930 
2931     if (LooseCompatible) {
2932       for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
2933         Diag(Warnings[Warn].NewParm->getLocation(),
2934              diag::ext_param_promoted_not_compatible_with_prototype)
2935           << Warnings[Warn].PromotedType
2936           << Warnings[Warn].OldParm->getType();
2937         if (Warnings[Warn].OldParm->getLocation().isValid())
2938           Diag(Warnings[Warn].OldParm->getLocation(),
2939                diag::note_previous_declaration);
2940       }
2941 
2942       if (MergeTypeWithOld)
2943         New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
2944                                              OldProto->getExtProtoInfo()));
2945       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2946     }
2947 
2948     // Fall through to diagnose conflicting types.
2949   }
2950 
2951   // A function that has already been declared has been redeclared or
2952   // defined with a different type; show an appropriate diagnostic.
2953 
2954   // If the previous declaration was an implicitly-generated builtin
2955   // declaration, then at the very least we should use a specialized note.
2956   unsigned BuiltinID;
2957   if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
2958     // If it's actually a library-defined builtin function like 'malloc'
2959     // or 'printf', just warn about the incompatible redeclaration.
2960     if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
2961       Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
2962       Diag(OldLocation, diag::note_previous_builtin_declaration)
2963         << Old << Old->getType();
2964 
2965       // If this is a global redeclaration, just forget hereafter
2966       // about the "builtin-ness" of the function.
2967       //
2968       // Doing this for local extern declarations is problematic.  If
2969       // the builtin declaration remains visible, a second invalid
2970       // local declaration will produce a hard error; if it doesn't
2971       // remain visible, a single bogus local redeclaration (which is
2972       // actually only a warning) could break all the downstream code.
2973       if (!New->getLexicalDeclContext()->isFunctionOrMethod())
2974         New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
2975 
2976       return false;
2977     }
2978 
2979     PrevDiag = diag::note_previous_builtin_declaration;
2980   }
2981 
2982   Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
2983   Diag(OldLocation, PrevDiag) << Old << Old->getType();
2984   return true;
2985 }
2986 
2987 /// \brief Completes the merge of two function declarations that are
2988 /// known to be compatible.
2989 ///
2990 /// This routine handles the merging of attributes and other
2991 /// properties of function declarations from the old declaration to
2992 /// the new declaration, once we know that New is in fact a
2993 /// redeclaration of Old.
2994 ///
2995 /// \returns false
2996 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
2997                                         Scope *S, bool MergeTypeWithOld) {
2998   // Merge the attributes
2999   mergeDeclAttributes(New, Old);
3000 
3001   // Merge "pure" flag.
3002   if (Old->isPure())
3003     New->setPure();
3004 
3005   // Merge "used" flag.
3006   if (Old->getMostRecentDecl()->isUsed(false))
3007     New->setIsUsed();
3008 
3009   // Merge attributes from the parameters.  These can mismatch with K&R
3010   // declarations.
3011   if (New->getNumParams() == Old->getNumParams())
3012     for (unsigned i = 0, e = New->getNumParams(); i != e; ++i)
3013       mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i),
3014                                *this);
3015 
3016   if (getLangOpts().CPlusPlus)
3017     return MergeCXXFunctionDecl(New, Old, S);
3018 
3019   // Merge the function types so the we get the composite types for the return
3020   // and argument types. Per C11 6.2.7/4, only update the type if the old decl
3021   // was visible.
3022   QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
3023   if (!Merged.isNull() && MergeTypeWithOld)
3024     New->setType(Merged);
3025 
3026   return false;
3027 }
3028 
3029 
3030 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
3031                                 ObjCMethodDecl *oldMethod) {
3032 
3033   // Merge the attributes, including deprecated/unavailable
3034   AvailabilityMergeKind MergeKind =
3035     isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
3036                                                    : AMK_Override;
3037   mergeDeclAttributes(newMethod, oldMethod, MergeKind);
3038 
3039   // Merge attributes from the parameters.
3040   ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
3041                                        oe = oldMethod->param_end();
3042   for (ObjCMethodDecl::param_iterator
3043          ni = newMethod->param_begin(), ne = newMethod->param_end();
3044        ni != ne && oi != oe; ++ni, ++oi)
3045     mergeParamDeclAttributes(*ni, *oi, *this);
3046 
3047   CheckObjCMethodOverride(newMethod, oldMethod);
3048 }
3049 
3050 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3051 /// scope as a previous declaration 'Old'.  Figure out how to merge their types,
3052 /// emitting diagnostics as appropriate.
3053 ///
3054 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3055 /// to here in AddInitializerToDecl. We can't check them before the initializer
3056 /// is attached.
3057 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old,
3058                              bool MergeTypeWithOld) {
3059   if (New->isInvalidDecl() || Old->isInvalidDecl())
3060     return;
3061 
3062   QualType MergedT;
3063   if (getLangOpts().CPlusPlus) {
3064     if (New->getType()->isUndeducedType()) {
3065       // We don't know what the new type is until the initializer is attached.
3066       return;
3067     } else if (Context.hasSameType(New->getType(), Old->getType())) {
3068       // These could still be something that needs exception specs checked.
3069       return MergeVarDeclExceptionSpecs(New, Old);
3070     }
3071     // C++ [basic.link]p10:
3072     //   [...] the types specified by all declarations referring to a given
3073     //   object or function shall be identical, except that declarations for an
3074     //   array object can specify array types that differ by the presence or
3075     //   absence of a major array bound (8.3.4).
3076     else if (Old->getType()->isIncompleteArrayType() &&
3077              New->getType()->isArrayType()) {
3078       const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3079       const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3080       if (Context.hasSameType(OldArray->getElementType(),
3081                               NewArray->getElementType()))
3082         MergedT = New->getType();
3083     } else if (Old->getType()->isArrayType() &&
3084                New->getType()->isIncompleteArrayType()) {
3085       const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3086       const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3087       if (Context.hasSameType(OldArray->getElementType(),
3088                               NewArray->getElementType()))
3089         MergedT = Old->getType();
3090     } else if (New->getType()->isObjCObjectPointerType() &&
3091                Old->getType()->isObjCObjectPointerType()) {
3092       MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3093                                               Old->getType());
3094     }
3095   } else {
3096     // C 6.2.7p2:
3097     //   All declarations that refer to the same object or function shall have
3098     //   compatible type.
3099     MergedT = Context.mergeTypes(New->getType(), Old->getType());
3100   }
3101   if (MergedT.isNull()) {
3102     // It's OK if we couldn't merge types if either type is dependent, for a
3103     // block-scope variable. In other cases (static data members of class
3104     // templates, variable templates, ...), we require the types to be
3105     // equivalent.
3106     // FIXME: The C++ standard doesn't say anything about this.
3107     if ((New->getType()->isDependentType() ||
3108          Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3109       // If the old type was dependent, we can't merge with it, so the new type
3110       // becomes dependent for now. We'll reproduce the original type when we
3111       // instantiate the TypeSourceInfo for the variable.
3112       if (!New->getType()->isDependentType() && MergeTypeWithOld)
3113         New->setType(Context.DependentTy);
3114       return;
3115     }
3116 
3117     // FIXME: Even if this merging succeeds, some other non-visible declaration
3118     // of this variable might have an incompatible type. For instance:
3119     //
3120     //   extern int arr[];
3121     //   void f() { extern int arr[2]; }
3122     //   void g() { extern int arr[3]; }
3123     //
3124     // Neither C nor C++ requires a diagnostic for this, but we should still try
3125     // to diagnose it.
3126     Diag(New->getLocation(), diag::err_redefinition_different_type)
3127       << New->getDeclName() << New->getType() << Old->getType();
3128     Diag(Old->getLocation(), diag::note_previous_definition);
3129     return New->setInvalidDecl();
3130   }
3131 
3132   // Don't actually update the type on the new declaration if the old
3133   // declaration was an extern declaration in a different scope.
3134   if (MergeTypeWithOld)
3135     New->setType(MergedT);
3136 }
3137 
3138 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3139                                   LookupResult &Previous) {
3140   // C11 6.2.7p4:
3141   //   For an identifier with internal or external linkage declared
3142   //   in a scope in which a prior declaration of that identifier is
3143   //   visible, if the prior declaration specifies internal or
3144   //   external linkage, the type of the identifier at the later
3145   //   declaration becomes the composite type.
3146   //
3147   // If the variable isn't visible, we do not merge with its type.
3148   if (Previous.isShadowed())
3149     return false;
3150 
3151   if (S.getLangOpts().CPlusPlus) {
3152     // C++11 [dcl.array]p3:
3153     //   If there is a preceding declaration of the entity in the same
3154     //   scope in which the bound was specified, an omitted array bound
3155     //   is taken to be the same as in that earlier declaration.
3156     return NewVD->isPreviousDeclInSameBlockScope() ||
3157            (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3158             !NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3159   } else {
3160     // If the old declaration was function-local, don't merge with its
3161     // type unless we're in the same function.
3162     return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
3163            OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3164   }
3165 }
3166 
3167 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
3168 /// and scope as a previous declaration 'Old'.  Figure out how to resolve this
3169 /// situation, merging decls or emitting diagnostics as appropriate.
3170 ///
3171 /// Tentative definition rules (C99 6.9.2p2) are checked by
3172 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
3173 /// definitions here, since the initializer hasn't been attached.
3174 ///
3175 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
3176   // If the new decl is already invalid, don't do any other checking.
3177   if (New->isInvalidDecl())
3178     return;
3179 
3180   VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3181 
3182   // Verify the old decl was also a variable or variable template.
3183   VarDecl *Old = nullptr;
3184   VarTemplateDecl *OldTemplate = nullptr;
3185   if (Previous.isSingleResult()) {
3186     if (NewTemplate) {
3187       OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
3188       Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
3189     } else
3190       Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
3191   }
3192   if (!Old) {
3193     Diag(New->getLocation(), diag::err_redefinition_different_kind)
3194       << New->getDeclName();
3195     Diag(Previous.getRepresentativeDecl()->getLocation(),
3196          diag::note_previous_definition);
3197     return New->setInvalidDecl();
3198   }
3199 
3200   if (!shouldLinkPossiblyHiddenDecl(Old, New))
3201     return;
3202 
3203   // Ensure the template parameters are compatible.
3204   if (NewTemplate &&
3205       !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3206                                       OldTemplate->getTemplateParameters(),
3207                                       /*Complain=*/true, TPL_TemplateMatch))
3208     return;
3209 
3210   // C++ [class.mem]p1:
3211   //   A member shall not be declared twice in the member-specification [...]
3212   //
3213   // Here, we need only consider static data members.
3214   if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3215     Diag(New->getLocation(), diag::err_duplicate_member)
3216       << New->getIdentifier();
3217     Diag(Old->getLocation(), diag::note_previous_declaration);
3218     New->setInvalidDecl();
3219   }
3220 
3221   mergeDeclAttributes(New, Old);
3222   // Warn if an already-declared variable is made a weak_import in a subsequent
3223   // declaration
3224   if (New->hasAttr<WeakImportAttr>() &&
3225       Old->getStorageClass() == SC_None &&
3226       !Old->hasAttr<WeakImportAttr>()) {
3227     Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3228     Diag(Old->getLocation(), diag::note_previous_definition);
3229     // Remove weak_import attribute on new declaration.
3230     New->dropAttr<WeakImportAttr>();
3231   }
3232 
3233   // Merge the types.
3234   MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
3235 
3236   if (New->isInvalidDecl())
3237     return;
3238 
3239   diag::kind PrevDiag;
3240   SourceLocation OldLocation;
3241   std::tie(PrevDiag, OldLocation) =
3242       getNoteDiagForInvalidRedeclaration(Old, New);
3243 
3244   // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
3245   if (New->getStorageClass() == SC_Static &&
3246       !New->isStaticDataMember() &&
3247       Old->hasExternalFormalLinkage()) {
3248     if (getLangOpts().MicrosoftExt) {
3249       Diag(New->getLocation(), diag::ext_static_non_static)
3250           << New->getDeclName();
3251       Diag(OldLocation, PrevDiag);
3252     } else {
3253       Diag(New->getLocation(), diag::err_static_non_static)
3254           << New->getDeclName();
3255       Diag(OldLocation, PrevDiag);
3256       return New->setInvalidDecl();
3257     }
3258   }
3259   // C99 6.2.2p4:
3260   //   For an identifier declared with the storage-class specifier
3261   //   extern in a scope in which a prior declaration of that
3262   //   identifier is visible,23) if the prior declaration specifies
3263   //   internal or external linkage, the linkage of the identifier at
3264   //   the later declaration is the same as the linkage specified at
3265   //   the prior declaration. If no prior declaration is visible, or
3266   //   if the prior declaration specifies no linkage, then the
3267   //   identifier has external linkage.
3268   if (New->hasExternalStorage() && Old->hasLinkage())
3269     /* Okay */;
3270   else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
3271            !New->isStaticDataMember() &&
3272            Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
3273     Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
3274     Diag(OldLocation, PrevDiag);
3275     return New->setInvalidDecl();
3276   }
3277 
3278   // Check if extern is followed by non-extern and vice-versa.
3279   if (New->hasExternalStorage() &&
3280       !Old->hasLinkage() && Old->isLocalVarDecl()) {
3281     Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
3282     Diag(OldLocation, PrevDiag);
3283     return New->setInvalidDecl();
3284   }
3285   if (Old->hasLinkage() && New->isLocalVarDecl() &&
3286       !New->hasExternalStorage()) {
3287     Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
3288     Diag(OldLocation, PrevDiag);
3289     return New->setInvalidDecl();
3290   }
3291 
3292   // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
3293 
3294   // FIXME: The test for external storage here seems wrong? We still
3295   // need to check for mismatches.
3296   if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
3297       // Don't complain about out-of-line definitions of static members.
3298       !(Old->getLexicalDeclContext()->isRecord() &&
3299         !New->getLexicalDeclContext()->isRecord())) {
3300     Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
3301     Diag(OldLocation, PrevDiag);
3302     return New->setInvalidDecl();
3303   }
3304 
3305   if (New->getTLSKind() != Old->getTLSKind()) {
3306     if (!Old->getTLSKind()) {
3307       Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
3308       Diag(OldLocation, PrevDiag);
3309     } else if (!New->getTLSKind()) {
3310       Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
3311       Diag(OldLocation, PrevDiag);
3312     } else {
3313       // Do not allow redeclaration to change the variable between requiring
3314       // static and dynamic initialization.
3315       // FIXME: GCC allows this, but uses the TLS keyword on the first
3316       // declaration to determine the kind. Do we need to be compatible here?
3317       Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3318         << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
3319       Diag(OldLocation, PrevDiag);
3320     }
3321   }
3322 
3323   // C++ doesn't have tentative definitions, so go right ahead and check here.
3324   const VarDecl *Def;
3325   if (getLangOpts().CPlusPlus &&
3326       New->isThisDeclarationADefinition() == VarDecl::Definition &&
3327       (Def = Old->getDefinition())) {
3328     Diag(New->getLocation(), diag::err_redefinition) << New;
3329     Diag(Def->getLocation(), diag::note_previous_definition);
3330     New->setInvalidDecl();
3331     return;
3332   }
3333 
3334   if (haveIncompatibleLanguageLinkages(Old, New)) {
3335     Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3336     Diag(OldLocation, PrevDiag);
3337     New->setInvalidDecl();
3338     return;
3339   }
3340 
3341   // Merge "used" flag.
3342   if (Old->getMostRecentDecl()->isUsed(false))
3343     New->setIsUsed();
3344 
3345   // Keep a chain of previous declarations.
3346   New->setPreviousDecl(Old);
3347   if (NewTemplate)
3348     NewTemplate->setPreviousDecl(OldTemplate);
3349 
3350   // Inherit access appropriately.
3351   New->setAccess(Old->getAccess());
3352   if (NewTemplate)
3353     NewTemplate->setAccess(New->getAccess());
3354 }
3355 
3356 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3357 /// no declarator (e.g. "struct foo;") is parsed.
3358 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3359                                        DeclSpec &DS) {
3360   return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
3361 }
3362 
3363 static void HandleTagNumbering(Sema &S, const TagDecl *Tag, Scope *TagScope) {
3364   if (!S.Context.getLangOpts().CPlusPlus)
3365     return;
3366 
3367   if (isa<CXXRecordDecl>(Tag->getParent())) {
3368     // If this tag is the direct child of a class, number it if
3369     // it is anonymous.
3370     if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3371       return;
3372     MangleNumberingContext &MCtx =
3373         S.Context.getManglingNumberContext(Tag->getParent());
3374     S.Context.setManglingNumber(
3375         Tag, MCtx.getManglingNumber(Tag, TagScope->getMSLocalManglingNumber()));
3376     return;
3377   }
3378 
3379   // If this tag isn't a direct child of a class, number it if it is local.
3380   Decl *ManglingContextDecl;
3381   if (MangleNumberingContext *MCtx =
3382           S.getCurrentMangleNumberContext(Tag->getDeclContext(),
3383                                           ManglingContextDecl)) {
3384     S.Context.setManglingNumber(
3385         Tag,
3386         MCtx->getManglingNumber(Tag, TagScope->getMSLocalManglingNumber()));
3387   }
3388 }
3389 
3390 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3391 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template
3392 /// parameters to cope with template friend declarations.
3393 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3394                                        DeclSpec &DS,
3395                                        MultiTemplateParamsArg TemplateParams,
3396                                        bool IsExplicitInstantiation) {
3397   Decl *TagD = nullptr;
3398   TagDecl *Tag = nullptr;
3399   if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3400       DS.getTypeSpecType() == DeclSpec::TST_struct ||
3401       DS.getTypeSpecType() == DeclSpec::TST_interface ||
3402       DS.getTypeSpecType() == DeclSpec::TST_union ||
3403       DS.getTypeSpecType() == DeclSpec::TST_enum) {
3404     TagD = DS.getRepAsDecl();
3405 
3406     if (!TagD) // We probably had an error
3407       return nullptr;
3408 
3409     // Note that the above type specs guarantee that the
3410     // type rep is a Decl, whereas in many of the others
3411     // it's a Type.
3412     if (isa<TagDecl>(TagD))
3413       Tag = cast<TagDecl>(TagD);
3414     else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3415       Tag = CTD->getTemplatedDecl();
3416   }
3417 
3418   if (Tag) {
3419     HandleTagNumbering(*this, Tag, S);
3420     Tag->setFreeStanding();
3421     if (Tag->isInvalidDecl())
3422       return Tag;
3423   }
3424 
3425   if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3426     // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3427     // or incomplete types shall not be restrict-qualified."
3428     if (TypeQuals & DeclSpec::TQ_restrict)
3429       Diag(DS.getRestrictSpecLoc(),
3430            diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3431            << DS.getSourceRange();
3432   }
3433 
3434   if (DS.isConstexprSpecified()) {
3435     // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3436     // and definitions of functions and variables.
3437     if (Tag)
3438       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
3439         << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
3440             DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
3441             DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
3442             DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4);
3443     else
3444       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3445     // Don't emit warnings after this error.
3446     return TagD;
3447   }
3448 
3449   DiagnoseFunctionSpecifiers(DS);
3450 
3451   if (DS.isFriendSpecified()) {
3452     // If we're dealing with a decl but not a TagDecl, assume that
3453     // whatever routines created it handled the friendship aspect.
3454     if (TagD && !Tag)
3455       return nullptr;
3456     return ActOnFriendTypeDecl(S, DS, TemplateParams);
3457   }
3458 
3459   CXXScopeSpec &SS = DS.getTypeSpecScope();
3460   bool IsExplicitSpecialization =
3461     !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3462   if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3463       !IsExplicitInstantiation && !IsExplicitSpecialization) {
3464     // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3465     // nested-name-specifier unless it is an explicit instantiation
3466     // or an explicit specialization.
3467     // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3468     Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
3469       << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
3470           DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
3471           DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
3472           DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4)
3473       << SS.getRange();
3474     return nullptr;
3475   }
3476 
3477   // Track whether this decl-specifier declares anything.
3478   bool DeclaresAnything = true;
3479 
3480   // Handle anonymous struct definitions.
3481   if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
3482     if (!Record->getDeclName() && Record->isCompleteDefinition() &&
3483         DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
3484       if (getLangOpts().CPlusPlus ||
3485           Record->getDeclContext()->isRecord())
3486         return BuildAnonymousStructOrUnion(S, DS, AS, Record, Context.getPrintingPolicy());
3487 
3488       DeclaresAnything = false;
3489     }
3490   }
3491 
3492   // C11 6.7.2.1p2:
3493   //   A struct-declaration that does not declare an anonymous structure or
3494   //   anonymous union shall contain a struct-declarator-list.
3495   //
3496   // This rule also existed in C89 and C99; the grammar for struct-declaration
3497   // did not permit a struct-declaration without a struct-declarator-list.
3498   if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
3499       DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
3500     // Check for Microsoft C extension: anonymous struct/union member.
3501     // Handle 2 kinds of anonymous struct/union:
3502     //   struct STRUCT;
3503     //   union UNION;
3504     // and
3505     //   STRUCT_TYPE;  <- where STRUCT_TYPE is a typedef struct.
3506     //   UNION_TYPE;   <- where UNION_TYPE is a typedef union.
3507     if ((Tag && Tag->getDeclName()) ||
3508         DS.getTypeSpecType() == DeclSpec::TST_typename) {
3509       RecordDecl *Record = nullptr;
3510       if (Tag)
3511         Record = dyn_cast<RecordDecl>(Tag);
3512       else if (const RecordType *RT =
3513                    DS.getRepAsType().get()->getAsStructureType())
3514         Record = RT->getDecl();
3515       else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3516         Record = UT->getDecl();
3517 
3518       if (Record && getLangOpts().MicrosoftExt) {
3519         Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3520           << Record->isUnion() << DS.getSourceRange();
3521         return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3522       }
3523 
3524       DeclaresAnything = false;
3525     }
3526   }
3527 
3528   // Skip all the checks below if we have a type error.
3529   if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3530       (TagD && TagD->isInvalidDecl()))
3531     return TagD;
3532 
3533   if (getLangOpts().CPlusPlus &&
3534       DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
3535     if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3536       if (Enum->enumerator_begin() == Enum->enumerator_end() &&
3537           !Enum->getIdentifier() && !Enum->isInvalidDecl())
3538         DeclaresAnything = false;
3539 
3540   if (!DS.isMissingDeclaratorOk()) {
3541     // Customize diagnostic for a typedef missing a name.
3542     if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
3543       Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
3544         << DS.getSourceRange();
3545     else
3546       DeclaresAnything = false;
3547   }
3548 
3549   if (DS.isModulePrivateSpecified() &&
3550       Tag && Tag->getDeclContext()->isFunctionOrMethod())
3551     Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
3552       << Tag->getTagKind()
3553       << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
3554 
3555   ActOnDocumentableDecl(TagD);
3556 
3557   // C 6.7/2:
3558   //   A declaration [...] shall declare at least a declarator [...], a tag,
3559   //   or the members of an enumeration.
3560   // C++ [dcl.dcl]p3:
3561   //   [If there are no declarators], and except for the declaration of an
3562   //   unnamed bit-field, the decl-specifier-seq shall introduce one or more
3563   //   names into the program, or shall redeclare a name introduced by a
3564   //   previous declaration.
3565   if (!DeclaresAnything) {
3566     // In C, we allow this as a (popular) extension / bug. Don't bother
3567     // producing further diagnostics for redundant qualifiers after this.
3568     Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
3569     return TagD;
3570   }
3571 
3572   // C++ [dcl.stc]p1:
3573   //   If a storage-class-specifier appears in a decl-specifier-seq, [...] the
3574   //   init-declarator-list of the declaration shall not be empty.
3575   // C++ [dcl.fct.spec]p1:
3576   //   If a cv-qualifier appears in a decl-specifier-seq, the
3577   //   init-declarator-list of the declaration shall not be empty.
3578   //
3579   // Spurious qualifiers here appear to be valid in C.
3580   unsigned DiagID = diag::warn_standalone_specifier;
3581   if (getLangOpts().CPlusPlus)
3582     DiagID = diag::ext_standalone_specifier;
3583 
3584   // Note that a linkage-specification sets a storage class, but
3585   // 'extern "C" struct foo;' is actually valid and not theoretically
3586   // useless.
3587   if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
3588     if (SCS == DeclSpec::SCS_mutable)
3589       // Since mutable is not a viable storage class specifier in C, there is
3590       // no reason to treat it as an extension. Instead, diagnose as an error.
3591       Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
3592     else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
3593       Diag(DS.getStorageClassSpecLoc(), DiagID)
3594         << DeclSpec::getSpecifierName(SCS);
3595   }
3596 
3597   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
3598     Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
3599       << DeclSpec::getSpecifierName(TSCS);
3600   if (DS.getTypeQualifiers()) {
3601     if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3602       Diag(DS.getConstSpecLoc(), DiagID) << "const";
3603     if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3604       Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
3605     // Restrict is covered above.
3606     if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3607       Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
3608   }
3609 
3610   // Warn about ignored type attributes, for example:
3611   // __attribute__((aligned)) struct A;
3612   // Attributes should be placed after tag to apply to type declaration.
3613   if (!DS.getAttributes().empty()) {
3614     DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
3615     if (TypeSpecType == DeclSpec::TST_class ||
3616         TypeSpecType == DeclSpec::TST_struct ||
3617         TypeSpecType == DeclSpec::TST_interface ||
3618         TypeSpecType == DeclSpec::TST_union ||
3619         TypeSpecType == DeclSpec::TST_enum) {
3620       AttributeList* attrs = DS.getAttributes().getList();
3621       while (attrs) {
3622         Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
3623         << attrs->getName()
3624         << (TypeSpecType == DeclSpec::TST_class ? 0 :
3625             TypeSpecType == DeclSpec::TST_struct ? 1 :
3626             TypeSpecType == DeclSpec::TST_union ? 2 :
3627             TypeSpecType == DeclSpec::TST_interface ? 3 : 4);
3628         attrs = attrs->getNext();
3629       }
3630     }
3631   }
3632 
3633   return TagD;
3634 }
3635 
3636 /// We are trying to inject an anonymous member into the given scope;
3637 /// check if there's an existing declaration that can't be overloaded.
3638 ///
3639 /// \return true if this is a forbidden redeclaration
3640 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
3641                                          Scope *S,
3642                                          DeclContext *Owner,
3643                                          DeclarationName Name,
3644                                          SourceLocation NameLoc,
3645                                          unsigned diagnostic) {
3646   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
3647                  Sema::ForRedeclaration);
3648   if (!SemaRef.LookupName(R, S)) return false;
3649 
3650   if (R.getAsSingle<TagDecl>())
3651     return false;
3652 
3653   // Pick a representative declaration.
3654   NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
3655   assert(PrevDecl && "Expected a non-null Decl");
3656 
3657   if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
3658     return false;
3659 
3660   SemaRef.Diag(NameLoc, diagnostic) << Name;
3661   SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3662 
3663   return true;
3664 }
3665 
3666 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
3667 /// anonymous struct or union AnonRecord into the owning context Owner
3668 /// and scope S. This routine will be invoked just after we realize
3669 /// that an unnamed union or struct is actually an anonymous union or
3670 /// struct, e.g.,
3671 ///
3672 /// @code
3673 /// union {
3674 ///   int i;
3675 ///   float f;
3676 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
3677 ///    // f into the surrounding scope.x
3678 /// @endcode
3679 ///
3680 /// This routine is recursive, injecting the names of nested anonymous
3681 /// structs/unions into the owning context and scope as well.
3682 static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
3683                                          DeclContext *Owner,
3684                                          RecordDecl *AnonRecord,
3685                                          AccessSpecifier AS,
3686                                          SmallVectorImpl<NamedDecl *> &Chaining,
3687                                          bool MSAnonStruct) {
3688   unsigned diagKind
3689     = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
3690                             : diag::err_anonymous_struct_member_redecl;
3691 
3692   bool Invalid = false;
3693 
3694   // Look every FieldDecl and IndirectFieldDecl with a name.
3695   for (auto *D : AnonRecord->decls()) {
3696     if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
3697         cast<NamedDecl>(D)->getDeclName()) {
3698       ValueDecl *VD = cast<ValueDecl>(D);
3699       if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
3700                                        VD->getLocation(), diagKind)) {
3701         // C++ [class.union]p2:
3702         //   The names of the members of an anonymous union shall be
3703         //   distinct from the names of any other entity in the
3704         //   scope in which the anonymous union is declared.
3705         Invalid = true;
3706       } else {
3707         // C++ [class.union]p2:
3708         //   For the purpose of name lookup, after the anonymous union
3709         //   definition, the members of the anonymous union are
3710         //   considered to have been defined in the scope in which the
3711         //   anonymous union is declared.
3712         unsigned OldChainingSize = Chaining.size();
3713         if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
3714           for (auto *PI : IF->chain())
3715             Chaining.push_back(PI);
3716         else
3717           Chaining.push_back(VD);
3718 
3719         assert(Chaining.size() >= 2);
3720         NamedDecl **NamedChain =
3721           new (SemaRef.Context)NamedDecl*[Chaining.size()];
3722         for (unsigned i = 0; i < Chaining.size(); i++)
3723           NamedChain[i] = Chaining[i];
3724 
3725         IndirectFieldDecl *IndirectField = IndirectFieldDecl::Create(
3726             SemaRef.Context, Owner, VD->getLocation(), VD->getIdentifier(),
3727             VD->getType(), NamedChain, Chaining.size());
3728 
3729         for (const auto *Attr : VD->attrs())
3730           IndirectField->addAttr(Attr->clone(SemaRef.Context));
3731 
3732         IndirectField->setAccess(AS);
3733         IndirectField->setImplicit();
3734         SemaRef.PushOnScopeChains(IndirectField, S);
3735 
3736         // That includes picking up the appropriate access specifier.
3737         if (AS != AS_none) IndirectField->setAccess(AS);
3738 
3739         Chaining.resize(OldChainingSize);
3740       }
3741     }
3742   }
3743 
3744   return Invalid;
3745 }
3746 
3747 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
3748 /// a VarDecl::StorageClass. Any error reporting is up to the caller:
3749 /// illegal input values are mapped to SC_None.
3750 static StorageClass
3751 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
3752   DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
3753   assert(StorageClassSpec != DeclSpec::SCS_typedef &&
3754          "Parser allowed 'typedef' as storage class VarDecl.");
3755   switch (StorageClassSpec) {
3756   case DeclSpec::SCS_unspecified:    return SC_None;
3757   case DeclSpec::SCS_extern:
3758     if (DS.isExternInLinkageSpec())
3759       return SC_None;
3760     return SC_Extern;
3761   case DeclSpec::SCS_static:         return SC_Static;
3762   case DeclSpec::SCS_auto:           return SC_Auto;
3763   case DeclSpec::SCS_register:       return SC_Register;
3764   case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
3765     // Illegal SCSs map to None: error reporting is up to the caller.
3766   case DeclSpec::SCS_mutable:        // Fall through.
3767   case DeclSpec::SCS_typedef:        return SC_None;
3768   }
3769   llvm_unreachable("unknown storage class specifier");
3770 }
3771 
3772 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
3773   assert(Record->hasInClassInitializer());
3774 
3775   for (const auto *I : Record->decls()) {
3776     const auto *FD = dyn_cast<FieldDecl>(I);
3777     if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
3778       FD = IFD->getAnonField();
3779     if (FD && FD->hasInClassInitializer())
3780       return FD->getLocation();
3781   }
3782 
3783   llvm_unreachable("couldn't find in-class initializer");
3784 }
3785 
3786 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3787                                       SourceLocation DefaultInitLoc) {
3788   if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3789     return;
3790 
3791   S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
3792   S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
3793 }
3794 
3795 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3796                                       CXXRecordDecl *AnonUnion) {
3797   if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3798     return;
3799 
3800   checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
3801 }
3802 
3803 /// BuildAnonymousStructOrUnion - Handle the declaration of an
3804 /// anonymous structure or union. Anonymous unions are a C++ feature
3805 /// (C++ [class.union]) and a C11 feature; anonymous structures
3806 /// are a C11 feature and GNU C++ extension.
3807 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
3808                                         AccessSpecifier AS,
3809                                         RecordDecl *Record,
3810                                         const PrintingPolicy &Policy) {
3811   DeclContext *Owner = Record->getDeclContext();
3812 
3813   // Diagnose whether this anonymous struct/union is an extension.
3814   if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
3815     Diag(Record->getLocation(), diag::ext_anonymous_union);
3816   else if (!Record->isUnion() && getLangOpts().CPlusPlus)
3817     Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
3818   else if (!Record->isUnion() && !getLangOpts().C11)
3819     Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
3820 
3821   // C and C++ require different kinds of checks for anonymous
3822   // structs/unions.
3823   bool Invalid = false;
3824   if (getLangOpts().CPlusPlus) {
3825     const char *PrevSpec = nullptr;
3826     unsigned DiagID;
3827     if (Record->isUnion()) {
3828       // C++ [class.union]p6:
3829       //   Anonymous unions declared in a named namespace or in the
3830       //   global namespace shall be declared static.
3831       if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
3832           (isa<TranslationUnitDecl>(Owner) ||
3833            (isa<NamespaceDecl>(Owner) &&
3834             cast<NamespaceDecl>(Owner)->getDeclName()))) {
3835         Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
3836           << FixItHint::CreateInsertion(Record->getLocation(), "static ");
3837 
3838         // Recover by adding 'static'.
3839         DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
3840                                PrevSpec, DiagID, Policy);
3841       }
3842       // C++ [class.union]p6:
3843       //   A storage class is not allowed in a declaration of an
3844       //   anonymous union in a class scope.
3845       else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
3846                isa<RecordDecl>(Owner)) {
3847         Diag(DS.getStorageClassSpecLoc(),
3848              diag::err_anonymous_union_with_storage_spec)
3849           << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
3850 
3851         // Recover by removing the storage specifier.
3852         DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
3853                                SourceLocation(),
3854                                PrevSpec, DiagID, Context.getPrintingPolicy());
3855       }
3856     }
3857 
3858     // Ignore const/volatile/restrict qualifiers.
3859     if (DS.getTypeQualifiers()) {
3860       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3861         Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
3862           << Record->isUnion() << "const"
3863           << FixItHint::CreateRemoval(DS.getConstSpecLoc());
3864       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3865         Diag(DS.getVolatileSpecLoc(),
3866              diag::ext_anonymous_struct_union_qualified)
3867           << Record->isUnion() << "volatile"
3868           << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
3869       if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
3870         Diag(DS.getRestrictSpecLoc(),
3871              diag::ext_anonymous_struct_union_qualified)
3872           << Record->isUnion() << "restrict"
3873           << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
3874       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3875         Diag(DS.getAtomicSpecLoc(),
3876              diag::ext_anonymous_struct_union_qualified)
3877           << Record->isUnion() << "_Atomic"
3878           << FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
3879 
3880       DS.ClearTypeQualifiers();
3881     }
3882 
3883     // C++ [class.union]p2:
3884     //   The member-specification of an anonymous union shall only
3885     //   define non-static data members. [Note: nested types and
3886     //   functions cannot be declared within an anonymous union. ]
3887     for (auto *Mem : Record->decls()) {
3888       if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
3889         // C++ [class.union]p3:
3890         //   An anonymous union shall not have private or protected
3891         //   members (clause 11).
3892         assert(FD->getAccess() != AS_none);
3893         if (FD->getAccess() != AS_public) {
3894           Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
3895             << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
3896           Invalid = true;
3897         }
3898 
3899         // C++ [class.union]p1
3900         //   An object of a class with a non-trivial constructor, a non-trivial
3901         //   copy constructor, a non-trivial destructor, or a non-trivial copy
3902         //   assignment operator cannot be a member of a union, nor can an
3903         //   array of such objects.
3904         if (CheckNontrivialField(FD))
3905           Invalid = true;
3906       } else if (Mem->isImplicit()) {
3907         // Any implicit members are fine.
3908       } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
3909         // This is a type that showed up in an
3910         // elaborated-type-specifier inside the anonymous struct or
3911         // union, but which actually declares a type outside of the
3912         // anonymous struct or union. It's okay.
3913       } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
3914         if (!MemRecord->isAnonymousStructOrUnion() &&
3915             MemRecord->getDeclName()) {
3916           // Visual C++ allows type definition in anonymous struct or union.
3917           if (getLangOpts().MicrosoftExt)
3918             Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
3919               << (int)Record->isUnion();
3920           else {
3921             // This is a nested type declaration.
3922             Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
3923               << (int)Record->isUnion();
3924             Invalid = true;
3925           }
3926         } else {
3927           // This is an anonymous type definition within another anonymous type.
3928           // This is a popular extension, provided by Plan9, MSVC and GCC, but
3929           // not part of standard C++.
3930           Diag(MemRecord->getLocation(),
3931                diag::ext_anonymous_record_with_anonymous_type)
3932             << (int)Record->isUnion();
3933         }
3934       } else if (isa<AccessSpecDecl>(Mem)) {
3935         // Any access specifier is fine.
3936       } else if (isa<StaticAssertDecl>(Mem)) {
3937         // In C++1z, static_assert declarations are also fine.
3938       } else {
3939         // We have something that isn't a non-static data
3940         // member. Complain about it.
3941         unsigned DK = diag::err_anonymous_record_bad_member;
3942         if (isa<TypeDecl>(Mem))
3943           DK = diag::err_anonymous_record_with_type;
3944         else if (isa<FunctionDecl>(Mem))
3945           DK = diag::err_anonymous_record_with_function;
3946         else if (isa<VarDecl>(Mem))
3947           DK = diag::err_anonymous_record_with_static;
3948 
3949         // Visual C++ allows type definition in anonymous struct or union.
3950         if (getLangOpts().MicrosoftExt &&
3951             DK == diag::err_anonymous_record_with_type)
3952           Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
3953             << (int)Record->isUnion();
3954         else {
3955           Diag(Mem->getLocation(), DK)
3956               << (int)Record->isUnion();
3957           Invalid = true;
3958         }
3959       }
3960     }
3961 
3962     // C++11 [class.union]p8 (DR1460):
3963     //   At most one variant member of a union may have a
3964     //   brace-or-equal-initializer.
3965     if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
3966         Owner->isRecord())
3967       checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
3968                                 cast<CXXRecordDecl>(Record));
3969   }
3970 
3971   if (!Record->isUnion() && !Owner->isRecord()) {
3972     Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
3973       << (int)getLangOpts().CPlusPlus;
3974     Invalid = true;
3975   }
3976 
3977   // Mock up a declarator.
3978   Declarator Dc(DS, Declarator::MemberContext);
3979   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
3980   assert(TInfo && "couldn't build declarator info for anonymous struct/union");
3981 
3982   // Create a declaration for this anonymous struct/union.
3983   NamedDecl *Anon = nullptr;
3984   if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
3985     Anon = FieldDecl::Create(Context, OwningClass,
3986                              DS.getLocStart(),
3987                              Record->getLocation(),
3988                              /*IdentifierInfo=*/nullptr,
3989                              Context.getTypeDeclType(Record),
3990                              TInfo,
3991                              /*BitWidth=*/nullptr, /*Mutable=*/false,
3992                              /*InitStyle=*/ICIS_NoInit);
3993     Anon->setAccess(AS);
3994     if (getLangOpts().CPlusPlus)
3995       FieldCollector->Add(cast<FieldDecl>(Anon));
3996   } else {
3997     DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
3998     StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
3999     if (SCSpec == DeclSpec::SCS_mutable) {
4000       // mutable can only appear on non-static class members, so it's always
4001       // an error here
4002       Diag(Record->getLocation(), diag::err_mutable_nonmember);
4003       Invalid = true;
4004       SC = SC_None;
4005     }
4006 
4007     Anon = VarDecl::Create(Context, Owner,
4008                            DS.getLocStart(),
4009                            Record->getLocation(), /*IdentifierInfo=*/nullptr,
4010                            Context.getTypeDeclType(Record),
4011                            TInfo, SC);
4012 
4013     // Default-initialize the implicit variable. This initialization will be
4014     // trivial in almost all cases, except if a union member has an in-class
4015     // initializer:
4016     //   union { int n = 0; };
4017     ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
4018   }
4019   Anon->setImplicit();
4020 
4021   // Mark this as an anonymous struct/union type.
4022   Record->setAnonymousStructOrUnion(true);
4023 
4024   // Add the anonymous struct/union object to the current
4025   // context. We'll be referencing this object when we refer to one of
4026   // its members.
4027   Owner->addDecl(Anon);
4028 
4029   // Inject the members of the anonymous struct/union into the owning
4030   // context and into the identifier resolver chain for name lookup
4031   // purposes.
4032   SmallVector<NamedDecl*, 2> Chain;
4033   Chain.push_back(Anon);
4034 
4035   if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
4036                                           Chain, false))
4037     Invalid = true;
4038 
4039   if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
4040     if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
4041       Decl *ManglingContextDecl;
4042       if (MangleNumberingContext *MCtx =
4043               getCurrentMangleNumberContext(NewVD->getDeclContext(),
4044                                             ManglingContextDecl)) {
4045         Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber()));
4046         Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4047       }
4048     }
4049   }
4050 
4051   if (Invalid)
4052     Anon->setInvalidDecl();
4053 
4054   return Anon;
4055 }
4056 
4057 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4058 /// Microsoft C anonymous structure.
4059 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4060 /// Example:
4061 ///
4062 /// struct A { int a; };
4063 /// struct B { struct A; int b; };
4064 ///
4065 /// void foo() {
4066 ///   B var;
4067 ///   var.a = 3;
4068 /// }
4069 ///
4070 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
4071                                            RecordDecl *Record) {
4072   assert(Record && "expected a record!");
4073 
4074   // Mock up a declarator.
4075   Declarator Dc(DS, Declarator::TypeNameContext);
4076   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4077   assert(TInfo && "couldn't build declarator info for anonymous struct");
4078 
4079   auto *ParentDecl = cast<RecordDecl>(CurContext);
4080   QualType RecTy = Context.getTypeDeclType(Record);
4081 
4082   // Create a declaration for this anonymous struct.
4083   NamedDecl *Anon = FieldDecl::Create(Context,
4084                              ParentDecl,
4085                              DS.getLocStart(),
4086                              DS.getLocStart(),
4087                              /*IdentifierInfo=*/nullptr,
4088                              RecTy,
4089                              TInfo,
4090                              /*BitWidth=*/nullptr, /*Mutable=*/false,
4091                              /*InitStyle=*/ICIS_NoInit);
4092   Anon->setImplicit();
4093 
4094   // Add the anonymous struct object to the current context.
4095   CurContext->addDecl(Anon);
4096 
4097   // Inject the members of the anonymous struct into the current
4098   // context and into the identifier resolver chain for name lookup
4099   // purposes.
4100   SmallVector<NamedDecl*, 2> Chain;
4101   Chain.push_back(Anon);
4102 
4103   RecordDecl *RecordDef = Record->getDefinition();
4104   if (RequireCompleteType(Anon->getLocation(), RecTy,
4105                           diag::err_field_incomplete) ||
4106       InjectAnonymousStructOrUnionMembers(*this, S, CurContext, RecordDef,
4107                                           AS_none, Chain, true)) {
4108     Anon->setInvalidDecl();
4109     ParentDecl->setInvalidDecl();
4110   }
4111 
4112   return Anon;
4113 }
4114 
4115 /// GetNameForDeclarator - Determine the full declaration name for the
4116 /// given Declarator.
4117 DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
4118   return GetNameFromUnqualifiedId(D.getName());
4119 }
4120 
4121 /// \brief Retrieves the declaration name from a parsed unqualified-id.
4122 DeclarationNameInfo
4123 Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
4124   DeclarationNameInfo NameInfo;
4125   NameInfo.setLoc(Name.StartLocation);
4126 
4127   switch (Name.getKind()) {
4128 
4129   case UnqualifiedId::IK_ImplicitSelfParam:
4130   case UnqualifiedId::IK_Identifier:
4131     NameInfo.setName(Name.Identifier);
4132     NameInfo.setLoc(Name.StartLocation);
4133     return NameInfo;
4134 
4135   case UnqualifiedId::IK_OperatorFunctionId:
4136     NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
4137                                            Name.OperatorFunctionId.Operator));
4138     NameInfo.setLoc(Name.StartLocation);
4139     NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
4140       = Name.OperatorFunctionId.SymbolLocations[0];
4141     NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
4142       = Name.EndLocation.getRawEncoding();
4143     return NameInfo;
4144 
4145   case UnqualifiedId::IK_LiteralOperatorId:
4146     NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
4147                                                            Name.Identifier));
4148     NameInfo.setLoc(Name.StartLocation);
4149     NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
4150     return NameInfo;
4151 
4152   case UnqualifiedId::IK_ConversionFunctionId: {
4153     TypeSourceInfo *TInfo;
4154     QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4155     if (Ty.isNull())
4156       return DeclarationNameInfo();
4157     NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
4158                                                Context.getCanonicalType(Ty)));
4159     NameInfo.setLoc(Name.StartLocation);
4160     NameInfo.setNamedTypeInfo(TInfo);
4161     return NameInfo;
4162   }
4163 
4164   case UnqualifiedId::IK_ConstructorName: {
4165     TypeSourceInfo *TInfo;
4166     QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4167     if (Ty.isNull())
4168       return DeclarationNameInfo();
4169     NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4170                                               Context.getCanonicalType(Ty)));
4171     NameInfo.setLoc(Name.StartLocation);
4172     NameInfo.setNamedTypeInfo(TInfo);
4173     return NameInfo;
4174   }
4175 
4176   case UnqualifiedId::IK_ConstructorTemplateId: {
4177     // In well-formed code, we can only have a constructor
4178     // template-id that refers to the current context, so go there
4179     // to find the actual type being constructed.
4180     CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4181     if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4182       return DeclarationNameInfo();
4183 
4184     // Determine the type of the class being constructed.
4185     QualType CurClassType = Context.getTypeDeclType(CurClass);
4186 
4187     // FIXME: Check two things: that the template-id names the same type as
4188     // CurClassType, and that the template-id does not occur when the name
4189     // was qualified.
4190 
4191     NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4192                                     Context.getCanonicalType(CurClassType)));
4193     NameInfo.setLoc(Name.StartLocation);
4194     // FIXME: should we retrieve TypeSourceInfo?
4195     NameInfo.setNamedTypeInfo(nullptr);
4196     return NameInfo;
4197   }
4198 
4199   case UnqualifiedId::IK_DestructorName: {
4200     TypeSourceInfo *TInfo;
4201     QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4202     if (Ty.isNull())
4203       return DeclarationNameInfo();
4204     NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
4205                                               Context.getCanonicalType(Ty)));
4206     NameInfo.setLoc(Name.StartLocation);
4207     NameInfo.setNamedTypeInfo(TInfo);
4208     return NameInfo;
4209   }
4210 
4211   case UnqualifiedId::IK_TemplateId: {
4212     TemplateName TName = Name.TemplateId->Template.get();
4213     SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4214     return Context.getNameForTemplate(TName, TNameLoc);
4215   }
4216 
4217   } // switch (Name.getKind())
4218 
4219   llvm_unreachable("Unknown name kind");
4220 }
4221 
4222 static QualType getCoreType(QualType Ty) {
4223   do {
4224     if (Ty->isPointerType() || Ty->isReferenceType())
4225       Ty = Ty->getPointeeType();
4226     else if (Ty->isArrayType())
4227       Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4228     else
4229       return Ty.withoutLocalFastQualifiers();
4230   } while (true);
4231 }
4232 
4233 /// hasSimilarParameters - Determine whether the C++ functions Declaration
4234 /// and Definition have "nearly" matching parameters. This heuristic is
4235 /// used to improve diagnostics in the case where an out-of-line function
4236 /// definition doesn't match any declaration within the class or namespace.
4237 /// Also sets Params to the list of indices to the parameters that differ
4238 /// between the declaration and the definition. If hasSimilarParameters
4239 /// returns true and Params is empty, then all of the parameters match.
4240 static bool hasSimilarParameters(ASTContext &Context,
4241                                      FunctionDecl *Declaration,
4242                                      FunctionDecl *Definition,
4243                                      SmallVectorImpl<unsigned> &Params) {
4244   Params.clear();
4245   if (Declaration->param_size() != Definition->param_size())
4246     return false;
4247   for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4248     QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4249     QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4250 
4251     // The parameter types are identical
4252     if (Context.hasSameType(DefParamTy, DeclParamTy))
4253       continue;
4254 
4255     QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4256     QualType DefParamBaseTy = getCoreType(DefParamTy);
4257     const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4258     const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4259 
4260     if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4261         (DeclTyName && DeclTyName == DefTyName))
4262       Params.push_back(Idx);
4263     else  // The two parameters aren't even close
4264       return false;
4265   }
4266 
4267   return true;
4268 }
4269 
4270 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4271 /// declarator needs to be rebuilt in the current instantiation.
4272 /// Any bits of declarator which appear before the name are valid for
4273 /// consideration here.  That's specifically the type in the decl spec
4274 /// and the base type in any member-pointer chunks.
4275 static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
4276                                                     DeclarationName Name) {
4277   // The types we specifically need to rebuild are:
4278   //   - typenames, typeofs, and decltypes
4279   //   - types which will become injected class names
4280   // Of course, we also need to rebuild any type referencing such a
4281   // type.  It's safest to just say "dependent", but we call out a
4282   // few cases here.
4283 
4284   DeclSpec &DS = D.getMutableDeclSpec();
4285   switch (DS.getTypeSpecType()) {
4286   case DeclSpec::TST_typename:
4287   case DeclSpec::TST_typeofType:
4288   case DeclSpec::TST_underlyingType:
4289   case DeclSpec::TST_atomic: {
4290     // Grab the type from the parser.
4291     TypeSourceInfo *TSI = nullptr;
4292     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
4293     if (T.isNull() || !T->isDependentType()) break;
4294 
4295     // Make sure there's a type source info.  This isn't really much
4296     // of a waste; most dependent types should have type source info
4297     // attached already.
4298     if (!TSI)
4299       TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
4300 
4301     // Rebuild the type in the current instantiation.
4302     TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
4303     if (!TSI) return true;
4304 
4305     // Store the new type back in the decl spec.
4306     ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4307     DS.UpdateTypeRep(LocType);
4308     break;
4309   }
4310 
4311   case DeclSpec::TST_decltype:
4312   case DeclSpec::TST_typeofExpr: {
4313     Expr *E = DS.getRepAsExpr();
4314     ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
4315     if (Result.isInvalid()) return true;
4316     DS.UpdateExprRep(Result.get());
4317     break;
4318   }
4319 
4320   default:
4321     // Nothing to do for these decl specs.
4322     break;
4323   }
4324 
4325   // It doesn't matter what order we do this in.
4326   for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4327     DeclaratorChunk &Chunk = D.getTypeObject(I);
4328 
4329     // The only type information in the declarator which can come
4330     // before the declaration name is the base type of a member
4331     // pointer.
4332     if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4333       continue;
4334 
4335     // Rebuild the scope specifier in-place.
4336     CXXScopeSpec &SS = Chunk.Mem.Scope();
4337     if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
4338       return true;
4339   }
4340 
4341   return false;
4342 }
4343 
4344 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
4345   D.setFunctionDefinitionKind(FDK_Declaration);
4346   Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
4347 
4348   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
4349       Dcl && Dcl->getDeclContext()->isFileContext())
4350     Dcl->setTopLevelDeclInObjCContainer();
4351 
4352   return Dcl;
4353 }
4354 
4355 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4356 ///   If T is the name of a class, then each of the following shall have a
4357 ///   name different from T:
4358 ///     - every static data member of class T;
4359 ///     - every member function of class T
4360 ///     - every member of class T that is itself a type;
4361 /// \returns true if the declaration name violates these rules.
4362 bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
4363                                    DeclarationNameInfo NameInfo) {
4364   DeclarationName Name = NameInfo.getName();
4365 
4366   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
4367     if (Record->getIdentifier() && Record->getDeclName() == Name) {
4368       Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4369       return true;
4370     }
4371 
4372   return false;
4373 }
4374 
4375 /// \brief Diagnose a declaration whose declarator-id has the given
4376 /// nested-name-specifier.
4377 ///
4378 /// \param SS The nested-name-specifier of the declarator-id.
4379 ///
4380 /// \param DC The declaration context to which the nested-name-specifier
4381 /// resolves.
4382 ///
4383 /// \param Name The name of the entity being declared.
4384 ///
4385 /// \param Loc The location of the name of the entity being declared.
4386 ///
4387 /// \returns true if we cannot safely recover from this error, false otherwise.
4388 bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
4389                                         DeclarationName Name,
4390                                         SourceLocation Loc) {
4391   DeclContext *Cur = CurContext;
4392   while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
4393     Cur = Cur->getParent();
4394 
4395   // If the user provided a superfluous scope specifier that refers back to the
4396   // class in which the entity is already declared, diagnose and ignore it.
4397   //
4398   // class X {
4399   //   void X::f();
4400   // };
4401   //
4402   // Note, it was once ill-formed to give redundant qualification in all
4403   // contexts, but that rule was removed by DR482.
4404   if (Cur->Equals(DC)) {
4405     if (Cur->isRecord()) {
4406       Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4407                                       : diag::err_member_extra_qualification)
4408         << Name << FixItHint::CreateRemoval(SS.getRange());
4409       SS.clear();
4410     } else {
4411       Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4412     }
4413     return false;
4414   }
4415 
4416   // Check whether the qualifying scope encloses the scope of the original
4417   // declaration.
4418   if (!Cur->Encloses(DC)) {
4419     if (Cur->isRecord())
4420       Diag(Loc, diag::err_member_qualification)
4421         << Name << SS.getRange();
4422     else if (isa<TranslationUnitDecl>(DC))
4423       Diag(Loc, diag::err_invalid_declarator_global_scope)
4424         << Name << SS.getRange();
4425     else if (isa<FunctionDecl>(Cur))
4426       Diag(Loc, diag::err_invalid_declarator_in_function)
4427         << Name << SS.getRange();
4428     else if (isa<BlockDecl>(Cur))
4429       Diag(Loc, diag::err_invalid_declarator_in_block)
4430         << Name << SS.getRange();
4431     else
4432       Diag(Loc, diag::err_invalid_declarator_scope)
4433       << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
4434 
4435     return true;
4436   }
4437 
4438   if (Cur->isRecord()) {
4439     // Cannot qualify members within a class.
4440     Diag(Loc, diag::err_member_qualification)
4441       << Name << SS.getRange();
4442     SS.clear();
4443 
4444     // C++ constructors and destructors with incorrect scopes can break
4445     // our AST invariants by having the wrong underlying types. If
4446     // that's the case, then drop this declaration entirely.
4447     if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
4448          Name.getNameKind() == DeclarationName::CXXDestructorName) &&
4449         !Context.hasSameType(Name.getCXXNameType(),
4450                              Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4451       return true;
4452 
4453     return false;
4454   }
4455 
4456   // C++11 [dcl.meaning]p1:
4457   //   [...] "The nested-name-specifier of the qualified declarator-id shall
4458   //   not begin with a decltype-specifer"
4459   NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4460   while (SpecLoc.getPrefix())
4461     SpecLoc = SpecLoc.getPrefix();
4462   if (dyn_cast_or_null<DecltypeType>(
4463         SpecLoc.getNestedNameSpecifier()->getAsType()))
4464     Diag(Loc, diag::err_decltype_in_declarator)
4465       << SpecLoc.getTypeLoc().getSourceRange();
4466 
4467   return false;
4468 }
4469 
4470 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
4471                                   MultiTemplateParamsArg TemplateParamLists) {
4472   // TODO: consider using NameInfo for diagnostic.
4473   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4474   DeclarationName Name = NameInfo.getName();
4475 
4476   // All of these full declarators require an identifier.  If it doesn't have
4477   // one, the ParsedFreeStandingDeclSpec action should be used.
4478   if (!Name) {
4479     if (!D.isInvalidType())  // Reject this if we think it is valid.
4480       Diag(D.getDeclSpec().getLocStart(),
4481            diag::err_declarator_need_ident)
4482         << D.getDeclSpec().getSourceRange() << D.getSourceRange();
4483     return nullptr;
4484   } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
4485     return nullptr;
4486 
4487   // The scope passed in may not be a decl scope.  Zip up the scope tree until
4488   // we find one that is.
4489   while ((S->getFlags() & Scope::DeclScope) == 0 ||
4490          (S->getFlags() & Scope::TemplateParamScope) != 0)
4491     S = S->getParent();
4492 
4493   DeclContext *DC = CurContext;
4494   if (D.getCXXScopeSpec().isInvalid())
4495     D.setInvalidType();
4496   else if (D.getCXXScopeSpec().isSet()) {
4497     if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4498                                         UPPC_DeclarationQualifier))
4499       return nullptr;
4500 
4501     bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4502     DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
4503     if (!DC || isa<EnumDecl>(DC)) {
4504       // If we could not compute the declaration context, it's because the
4505       // declaration context is dependent but does not refer to a class,
4506       // class template, or class template partial specialization. Complain
4507       // and return early, to avoid the coming semantic disaster.
4508       Diag(D.getIdentifierLoc(),
4509            diag::err_template_qualified_declarator_no_match)
4510         << D.getCXXScopeSpec().getScopeRep()
4511         << D.getCXXScopeSpec().getRange();
4512       return nullptr;
4513     }
4514     bool IsDependentContext = DC->isDependentContext();
4515 
4516     if (!IsDependentContext &&
4517         RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
4518       return nullptr;
4519 
4520     if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4521       Diag(D.getIdentifierLoc(),
4522            diag::err_member_def_undefined_record)
4523         << Name << DC << D.getCXXScopeSpec().getRange();
4524       D.setInvalidType();
4525     } else if (!D.getDeclSpec().isFriendSpecified()) {
4526       if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4527                                       Name, D.getIdentifierLoc())) {
4528         if (DC->isRecord())
4529           return nullptr;
4530 
4531         D.setInvalidType();
4532       }
4533     }
4534 
4535     // Check whether we need to rebuild the type of the given
4536     // declaration in the current instantiation.
4537     if (EnteringContext && IsDependentContext &&
4538         TemplateParamLists.size() != 0) {
4539       ContextRAII SavedContext(*this, DC);
4540       if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4541         D.setInvalidType();
4542     }
4543   }
4544 
4545   if (DiagnoseClassNameShadow(DC, NameInfo))
4546     // If this is a typedef, we'll end up spewing multiple diagnostics.
4547     // Just return early; it's safer.
4548     if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4549       return nullptr;
4550 
4551   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4552   QualType R = TInfo->getType();
4553 
4554   if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
4555                                       UPPC_DeclarationType))
4556     D.setInvalidType();
4557 
4558   LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
4559                         ForRedeclaration);
4560 
4561   // See if this is a redefinition of a variable in the same scope.
4562   if (!D.getCXXScopeSpec().isSet()) {
4563     bool IsLinkageLookup = false;
4564     bool CreateBuiltins = false;
4565 
4566     // If the declaration we're planning to build will be a function
4567     // or object with linkage, then look for another declaration with
4568     // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
4569     //
4570     // If the declaration we're planning to build will be declared with
4571     // external linkage in the translation unit, create any builtin with
4572     // the same name.
4573     if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4574       /* Do nothing*/;
4575     else if (CurContext->isFunctionOrMethod() &&
4576              (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern ||
4577               R->isFunctionType())) {
4578       IsLinkageLookup = true;
4579       CreateBuiltins =
4580           CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
4581     } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
4582                D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
4583       CreateBuiltins = true;
4584 
4585     if (IsLinkageLookup)
4586       Previous.clear(LookupRedeclarationWithLinkage);
4587 
4588     LookupName(Previous, S, CreateBuiltins);
4589   } else { // Something like "int foo::x;"
4590     LookupQualifiedName(Previous, DC);
4591 
4592     // C++ [dcl.meaning]p1:
4593     //   When the declarator-id is qualified, the declaration shall refer to a
4594     //  previously declared member of the class or namespace to which the
4595     //  qualifier refers (or, in the case of a namespace, of an element of the
4596     //  inline namespace set of that namespace (7.3.1)) or to a specialization
4597     //  thereof; [...]
4598     //
4599     // Note that we already checked the context above, and that we do not have
4600     // enough information to make sure that Previous contains the declaration
4601     // we want to match. For example, given:
4602     //
4603     //   class X {
4604     //     void f();
4605     //     void f(float);
4606     //   };
4607     //
4608     //   void X::f(int) { } // ill-formed
4609     //
4610     // In this case, Previous will point to the overload set
4611     // containing the two f's declared in X, but neither of them
4612     // matches.
4613 
4614     // C++ [dcl.meaning]p1:
4615     //   [...] the member shall not merely have been introduced by a
4616     //   using-declaration in the scope of the class or namespace nominated by
4617     //   the nested-name-specifier of the declarator-id.
4618     RemoveUsingDecls(Previous);
4619   }
4620 
4621   if (Previous.isSingleResult() &&
4622       Previous.getFoundDecl()->isTemplateParameter()) {
4623     // Maybe we will complain about the shadowed template parameter.
4624     if (!D.isInvalidType())
4625       DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
4626                                       Previous.getFoundDecl());
4627 
4628     // Just pretend that we didn't see the previous declaration.
4629     Previous.clear();
4630   }
4631 
4632   // In C++, the previous declaration we find might be a tag type
4633   // (class or enum). In this case, the new declaration will hide the
4634   // tag type. Note that this does does not apply if we're declaring a
4635   // typedef (C++ [dcl.typedef]p4).
4636   if (Previous.isSingleTagDecl() &&
4637       D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
4638     Previous.clear();
4639 
4640   // Check that there are no default arguments other than in the parameters
4641   // of a function declaration (C++ only).
4642   if (getLangOpts().CPlusPlus)
4643     CheckExtraCXXDefaultArguments(D);
4644 
4645   NamedDecl *New;
4646 
4647   bool AddToScope = true;
4648   if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
4649     if (TemplateParamLists.size()) {
4650       Diag(D.getIdentifierLoc(), diag::err_template_typedef);
4651       return nullptr;
4652     }
4653 
4654     New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
4655   } else if (R->isFunctionType()) {
4656     New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
4657                                   TemplateParamLists,
4658                                   AddToScope);
4659   } else {
4660     New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
4661                                   AddToScope);
4662   }
4663 
4664   if (!New)
4665     return nullptr;
4666 
4667   // If this has an identifier and is not an invalid redeclaration or
4668   // function template specialization, add it to the scope stack.
4669   if (New->getDeclName() && AddToScope &&
4670        !(D.isRedeclaration() && New->isInvalidDecl())) {
4671     // Only make a locally-scoped extern declaration visible if it is the first
4672     // declaration of this entity. Qualified lookup for such an entity should
4673     // only find this declaration if there is no visible declaration of it.
4674     bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
4675     PushOnScopeChains(New, S, AddToContext);
4676     if (!AddToContext)
4677       CurContext->addHiddenDecl(New);
4678   }
4679 
4680   return New;
4681 }
4682 
4683 /// Helper method to turn variable array types into constant array
4684 /// types in certain situations which would otherwise be errors (for
4685 /// GCC compatibility).
4686 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
4687                                                     ASTContext &Context,
4688                                                     bool &SizeIsNegative,
4689                                                     llvm::APSInt &Oversized) {
4690   // This method tries to turn a variable array into a constant
4691   // array even when the size isn't an ICE.  This is necessary
4692   // for compatibility with code that depends on gcc's buggy
4693   // constant expression folding, like struct {char x[(int)(char*)2];}
4694   SizeIsNegative = false;
4695   Oversized = 0;
4696 
4697   if (T->isDependentType())
4698     return QualType();
4699 
4700   QualifierCollector Qs;
4701   const Type *Ty = Qs.strip(T);
4702 
4703   if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
4704     QualType Pointee = PTy->getPointeeType();
4705     QualType FixedType =
4706         TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
4707                                             Oversized);
4708     if (FixedType.isNull()) return FixedType;
4709     FixedType = Context.getPointerType(FixedType);
4710     return Qs.apply(Context, FixedType);
4711   }
4712   if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
4713     QualType Inner = PTy->getInnerType();
4714     QualType FixedType =
4715         TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
4716                                             Oversized);
4717     if (FixedType.isNull()) return FixedType;
4718     FixedType = Context.getParenType(FixedType);
4719     return Qs.apply(Context, FixedType);
4720   }
4721 
4722   const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
4723   if (!VLATy)
4724     return QualType();
4725   // FIXME: We should probably handle this case
4726   if (VLATy->getElementType()->isVariablyModifiedType())
4727     return QualType();
4728 
4729   llvm::APSInt Res;
4730   if (!VLATy->getSizeExpr() ||
4731       !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
4732     return QualType();
4733 
4734   // Check whether the array size is negative.
4735   if (Res.isSigned() && Res.isNegative()) {
4736     SizeIsNegative = true;
4737     return QualType();
4738   }
4739 
4740   // Check whether the array is too large to be addressed.
4741   unsigned ActiveSizeBits
4742     = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
4743                                               Res);
4744   if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
4745     Oversized = Res;
4746     return QualType();
4747   }
4748 
4749   return Context.getConstantArrayType(VLATy->getElementType(),
4750                                       Res, ArrayType::Normal, 0);
4751 }
4752 
4753 static void
4754 FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
4755   if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
4756     PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
4757     FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
4758                                       DstPTL.getPointeeLoc());
4759     DstPTL.setStarLoc(SrcPTL.getStarLoc());
4760     return;
4761   }
4762   if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
4763     ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
4764     FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
4765                                       DstPTL.getInnerLoc());
4766     DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
4767     DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
4768     return;
4769   }
4770   ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
4771   ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
4772   TypeLoc SrcElemTL = SrcATL.getElementLoc();
4773   TypeLoc DstElemTL = DstATL.getElementLoc();
4774   DstElemTL.initializeFullCopy(SrcElemTL);
4775   DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
4776   DstATL.setSizeExpr(SrcATL.getSizeExpr());
4777   DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
4778 }
4779 
4780 /// Helper method to turn variable array types into constant array
4781 /// types in certain situations which would otherwise be errors (for
4782 /// GCC compatibility).
4783 static TypeSourceInfo*
4784 TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
4785                                               ASTContext &Context,
4786                                               bool &SizeIsNegative,
4787                                               llvm::APSInt &Oversized) {
4788   QualType FixedTy
4789     = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
4790                                           SizeIsNegative, Oversized);
4791   if (FixedTy.isNull())
4792     return nullptr;
4793   TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
4794   FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
4795                                     FixedTInfo->getTypeLoc());
4796   return FixedTInfo;
4797 }
4798 
4799 /// \brief Register the given locally-scoped extern "C" declaration so
4800 /// that it can be found later for redeclarations. We include any extern "C"
4801 /// declaration that is not visible in the translation unit here, not just
4802 /// function-scope declarations.
4803 void
4804 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) {
4805   if (!getLangOpts().CPlusPlus &&
4806       ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
4807     // Don't need to track declarations in the TU in C.
4808     return;
4809 
4810   // Note that we have a locally-scoped external with this name.
4811   // FIXME: There can be multiple such declarations if they are functions marked
4812   // __attribute__((overloadable)) declared in function scope in C.
4813   LocallyScopedExternCDecls[ND->getDeclName()] = ND;
4814 }
4815 
4816 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
4817   if (ExternalSource) {
4818     // Load locally-scoped external decls from the external source.
4819     // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls?
4820     SmallVector<NamedDecl *, 4> Decls;
4821     ExternalSource->ReadLocallyScopedExternCDecls(Decls);
4822     for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
4823       llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4824         = LocallyScopedExternCDecls.find(Decls[I]->getDeclName());
4825       if (Pos == LocallyScopedExternCDecls.end())
4826         LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I];
4827     }
4828   }
4829 
4830   NamedDecl *D = LocallyScopedExternCDecls.lookup(Name);
4831   return D ? D->getMostRecentDecl() : nullptr;
4832 }
4833 
4834 /// \brief Diagnose function specifiers on a declaration of an identifier that
4835 /// does not identify a function.
4836 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
4837   // FIXME: We should probably indicate the identifier in question to avoid
4838   // confusion for constructs like "inline int a(), b;"
4839   if (DS.isInlineSpecified())
4840     Diag(DS.getInlineSpecLoc(),
4841          diag::err_inline_non_function);
4842 
4843   if (DS.isVirtualSpecified())
4844     Diag(DS.getVirtualSpecLoc(),
4845          diag::err_virtual_non_function);
4846 
4847   if (DS.isExplicitSpecified())
4848     Diag(DS.getExplicitSpecLoc(),
4849          diag::err_explicit_non_function);
4850 
4851   if (DS.isNoreturnSpecified())
4852     Diag(DS.getNoreturnSpecLoc(),
4853          diag::err_noreturn_non_function);
4854 }
4855 
4856 NamedDecl*
4857 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
4858                              TypeSourceInfo *TInfo, LookupResult &Previous) {
4859   // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
4860   if (D.getCXXScopeSpec().isSet()) {
4861     Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
4862       << D.getCXXScopeSpec().getRange();
4863     D.setInvalidType();
4864     // Pretend we didn't see the scope specifier.
4865     DC = CurContext;
4866     Previous.clear();
4867   }
4868 
4869   DiagnoseFunctionSpecifiers(D.getDeclSpec());
4870 
4871   if (D.getDeclSpec().isConstexprSpecified())
4872     Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
4873       << 1;
4874 
4875   if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
4876     Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
4877       << D.getName().getSourceRange();
4878     return nullptr;
4879   }
4880 
4881   TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
4882   if (!NewTD) return nullptr;
4883 
4884   // Handle attributes prior to checking for duplicates in MergeVarDecl
4885   ProcessDeclAttributes(S, NewTD, D);
4886 
4887   CheckTypedefForVariablyModifiedType(S, NewTD);
4888 
4889   bool Redeclaration = D.isRedeclaration();
4890   NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
4891   D.setRedeclaration(Redeclaration);
4892   return ND;
4893 }
4894 
4895 void
4896 Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
4897   // C99 6.7.7p2: If a typedef name specifies a variably modified type
4898   // then it shall have block scope.
4899   // Note that variably modified types must be fixed before merging the decl so
4900   // that redeclarations will match.
4901   TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
4902   QualType T = TInfo->getType();
4903   if (T->isVariablyModifiedType()) {
4904     getCurFunction()->setHasBranchProtectedScope();
4905 
4906     if (S->getFnParent() == nullptr) {
4907       bool SizeIsNegative;
4908       llvm::APSInt Oversized;
4909       TypeSourceInfo *FixedTInfo =
4910         TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
4911                                                       SizeIsNegative,
4912                                                       Oversized);
4913       if (FixedTInfo) {
4914         Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
4915         NewTD->setTypeSourceInfo(FixedTInfo);
4916       } else {
4917         if (SizeIsNegative)
4918           Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
4919         else if (T->isVariableArrayType())
4920           Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
4921         else if (Oversized.getBoolValue())
4922           Diag(NewTD->getLocation(), diag::err_array_too_large)
4923             << Oversized.toString(10);
4924         else
4925           Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
4926         NewTD->setInvalidDecl();
4927       }
4928     }
4929   }
4930 }
4931 
4932 
4933 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
4934 /// declares a typedef-name, either using the 'typedef' type specifier or via
4935 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
4936 NamedDecl*
4937 Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
4938                            LookupResult &Previous, bool &Redeclaration) {
4939   // Merge the decl with the existing one if appropriate. If the decl is
4940   // in an outer scope, it isn't the same thing.
4941   FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
4942                        /*AllowInlineNamespace*/false);
4943   filterNonConflictingPreviousTypedefDecls(Context, NewTD, Previous);
4944   if (!Previous.empty()) {
4945     Redeclaration = true;
4946     MergeTypedefNameDecl(NewTD, Previous);
4947   }
4948 
4949   // If this is the C FILE type, notify the AST context.
4950   if (IdentifierInfo *II = NewTD->getIdentifier())
4951     if (!NewTD->isInvalidDecl() &&
4952         NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
4953       if (II->isStr("FILE"))
4954         Context.setFILEDecl(NewTD);
4955       else if (II->isStr("jmp_buf"))
4956         Context.setjmp_bufDecl(NewTD);
4957       else if (II->isStr("sigjmp_buf"))
4958         Context.setsigjmp_bufDecl(NewTD);
4959       else if (II->isStr("ucontext_t"))
4960         Context.setucontext_tDecl(NewTD);
4961     }
4962 
4963   return NewTD;
4964 }
4965 
4966 /// \brief Determines whether the given declaration is an out-of-scope
4967 /// previous declaration.
4968 ///
4969 /// This routine should be invoked when name lookup has found a
4970 /// previous declaration (PrevDecl) that is not in the scope where a
4971 /// new declaration by the same name is being introduced. If the new
4972 /// declaration occurs in a local scope, previous declarations with
4973 /// linkage may still be considered previous declarations (C99
4974 /// 6.2.2p4-5, C++ [basic.link]p6).
4975 ///
4976 /// \param PrevDecl the previous declaration found by name
4977 /// lookup
4978 ///
4979 /// \param DC the context in which the new declaration is being
4980 /// declared.
4981 ///
4982 /// \returns true if PrevDecl is an out-of-scope previous declaration
4983 /// for a new delcaration with the same name.
4984 static bool
4985 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
4986                                 ASTContext &Context) {
4987   if (!PrevDecl)
4988     return false;
4989 
4990   if (!PrevDecl->hasLinkage())
4991     return false;
4992 
4993   if (Context.getLangOpts().CPlusPlus) {
4994     // C++ [basic.link]p6:
4995     //   If there is a visible declaration of an entity with linkage
4996     //   having the same name and type, ignoring entities declared
4997     //   outside the innermost enclosing namespace scope, the block
4998     //   scope declaration declares that same entity and receives the
4999     //   linkage of the previous declaration.
5000     DeclContext *OuterContext = DC->getRedeclContext();
5001     if (!OuterContext->isFunctionOrMethod())
5002       // This rule only applies to block-scope declarations.
5003       return false;
5004 
5005     DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
5006     if (PrevOuterContext->isRecord())
5007       // We found a member function: ignore it.
5008       return false;
5009 
5010     // Find the innermost enclosing namespace for the new and
5011     // previous declarations.
5012     OuterContext = OuterContext->getEnclosingNamespaceContext();
5013     PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
5014 
5015     // The previous declaration is in a different namespace, so it
5016     // isn't the same function.
5017     if (!OuterContext->Equals(PrevOuterContext))
5018       return false;
5019   }
5020 
5021   return true;
5022 }
5023 
5024 static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
5025   CXXScopeSpec &SS = D.getCXXScopeSpec();
5026   if (!SS.isSet()) return;
5027   DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
5028 }
5029 
5030 bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
5031   QualType type = decl->getType();
5032   Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
5033   if (lifetime == Qualifiers::OCL_Autoreleasing) {
5034     // Various kinds of declaration aren't allowed to be __autoreleasing.
5035     unsigned kind = -1U;
5036     if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5037       if (var->hasAttr<BlocksAttr>())
5038         kind = 0; // __block
5039       else if (!var->hasLocalStorage())
5040         kind = 1; // global
5041     } else if (isa<ObjCIvarDecl>(decl)) {
5042       kind = 3; // ivar
5043     } else if (isa<FieldDecl>(decl)) {
5044       kind = 2; // field
5045     }
5046 
5047     if (kind != -1U) {
5048       Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
5049         << kind;
5050     }
5051   } else if (lifetime == Qualifiers::OCL_None) {
5052     // Try to infer lifetime.
5053     if (!type->isObjCLifetimeType())
5054       return false;
5055 
5056     lifetime = type->getObjCARCImplicitLifetime();
5057     type = Context.getLifetimeQualifiedType(type, lifetime);
5058     decl->setType(type);
5059   }
5060 
5061   if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5062     // Thread-local variables cannot have lifetime.
5063     if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
5064         var->getTLSKind()) {
5065       Diag(var->getLocation(), diag::err_arc_thread_ownership)
5066         << var->getType();
5067       return true;
5068     }
5069   }
5070 
5071   return false;
5072 }
5073 
5074 static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
5075   // Ensure that an auto decl is deduced otherwise the checks below might cache
5076   // the wrong linkage.
5077   assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5078 
5079   // 'weak' only applies to declarations with external linkage.
5080   if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
5081     if (!ND.isExternallyVisible()) {
5082       S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5083       ND.dropAttr<WeakAttr>();
5084     }
5085   }
5086   if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
5087     if (ND.isExternallyVisible()) {
5088       S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5089       ND.dropAttr<WeakRefAttr>();
5090     }
5091   }
5092 
5093   // 'selectany' only applies to externally visible varable declarations.
5094   // It does not apply to functions.
5095   if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5096     if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
5097       S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data);
5098       ND.dropAttr<SelectAnyAttr>();
5099     }
5100   }
5101 
5102   // dll attributes require external linkage.
5103   if (const InheritableAttr *Attr = getDLLAttr(&ND)) {
5104     if (!ND.isExternallyVisible()) {
5105       S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5106         << &ND << Attr;
5107       ND.setInvalidDecl();
5108     }
5109   }
5110 }
5111 
5112 static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
5113                                            NamedDecl *NewDecl,
5114                                            bool IsSpecialization) {
5115   if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl))
5116     OldDecl = OldTD->getTemplatedDecl();
5117   if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5118     NewDecl = NewTD->getTemplatedDecl();
5119 
5120   if (!OldDecl || !NewDecl)
5121     return;
5122 
5123   const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5124   const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5125   const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5126   const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5127 
5128   // dllimport and dllexport are inheritable attributes so we have to exclude
5129   // inherited attribute instances.
5130   bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5131                     (NewExportAttr && !NewExportAttr->isInherited());
5132 
5133   // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5134   // the only exception being explicit specializations.
5135   // Implicitly generated declarations are also excluded for now because there
5136   // is no other way to switch these to use dllimport or dllexport.
5137   bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
5138 
5139   if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
5140     // If the declaration hasn't been used yet, allow with a warning for
5141     // free functions and global variables.
5142     bool JustWarn = false;
5143     if (!OldDecl->isUsed() && !OldDecl->isCXXClassMember()) {
5144       auto *VD = dyn_cast<VarDecl>(OldDecl);
5145       if (VD && !VD->getDescribedVarTemplate())
5146         JustWarn = true;
5147       auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5148       if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5149         JustWarn = true;
5150     }
5151 
5152     unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5153                                : diag::err_attribute_dll_redeclaration;
5154     S.Diag(NewDecl->getLocation(), DiagID)
5155         << NewDecl
5156         << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
5157     S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5158     if (!JustWarn) {
5159       NewDecl->setInvalidDecl();
5160       return;
5161     }
5162   }
5163 
5164   // A redeclaration is not allowed to drop a dllimport attribute, the only
5165   // exceptions being inline function definitions, local extern declarations,
5166   // and qualified friend declarations.
5167   // NB: MSVC converts such a declaration to dllexport.
5168   bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
5169   if (const auto *VD = dyn_cast<VarDecl>(NewDecl))
5170     // Ignore static data because out-of-line definitions are diagnosed
5171     // separately.
5172     IsStaticDataMember = VD->isStaticDataMember();
5173   else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
5174     IsInline = FD->isInlined();
5175     IsQualifiedFriend = FD->getQualifier() &&
5176                         FD->getFriendObjectKind() == Decl::FOK_Declared;
5177   }
5178 
5179   if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
5180       !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
5181     S.Diag(NewDecl->getLocation(),
5182            diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5183       << NewDecl << OldImportAttr;
5184     S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5185     S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5186     OldDecl->dropAttr<DLLImportAttr>();
5187     NewDecl->dropAttr<DLLImportAttr>();
5188   } else if (IsInline && OldImportAttr &&
5189              !S.Context.getTargetInfo().getCXXABI().isMicrosoft()) {
5190     // In MinGW, seeing a function declared inline drops the dllimport attribute.
5191     OldDecl->dropAttr<DLLImportAttr>();
5192     NewDecl->dropAttr<DLLImportAttr>();
5193     S.Diag(NewDecl->getLocation(),
5194            diag::warn_dllimport_dropped_from_inline_function)
5195         << NewDecl << OldImportAttr;
5196   }
5197 }
5198 
5199 /// Given that we are within the definition of the given function,
5200 /// will that definition behave like C99's 'inline', where the
5201 /// definition is discarded except for optimization purposes?
5202 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
5203   // Try to avoid calling GetGVALinkageForFunction.
5204 
5205   // All cases of this require the 'inline' keyword.
5206   if (!FD->isInlined()) return false;
5207 
5208   // This is only possible in C++ with the gnu_inline attribute.
5209   if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5210     return false;
5211 
5212   // Okay, go ahead and call the relatively-more-expensive function.
5213 
5214 #ifndef NDEBUG
5215   // AST quite reasonably asserts that it's working on a function
5216   // definition.  We don't really have a way to tell it that we're
5217   // currently defining the function, so just lie to it in +Asserts
5218   // builds.  This is an awful hack.
5219   FD->setLazyBody(1);
5220 #endif
5221 
5222   bool isC99Inline =
5223       S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
5224 
5225 #ifndef NDEBUG
5226   FD->setLazyBody(0);
5227 #endif
5228 
5229   return isC99Inline;
5230 }
5231 
5232 /// Determine whether a variable is extern "C" prior to attaching
5233 /// an initializer. We can't just call isExternC() here, because that
5234 /// will also compute and cache whether the declaration is externally
5235 /// visible, which might change when we attach the initializer.
5236 ///
5237 /// This can only be used if the declaration is known to not be a
5238 /// redeclaration of an internal linkage declaration.
5239 ///
5240 /// For instance:
5241 ///
5242 ///   auto x = []{};
5243 ///
5244 /// Attaching the initializer here makes this declaration not externally
5245 /// visible, because its type has internal linkage.
5246 ///
5247 /// FIXME: This is a hack.
5248 template<typename T>
5249 static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5250   if (S.getLangOpts().CPlusPlus) {
5251     // In C++, the overloadable attribute negates the effects of extern "C".
5252     if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5253       return false;
5254   }
5255   return D->isExternC();
5256 }
5257 
5258 static bool shouldConsiderLinkage(const VarDecl *VD) {
5259   const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5260   if (DC->isFunctionOrMethod())
5261     return VD->hasExternalStorage();
5262   if (DC->isFileContext())
5263     return true;
5264   if (DC->isRecord())
5265     return false;
5266   llvm_unreachable("Unexpected context");
5267 }
5268 
5269 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5270   const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5271   if (DC->isFileContext() || DC->isFunctionOrMethod())
5272     return true;
5273   if (DC->isRecord())
5274     return false;
5275   llvm_unreachable("Unexpected context");
5276 }
5277 
5278 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5279                           AttributeList::Kind Kind) {
5280   for (const AttributeList *L = AttrList; L; L = L->getNext())
5281     if (L->getKind() == Kind)
5282       return true;
5283   return false;
5284 }
5285 
5286 static bool hasParsedAttr(Scope *S, const Declarator &PD,
5287                           AttributeList::Kind Kind) {
5288   // Check decl attributes on the DeclSpec.
5289   if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind))
5290     return true;
5291 
5292   // Walk the declarator structure, checking decl attributes that were in a type
5293   // position to the decl itself.
5294   for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5295     if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5296       return true;
5297   }
5298 
5299   // Finally, check attributes on the decl itself.
5300   return hasParsedAttr(S, PD.getAttributes(), Kind);
5301 }
5302 
5303 /// Adjust the \c DeclContext for a function or variable that might be a
5304 /// function-local external declaration.
5305 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
5306   if (!DC->isFunctionOrMethod())
5307     return false;
5308 
5309   // If this is a local extern function or variable declared within a function
5310   // template, don't add it into the enclosing namespace scope until it is
5311   // instantiated; it might have a dependent type right now.
5312   if (DC->isDependentContext())
5313     return true;
5314 
5315   // C++11 [basic.link]p7:
5316   //   When a block scope declaration of an entity with linkage is not found to
5317   //   refer to some other declaration, then that entity is a member of the
5318   //   innermost enclosing namespace.
5319   //
5320   // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5321   // semantically-enclosing namespace, not a lexically-enclosing one.
5322   while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5323     DC = DC->getParent();
5324   return true;
5325 }
5326 
5327 NamedDecl *
5328 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
5329                               TypeSourceInfo *TInfo, LookupResult &Previous,
5330                               MultiTemplateParamsArg TemplateParamLists,
5331                               bool &AddToScope) {
5332   QualType R = TInfo->getType();
5333   DeclarationName Name = GetNameForDeclarator(D).getName();
5334 
5335   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
5336   StorageClass SC = StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
5337 
5338   // dllimport globals without explicit storage class are treated as extern. We
5339   // have to change the storage class this early to get the right DeclContext.
5340   if (SC == SC_None && !DC->isRecord() &&
5341       hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5342       !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
5343     SC = SC_Extern;
5344 
5345   DeclContext *OriginalDC = DC;
5346   bool IsLocalExternDecl = SC == SC_Extern &&
5347                            adjustContextForLocalExternDecl(DC);
5348 
5349   if (getLangOpts().OpenCL) {
5350     // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5351     QualType NR = R;
5352     while (NR->isPointerType()) {
5353       if (NR->isFunctionPointerType()) {
5354         Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5355         D.setInvalidType();
5356         break;
5357       }
5358       NR = NR->getPointeeType();
5359     }
5360 
5361     if (!getOpenCLOptions().cl_khr_fp16) {
5362       // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5363       // half array type (unless the cl_khr_fp16 extension is enabled).
5364       if (Context.getBaseElementType(R)->isHalfType()) {
5365         Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5366         D.setInvalidType();
5367       }
5368     }
5369   }
5370 
5371   if (SCSpec == DeclSpec::SCS_mutable) {
5372     // mutable can only appear on non-static class members, so it's always
5373     // an error here
5374     Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
5375     D.setInvalidType();
5376     SC = SC_None;
5377   }
5378 
5379   if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5380       !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5381                               D.getDeclSpec().getStorageClassSpecLoc())) {
5382     // In C++11, the 'register' storage class specifier is deprecated.
5383     // Suppress the warning in system macros, it's used in macros in some
5384     // popular C system headers, such as in glibc's htonl() macro.
5385     Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5386          diag::warn_deprecated_register)
5387       << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5388   }
5389 
5390   IdentifierInfo *II = Name.getAsIdentifierInfo();
5391   if (!II) {
5392     Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
5393       << Name;
5394     return nullptr;
5395   }
5396 
5397   DiagnoseFunctionSpecifiers(D.getDeclSpec());
5398 
5399   if (!DC->isRecord() && S->getFnParent() == nullptr) {
5400     // C99 6.9p2: The storage-class specifiers auto and register shall not
5401     // appear in the declaration specifiers in an external declaration.
5402     // Global Register+Asm is a GNU extension we support.
5403     if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5404       Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
5405       D.setInvalidType();
5406     }
5407   }
5408 
5409   if (getLangOpts().OpenCL) {
5410     // Set up the special work-group-local storage class for variables in the
5411     // OpenCL __local address space.
5412     if (R.getAddressSpace() == LangAS::opencl_local) {
5413       SC = SC_OpenCLWorkGroupLocal;
5414     }
5415 
5416     // OpenCL v1.2 s6.9.b p4:
5417     // The sampler type cannot be used with the __local and __global address
5418     // space qualifiers.
5419     if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5420       R.getAddressSpace() == LangAS::opencl_global)) {
5421       Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5422     }
5423 
5424     // OpenCL 1.2 spec, p6.9 r:
5425     // The event type cannot be used to declare a program scope variable.
5426     // The event type cannot be used with the __local, __constant and __global
5427     // address space qualifiers.
5428     if (R->isEventT()) {
5429       if (S->getParent() == nullptr) {
5430         Diag(D.getLocStart(), diag::err_event_t_global_var);
5431         D.setInvalidType();
5432       }
5433 
5434       if (R.getAddressSpace()) {
5435         Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5436         D.setInvalidType();
5437       }
5438     }
5439   }
5440 
5441   bool IsExplicitSpecialization = false;
5442   bool IsVariableTemplateSpecialization = false;
5443   bool IsPartialSpecialization = false;
5444   bool IsVariableTemplate = false;
5445   VarDecl *NewVD = nullptr;
5446   VarTemplateDecl *NewTemplate = nullptr;
5447   TemplateParameterList *TemplateParams = nullptr;
5448   if (!getLangOpts().CPlusPlus) {
5449     NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5450                             D.getIdentifierLoc(), II,
5451                             R, TInfo, SC);
5452 
5453     if (D.isInvalidType())
5454       NewVD->setInvalidDecl();
5455   } else {
5456     bool Invalid = false;
5457 
5458     if (DC->isRecord() && !CurContext->isRecord()) {
5459       // This is an out-of-line definition of a static data member.
5460       switch (SC) {
5461       case SC_None:
5462         break;
5463       case SC_Static:
5464         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5465              diag::err_static_out_of_line)
5466           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5467         break;
5468       case SC_Auto:
5469       case SC_Register:
5470       case SC_Extern:
5471         // [dcl.stc] p2: The auto or register specifiers shall be applied only
5472         // to names of variables declared in a block or to function parameters.
5473         // [dcl.stc] p6: The extern specifier cannot be used in the declaration
5474         // of class members
5475 
5476         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5477              diag::err_storage_class_for_static_member)
5478           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5479         break;
5480       case SC_PrivateExtern:
5481         llvm_unreachable("C storage class in c++!");
5482       case SC_OpenCLWorkGroupLocal:
5483         llvm_unreachable("OpenCL storage class in c++!");
5484       }
5485     }
5486 
5487     if (SC == SC_Static && CurContext->isRecord()) {
5488       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
5489         if (RD->isLocalClass())
5490           Diag(D.getIdentifierLoc(),
5491                diag::err_static_data_member_not_allowed_in_local_class)
5492             << Name << RD->getDeclName();
5493 
5494         // C++98 [class.union]p1: If a union contains a static data member,
5495         // the program is ill-formed. C++11 drops this restriction.
5496         if (RD->isUnion())
5497           Diag(D.getIdentifierLoc(),
5498                getLangOpts().CPlusPlus11
5499                  ? diag::warn_cxx98_compat_static_data_member_in_union
5500                  : diag::ext_static_data_member_in_union) << Name;
5501         // We conservatively disallow static data members in anonymous structs.
5502         else if (!RD->getDeclName())
5503           Diag(D.getIdentifierLoc(),
5504                diag::err_static_data_member_not_allowed_in_anon_struct)
5505             << Name << RD->isUnion();
5506       }
5507     }
5508 
5509     // Match up the template parameter lists with the scope specifier, then
5510     // determine whether we have a template or a template specialization.
5511     TemplateParams = MatchTemplateParametersToScopeSpecifier(
5512         D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
5513         D.getCXXScopeSpec(),
5514         D.getName().getKind() == UnqualifiedId::IK_TemplateId
5515             ? D.getName().TemplateId
5516             : nullptr,
5517         TemplateParamLists,
5518         /*never a friend*/ false, IsExplicitSpecialization, Invalid);
5519 
5520     if (TemplateParams) {
5521       if (!TemplateParams->size() &&
5522           D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
5523         // There is an extraneous 'template<>' for this variable. Complain
5524         // about it, but allow the declaration of the variable.
5525         Diag(TemplateParams->getTemplateLoc(),
5526              diag::err_template_variable_noparams)
5527           << II
5528           << SourceRange(TemplateParams->getTemplateLoc(),
5529                          TemplateParams->getRAngleLoc());
5530         TemplateParams = nullptr;
5531       } else {
5532         if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
5533           // This is an explicit specialization or a partial specialization.
5534           // FIXME: Check that we can declare a specialization here.
5535           IsVariableTemplateSpecialization = true;
5536           IsPartialSpecialization = TemplateParams->size() > 0;
5537         } else { // if (TemplateParams->size() > 0)
5538           // This is a template declaration.
5539           IsVariableTemplate = true;
5540 
5541           // Check that we can declare a template here.
5542           if (CheckTemplateDeclScope(S, TemplateParams))
5543             return nullptr;
5544 
5545           // Only C++1y supports variable templates (N3651).
5546           Diag(D.getIdentifierLoc(),
5547                getLangOpts().CPlusPlus14
5548                    ? diag::warn_cxx11_compat_variable_template
5549                    : diag::ext_variable_template);
5550         }
5551       }
5552     } else {
5553       assert(D.getName().getKind() != UnqualifiedId::IK_TemplateId &&
5554              "should have a 'template<>' for this decl");
5555     }
5556 
5557     if (IsVariableTemplateSpecialization) {
5558       SourceLocation TemplateKWLoc =
5559           TemplateParamLists.size() > 0
5560               ? TemplateParamLists[0]->getTemplateLoc()
5561               : SourceLocation();
5562       DeclResult Res = ActOnVarTemplateSpecialization(
5563           S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
5564           IsPartialSpecialization);
5565       if (Res.isInvalid())
5566         return nullptr;
5567       NewVD = cast<VarDecl>(Res.get());
5568       AddToScope = false;
5569     } else
5570       NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5571                               D.getIdentifierLoc(), II, R, TInfo, SC);
5572 
5573     // If this is supposed to be a variable template, create it as such.
5574     if (IsVariableTemplate) {
5575       NewTemplate =
5576           VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
5577                                   TemplateParams, NewVD);
5578       NewVD->setDescribedVarTemplate(NewTemplate);
5579     }
5580 
5581     // If this decl has an auto type in need of deduction, make a note of the
5582     // Decl so we can diagnose uses of it in its own initializer.
5583     if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
5584       ParsingInitForAutoVars.insert(NewVD);
5585 
5586     if (D.isInvalidType() || Invalid) {
5587       NewVD->setInvalidDecl();
5588       if (NewTemplate)
5589         NewTemplate->setInvalidDecl();
5590     }
5591 
5592     SetNestedNameSpecifier(NewVD, D);
5593 
5594     // If we have any template parameter lists that don't directly belong to
5595     // the variable (matching the scope specifier), store them.
5596     unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
5597     if (TemplateParamLists.size() > VDTemplateParamLists)
5598       NewVD->setTemplateParameterListsInfo(
5599           Context, TemplateParamLists.size() - VDTemplateParamLists,
5600           TemplateParamLists.data());
5601 
5602     if (D.getDeclSpec().isConstexprSpecified())
5603       NewVD->setConstexpr(true);
5604   }
5605 
5606   // Set the lexical context. If the declarator has a C++ scope specifier, the
5607   // lexical context will be different from the semantic context.
5608   NewVD->setLexicalDeclContext(CurContext);
5609   if (NewTemplate)
5610     NewTemplate->setLexicalDeclContext(CurContext);
5611 
5612   if (IsLocalExternDecl)
5613     NewVD->setLocalExternDecl();
5614 
5615   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
5616     if (NewVD->hasLocalStorage()) {
5617       // C++11 [dcl.stc]p4:
5618       //   When thread_local is applied to a variable of block scope the
5619       //   storage-class-specifier static is implied if it does not appear
5620       //   explicitly.
5621       // Core issue: 'static' is not implied if the variable is declared
5622       //   'extern'.
5623       if (SCSpec == DeclSpec::SCS_unspecified &&
5624           TSCS == DeclSpec::TSCS_thread_local &&
5625           DC->isFunctionOrMethod())
5626         NewVD->setTSCSpec(TSCS);
5627       else
5628         Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5629              diag::err_thread_non_global)
5630           << DeclSpec::getSpecifierName(TSCS);
5631     } else if (!Context.getTargetInfo().isTLSSupported())
5632       Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5633            diag::err_thread_unsupported);
5634     else
5635       NewVD->setTSCSpec(TSCS);
5636   }
5637 
5638   // C99 6.7.4p3
5639   //   An inline definition of a function with external linkage shall
5640   //   not contain a definition of a modifiable object with static or
5641   //   thread storage duration...
5642   // We only apply this when the function is required to be defined
5643   // elsewhere, i.e. when the function is not 'extern inline'.  Note
5644   // that a local variable with thread storage duration still has to
5645   // be marked 'static'.  Also note that it's possible to get these
5646   // semantics in C++ using __attribute__((gnu_inline)).
5647   if (SC == SC_Static && S->getFnParent() != nullptr &&
5648       !NewVD->getType().isConstQualified()) {
5649     FunctionDecl *CurFD = getCurFunctionDecl();
5650     if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
5651       Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5652            diag::warn_static_local_in_extern_inline);
5653       MaybeSuggestAddingStaticToDecl(CurFD);
5654     }
5655   }
5656 
5657   if (D.getDeclSpec().isModulePrivateSpecified()) {
5658     if (IsVariableTemplateSpecialization)
5659       Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5660           << (IsPartialSpecialization ? 1 : 0)
5661           << FixItHint::CreateRemoval(
5662                  D.getDeclSpec().getModulePrivateSpecLoc());
5663     else if (IsExplicitSpecialization)
5664       Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5665         << 2
5666         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
5667     else if (NewVD->hasLocalStorage())
5668       Diag(NewVD->getLocation(), diag::err_module_private_local)
5669         << 0 << NewVD->getDeclName()
5670         << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
5671         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
5672     else {
5673       NewVD->setModulePrivate();
5674       if (NewTemplate)
5675         NewTemplate->setModulePrivate();
5676     }
5677   }
5678 
5679   // Handle attributes prior to checking for duplicates in MergeVarDecl
5680   ProcessDeclAttributes(S, NewVD, D);
5681 
5682   if (getLangOpts().CUDA) {
5683     // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
5684     // storage [duration]."
5685     if (SC == SC_None && S->getFnParent() != nullptr &&
5686         (NewVD->hasAttr<CUDASharedAttr>() ||
5687          NewVD->hasAttr<CUDAConstantAttr>())) {
5688       NewVD->setStorageClass(SC_Static);
5689     }
5690   }
5691 
5692   // Ensure that dllimport globals without explicit storage class are treated as
5693   // extern. The storage class is set above using parsed attributes. Now we can
5694   // check the VarDecl itself.
5695   assert(!NewVD->hasAttr<DLLImportAttr>() ||
5696          NewVD->getAttr<DLLImportAttr>()->isInherited() ||
5697          NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
5698 
5699   // In auto-retain/release, infer strong retension for variables of
5700   // retainable type.
5701   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
5702     NewVD->setInvalidDecl();
5703 
5704   // Handle GNU asm-label extension (encoded as an attribute).
5705   if (Expr *E = (Expr*)D.getAsmLabel()) {
5706     // The parser guarantees this is a string.
5707     StringLiteral *SE = cast<StringLiteral>(E);
5708     StringRef Label = SE->getString();
5709     if (S->getFnParent() != nullptr) {
5710       switch (SC) {
5711       case SC_None:
5712       case SC_Auto:
5713         Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
5714         break;
5715       case SC_Register:
5716         // Local Named register
5717         if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5718           Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5719         break;
5720       case SC_Static:
5721       case SC_Extern:
5722       case SC_PrivateExtern:
5723       case SC_OpenCLWorkGroupLocal:
5724         break;
5725       }
5726     } else if (SC == SC_Register) {
5727       // Global Named register
5728       if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5729         Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5730       if (!R->isIntegralType(Context) && !R->isPointerType()) {
5731         Diag(D.getLocStart(), diag::err_asm_bad_register_type);
5732         NewVD->setInvalidDecl(true);
5733       }
5734     }
5735 
5736     NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
5737                                                 Context, Label, 0));
5738   } else if (!ExtnameUndeclaredIdentifiers.empty()) {
5739     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
5740       ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
5741     if (I != ExtnameUndeclaredIdentifiers.end()) {
5742       NewVD->addAttr(I->second);
5743       ExtnameUndeclaredIdentifiers.erase(I);
5744     }
5745   }
5746 
5747   // Diagnose shadowed variables before filtering for scope.
5748   if (D.getCXXScopeSpec().isEmpty())
5749     CheckShadow(S, NewVD, Previous);
5750 
5751   // Don't consider existing declarations that are in a different
5752   // scope and are out-of-semantic-context declarations (if the new
5753   // declaration has linkage).
5754   FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
5755                        D.getCXXScopeSpec().isNotEmpty() ||
5756                        IsExplicitSpecialization ||
5757                        IsVariableTemplateSpecialization);
5758 
5759   // Check whether the previous declaration is in the same block scope. This
5760   // affects whether we merge types with it, per C++11 [dcl.array]p3.
5761   if (getLangOpts().CPlusPlus &&
5762       NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
5763     NewVD->setPreviousDeclInSameBlockScope(
5764         Previous.isSingleResult() && !Previous.isShadowed() &&
5765         isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
5766 
5767   if (!getLangOpts().CPlusPlus) {
5768     D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
5769   } else {
5770     // If this is an explicit specialization of a static data member, check it.
5771     if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
5772         CheckMemberSpecialization(NewVD, Previous))
5773       NewVD->setInvalidDecl();
5774 
5775     // Merge the decl with the existing one if appropriate.
5776     if (!Previous.empty()) {
5777       if (Previous.isSingleResult() &&
5778           isa<FieldDecl>(Previous.getFoundDecl()) &&
5779           D.getCXXScopeSpec().isSet()) {
5780         // The user tried to define a non-static data member
5781         // out-of-line (C++ [dcl.meaning]p1).
5782         Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
5783           << D.getCXXScopeSpec().getRange();
5784         Previous.clear();
5785         NewVD->setInvalidDecl();
5786       }
5787     } else if (D.getCXXScopeSpec().isSet()) {
5788       // No previous declaration in the qualifying scope.
5789       Diag(D.getIdentifierLoc(), diag::err_no_member)
5790         << Name << computeDeclContext(D.getCXXScopeSpec(), true)
5791         << D.getCXXScopeSpec().getRange();
5792       NewVD->setInvalidDecl();
5793     }
5794 
5795     if (!IsVariableTemplateSpecialization)
5796       D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
5797 
5798     if (NewTemplate) {
5799       VarTemplateDecl *PrevVarTemplate =
5800           NewVD->getPreviousDecl()
5801               ? NewVD->getPreviousDecl()->getDescribedVarTemplate()
5802               : nullptr;
5803 
5804       // Check the template parameter list of this declaration, possibly
5805       // merging in the template parameter list from the previous variable
5806       // template declaration.
5807       if (CheckTemplateParameterList(
5808               TemplateParams,
5809               PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
5810                               : nullptr,
5811               (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
5812                DC->isDependentContext())
5813                   ? TPC_ClassTemplateMember
5814                   : TPC_VarTemplate))
5815         NewVD->setInvalidDecl();
5816 
5817       // If we are providing an explicit specialization of a static variable
5818       // template, make a note of that.
5819       if (PrevVarTemplate &&
5820           PrevVarTemplate->getInstantiatedFromMemberTemplate())
5821         PrevVarTemplate->setMemberSpecialization();
5822     }
5823   }
5824 
5825   ProcessPragmaWeak(S, NewVD);
5826 
5827   // If this is the first declaration of an extern C variable, update
5828   // the map of such variables.
5829   if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
5830       isIncompleteDeclExternC(*this, NewVD))
5831     RegisterLocallyScopedExternCDecl(NewVD, S);
5832 
5833   if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
5834     Decl *ManglingContextDecl;
5835     if (MangleNumberingContext *MCtx =
5836             getCurrentMangleNumberContext(NewVD->getDeclContext(),
5837                                           ManglingContextDecl)) {
5838       Context.setManglingNumber(
5839           NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber()));
5840       Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
5841     }
5842   }
5843 
5844   if (D.isRedeclaration() && !Previous.empty()) {
5845     checkDLLAttributeRedeclaration(
5846         *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
5847         IsExplicitSpecialization);
5848   }
5849 
5850   if (NewTemplate) {
5851     if (NewVD->isInvalidDecl())
5852       NewTemplate->setInvalidDecl();
5853     ActOnDocumentableDecl(NewTemplate);
5854     return NewTemplate;
5855   }
5856 
5857   return NewVD;
5858 }
5859 
5860 /// \brief Diagnose variable or built-in function shadowing.  Implements
5861 /// -Wshadow.
5862 ///
5863 /// This method is called whenever a VarDecl is added to a "useful"
5864 /// scope.
5865 ///
5866 /// \param S the scope in which the shadowing name is being declared
5867 /// \param R the lookup of the name
5868 ///
5869 void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
5870   // Return if warning is ignored.
5871   if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
5872     return;
5873 
5874   // Don't diagnose declarations at file scope.
5875   if (D->hasGlobalStorage())
5876     return;
5877 
5878   DeclContext *NewDC = D->getDeclContext();
5879 
5880   // Only diagnose if we're shadowing an unambiguous field or variable.
5881   if (R.getResultKind() != LookupResult::Found)
5882     return;
5883 
5884   NamedDecl* ShadowedDecl = R.getFoundDecl();
5885   if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
5886     return;
5887 
5888   // Fields are not shadowed by variables in C++ static methods.
5889   if (isa<FieldDecl>(ShadowedDecl))
5890     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
5891       if (MD->isStatic())
5892         return;
5893 
5894   if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
5895     if (shadowedVar->isExternC()) {
5896       // For shadowing external vars, make sure that we point to the global
5897       // declaration, not a locally scoped extern declaration.
5898       for (auto I : shadowedVar->redecls())
5899         if (I->isFileVarDecl()) {
5900           ShadowedDecl = I;
5901           break;
5902         }
5903     }
5904 
5905   DeclContext *OldDC = ShadowedDecl->getDeclContext();
5906 
5907   // Only warn about certain kinds of shadowing for class members.
5908   if (NewDC && NewDC->isRecord()) {
5909     // In particular, don't warn about shadowing non-class members.
5910     if (!OldDC->isRecord())
5911       return;
5912 
5913     // TODO: should we warn about static data members shadowing
5914     // static data members from base classes?
5915 
5916     // TODO: don't diagnose for inaccessible shadowed members.
5917     // This is hard to do perfectly because we might friend the
5918     // shadowing context, but that's just a false negative.
5919   }
5920 
5921   // Determine what kind of declaration we're shadowing.
5922   unsigned Kind;
5923   if (isa<RecordDecl>(OldDC)) {
5924     if (isa<FieldDecl>(ShadowedDecl))
5925       Kind = 3; // field
5926     else
5927       Kind = 2; // static data member
5928   } else if (OldDC->isFileContext())
5929     Kind = 1; // global
5930   else
5931     Kind = 0; // local
5932 
5933   DeclarationName Name = R.getLookupName();
5934 
5935   // Emit warning and note.
5936   if (getSourceManager().isInSystemMacro(R.getNameLoc()))
5937     return;
5938   Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
5939   Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
5940 }
5941 
5942 /// \brief Check -Wshadow without the advantage of a previous lookup.
5943 void Sema::CheckShadow(Scope *S, VarDecl *D) {
5944   if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
5945     return;
5946 
5947   LookupResult R(*this, D->getDeclName(), D->getLocation(),
5948                  Sema::LookupOrdinaryName, Sema::ForRedeclaration);
5949   LookupName(R, S);
5950   CheckShadow(S, D, R);
5951 }
5952 
5953 /// Check for conflict between this global or extern "C" declaration and
5954 /// previous global or extern "C" declarations. This is only used in C++.
5955 template<typename T>
5956 static bool checkGlobalOrExternCConflict(
5957     Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
5958   assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
5959   NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
5960 
5961   if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
5962     // The common case: this global doesn't conflict with any extern "C"
5963     // declaration.
5964     return false;
5965   }
5966 
5967   if (Prev) {
5968     if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
5969       // Both the old and new declarations have C language linkage. This is a
5970       // redeclaration.
5971       Previous.clear();
5972       Previous.addDecl(Prev);
5973       return true;
5974     }
5975 
5976     // This is a global, non-extern "C" declaration, and there is a previous
5977     // non-global extern "C" declaration. Diagnose if this is a variable
5978     // declaration.
5979     if (!isa<VarDecl>(ND))
5980       return false;
5981   } else {
5982     // The declaration is extern "C". Check for any declaration in the
5983     // translation unit which might conflict.
5984     if (IsGlobal) {
5985       // We have already performed the lookup into the translation unit.
5986       IsGlobal = false;
5987       for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
5988            I != E; ++I) {
5989         if (isa<VarDecl>(*I)) {
5990           Prev = *I;
5991           break;
5992         }
5993       }
5994     } else {
5995       DeclContext::lookup_result R =
5996           S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
5997       for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
5998            I != E; ++I) {
5999         if (isa<VarDecl>(*I)) {
6000           Prev = *I;
6001           break;
6002         }
6003         // FIXME: If we have any other entity with this name in global scope,
6004         // the declaration is ill-formed, but that is a defect: it breaks the
6005         // 'stat' hack, for instance. Only variables can have mangled name
6006         // clashes with extern "C" declarations, so only they deserve a
6007         // diagnostic.
6008       }
6009     }
6010 
6011     if (!Prev)
6012       return false;
6013   }
6014 
6015   // Use the first declaration's location to ensure we point at something which
6016   // is lexically inside an extern "C" linkage-spec.
6017   assert(Prev && "should have found a previous declaration to diagnose");
6018   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
6019     Prev = FD->getFirstDecl();
6020   else
6021     Prev = cast<VarDecl>(Prev)->getFirstDecl();
6022 
6023   S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
6024     << IsGlobal << ND;
6025   S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
6026     << IsGlobal;
6027   return false;
6028 }
6029 
6030 /// Apply special rules for handling extern "C" declarations. Returns \c true
6031 /// if we have found that this is a redeclaration of some prior entity.
6032 ///
6033 /// Per C++ [dcl.link]p6:
6034 ///   Two declarations [for a function or variable] with C language linkage
6035 ///   with the same name that appear in different scopes refer to the same
6036 ///   [entity]. An entity with C language linkage shall not be declared with
6037 ///   the same name as an entity in global scope.
6038 template<typename T>
6039 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
6040                                                   LookupResult &Previous) {
6041   if (!S.getLangOpts().CPlusPlus) {
6042     // In C, when declaring a global variable, look for a corresponding 'extern'
6043     // variable declared in function scope. We don't need this in C++, because
6044     // we find local extern decls in the surrounding file-scope DeclContext.
6045     if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
6046       if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
6047         Previous.clear();
6048         Previous.addDecl(Prev);
6049         return true;
6050       }
6051     }
6052     return false;
6053   }
6054 
6055   // A declaration in the translation unit can conflict with an extern "C"
6056   // declaration.
6057   if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6058     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6059 
6060   // An extern "C" declaration can conflict with a declaration in the
6061   // translation unit or can be a redeclaration of an extern "C" declaration
6062   // in another scope.
6063   if (isIncompleteDeclExternC(S,ND))
6064     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6065 
6066   // Neither global nor extern "C": nothing to do.
6067   return false;
6068 }
6069 
6070 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
6071   // If the decl is already known invalid, don't check it.
6072   if (NewVD->isInvalidDecl())
6073     return;
6074 
6075   TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6076   QualType T = TInfo->getType();
6077 
6078   // Defer checking an 'auto' type until its initializer is attached.
6079   if (T->isUndeducedType())
6080     return;
6081 
6082   if (NewVD->hasAttrs())
6083     CheckAlignasUnderalignment(NewVD);
6084 
6085   if (T->isObjCObjectType()) {
6086     Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6087       << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
6088     T = Context.getObjCObjectPointerType(T);
6089     NewVD->setType(T);
6090   }
6091 
6092   // Emit an error if an address space was applied to decl with local storage.
6093   // This includes arrays of objects with address space qualifiers, but not
6094   // automatic variables that point to other address spaces.
6095   // ISO/IEC TR 18037 S5.1.2
6096   if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
6097     Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
6098     NewVD->setInvalidDecl();
6099     return;
6100   }
6101 
6102   // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6103   // __constant address space.
6104   if (getLangOpts().OpenCL && NewVD->isFileVarDecl()
6105       && T.getAddressSpace() != LangAS::opencl_constant
6106       && !T->isSamplerT()){
6107     Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space);
6108     NewVD->setInvalidDecl();
6109     return;
6110   }
6111 
6112   // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
6113   // scope.
6114   if ((getLangOpts().OpenCLVersion >= 120)
6115       && NewVD->isStaticLocal()) {
6116     Diag(NewVD->getLocation(), diag::err_static_function_scope);
6117     NewVD->setInvalidDecl();
6118     return;
6119   }
6120 
6121   if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
6122       && !NewVD->hasAttr<BlocksAttr>()) {
6123     if (getLangOpts().getGC() != LangOptions::NonGC)
6124       Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
6125     else {
6126       assert(!getLangOpts().ObjCAutoRefCount);
6127       Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
6128     }
6129   }
6130 
6131   bool isVM = T->isVariablyModifiedType();
6132   if (isVM || NewVD->hasAttr<CleanupAttr>() ||
6133       NewVD->hasAttr<BlocksAttr>())
6134     getCurFunction()->setHasBranchProtectedScope();
6135 
6136   if ((isVM && NewVD->hasLinkage()) ||
6137       (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
6138     bool SizeIsNegative;
6139     llvm::APSInt Oversized;
6140     TypeSourceInfo *FixedTInfo =
6141       TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
6142                                                     SizeIsNegative, Oversized);
6143     if (!FixedTInfo && T->isVariableArrayType()) {
6144       const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
6145       // FIXME: This won't give the correct result for
6146       // int a[10][n];
6147       SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
6148 
6149       if (NewVD->isFileVarDecl())
6150         Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
6151         << SizeRange;
6152       else if (NewVD->isStaticLocal())
6153         Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
6154         << SizeRange;
6155       else
6156         Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
6157         << SizeRange;
6158       NewVD->setInvalidDecl();
6159       return;
6160     }
6161 
6162     if (!FixedTInfo) {
6163       if (NewVD->isFileVarDecl())
6164         Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6165       else
6166         Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
6167       NewVD->setInvalidDecl();
6168       return;
6169     }
6170 
6171     Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
6172     NewVD->setType(FixedTInfo->getType());
6173     NewVD->setTypeSourceInfo(FixedTInfo);
6174   }
6175 
6176   if (T->isVoidType()) {
6177     // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6178     //                    of objects and functions.
6179     if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6180       Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6181         << T;
6182       NewVD->setInvalidDecl();
6183       return;
6184     }
6185   }
6186 
6187   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6188     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6189     NewVD->setInvalidDecl();
6190     return;
6191   }
6192 
6193   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6194     Diag(NewVD->getLocation(), diag::err_block_on_vm);
6195     NewVD->setInvalidDecl();
6196     return;
6197   }
6198 
6199   if (NewVD->isConstexpr() && !T->isDependentType() &&
6200       RequireLiteralType(NewVD->getLocation(), T,
6201                          diag::err_constexpr_var_non_literal)) {
6202     NewVD->setInvalidDecl();
6203     return;
6204   }
6205 }
6206 
6207 /// \brief Perform semantic checking on a newly-created variable
6208 /// declaration.
6209 ///
6210 /// This routine performs all of the type-checking required for a
6211 /// variable declaration once it has been built. It is used both to
6212 /// check variables after they have been parsed and their declarators
6213 /// have been translated into a declaration, and to check variables
6214 /// that have been instantiated from a template.
6215 ///
6216 /// Sets NewVD->isInvalidDecl() if an error was encountered.
6217 ///
6218 /// Returns true if the variable declaration is a redeclaration.
6219 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
6220   CheckVariableDeclarationType(NewVD);
6221 
6222   // If the decl is already known invalid, don't check it.
6223   if (NewVD->isInvalidDecl())
6224     return false;
6225 
6226   // If we did not find anything by this name, look for a non-visible
6227   // extern "C" declaration with the same name.
6228   if (Previous.empty() &&
6229       checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
6230     Previous.setShadowed();
6231 
6232   // Filter out any non-conflicting previous declarations.
6233   filterNonConflictingPreviousDecls(Context, NewVD, Previous);
6234 
6235   if (!Previous.empty()) {
6236     MergeVarDecl(NewVD, Previous);
6237     return true;
6238   }
6239   return false;
6240 }
6241 
6242 /// \brief Data used with FindOverriddenMethod
6243 struct FindOverriddenMethodData {
6244   Sema *S;
6245   CXXMethodDecl *Method;
6246 };
6247 
6248 /// \brief Member lookup function that determines whether a given C++
6249 /// method overrides a method in a base class, to be used with
6250 /// CXXRecordDecl::lookupInBases().
6251 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
6252                                  CXXBasePath &Path,
6253                                  void *UserData) {
6254   RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
6255 
6256   FindOverriddenMethodData *Data
6257     = reinterpret_cast<FindOverriddenMethodData*>(UserData);
6258 
6259   DeclarationName Name = Data->Method->getDeclName();
6260 
6261   // FIXME: Do we care about other names here too?
6262   if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6263     // We really want to find the base class destructor here.
6264     QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
6265     CanQualType CT = Data->S->Context.getCanonicalType(T);
6266 
6267     Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
6268   }
6269 
6270   for (Path.Decls = BaseRecord->lookup(Name);
6271        !Path.Decls.empty();
6272        Path.Decls = Path.Decls.slice(1)) {
6273     NamedDecl *D = Path.Decls.front();
6274     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6275       if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false))
6276         return true;
6277     }
6278   }
6279 
6280   return false;
6281 }
6282 
6283 namespace {
6284   enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
6285 }
6286 /// \brief Report an error regarding overriding, along with any relevant
6287 /// overriden methods.
6288 ///
6289 /// \param DiagID the primary error to report.
6290 /// \param MD the overriding method.
6291 /// \param OEK which overrides to include as notes.
6292 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
6293                             OverrideErrorKind OEK = OEK_All) {
6294   S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6295   for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6296                                       E = MD->end_overridden_methods();
6297        I != E; ++I) {
6298     // This check (& the OEK parameter) could be replaced by a predicate, but
6299     // without lambdas that would be overkill. This is still nicer than writing
6300     // out the diag loop 3 times.
6301     if ((OEK == OEK_All) ||
6302         (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
6303         (OEK == OEK_Deleted && (*I)->isDeleted()))
6304       S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
6305   }
6306 }
6307 
6308 /// AddOverriddenMethods - See if a method overrides any in the base classes,
6309 /// and if so, check that it's a valid override and remember it.
6310 bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
6311   // Look for methods in base classes that this method might override.
6312   CXXBasePaths Paths;
6313   FindOverriddenMethodData Data;
6314   Data.Method = MD;
6315   Data.S = this;
6316   bool hasDeletedOverridenMethods = false;
6317   bool hasNonDeletedOverridenMethods = false;
6318   bool AddedAny = false;
6319   if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
6320     for (auto *I : Paths.found_decls()) {
6321       if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
6322         MD->addOverriddenMethod(OldMD->getCanonicalDecl());
6323         if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
6324             !CheckOverridingFunctionAttributes(MD, OldMD) &&
6325             !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
6326             !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
6327           hasDeletedOverridenMethods |= OldMD->isDeleted();
6328           hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
6329           AddedAny = true;
6330         }
6331       }
6332     }
6333   }
6334 
6335   if (hasDeletedOverridenMethods && !MD->isDeleted()) {
6336     ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
6337   }
6338   if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
6339     ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
6340   }
6341 
6342   return AddedAny;
6343 }
6344 
6345 namespace {
6346   // Struct for holding all of the extra arguments needed by
6347   // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
6348   struct ActOnFDArgs {
6349     Scope *S;
6350     Declarator &D;
6351     MultiTemplateParamsArg TemplateParamLists;
6352     bool AddToScope;
6353   };
6354 }
6355 
6356 namespace {
6357 
6358 // Callback to only accept typo corrections that have a non-zero edit distance.
6359 // Also only accept corrections that have the same parent decl.
6360 class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
6361  public:
6362   DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
6363                             CXXRecordDecl *Parent)
6364       : Context(Context), OriginalFD(TypoFD),
6365         ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
6366 
6367   bool ValidateCandidate(const TypoCorrection &candidate) override {
6368     if (candidate.getEditDistance() == 0)
6369       return false;
6370 
6371     SmallVector<unsigned, 1> MismatchedParams;
6372     for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
6373                                           CDeclEnd = candidate.end();
6374          CDecl != CDeclEnd; ++CDecl) {
6375       FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6376 
6377       if (FD && !FD->hasBody() &&
6378           hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
6379         if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
6380           CXXRecordDecl *Parent = MD->getParent();
6381           if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
6382             return true;
6383         } else if (!ExpectedParent) {
6384           return true;
6385         }
6386       }
6387     }
6388 
6389     return false;
6390   }
6391 
6392  private:
6393   ASTContext &Context;
6394   FunctionDecl *OriginalFD;
6395   CXXRecordDecl *ExpectedParent;
6396 };
6397 
6398 }
6399 
6400 /// \brief Generate diagnostics for an invalid function redeclaration.
6401 ///
6402 /// This routine handles generating the diagnostic messages for an invalid
6403 /// function redeclaration, including finding possible similar declarations
6404 /// or performing typo correction if there are no previous declarations with
6405 /// the same name.
6406 ///
6407 /// Returns a NamedDecl iff typo correction was performed and substituting in
6408 /// the new declaration name does not cause new errors.
6409 static NamedDecl *DiagnoseInvalidRedeclaration(
6410     Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
6411     ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
6412   DeclarationName Name = NewFD->getDeclName();
6413   DeclContext *NewDC = NewFD->getDeclContext();
6414   SmallVector<unsigned, 1> MismatchedParams;
6415   SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
6416   TypoCorrection Correction;
6417   bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
6418   unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
6419                                    : diag::err_member_decl_does_not_match;
6420   LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
6421                     IsLocalFriend ? Sema::LookupLocalFriendName
6422                                   : Sema::LookupOrdinaryName,
6423                     Sema::ForRedeclaration);
6424 
6425   NewFD->setInvalidDecl();
6426   if (IsLocalFriend)
6427     SemaRef.LookupName(Prev, S);
6428   else
6429     SemaRef.LookupQualifiedName(Prev, NewDC);
6430   assert(!Prev.isAmbiguous() &&
6431          "Cannot have an ambiguity in previous-declaration lookup");
6432   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
6433   if (!Prev.empty()) {
6434     for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
6435          Func != FuncEnd; ++Func) {
6436       FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
6437       if (FD &&
6438           hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6439         // Add 1 to the index so that 0 can mean the mismatch didn't
6440         // involve a parameter
6441         unsigned ParamNum =
6442             MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
6443         NearMatches.push_back(std::make_pair(FD, ParamNum));
6444       }
6445     }
6446   // If the qualified name lookup yielded nothing, try typo correction
6447   } else if ((Correction = SemaRef.CorrectTypo(
6448                   Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
6449                   &ExtraArgs.D.getCXXScopeSpec(),
6450                   llvm::make_unique<DifferentNameValidatorCCC>(
6451                       SemaRef.Context, NewFD, MD ? MD->getParent() : nullptr),
6452                   Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
6453     // Set up everything for the call to ActOnFunctionDeclarator
6454     ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
6455                               ExtraArgs.D.getIdentifierLoc());
6456     Previous.clear();
6457     Previous.setLookupName(Correction.getCorrection());
6458     for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
6459                                     CDeclEnd = Correction.end();
6460          CDecl != CDeclEnd; ++CDecl) {
6461       FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6462       if (FD && !FD->hasBody() &&
6463           hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6464         Previous.addDecl(FD);
6465       }
6466     }
6467     bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
6468 
6469     NamedDecl *Result;
6470     // Retry building the function declaration with the new previous
6471     // declarations, and with errors suppressed.
6472     {
6473       // Trap errors.
6474       Sema::SFINAETrap Trap(SemaRef);
6475 
6476       // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
6477       // pieces need to verify the typo-corrected C++ declaration and hopefully
6478       // eliminate the need for the parameter pack ExtraArgs.
6479       Result = SemaRef.ActOnFunctionDeclarator(
6480           ExtraArgs.S, ExtraArgs.D,
6481           Correction.getCorrectionDecl()->getDeclContext(),
6482           NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
6483           ExtraArgs.AddToScope);
6484 
6485       if (Trap.hasErrorOccurred())
6486         Result = nullptr;
6487     }
6488 
6489     if (Result) {
6490       // Determine which correction we picked.
6491       Decl *Canonical = Result->getCanonicalDecl();
6492       for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6493            I != E; ++I)
6494         if ((*I)->getCanonicalDecl() == Canonical)
6495           Correction.setCorrectionDecl(*I);
6496 
6497       SemaRef.diagnoseTypo(
6498           Correction,
6499           SemaRef.PDiag(IsLocalFriend
6500                           ? diag::err_no_matching_local_friend_suggest
6501                           : diag::err_member_decl_does_not_match_suggest)
6502             << Name << NewDC << IsDefinition);
6503       return Result;
6504     }
6505 
6506     // Pretend the typo correction never occurred
6507     ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
6508                               ExtraArgs.D.getIdentifierLoc());
6509     ExtraArgs.D.setRedeclaration(wasRedeclaration);
6510     Previous.clear();
6511     Previous.setLookupName(Name);
6512   }
6513 
6514   SemaRef.Diag(NewFD->getLocation(), DiagMsg)
6515       << Name << NewDC << IsDefinition << NewFD->getLocation();
6516 
6517   bool NewFDisConst = false;
6518   if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
6519     NewFDisConst = NewMD->isConst();
6520 
6521   for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
6522        NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
6523        NearMatch != NearMatchEnd; ++NearMatch) {
6524     FunctionDecl *FD = NearMatch->first;
6525     CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6526     bool FDisConst = MD && MD->isConst();
6527     bool IsMember = MD || !IsLocalFriend;
6528 
6529     // FIXME: These notes are poorly worded for the local friend case.
6530     if (unsigned Idx = NearMatch->second) {
6531       ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
6532       SourceLocation Loc = FDParam->getTypeSpecStartLoc();
6533       if (Loc.isInvalid()) Loc = FD->getLocation();
6534       SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
6535                                  : diag::note_local_decl_close_param_match)
6536         << Idx << FDParam->getType()
6537         << NewFD->getParamDecl(Idx - 1)->getType();
6538     } else if (FDisConst != NewFDisConst) {
6539       SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
6540           << NewFDisConst << FD->getSourceRange().getEnd();
6541     } else
6542       SemaRef.Diag(FD->getLocation(),
6543                    IsMember ? diag::note_member_def_close_match
6544                             : diag::note_local_decl_close_match);
6545   }
6546   return nullptr;
6547 }
6548 
6549 static StorageClass getFunctionStorageClass(Sema &SemaRef, Declarator &D) {
6550   switch (D.getDeclSpec().getStorageClassSpec()) {
6551   default: llvm_unreachable("Unknown storage class!");
6552   case DeclSpec::SCS_auto:
6553   case DeclSpec::SCS_register:
6554   case DeclSpec::SCS_mutable:
6555     SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6556                  diag::err_typecheck_sclass_func);
6557     D.setInvalidType();
6558     break;
6559   case DeclSpec::SCS_unspecified: break;
6560   case DeclSpec::SCS_extern:
6561     if (D.getDeclSpec().isExternInLinkageSpec())
6562       return SC_None;
6563     return SC_Extern;
6564   case DeclSpec::SCS_static: {
6565     if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
6566       // C99 6.7.1p5:
6567       //   The declaration of an identifier for a function that has
6568       //   block scope shall have no explicit storage-class specifier
6569       //   other than extern
6570       // See also (C++ [dcl.stc]p4).
6571       SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6572                    diag::err_static_block_func);
6573       break;
6574     } else
6575       return SC_Static;
6576   }
6577   case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
6578   }
6579 
6580   // No explicit storage class has already been returned
6581   return SC_None;
6582 }
6583 
6584 static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
6585                                            DeclContext *DC, QualType &R,
6586                                            TypeSourceInfo *TInfo,
6587                                            StorageClass SC,
6588                                            bool &IsVirtualOkay) {
6589   DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
6590   DeclarationName Name = NameInfo.getName();
6591 
6592   FunctionDecl *NewFD = nullptr;
6593   bool isInline = D.getDeclSpec().isInlineSpecified();
6594 
6595   if (!SemaRef.getLangOpts().CPlusPlus) {
6596     // Determine whether the function was written with a
6597     // prototype. This true when:
6598     //   - there is a prototype in the declarator, or
6599     //   - the type R of the function is some kind of typedef or other reference
6600     //     to a type name (which eventually refers to a function type).
6601     bool HasPrototype =
6602       (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
6603       (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
6604 
6605     NewFD = FunctionDecl::Create(SemaRef.Context, DC,
6606                                  D.getLocStart(), NameInfo, R,
6607                                  TInfo, SC, isInline,
6608                                  HasPrototype, false);
6609     if (D.isInvalidType())
6610       NewFD->setInvalidDecl();
6611 
6612     // Set the lexical context.
6613     NewFD->setLexicalDeclContext(SemaRef.CurContext);
6614 
6615     return NewFD;
6616   }
6617 
6618   bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6619   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6620 
6621   // Check that the return type is not an abstract class type.
6622   // For record types, this is done by the AbstractClassUsageDiagnoser once
6623   // the class has been completely parsed.
6624   if (!DC->isRecord() &&
6625       SemaRef.RequireNonAbstractType(
6626           D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
6627           diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
6628     D.setInvalidType();
6629 
6630   if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
6631     // This is a C++ constructor declaration.
6632     assert(DC->isRecord() &&
6633            "Constructors can only be declared in a member context");
6634 
6635     R = SemaRef.CheckConstructorDeclarator(D, R, SC);
6636     return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
6637                                       D.getLocStart(), NameInfo,
6638                                       R, TInfo, isExplicit, isInline,
6639                                       /*isImplicitlyDeclared=*/false,
6640                                       isConstexpr);
6641 
6642   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6643     // This is a C++ destructor declaration.
6644     if (DC->isRecord()) {
6645       R = SemaRef.CheckDestructorDeclarator(D, R, SC);
6646       CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
6647       CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
6648                                         SemaRef.Context, Record,
6649                                         D.getLocStart(),
6650                                         NameInfo, R, TInfo, isInline,
6651                                         /*isImplicitlyDeclared=*/false);
6652 
6653       // If the class is complete, then we now create the implicit exception
6654       // specification. If the class is incomplete or dependent, we can't do
6655       // it yet.
6656       if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
6657           Record->getDefinition() && !Record->isBeingDefined() &&
6658           R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
6659         SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
6660       }
6661 
6662       IsVirtualOkay = true;
6663       return NewDD;
6664 
6665     } else {
6666       SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
6667       D.setInvalidType();
6668 
6669       // Create a FunctionDecl to satisfy the function definition parsing
6670       // code path.
6671       return FunctionDecl::Create(SemaRef.Context, DC,
6672                                   D.getLocStart(),
6673                                   D.getIdentifierLoc(), Name, R, TInfo,
6674                                   SC, isInline,
6675                                   /*hasPrototype=*/true, isConstexpr);
6676     }
6677 
6678   } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
6679     if (!DC->isRecord()) {
6680       SemaRef.Diag(D.getIdentifierLoc(),
6681            diag::err_conv_function_not_member);
6682       return nullptr;
6683     }
6684 
6685     SemaRef.CheckConversionDeclarator(D, R, SC);
6686     IsVirtualOkay = true;
6687     return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
6688                                      D.getLocStart(), NameInfo,
6689                                      R, TInfo, isInline, isExplicit,
6690                                      isConstexpr, SourceLocation());
6691 
6692   } else if (DC->isRecord()) {
6693     // If the name of the function is the same as the name of the record,
6694     // then this must be an invalid constructor that has a return type.
6695     // (The parser checks for a return type and makes the declarator a
6696     // constructor if it has no return type).
6697     if (Name.getAsIdentifierInfo() &&
6698         Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
6699       SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
6700         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6701         << SourceRange(D.getIdentifierLoc());
6702       return nullptr;
6703     }
6704 
6705     // This is a C++ method declaration.
6706     CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
6707                                                cast<CXXRecordDecl>(DC),
6708                                                D.getLocStart(), NameInfo, R,
6709                                                TInfo, SC, isInline,
6710                                                isConstexpr, SourceLocation());
6711     IsVirtualOkay = !Ret->isStatic();
6712     return Ret;
6713   } else {
6714     // Determine whether the function was written with a
6715     // prototype. This true when:
6716     //   - we're in C++ (where every function has a prototype),
6717     return FunctionDecl::Create(SemaRef.Context, DC,
6718                                 D.getLocStart(),
6719                                 NameInfo, R, TInfo, SC, isInline,
6720                                 true/*HasPrototype*/, isConstexpr);
6721   }
6722 }
6723 
6724 enum OpenCLParamType {
6725   ValidKernelParam,
6726   PtrPtrKernelParam,
6727   PtrKernelParam,
6728   PrivatePtrKernelParam,
6729   InvalidKernelParam,
6730   RecordKernelParam
6731 };
6732 
6733 static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
6734   if (PT->isPointerType()) {
6735     QualType PointeeType = PT->getPointeeType();
6736     if (PointeeType->isPointerType())
6737       return PtrPtrKernelParam;
6738     return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
6739                                               : PtrKernelParam;
6740   }
6741 
6742   // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
6743   // be used as builtin types.
6744 
6745   if (PT->isImageType())
6746     return PtrKernelParam;
6747 
6748   if (PT->isBooleanType())
6749     return InvalidKernelParam;
6750 
6751   if (PT->isEventT())
6752     return InvalidKernelParam;
6753 
6754   if (PT->isHalfType())
6755     return InvalidKernelParam;
6756 
6757   if (PT->isRecordType())
6758     return RecordKernelParam;
6759 
6760   return ValidKernelParam;
6761 }
6762 
6763 static void checkIsValidOpenCLKernelParameter(
6764   Sema &S,
6765   Declarator &D,
6766   ParmVarDecl *Param,
6767   llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
6768   QualType PT = Param->getType();
6769 
6770   // Cache the valid types we encounter to avoid rechecking structs that are
6771   // used again
6772   if (ValidTypes.count(PT.getTypePtr()))
6773     return;
6774 
6775   switch (getOpenCLKernelParameterType(PT)) {
6776   case PtrPtrKernelParam:
6777     // OpenCL v1.2 s6.9.a:
6778     // A kernel function argument cannot be declared as a
6779     // pointer to a pointer type.
6780     S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
6781     D.setInvalidType();
6782     return;
6783 
6784   case PrivatePtrKernelParam:
6785     // OpenCL v1.2 s6.9.a:
6786     // A kernel function argument cannot be declared as a
6787     // pointer to the private address space.
6788     S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
6789     D.setInvalidType();
6790     return;
6791 
6792     // OpenCL v1.2 s6.9.k:
6793     // Arguments to kernel functions in a program cannot be declared with the
6794     // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
6795     // uintptr_t or a struct and/or union that contain fields declared to be
6796     // one of these built-in scalar types.
6797 
6798   case InvalidKernelParam:
6799     // OpenCL v1.2 s6.8 n:
6800     // A kernel function argument cannot be declared
6801     // of event_t type.
6802     S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
6803     D.setInvalidType();
6804     return;
6805 
6806   case PtrKernelParam:
6807   case ValidKernelParam:
6808     ValidTypes.insert(PT.getTypePtr());
6809     return;
6810 
6811   case RecordKernelParam:
6812     break;
6813   }
6814 
6815   // Track nested structs we will inspect
6816   SmallVector<const Decl *, 4> VisitStack;
6817 
6818   // Track where we are in the nested structs. Items will migrate from
6819   // VisitStack to HistoryStack as we do the DFS for bad field.
6820   SmallVector<const FieldDecl *, 4> HistoryStack;
6821   HistoryStack.push_back(nullptr);
6822 
6823   const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
6824   VisitStack.push_back(PD);
6825 
6826   assert(VisitStack.back() && "First decl null?");
6827 
6828   do {
6829     const Decl *Next = VisitStack.pop_back_val();
6830     if (!Next) {
6831       assert(!HistoryStack.empty());
6832       // Found a marker, we have gone up a level
6833       if (const FieldDecl *Hist = HistoryStack.pop_back_val())
6834         ValidTypes.insert(Hist->getType().getTypePtr());
6835 
6836       continue;
6837     }
6838 
6839     // Adds everything except the original parameter declaration (which is not a
6840     // field itself) to the history stack.
6841     const RecordDecl *RD;
6842     if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
6843       HistoryStack.push_back(Field);
6844       RD = Field->getType()->castAs<RecordType>()->getDecl();
6845     } else {
6846       RD = cast<RecordDecl>(Next);
6847     }
6848 
6849     // Add a null marker so we know when we've gone back up a level
6850     VisitStack.push_back(nullptr);
6851 
6852     for (const auto *FD : RD->fields()) {
6853       QualType QT = FD->getType();
6854 
6855       if (ValidTypes.count(QT.getTypePtr()))
6856         continue;
6857 
6858       OpenCLParamType ParamType = getOpenCLKernelParameterType(QT);
6859       if (ParamType == ValidKernelParam)
6860         continue;
6861 
6862       if (ParamType == RecordKernelParam) {
6863         VisitStack.push_back(FD);
6864         continue;
6865       }
6866 
6867       // OpenCL v1.2 s6.9.p:
6868       // Arguments to kernel functions that are declared to be a struct or union
6869       // do not allow OpenCL objects to be passed as elements of the struct or
6870       // union.
6871       if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
6872           ParamType == PrivatePtrKernelParam) {
6873         S.Diag(Param->getLocation(),
6874                diag::err_record_with_pointers_kernel_param)
6875           << PT->isUnionType()
6876           << PT;
6877       } else {
6878         S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
6879       }
6880 
6881       S.Diag(PD->getLocation(), diag::note_within_field_of_type)
6882         << PD->getDeclName();
6883 
6884       // We have an error, now let's go back up through history and show where
6885       // the offending field came from
6886       for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1,
6887              E = HistoryStack.end(); I != E; ++I) {
6888         const FieldDecl *OuterField = *I;
6889         S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
6890           << OuterField->getType();
6891       }
6892 
6893       S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
6894         << QT->isPointerType()
6895         << QT;
6896       D.setInvalidType();
6897       return;
6898     }
6899   } while (!VisitStack.empty());
6900 }
6901 
6902 NamedDecl*
6903 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
6904                               TypeSourceInfo *TInfo, LookupResult &Previous,
6905                               MultiTemplateParamsArg TemplateParamLists,
6906                               bool &AddToScope) {
6907   QualType R = TInfo->getType();
6908 
6909   assert(R.getTypePtr()->isFunctionType());
6910 
6911   // TODO: consider using NameInfo for diagnostic.
6912   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
6913   DeclarationName Name = NameInfo.getName();
6914   StorageClass SC = getFunctionStorageClass(*this, D);
6915 
6916   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
6917     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6918          diag::err_invalid_thread)
6919       << DeclSpec::getSpecifierName(TSCS);
6920 
6921   if (D.isFirstDeclarationOfMember())
6922     adjustMemberFunctionCC(R, D.isStaticMember());
6923 
6924   bool isFriend = false;
6925   FunctionTemplateDecl *FunctionTemplate = nullptr;
6926   bool isExplicitSpecialization = false;
6927   bool isFunctionTemplateSpecialization = false;
6928 
6929   bool isDependentClassScopeExplicitSpecialization = false;
6930   bool HasExplicitTemplateArgs = false;
6931   TemplateArgumentListInfo TemplateArgs;
6932 
6933   bool isVirtualOkay = false;
6934 
6935   DeclContext *OriginalDC = DC;
6936   bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
6937 
6938   FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
6939                                               isVirtualOkay);
6940   if (!NewFD) return nullptr;
6941 
6942   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
6943     NewFD->setTopLevelDeclInObjCContainer();
6944 
6945   // Set the lexical context. If this is a function-scope declaration, or has a
6946   // C++ scope specifier, or is the object of a friend declaration, the lexical
6947   // context will be different from the semantic context.
6948   NewFD->setLexicalDeclContext(CurContext);
6949 
6950   if (IsLocalExternDecl)
6951     NewFD->setLocalExternDecl();
6952 
6953   if (getLangOpts().CPlusPlus) {
6954     bool isInline = D.getDeclSpec().isInlineSpecified();
6955     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
6956     bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6957     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6958     isFriend = D.getDeclSpec().isFriendSpecified();
6959     if (isFriend && !isInline && D.isFunctionDefinition()) {
6960       // C++ [class.friend]p5
6961       //   A function can be defined in a friend declaration of a
6962       //   class . . . . Such a function is implicitly inline.
6963       NewFD->setImplicitlyInline();
6964     }
6965 
6966     // If this is a method defined in an __interface, and is not a constructor
6967     // or an overloaded operator, then set the pure flag (isVirtual will already
6968     // return true).
6969     if (const CXXRecordDecl *Parent =
6970           dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
6971       if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
6972         NewFD->setPure(true);
6973     }
6974 
6975     SetNestedNameSpecifier(NewFD, D);
6976     isExplicitSpecialization = false;
6977     isFunctionTemplateSpecialization = false;
6978     if (D.isInvalidType())
6979       NewFD->setInvalidDecl();
6980 
6981     // Match up the template parameter lists with the scope specifier, then
6982     // determine whether we have a template or a template specialization.
6983     bool Invalid = false;
6984     if (TemplateParameterList *TemplateParams =
6985             MatchTemplateParametersToScopeSpecifier(
6986                 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
6987                 D.getCXXScopeSpec(),
6988                 D.getName().getKind() == UnqualifiedId::IK_TemplateId
6989                     ? D.getName().TemplateId
6990                     : nullptr,
6991                 TemplateParamLists, isFriend, isExplicitSpecialization,
6992                 Invalid)) {
6993       if (TemplateParams->size() > 0) {
6994         // This is a function template
6995 
6996         // Check that we can declare a template here.
6997         if (CheckTemplateDeclScope(S, TemplateParams))
6998           return nullptr;
6999 
7000         // A destructor cannot be a template.
7001         if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
7002           Diag(NewFD->getLocation(), diag::err_destructor_template);
7003           return nullptr;
7004         }
7005 
7006         // If we're adding a template to a dependent context, we may need to
7007         // rebuilding some of the types used within the template parameter list,
7008         // now that we know what the current instantiation is.
7009         if (DC->isDependentContext()) {
7010           ContextRAII SavedContext(*this, DC);
7011           if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
7012             Invalid = true;
7013         }
7014 
7015 
7016         FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
7017                                                         NewFD->getLocation(),
7018                                                         Name, TemplateParams,
7019                                                         NewFD);
7020         FunctionTemplate->setLexicalDeclContext(CurContext);
7021         NewFD->setDescribedFunctionTemplate(FunctionTemplate);
7022 
7023         // For source fidelity, store the other template param lists.
7024         if (TemplateParamLists.size() > 1) {
7025           NewFD->setTemplateParameterListsInfo(Context,
7026                                                TemplateParamLists.size() - 1,
7027                                                TemplateParamLists.data());
7028         }
7029       } else {
7030         // This is a function template specialization.
7031         isFunctionTemplateSpecialization = true;
7032         // For source fidelity, store all the template param lists.
7033         if (TemplateParamLists.size() > 0)
7034           NewFD->setTemplateParameterListsInfo(Context,
7035                                                TemplateParamLists.size(),
7036                                                TemplateParamLists.data());
7037 
7038         // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
7039         if (isFriend) {
7040           // We want to remove the "template<>", found here.
7041           SourceRange RemoveRange = TemplateParams->getSourceRange();
7042 
7043           // If we remove the template<> and the name is not a
7044           // template-id, we're actually silently creating a problem:
7045           // the friend declaration will refer to an untemplated decl,
7046           // and clearly the user wants a template specialization.  So
7047           // we need to insert '<>' after the name.
7048           SourceLocation InsertLoc;
7049           if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
7050             InsertLoc = D.getName().getSourceRange().getEnd();
7051             InsertLoc = getLocForEndOfToken(InsertLoc);
7052           }
7053 
7054           Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7055             << Name << RemoveRange
7056             << FixItHint::CreateRemoval(RemoveRange)
7057             << FixItHint::CreateInsertion(InsertLoc, "<>");
7058         }
7059       }
7060     }
7061     else {
7062       // All template param lists were matched against the scope specifier:
7063       // this is NOT (an explicit specialization of) a template.
7064       if (TemplateParamLists.size() > 0)
7065         // For source fidelity, store all the template param lists.
7066         NewFD->setTemplateParameterListsInfo(Context,
7067                                              TemplateParamLists.size(),
7068                                              TemplateParamLists.data());
7069     }
7070 
7071     if (Invalid) {
7072       NewFD->setInvalidDecl();
7073       if (FunctionTemplate)
7074         FunctionTemplate->setInvalidDecl();
7075     }
7076 
7077     // C++ [dcl.fct.spec]p5:
7078     //   The virtual specifier shall only be used in declarations of
7079     //   nonstatic class member functions that appear within a
7080     //   member-specification of a class declaration; see 10.3.
7081     //
7082     if (isVirtual && !NewFD->isInvalidDecl()) {
7083       if (!isVirtualOkay) {
7084         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7085              diag::err_virtual_non_function);
7086       } else if (!CurContext->isRecord()) {
7087         // 'virtual' was specified outside of the class.
7088         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7089              diag::err_virtual_out_of_class)
7090           << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7091       } else if (NewFD->getDescribedFunctionTemplate()) {
7092         // C++ [temp.mem]p3:
7093         //  A member function template shall not be virtual.
7094         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7095              diag::err_virtual_member_function_template)
7096           << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7097       } else {
7098         // Okay: Add virtual to the method.
7099         NewFD->setVirtualAsWritten(true);
7100       }
7101 
7102       if (getLangOpts().CPlusPlus14 &&
7103           NewFD->getReturnType()->isUndeducedType())
7104         Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
7105     }
7106 
7107     if (getLangOpts().CPlusPlus14 &&
7108         (NewFD->isDependentContext() ||
7109          (isFriend && CurContext->isDependentContext())) &&
7110         NewFD->getReturnType()->isUndeducedType()) {
7111       // If the function template is referenced directly (for instance, as a
7112       // member of the current instantiation), pretend it has a dependent type.
7113       // This is not really justified by the standard, but is the only sane
7114       // thing to do.
7115       // FIXME: For a friend function, we have not marked the function as being
7116       // a friend yet, so 'isDependentContext' on the FD doesn't work.
7117       const FunctionProtoType *FPT =
7118           NewFD->getType()->castAs<FunctionProtoType>();
7119       QualType Result =
7120           SubstAutoType(FPT->getReturnType(), Context.DependentTy);
7121       NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
7122                                              FPT->getExtProtoInfo()));
7123     }
7124 
7125     // C++ [dcl.fct.spec]p3:
7126     //  The inline specifier shall not appear on a block scope function
7127     //  declaration.
7128     if (isInline && !NewFD->isInvalidDecl()) {
7129       if (CurContext->isFunctionOrMethod()) {
7130         // 'inline' is not allowed on block scope function declaration.
7131         Diag(D.getDeclSpec().getInlineSpecLoc(),
7132              diag::err_inline_declaration_block_scope) << Name
7133           << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
7134       }
7135     }
7136 
7137     // C++ [dcl.fct.spec]p6:
7138     //  The explicit specifier shall be used only in the declaration of a
7139     //  constructor or conversion function within its class definition;
7140     //  see 12.3.1 and 12.3.2.
7141     if (isExplicit && !NewFD->isInvalidDecl()) {
7142       if (!CurContext->isRecord()) {
7143         // 'explicit' was specified outside of the class.
7144         Diag(D.getDeclSpec().getExplicitSpecLoc(),
7145              diag::err_explicit_out_of_class)
7146           << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7147       } else if (!isa<CXXConstructorDecl>(NewFD) &&
7148                  !isa<CXXConversionDecl>(NewFD)) {
7149         // 'explicit' was specified on a function that wasn't a constructor
7150         // or conversion function.
7151         Diag(D.getDeclSpec().getExplicitSpecLoc(),
7152              diag::err_explicit_non_ctor_or_conv_function)
7153           << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7154       }
7155     }
7156 
7157     if (isConstexpr) {
7158       // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
7159       // are implicitly inline.
7160       NewFD->setImplicitlyInline();
7161 
7162       // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
7163       // be either constructors or to return a literal type. Therefore,
7164       // destructors cannot be declared constexpr.
7165       if (isa<CXXDestructorDecl>(NewFD))
7166         Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
7167     }
7168 
7169     // If __module_private__ was specified, mark the function accordingly.
7170     if (D.getDeclSpec().isModulePrivateSpecified()) {
7171       if (isFunctionTemplateSpecialization) {
7172         SourceLocation ModulePrivateLoc
7173           = D.getDeclSpec().getModulePrivateSpecLoc();
7174         Diag(ModulePrivateLoc, diag::err_module_private_specialization)
7175           << 0
7176           << FixItHint::CreateRemoval(ModulePrivateLoc);
7177       } else {
7178         NewFD->setModulePrivate();
7179         if (FunctionTemplate)
7180           FunctionTemplate->setModulePrivate();
7181       }
7182     }
7183 
7184     if (isFriend) {
7185       if (FunctionTemplate) {
7186         FunctionTemplate->setObjectOfFriendDecl();
7187         FunctionTemplate->setAccess(AS_public);
7188       }
7189       NewFD->setObjectOfFriendDecl();
7190       NewFD->setAccess(AS_public);
7191     }
7192 
7193     // If a function is defined as defaulted or deleted, mark it as such now.
7194     // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
7195     // definition kind to FDK_Definition.
7196     switch (D.getFunctionDefinitionKind()) {
7197       case FDK_Declaration:
7198       case FDK_Definition:
7199         break;
7200 
7201       case FDK_Defaulted:
7202         NewFD->setDefaulted();
7203         break;
7204 
7205       case FDK_Deleted:
7206         NewFD->setDeletedAsWritten();
7207         break;
7208     }
7209 
7210     if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
7211         D.isFunctionDefinition()) {
7212       // C++ [class.mfct]p2:
7213       //   A member function may be defined (8.4) in its class definition, in
7214       //   which case it is an inline member function (7.1.2)
7215       NewFD->setImplicitlyInline();
7216     }
7217 
7218     if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
7219         !CurContext->isRecord()) {
7220       // C++ [class.static]p1:
7221       //   A data or function member of a class may be declared static
7222       //   in a class definition, in which case it is a static member of
7223       //   the class.
7224 
7225       // Complain about the 'static' specifier if it's on an out-of-line
7226       // member function definition.
7227       Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7228            diag::err_static_out_of_line)
7229         << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
7230     }
7231 
7232     // C++11 [except.spec]p15:
7233     //   A deallocation function with no exception-specification is treated
7234     //   as if it were specified with noexcept(true).
7235     const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
7236     if ((Name.getCXXOverloadedOperator() == OO_Delete ||
7237          Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
7238         getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
7239       NewFD->setType(Context.getFunctionType(
7240           FPT->getReturnType(), FPT->getParamTypes(),
7241           FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept)));
7242   }
7243 
7244   // Filter out previous declarations that don't match the scope.
7245   FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
7246                        D.getCXXScopeSpec().isNotEmpty() ||
7247                        isExplicitSpecialization ||
7248                        isFunctionTemplateSpecialization);
7249 
7250   // Handle GNU asm-label extension (encoded as an attribute).
7251   if (Expr *E = (Expr*) D.getAsmLabel()) {
7252     // The parser guarantees this is a string.
7253     StringLiteral *SE = cast<StringLiteral>(E);
7254     NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
7255                                                 SE->getString(), 0));
7256   } else if (!ExtnameUndeclaredIdentifiers.empty()) {
7257     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7258       ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
7259     if (I != ExtnameUndeclaredIdentifiers.end()) {
7260       NewFD->addAttr(I->second);
7261       ExtnameUndeclaredIdentifiers.erase(I);
7262     }
7263   }
7264 
7265   // Copy the parameter declarations from the declarator D to the function
7266   // declaration NewFD, if they are available.  First scavenge them into Params.
7267   SmallVector<ParmVarDecl*, 16> Params;
7268   if (D.isFunctionDeclarator()) {
7269     DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
7270 
7271     // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
7272     // function that takes no arguments, not a function that takes a
7273     // single void argument.
7274     // We let through "const void" here because Sema::GetTypeForDeclarator
7275     // already checks for that case.
7276     if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
7277       for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
7278         ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
7279         assert(Param->getDeclContext() != NewFD && "Was set before ?");
7280         Param->setDeclContext(NewFD);
7281         Params.push_back(Param);
7282 
7283         if (Param->isInvalidDecl())
7284           NewFD->setInvalidDecl();
7285       }
7286     }
7287 
7288   } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
7289     // When we're declaring a function with a typedef, typeof, etc as in the
7290     // following example, we'll need to synthesize (unnamed)
7291     // parameters for use in the declaration.
7292     //
7293     // @code
7294     // typedef void fn(int);
7295     // fn f;
7296     // @endcode
7297 
7298     // Synthesize a parameter for each argument type.
7299     for (const auto &AI : FT->param_types()) {
7300       ParmVarDecl *Param =
7301           BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
7302       Param->setScopeInfo(0, Params.size());
7303       Params.push_back(Param);
7304     }
7305   } else {
7306     assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
7307            "Should not need args for typedef of non-prototype fn");
7308   }
7309 
7310   // Finally, we know we have the right number of parameters, install them.
7311   NewFD->setParams(Params);
7312 
7313   // Find all anonymous symbols defined during the declaration of this function
7314   // and add to NewFD. This lets us track decls such 'enum Y' in:
7315   //
7316   //   void f(enum Y {AA} x) {}
7317   //
7318   // which would otherwise incorrectly end up in the translation unit scope.
7319   NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
7320   DeclsInPrototypeScope.clear();
7321 
7322   if (D.getDeclSpec().isNoreturnSpecified())
7323     NewFD->addAttr(
7324         ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
7325                                        Context, 0));
7326 
7327   // Functions returning a variably modified type violate C99 6.7.5.2p2
7328   // because all functions have linkage.
7329   if (!NewFD->isInvalidDecl() &&
7330       NewFD->getReturnType()->isVariablyModifiedType()) {
7331     Diag(NewFD->getLocation(), diag::err_vm_func_decl);
7332     NewFD->setInvalidDecl();
7333   }
7334 
7335   if (D.isFunctionDefinition() && CodeSegStack.CurrentValue &&
7336       !NewFD->hasAttr<SectionAttr>()) {
7337     NewFD->addAttr(
7338         SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
7339                                     CodeSegStack.CurrentValue->getString(),
7340                                     CodeSegStack.CurrentPragmaLocation));
7341     if (UnifySection(CodeSegStack.CurrentValue->getString(),
7342                      ASTContext::PSF_Implicit | ASTContext::PSF_Execute |
7343                          ASTContext::PSF_Read,
7344                      NewFD))
7345       NewFD->dropAttr<SectionAttr>();
7346   }
7347 
7348   // Handle attributes.
7349   ProcessDeclAttributes(S, NewFD, D);
7350 
7351   QualType RetType = NewFD->getReturnType();
7352   const CXXRecordDecl *Ret = RetType->isRecordType() ?
7353       RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl();
7354   if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() &&
7355       Ret && Ret->hasAttr<WarnUnusedResultAttr>()) {
7356     const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7357     // Attach WarnUnusedResult to functions returning types with that attribute.
7358     // Don't apply the attribute to that type's own non-static member functions
7359     // (to avoid warning on things like assignment operators)
7360     if (!MD || MD->getParent() != Ret)
7361       NewFD->addAttr(WarnUnusedResultAttr::CreateImplicit(Context));
7362   }
7363 
7364   if (getLangOpts().OpenCL) {
7365     // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
7366     // type declaration will generate a compilation error.
7367     unsigned AddressSpace = RetType.getAddressSpace();
7368     if (AddressSpace == LangAS::opencl_local ||
7369         AddressSpace == LangAS::opencl_global ||
7370         AddressSpace == LangAS::opencl_constant) {
7371       Diag(NewFD->getLocation(),
7372            diag::err_opencl_return_value_with_address_space);
7373       NewFD->setInvalidDecl();
7374     }
7375   }
7376 
7377   if (!getLangOpts().CPlusPlus) {
7378     // Perform semantic checking on the function declaration.
7379     bool isExplicitSpecialization=false;
7380     if (!NewFD->isInvalidDecl() && NewFD->isMain())
7381       CheckMain(NewFD, D.getDeclSpec());
7382 
7383     if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7384       CheckMSVCRTEntryPoint(NewFD);
7385 
7386     if (!NewFD->isInvalidDecl())
7387       D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7388                                                   isExplicitSpecialization));
7389     else if (!Previous.empty())
7390       // Make graceful recovery from an invalid redeclaration.
7391       D.setRedeclaration(true);
7392     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7393             Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7394            "previous declaration set still overloaded");
7395 
7396     // Diagnose no-prototype function declarations with calling conventions that
7397     // don't support variadic calls. Only do this in C and do it after merging
7398     // possibly prototyped redeclarations.
7399     const FunctionType *FT = NewFD->getType()->castAs<FunctionType>();
7400     if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {
7401       CallingConv CC = FT->getExtInfo().getCC();
7402       if (!supportsVariadicCall(CC)) {
7403         // Windows system headers sometimes accidentally use stdcall without
7404         // (void) parameters, so we relax this to a warning.
7405         int DiagID =
7406             CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;
7407         Diag(NewFD->getLocation(), DiagID)
7408             << FunctionType::getNameForCallConv(CC);
7409       }
7410     }
7411   } else {
7412     // C++11 [replacement.functions]p3:
7413     //  The program's definitions shall not be specified as inline.
7414     //
7415     // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
7416     //
7417     // Suppress the diagnostic if the function is __attribute__((used)), since
7418     // that forces an external definition to be emitted.
7419     if (D.getDeclSpec().isInlineSpecified() &&
7420         NewFD->isReplaceableGlobalAllocationFunction() &&
7421         !NewFD->hasAttr<UsedAttr>())
7422       Diag(D.getDeclSpec().getInlineSpecLoc(),
7423            diag::ext_operator_new_delete_declared_inline)
7424         << NewFD->getDeclName();
7425 
7426     // If the declarator is a template-id, translate the parser's template
7427     // argument list into our AST format.
7428     if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
7429       TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
7430       TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
7431       TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
7432       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
7433                                          TemplateId->NumArgs);
7434       translateTemplateArguments(TemplateArgsPtr,
7435                                  TemplateArgs);
7436 
7437       HasExplicitTemplateArgs = true;
7438 
7439       if (NewFD->isInvalidDecl()) {
7440         HasExplicitTemplateArgs = false;
7441       } else if (FunctionTemplate) {
7442         // Function template with explicit template arguments.
7443         Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
7444           << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
7445 
7446         HasExplicitTemplateArgs = false;
7447       } else {
7448         assert((isFunctionTemplateSpecialization ||
7449                 D.getDeclSpec().isFriendSpecified()) &&
7450                "should have a 'template<>' for this decl");
7451         // "friend void foo<>(int);" is an implicit specialization decl.
7452         isFunctionTemplateSpecialization = true;
7453       }
7454     } else if (isFriend && isFunctionTemplateSpecialization) {
7455       // This combination is only possible in a recovery case;  the user
7456       // wrote something like:
7457       //   template <> friend void foo(int);
7458       // which we're recovering from as if the user had written:
7459       //   friend void foo<>(int);
7460       // Go ahead and fake up a template id.
7461       HasExplicitTemplateArgs = true;
7462       TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
7463       TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
7464     }
7465 
7466     // If it's a friend (and only if it's a friend), it's possible
7467     // that either the specialized function type or the specialized
7468     // template is dependent, and therefore matching will fail.  In
7469     // this case, don't check the specialization yet.
7470     bool InstantiationDependent = false;
7471     if (isFunctionTemplateSpecialization && isFriend &&
7472         (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
7473          TemplateSpecializationType::anyDependentTemplateArguments(
7474             TemplateArgs.getArgumentArray(), TemplateArgs.size(),
7475             InstantiationDependent))) {
7476       assert(HasExplicitTemplateArgs &&
7477              "friend function specialization without template args");
7478       if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
7479                                                        Previous))
7480         NewFD->setInvalidDecl();
7481     } else if (isFunctionTemplateSpecialization) {
7482       if (CurContext->isDependentContext() && CurContext->isRecord()
7483           && !isFriend) {
7484         isDependentClassScopeExplicitSpecialization = true;
7485         Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
7486           diag::ext_function_specialization_in_class :
7487           diag::err_function_specialization_in_class)
7488           << NewFD->getDeclName();
7489       } else if (CheckFunctionTemplateSpecialization(NewFD,
7490                                   (HasExplicitTemplateArgs ? &TemplateArgs
7491                                                            : nullptr),
7492                                                      Previous))
7493         NewFD->setInvalidDecl();
7494 
7495       // C++ [dcl.stc]p1:
7496       //   A storage-class-specifier shall not be specified in an explicit
7497       //   specialization (14.7.3)
7498       FunctionTemplateSpecializationInfo *Info =
7499           NewFD->getTemplateSpecializationInfo();
7500       if (Info && SC != SC_None) {
7501         if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
7502           Diag(NewFD->getLocation(),
7503                diag::err_explicit_specialization_inconsistent_storage_class)
7504             << SC
7505             << FixItHint::CreateRemoval(
7506                                       D.getDeclSpec().getStorageClassSpecLoc());
7507 
7508         else
7509           Diag(NewFD->getLocation(),
7510                diag::ext_explicit_specialization_storage_class)
7511             << FixItHint::CreateRemoval(
7512                                       D.getDeclSpec().getStorageClassSpecLoc());
7513       }
7514 
7515     } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
7516       if (CheckMemberSpecialization(NewFD, Previous))
7517           NewFD->setInvalidDecl();
7518     }
7519 
7520     // Perform semantic checking on the function declaration.
7521     if (!isDependentClassScopeExplicitSpecialization) {
7522       if (!NewFD->isInvalidDecl() && NewFD->isMain())
7523         CheckMain(NewFD, D.getDeclSpec());
7524 
7525       if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7526         CheckMSVCRTEntryPoint(NewFD);
7527 
7528       if (!NewFD->isInvalidDecl())
7529         D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7530                                                     isExplicitSpecialization));
7531     }
7532 
7533     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7534             Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7535            "previous declaration set still overloaded");
7536 
7537     NamedDecl *PrincipalDecl = (FunctionTemplate
7538                                 ? cast<NamedDecl>(FunctionTemplate)
7539                                 : NewFD);
7540 
7541     if (isFriend && D.isRedeclaration()) {
7542       AccessSpecifier Access = AS_public;
7543       if (!NewFD->isInvalidDecl())
7544         Access = NewFD->getPreviousDecl()->getAccess();
7545 
7546       NewFD->setAccess(Access);
7547       if (FunctionTemplate) FunctionTemplate->setAccess(Access);
7548     }
7549 
7550     if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
7551         PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
7552       PrincipalDecl->setNonMemberOperator();
7553 
7554     // If we have a function template, check the template parameter
7555     // list. This will check and merge default template arguments.
7556     if (FunctionTemplate) {
7557       FunctionTemplateDecl *PrevTemplate =
7558                                      FunctionTemplate->getPreviousDecl();
7559       CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
7560                        PrevTemplate ? PrevTemplate->getTemplateParameters()
7561                                     : nullptr,
7562                             D.getDeclSpec().isFriendSpecified()
7563                               ? (D.isFunctionDefinition()
7564                                    ? TPC_FriendFunctionTemplateDefinition
7565                                    : TPC_FriendFunctionTemplate)
7566                               : (D.getCXXScopeSpec().isSet() &&
7567                                  DC && DC->isRecord() &&
7568                                  DC->isDependentContext())
7569                                   ? TPC_ClassTemplateMember
7570                                   : TPC_FunctionTemplate);
7571     }
7572 
7573     if (NewFD->isInvalidDecl()) {
7574       // Ignore all the rest of this.
7575     } else if (!D.isRedeclaration()) {
7576       struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
7577                                        AddToScope };
7578       // Fake up an access specifier if it's supposed to be a class member.
7579       if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
7580         NewFD->setAccess(AS_public);
7581 
7582       // Qualified decls generally require a previous declaration.
7583       if (D.getCXXScopeSpec().isSet()) {
7584         // ...with the major exception of templated-scope or
7585         // dependent-scope friend declarations.
7586 
7587         // TODO: we currently also suppress this check in dependent
7588         // contexts because (1) the parameter depth will be off when
7589         // matching friend templates and (2) we might actually be
7590         // selecting a friend based on a dependent factor.  But there
7591         // are situations where these conditions don't apply and we
7592         // can actually do this check immediately.
7593         if (isFriend &&
7594             (TemplateParamLists.size() ||
7595              D.getCXXScopeSpec().getScopeRep()->isDependent() ||
7596              CurContext->isDependentContext())) {
7597           // ignore these
7598         } else {
7599           // The user tried to provide an out-of-line definition for a
7600           // function that is a member of a class or namespace, but there
7601           // was no such member function declared (C++ [class.mfct]p2,
7602           // C++ [namespace.memdef]p2). For example:
7603           //
7604           // class X {
7605           //   void f() const;
7606           // };
7607           //
7608           // void X::f() { } // ill-formed
7609           //
7610           // Complain about this problem, and attempt to suggest close
7611           // matches (e.g., those that differ only in cv-qualifiers and
7612           // whether the parameter types are references).
7613 
7614           if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7615                   *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
7616             AddToScope = ExtraArgs.AddToScope;
7617             return Result;
7618           }
7619         }
7620 
7621         // Unqualified local friend declarations are required to resolve
7622         // to something.
7623       } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
7624         if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7625                 *this, Previous, NewFD, ExtraArgs, true, S)) {
7626           AddToScope = ExtraArgs.AddToScope;
7627           return Result;
7628         }
7629       }
7630 
7631     } else if (!D.isFunctionDefinition() &&
7632                isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
7633                !isFriend && !isFunctionTemplateSpecialization &&
7634                !isExplicitSpecialization) {
7635       // An out-of-line member function declaration must also be a
7636       // definition (C++ [class.mfct]p2).
7637       // Note that this is not the case for explicit specializations of
7638       // function templates or member functions of class templates, per
7639       // C++ [temp.expl.spec]p2. We also allow these declarations as an
7640       // extension for compatibility with old SWIG code which likes to
7641       // generate them.
7642       Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
7643         << D.getCXXScopeSpec().getRange();
7644     }
7645   }
7646 
7647   ProcessPragmaWeak(S, NewFD);
7648   checkAttributesAfterMerging(*this, *NewFD);
7649 
7650   AddKnownFunctionAttributes(NewFD);
7651 
7652   if (NewFD->hasAttr<OverloadableAttr>() &&
7653       !NewFD->getType()->getAs<FunctionProtoType>()) {
7654     Diag(NewFD->getLocation(),
7655          diag::err_attribute_overloadable_no_prototype)
7656       << NewFD;
7657 
7658     // Turn this into a variadic function with no parameters.
7659     const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
7660     FunctionProtoType::ExtProtoInfo EPI(
7661         Context.getDefaultCallingConvention(true, false));
7662     EPI.Variadic = true;
7663     EPI.ExtInfo = FT->getExtInfo();
7664 
7665     QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
7666     NewFD->setType(R);
7667   }
7668 
7669   // If there's a #pragma GCC visibility in scope, and this isn't a class
7670   // member, set the visibility of this function.
7671   if (!DC->isRecord() && NewFD->isExternallyVisible())
7672     AddPushedVisibilityAttribute(NewFD);
7673 
7674   // If there's a #pragma clang arc_cf_code_audited in scope, consider
7675   // marking the function.
7676   AddCFAuditedAttribute(NewFD);
7677 
7678   // If this is a function definition, check if we have to apply optnone due to
7679   // a pragma.
7680   if(D.isFunctionDefinition())
7681     AddRangeBasedOptnone(NewFD);
7682 
7683   // If this is the first declaration of an extern C variable, update
7684   // the map of such variables.
7685   if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
7686       isIncompleteDeclExternC(*this, NewFD))
7687     RegisterLocallyScopedExternCDecl(NewFD, S);
7688 
7689   // Set this FunctionDecl's range up to the right paren.
7690   NewFD->setRangeEnd(D.getSourceRange().getEnd());
7691 
7692   if (D.isRedeclaration() && !Previous.empty()) {
7693     checkDLLAttributeRedeclaration(
7694         *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
7695         isExplicitSpecialization || isFunctionTemplateSpecialization);
7696   }
7697 
7698   if (getLangOpts().CPlusPlus) {
7699     if (FunctionTemplate) {
7700       if (NewFD->isInvalidDecl())
7701         FunctionTemplate->setInvalidDecl();
7702       return FunctionTemplate;
7703     }
7704   }
7705 
7706   if (NewFD->hasAttr<OpenCLKernelAttr>()) {
7707     // OpenCL v1.2 s6.8 static is invalid for kernel functions.
7708     if ((getLangOpts().OpenCLVersion >= 120)
7709         && (SC == SC_Static)) {
7710       Diag(D.getIdentifierLoc(), diag::err_static_kernel);
7711       D.setInvalidType();
7712     }
7713 
7714     // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
7715     if (!NewFD->getReturnType()->isVoidType()) {
7716       SourceRange RTRange = NewFD->getReturnTypeSourceRange();
7717       Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
7718           << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
7719                                 : FixItHint());
7720       D.setInvalidType();
7721     }
7722 
7723     llvm::SmallPtrSet<const Type *, 16> ValidTypes;
7724     for (auto Param : NewFD->params())
7725       checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
7726   }
7727 
7728   MarkUnusedFileScopedDecl(NewFD);
7729 
7730   if (getLangOpts().CUDA)
7731     if (IdentifierInfo *II = NewFD->getIdentifier())
7732       if (!NewFD->isInvalidDecl() &&
7733           NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
7734         if (II->isStr("cudaConfigureCall")) {
7735           if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
7736             Diag(NewFD->getLocation(), diag::err_config_scalar_return);
7737 
7738           Context.setcudaConfigureCallDecl(NewFD);
7739         }
7740       }
7741 
7742   // Here we have an function template explicit specialization at class scope.
7743   // The actually specialization will be postponed to template instatiation
7744   // time via the ClassScopeFunctionSpecializationDecl node.
7745   if (isDependentClassScopeExplicitSpecialization) {
7746     ClassScopeFunctionSpecializationDecl *NewSpec =
7747                          ClassScopeFunctionSpecializationDecl::Create(
7748                                 Context, CurContext, SourceLocation(),
7749                                 cast<CXXMethodDecl>(NewFD),
7750                                 HasExplicitTemplateArgs, TemplateArgs);
7751     CurContext->addDecl(NewSpec);
7752     AddToScope = false;
7753   }
7754 
7755   return NewFD;
7756 }
7757 
7758 /// \brief Perform semantic checking of a new function declaration.
7759 ///
7760 /// Performs semantic analysis of the new function declaration
7761 /// NewFD. This routine performs all semantic checking that does not
7762 /// require the actual declarator involved in the declaration, and is
7763 /// used both for the declaration of functions as they are parsed
7764 /// (called via ActOnDeclarator) and for the declaration of functions
7765 /// that have been instantiated via C++ template instantiation (called
7766 /// via InstantiateDecl).
7767 ///
7768 /// \param IsExplicitSpecialization whether this new function declaration is
7769 /// an explicit specialization of the previous declaration.
7770 ///
7771 /// This sets NewFD->isInvalidDecl() to true if there was an error.
7772 ///
7773 /// \returns true if the function declaration is a redeclaration.
7774 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
7775                                     LookupResult &Previous,
7776                                     bool IsExplicitSpecialization) {
7777   assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
7778          "Variably modified return types are not handled here");
7779 
7780   // Determine whether the type of this function should be merged with
7781   // a previous visible declaration. This never happens for functions in C++,
7782   // and always happens in C if the previous declaration was visible.
7783   bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
7784                                !Previous.isShadowed();
7785 
7786   // Filter out any non-conflicting previous declarations.
7787   filterNonConflictingPreviousDecls(Context, NewFD, Previous);
7788 
7789   bool Redeclaration = false;
7790   NamedDecl *OldDecl = nullptr;
7791 
7792   // Merge or overload the declaration with an existing declaration of
7793   // the same name, if appropriate.
7794   if (!Previous.empty()) {
7795     // Determine whether NewFD is an overload of PrevDecl or
7796     // a declaration that requires merging. If it's an overload,
7797     // there's no more work to do here; we'll just add the new
7798     // function to the scope.
7799     if (!AllowOverloadingOfFunction(Previous, Context)) {
7800       NamedDecl *Candidate = Previous.getFoundDecl();
7801       if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
7802         Redeclaration = true;
7803         OldDecl = Candidate;
7804       }
7805     } else {
7806       switch (CheckOverload(S, NewFD, Previous, OldDecl,
7807                             /*NewIsUsingDecl*/ false)) {
7808       case Ovl_Match:
7809         Redeclaration = true;
7810         break;
7811 
7812       case Ovl_NonFunction:
7813         Redeclaration = true;
7814         break;
7815 
7816       case Ovl_Overload:
7817         Redeclaration = false;
7818         break;
7819       }
7820 
7821       if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
7822         // If a function name is overloadable in C, then every function
7823         // with that name must be marked "overloadable".
7824         Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
7825           << Redeclaration << NewFD;
7826         NamedDecl *OverloadedDecl = nullptr;
7827         if (Redeclaration)
7828           OverloadedDecl = OldDecl;
7829         else if (!Previous.empty())
7830           OverloadedDecl = Previous.getRepresentativeDecl();
7831         if (OverloadedDecl)
7832           Diag(OverloadedDecl->getLocation(),
7833                diag::note_attribute_overloadable_prev_overload);
7834         NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
7835       }
7836     }
7837   }
7838 
7839   // Check for a previous extern "C" declaration with this name.
7840   if (!Redeclaration &&
7841       checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
7842     filterNonConflictingPreviousDecls(Context, NewFD, Previous);
7843     if (!Previous.empty()) {
7844       // This is an extern "C" declaration with the same name as a previous
7845       // declaration, and thus redeclares that entity...
7846       Redeclaration = true;
7847       OldDecl = Previous.getFoundDecl();
7848       MergeTypeWithPrevious = false;
7849 
7850       // ... except in the presence of __attribute__((overloadable)).
7851       if (OldDecl->hasAttr<OverloadableAttr>()) {
7852         if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
7853           Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
7854             << Redeclaration << NewFD;
7855           Diag(Previous.getFoundDecl()->getLocation(),
7856                diag::note_attribute_overloadable_prev_overload);
7857           NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
7858         }
7859         if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
7860           Redeclaration = false;
7861           OldDecl = nullptr;
7862         }
7863       }
7864     }
7865   }
7866 
7867   // C++11 [dcl.constexpr]p8:
7868   //   A constexpr specifier for a non-static member function that is not
7869   //   a constructor declares that member function to be const.
7870   //
7871   // This needs to be delayed until we know whether this is an out-of-line
7872   // definition of a static member function.
7873   //
7874   // This rule is not present in C++1y, so we produce a backwards
7875   // compatibility warning whenever it happens in C++11.
7876   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7877   if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
7878       !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
7879       (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
7880     CXXMethodDecl *OldMD = nullptr;
7881     if (OldDecl)
7882       OldMD = dyn_cast<CXXMethodDecl>(OldDecl->getAsFunction());
7883     if (!OldMD || !OldMD->isStatic()) {
7884       const FunctionProtoType *FPT =
7885         MD->getType()->castAs<FunctionProtoType>();
7886       FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
7887       EPI.TypeQuals |= Qualifiers::Const;
7888       MD->setType(Context.getFunctionType(FPT->getReturnType(),
7889                                           FPT->getParamTypes(), EPI));
7890 
7891       // Warn that we did this, if we're not performing template instantiation.
7892       // In that case, we'll have warned already when the template was defined.
7893       if (ActiveTemplateInstantiations.empty()) {
7894         SourceLocation AddConstLoc;
7895         if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
7896                 .IgnoreParens().getAs<FunctionTypeLoc>())
7897           AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
7898 
7899         Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
7900           << FixItHint::CreateInsertion(AddConstLoc, " const");
7901       }
7902     }
7903   }
7904 
7905   if (Redeclaration) {
7906     // NewFD and OldDecl represent declarations that need to be
7907     // merged.
7908     if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
7909       NewFD->setInvalidDecl();
7910       return Redeclaration;
7911     }
7912 
7913     Previous.clear();
7914     Previous.addDecl(OldDecl);
7915 
7916     if (FunctionTemplateDecl *OldTemplateDecl
7917                                   = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
7918       NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
7919       FunctionTemplateDecl *NewTemplateDecl
7920         = NewFD->getDescribedFunctionTemplate();
7921       assert(NewTemplateDecl && "Template/non-template mismatch");
7922       if (CXXMethodDecl *Method
7923             = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
7924         Method->setAccess(OldTemplateDecl->getAccess());
7925         NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
7926       }
7927 
7928       // If this is an explicit specialization of a member that is a function
7929       // template, mark it as a member specialization.
7930       if (IsExplicitSpecialization &&
7931           NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
7932         NewTemplateDecl->setMemberSpecialization();
7933         assert(OldTemplateDecl->isMemberSpecialization());
7934       }
7935 
7936     } else {
7937       // This needs to happen first so that 'inline' propagates.
7938       NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
7939 
7940       if (isa<CXXMethodDecl>(NewFD)) {
7941         // A valid redeclaration of a C++ method must be out-of-line,
7942         // but (unfortunately) it's not necessarily a definition
7943         // because of templates, which means that the previous
7944         // declaration is not necessarily from the class definition.
7945 
7946         // For just setting the access, that doesn't matter.
7947         CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl);
7948         NewFD->setAccess(oldMethod->getAccess());
7949 
7950         // Update the key-function state if necessary for this ABI.
7951         if (NewFD->isInlined() &&
7952             !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
7953           // setNonKeyFunction needs to work with the original
7954           // declaration from the class definition, and isVirtual() is
7955           // just faster in that case, so map back to that now.
7956           oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDecl());
7957           if (oldMethod->isVirtual()) {
7958             Context.setNonKeyFunction(oldMethod);
7959           }
7960         }
7961       }
7962     }
7963   }
7964 
7965   // Semantic checking for this function declaration (in isolation).
7966 
7967   if (getLangOpts().CPlusPlus) {
7968     // C++-specific checks.
7969     if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
7970       CheckConstructor(Constructor);
7971     } else if (CXXDestructorDecl *Destructor =
7972                 dyn_cast<CXXDestructorDecl>(NewFD)) {
7973       CXXRecordDecl *Record = Destructor->getParent();
7974       QualType ClassType = Context.getTypeDeclType(Record);
7975 
7976       // FIXME: Shouldn't we be able to perform this check even when the class
7977       // type is dependent? Both gcc and edg can handle that.
7978       if (!ClassType->isDependentType()) {
7979         DeclarationName Name
7980           = Context.DeclarationNames.getCXXDestructorName(
7981                                         Context.getCanonicalType(ClassType));
7982         if (NewFD->getDeclName() != Name) {
7983           Diag(NewFD->getLocation(), diag::err_destructor_name);
7984           NewFD->setInvalidDecl();
7985           return Redeclaration;
7986         }
7987       }
7988     } else if (CXXConversionDecl *Conversion
7989                = dyn_cast<CXXConversionDecl>(NewFD)) {
7990       ActOnConversionDeclarator(Conversion);
7991     }
7992 
7993     // Find any virtual functions that this function overrides.
7994     if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
7995       if (!Method->isFunctionTemplateSpecialization() &&
7996           !Method->getDescribedFunctionTemplate() &&
7997           Method->isCanonicalDecl()) {
7998         if (AddOverriddenMethods(Method->getParent(), Method)) {
7999           // If the function was marked as "static", we have a problem.
8000           if (NewFD->getStorageClass() == SC_Static) {
8001             ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
8002           }
8003         }
8004       }
8005 
8006       if (Method->isStatic())
8007         checkThisInStaticMemberFunctionType(Method);
8008     }
8009 
8010     // Extra checking for C++ overloaded operators (C++ [over.oper]).
8011     if (NewFD->isOverloadedOperator() &&
8012         CheckOverloadedOperatorDeclaration(NewFD)) {
8013       NewFD->setInvalidDecl();
8014       return Redeclaration;
8015     }
8016 
8017     // Extra checking for C++0x literal operators (C++0x [over.literal]).
8018     if (NewFD->getLiteralIdentifier() &&
8019         CheckLiteralOperatorDeclaration(NewFD)) {
8020       NewFD->setInvalidDecl();
8021       return Redeclaration;
8022     }
8023 
8024     // In C++, check default arguments now that we have merged decls. Unless
8025     // the lexical context is the class, because in this case this is done
8026     // during delayed parsing anyway.
8027     if (!CurContext->isRecord())
8028       CheckCXXDefaultArguments(NewFD);
8029 
8030     // If this function declares a builtin function, check the type of this
8031     // declaration against the expected type for the builtin.
8032     if (unsigned BuiltinID = NewFD->getBuiltinID()) {
8033       ASTContext::GetBuiltinTypeError Error;
8034       LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
8035       QualType T = Context.GetBuiltinType(BuiltinID, Error);
8036       if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
8037         // The type of this function differs from the type of the builtin,
8038         // so forget about the builtin entirely.
8039         Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
8040       }
8041     }
8042 
8043     // If this function is declared as being extern "C", then check to see if
8044     // the function returns a UDT (class, struct, or union type) that is not C
8045     // compatible, and if it does, warn the user.
8046     // But, issue any diagnostic on the first declaration only.
8047     if (NewFD->isExternC() && Previous.empty()) {
8048       QualType R = NewFD->getReturnType();
8049       if (R->isIncompleteType() && !R->isVoidType())
8050         Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
8051             << NewFD << R;
8052       else if (!R.isPODType(Context) && !R->isVoidType() &&
8053                !R->isObjCObjectPointerType())
8054         Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
8055     }
8056   }
8057   return Redeclaration;
8058 }
8059 
8060 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
8061   // C++11 [basic.start.main]p3:
8062   //   A program that [...] declares main to be inline, static or
8063   //   constexpr is ill-formed.
8064   // C11 6.7.4p4:  In a hosted environment, no function specifier(s) shall
8065   //   appear in a declaration of main.
8066   // static main is not an error under C99, but we should warn about it.
8067   // We accept _Noreturn main as an extension.
8068   if (FD->getStorageClass() == SC_Static)
8069     Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
8070          ? diag::err_static_main : diag::warn_static_main)
8071       << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
8072   if (FD->isInlineSpecified())
8073     Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8074       << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
8075   if (DS.isNoreturnSpecified()) {
8076     SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
8077     SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
8078     Diag(NoreturnLoc, diag::ext_noreturn_main);
8079     Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8080       << FixItHint::CreateRemoval(NoreturnRange);
8081   }
8082   if (FD->isConstexpr()) {
8083     Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8084       << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
8085     FD->setConstexpr(false);
8086   }
8087 
8088   if (getLangOpts().OpenCL) {
8089     Diag(FD->getLocation(), diag::err_opencl_no_main)
8090         << FD->hasAttr<OpenCLKernelAttr>();
8091     FD->setInvalidDecl();
8092     return;
8093   }
8094 
8095   QualType T = FD->getType();
8096   assert(T->isFunctionType() && "function decl is not of function type");
8097   const FunctionType* FT = T->castAs<FunctionType>();
8098 
8099   if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8100     // In C with GNU extensions we allow main() to have non-integer return
8101     // type, but we should warn about the extension, and we disable the
8102     // implicit-return-zero rule.
8103 
8104     // GCC in C mode accepts qualified 'int'.
8105     if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8106       FD->setHasImplicitReturnZero(true);
8107     else {
8108       Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8109       SourceRange RTRange = FD->getReturnTypeSourceRange();
8110       if (RTRange.isValid())
8111         Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8112             << FixItHint::CreateReplacement(RTRange, "int");
8113     }
8114   } else {
8115     // In C and C++, main magically returns 0 if you fall off the end;
8116     // set the flag which tells us that.
8117     // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
8118 
8119     // All the standards say that main() should return 'int'.
8120     if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8121       FD->setHasImplicitReturnZero(true);
8122     else {
8123       // Otherwise, this is just a flat-out error.
8124       SourceRange RTRange = FD->getReturnTypeSourceRange();
8125       Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8126           << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8127                                 : FixItHint());
8128       FD->setInvalidDecl(true);
8129     }
8130   }
8131 
8132   // Treat protoless main() as nullary.
8133   if (isa<FunctionNoProtoType>(FT)) return;
8134 
8135   const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
8136   unsigned nparams = FTP->getNumParams();
8137   assert(FD->getNumParams() == nparams);
8138 
8139   bool HasExtraParameters = (nparams > 3);
8140 
8141   // Darwin passes an undocumented fourth argument of type char**.  If
8142   // other platforms start sprouting these, the logic below will start
8143   // getting shifty.
8144   if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
8145     HasExtraParameters = false;
8146 
8147   if (HasExtraParameters) {
8148     Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
8149     FD->setInvalidDecl(true);
8150     nparams = 3;
8151   }
8152 
8153   // FIXME: a lot of the following diagnostics would be improved
8154   // if we had some location information about types.
8155 
8156   QualType CharPP =
8157     Context.getPointerType(Context.getPointerType(Context.CharTy));
8158   QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
8159 
8160   for (unsigned i = 0; i < nparams; ++i) {
8161     QualType AT = FTP->getParamType(i);
8162 
8163     bool mismatch = true;
8164 
8165     if (Context.hasSameUnqualifiedType(AT, Expected[i]))
8166       mismatch = false;
8167     else if (Expected[i] == CharPP) {
8168       // As an extension, the following forms are okay:
8169       //   char const **
8170       //   char const * const *
8171       //   char * const *
8172 
8173       QualifierCollector qs;
8174       const PointerType* PT;
8175       if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
8176           (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
8177           Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
8178                               Context.CharTy)) {
8179         qs.removeConst();
8180         mismatch = !qs.empty();
8181       }
8182     }
8183 
8184     if (mismatch) {
8185       Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
8186       // TODO: suggest replacing given type with expected type
8187       FD->setInvalidDecl(true);
8188     }
8189   }
8190 
8191   if (nparams == 1 && !FD->isInvalidDecl()) {
8192     Diag(FD->getLocation(), diag::warn_main_one_arg);
8193   }
8194 
8195   if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8196     Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8197     FD->setInvalidDecl();
8198   }
8199 }
8200 
8201 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
8202   QualType T = FD->getType();
8203   assert(T->isFunctionType() && "function decl is not of function type");
8204   const FunctionType *FT = T->castAs<FunctionType>();
8205 
8206   // Set an implicit return of 'zero' if the function can return some integral,
8207   // enumeration, pointer or nullptr type.
8208   if (FT->getReturnType()->isIntegralOrEnumerationType() ||
8209       FT->getReturnType()->isAnyPointerType() ||
8210       FT->getReturnType()->isNullPtrType())
8211     // DllMain is exempt because a return value of zero means it failed.
8212     if (FD->getName() != "DllMain")
8213       FD->setHasImplicitReturnZero(true);
8214 
8215   if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8216     Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8217     FD->setInvalidDecl();
8218   }
8219 }
8220 
8221 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
8222   // FIXME: Need strict checking.  In C89, we need to check for
8223   // any assignment, increment, decrement, function-calls, or
8224   // commas outside of a sizeof.  In C99, it's the same list,
8225   // except that the aforementioned are allowed in unevaluated
8226   // expressions.  Everything else falls under the
8227   // "may accept other forms of constant expressions" exception.
8228   // (We never end up here for C++, so the constant expression
8229   // rules there don't matter.)
8230   const Expr *Culprit;
8231   if (Init->isConstantInitializer(Context, false, &Culprit))
8232     return false;
8233   Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
8234     << Culprit->getSourceRange();
8235   return true;
8236 }
8237 
8238 namespace {
8239   // Visits an initialization expression to see if OrigDecl is evaluated in
8240   // its own initialization and throws a warning if it does.
8241   class SelfReferenceChecker
8242       : public EvaluatedExprVisitor<SelfReferenceChecker> {
8243     Sema &S;
8244     Decl *OrigDecl;
8245     bool isRecordType;
8246     bool isPODType;
8247     bool isReferenceType;
8248 
8249     bool isInitList;
8250     llvm::SmallVector<unsigned, 4> InitFieldIndex;
8251   public:
8252     typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
8253 
8254     SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
8255                                                     S(S), OrigDecl(OrigDecl) {
8256       isPODType = false;
8257       isRecordType = false;
8258       isReferenceType = false;
8259       isInitList = false;
8260       if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
8261         isPODType = VD->getType().isPODType(S.Context);
8262         isRecordType = VD->getType()->isRecordType();
8263         isReferenceType = VD->getType()->isReferenceType();
8264       }
8265     }
8266 
8267     // For most expressions, just call the visitor.  For initializer lists,
8268     // track the index of the field being initialized since fields are
8269     // initialized in order allowing use of previously initialized fields.
8270     void CheckExpr(Expr *E) {
8271       InitListExpr *InitList = dyn_cast<InitListExpr>(E);
8272       if (!InitList) {
8273         Visit(E);
8274         return;
8275       }
8276 
8277       // Track and increment the index here.
8278       isInitList = true;
8279       InitFieldIndex.push_back(0);
8280       for (auto Child : InitList->children()) {
8281         CheckExpr(cast<Expr>(Child));
8282         ++InitFieldIndex.back();
8283       }
8284       InitFieldIndex.pop_back();
8285     }
8286 
8287     // Returns true if MemberExpr is checked and no futher checking is needed.
8288     // Returns false if additional checking is required.
8289     bool CheckInitListMemberExpr(MemberExpr *E, bool CheckReference) {
8290       llvm::SmallVector<FieldDecl*, 4> Fields;
8291       Expr *Base = E;
8292       bool ReferenceField = false;
8293 
8294       // Get the field memebers used.
8295       while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8296         FieldDecl *FD = dyn_cast<FieldDecl>(ME->getMemberDecl());
8297         if (!FD)
8298           return false;
8299         Fields.push_back(FD);
8300         if (FD->getType()->isReferenceType())
8301           ReferenceField = true;
8302         Base = ME->getBase()->IgnoreParenImpCasts();
8303       }
8304 
8305       // Keep checking only if the base Decl is the same.
8306       DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base);
8307       if (!DRE || DRE->getDecl() != OrigDecl)
8308         return false;
8309 
8310       // A reference field can be bound to an unininitialized field.
8311       if (CheckReference && !ReferenceField)
8312         return true;
8313 
8314       // Convert FieldDecls to their index number.
8315       llvm::SmallVector<unsigned, 4> UsedFieldIndex;
8316       for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) {
8317         UsedFieldIndex.push_back((*I)->getFieldIndex());
8318       }
8319 
8320       // See if a warning is needed by checking the first difference in index
8321       // numbers.  If field being used has index less than the field being
8322       // initialized, then the use is safe.
8323       for (auto UsedIter = UsedFieldIndex.begin(),
8324                 UsedEnd = UsedFieldIndex.end(),
8325                 OrigIter = InitFieldIndex.begin(),
8326                 OrigEnd = InitFieldIndex.end();
8327            UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {
8328         if (*UsedIter < *OrigIter)
8329           return true;
8330         if (*UsedIter > *OrigIter)
8331           break;
8332       }
8333 
8334       // TODO: Add a different warning which will print the field names.
8335       HandleDeclRefExpr(DRE);
8336       return true;
8337     }
8338 
8339     // For most expressions, the cast is directly above the DeclRefExpr.
8340     // For conditional operators, the cast can be outside the conditional
8341     // operator if both expressions are DeclRefExpr's.
8342     void HandleValue(Expr *E) {
8343       E = E->IgnoreParens();
8344       if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
8345         HandleDeclRefExpr(DRE);
8346         return;
8347       }
8348 
8349       if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
8350         Visit(CO->getCond());
8351         HandleValue(CO->getTrueExpr());
8352         HandleValue(CO->getFalseExpr());
8353         return;
8354       }
8355 
8356       if (BinaryConditionalOperator *BCO =
8357               dyn_cast<BinaryConditionalOperator>(E)) {
8358         Visit(BCO->getCond());
8359         HandleValue(BCO->getFalseExpr());
8360         return;
8361       }
8362 
8363       if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
8364         HandleValue(OVE->getSourceExpr());
8365         return;
8366       }
8367 
8368       if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
8369         if (BO->getOpcode() == BO_Comma) {
8370           Visit(BO->getLHS());
8371           HandleValue(BO->getRHS());
8372           return;
8373         }
8374       }
8375 
8376       if (isa<MemberExpr>(E)) {
8377         if (isInitList) {
8378           if (CheckInitListMemberExpr(cast<MemberExpr>(E),
8379                                       false /*CheckReference*/))
8380             return;
8381         }
8382 
8383         Expr *Base = E->IgnoreParenImpCasts();
8384         while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8385           // Check for static member variables and don't warn on them.
8386           if (!isa<FieldDecl>(ME->getMemberDecl()))
8387             return;
8388           Base = ME->getBase()->IgnoreParenImpCasts();
8389         }
8390         if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
8391           HandleDeclRefExpr(DRE);
8392         return;
8393       }
8394 
8395       Visit(E);
8396     }
8397 
8398     // Reference types not handled in HandleValue are handled here since all
8399     // uses of references are bad, not just r-value uses.
8400     void VisitDeclRefExpr(DeclRefExpr *E) {
8401       if (isReferenceType)
8402         HandleDeclRefExpr(E);
8403     }
8404 
8405     void VisitImplicitCastExpr(ImplicitCastExpr *E) {
8406       if (E->getCastKind() == CK_LValueToRValue) {
8407         HandleValue(E->getSubExpr());
8408         return;
8409       }
8410 
8411       Inherited::VisitImplicitCastExpr(E);
8412     }
8413 
8414     void VisitMemberExpr(MemberExpr *E) {
8415       if (isInitList) {
8416         if (CheckInitListMemberExpr(E, true /*CheckReference*/))
8417           return;
8418       }
8419 
8420       // Don't warn on arrays since they can be treated as pointers.
8421       if (E->getType()->canDecayToPointerType()) return;
8422 
8423       // Warn when a non-static method call is followed by non-static member
8424       // field accesses, which is followed by a DeclRefExpr.
8425       CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
8426       bool Warn = (MD && !MD->isStatic());
8427       Expr *Base = E->getBase()->IgnoreParenImpCasts();
8428       while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8429         if (!isa<FieldDecl>(ME->getMemberDecl()))
8430           Warn = false;
8431         Base = ME->getBase()->IgnoreParenImpCasts();
8432       }
8433 
8434       if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
8435         if (Warn)
8436           HandleDeclRefExpr(DRE);
8437         return;
8438       }
8439 
8440       // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
8441       // Visit that expression.
8442       Visit(Base);
8443     }
8444 
8445     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8446       Expr *Callee = E->getCallee();
8447 
8448       if (isa<UnresolvedLookupExpr>(Callee))
8449         return Inherited::VisitCXXOperatorCallExpr(E);
8450 
8451       Visit(Callee);
8452       for (auto Arg: E->arguments())
8453         HandleValue(Arg->IgnoreParenImpCasts());
8454     }
8455 
8456     void VisitUnaryOperator(UnaryOperator *E) {
8457       // For POD record types, addresses of its own members are well-defined.
8458       if (E->getOpcode() == UO_AddrOf && isRecordType &&
8459           isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
8460         if (!isPODType)
8461           HandleValue(E->getSubExpr());
8462         return;
8463       }
8464 
8465       if (E->isIncrementDecrementOp()) {
8466         HandleValue(E->getSubExpr());
8467         return;
8468       }
8469 
8470       Inherited::VisitUnaryOperator(E);
8471     }
8472 
8473     void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
8474 
8475     void VisitCXXConstructExpr(CXXConstructExpr *E) {
8476       if (E->getConstructor()->isCopyConstructor()) {
8477         Expr *ArgExpr = E->getArg(0);
8478         if (InitListExpr *ILE = dyn_cast<InitListExpr>(ArgExpr))
8479           if (ILE->getNumInits() == 1)
8480             ArgExpr = ILE->getInit(0);
8481         if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(ArgExpr))
8482           if (ICE->getCastKind() == CK_NoOp)
8483             ArgExpr = ICE->getSubExpr();
8484         HandleValue(ArgExpr);
8485         return;
8486       }
8487       Inherited::VisitCXXConstructExpr(E);
8488     }
8489 
8490     void VisitCallExpr(CallExpr *E) {
8491       // Treat std::move as a use.
8492       if (E->getNumArgs() == 1) {
8493         if (FunctionDecl *FD = E->getDirectCallee()) {
8494           if (FD->getIdentifier() && FD->getIdentifier()->isStr("move")) {
8495             HandleValue(E->getArg(0));
8496             return;
8497           }
8498         }
8499       }
8500 
8501       Inherited::VisitCallExpr(E);
8502     }
8503 
8504     void VisitBinaryOperator(BinaryOperator *E) {
8505       if (E->isCompoundAssignmentOp()) {
8506         HandleValue(E->getLHS());
8507         Visit(E->getRHS());
8508         return;
8509       }
8510 
8511       Inherited::VisitBinaryOperator(E);
8512     }
8513 
8514     // A custom visitor for BinaryConditionalOperator is needed because the
8515     // regular visitor would check the condition and true expression separately
8516     // but both point to the same place giving duplicate diagnostics.
8517     void VisitBinaryConditionalOperator(BinaryConditionalOperator *E) {
8518       Visit(E->getCond());
8519       Visit(E->getFalseExpr());
8520     }
8521 
8522     void HandleDeclRefExpr(DeclRefExpr *DRE) {
8523       Decl* ReferenceDecl = DRE->getDecl();
8524       if (OrigDecl != ReferenceDecl) return;
8525       unsigned diag;
8526       if (isReferenceType) {
8527         diag = diag::warn_uninit_self_reference_in_reference_init;
8528       } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
8529         diag = diag::warn_static_self_reference_in_init;
8530       } else {
8531         diag = diag::warn_uninit_self_reference_in_init;
8532       }
8533 
8534       S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
8535                             S.PDiag(diag)
8536                               << DRE->getNameInfo().getName()
8537                               << OrigDecl->getLocation()
8538                               << DRE->getSourceRange());
8539     }
8540   };
8541 
8542   /// CheckSelfReference - Warns if OrigDecl is used in expression E.
8543   static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
8544                                  bool DirectInit) {
8545     // Parameters arguments are occassionially constructed with itself,
8546     // for instance, in recursive functions.  Skip them.
8547     if (isa<ParmVarDecl>(OrigDecl))
8548       return;
8549 
8550     E = E->IgnoreParens();
8551 
8552     // Skip checking T a = a where T is not a record or reference type.
8553     // Doing so is a way to silence uninitialized warnings.
8554     if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
8555       if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
8556         if (ICE->getCastKind() == CK_LValueToRValue)
8557           if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
8558             if (DRE->getDecl() == OrigDecl)
8559               return;
8560 
8561     SelfReferenceChecker(S, OrigDecl).CheckExpr(E);
8562   }
8563 }
8564 
8565 /// AddInitializerToDecl - Adds the initializer Init to the
8566 /// declaration dcl. If DirectInit is true, this is C++ direct
8567 /// initialization rather than copy initialization.
8568 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
8569                                 bool DirectInit, bool TypeMayContainAuto) {
8570   // If there is no declaration, there was an error parsing it.  Just ignore
8571   // the initializer.
8572   if (!RealDecl || RealDecl->isInvalidDecl())
8573     return;
8574 
8575   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
8576     // With declarators parsed the way they are, the parser cannot
8577     // distinguish between a normal initializer and a pure-specifier.
8578     // Thus this grotesque test.
8579     IntegerLiteral *IL;
8580     if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
8581         Context.getCanonicalType(IL->getType()) == Context.IntTy)
8582       CheckPureMethod(Method, Init->getSourceRange());
8583     else {
8584       Diag(Method->getLocation(), diag::err_member_function_initialization)
8585         << Method->getDeclName() << Init->getSourceRange();
8586       Method->setInvalidDecl();
8587     }
8588     return;
8589   }
8590 
8591   VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
8592   if (!VDecl) {
8593     assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
8594     Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
8595     RealDecl->setInvalidDecl();
8596     return;
8597   }
8598   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8599 
8600   // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
8601   if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
8602     Expr *DeduceInit = Init;
8603     // Initializer could be a C++ direct-initializer. Deduction only works if it
8604     // contains exactly one expression.
8605     if (CXXDirectInit) {
8606       if (CXXDirectInit->getNumExprs() == 0) {
8607         // It isn't possible to write this directly, but it is possible to
8608         // end up in this situation with "auto x(some_pack...);"
8609         Diag(CXXDirectInit->getLocStart(),
8610              VDecl->isInitCapture() ? diag::err_init_capture_no_expression
8611                                     : diag::err_auto_var_init_no_expression)
8612           << VDecl->getDeclName() << VDecl->getType()
8613           << VDecl->getSourceRange();
8614         RealDecl->setInvalidDecl();
8615         return;
8616       } else if (CXXDirectInit->getNumExprs() > 1) {
8617         Diag(CXXDirectInit->getExpr(1)->getLocStart(),
8618              VDecl->isInitCapture()
8619                  ? diag::err_init_capture_multiple_expressions
8620                  : diag::err_auto_var_init_multiple_expressions)
8621           << VDecl->getDeclName() << VDecl->getType()
8622           << VDecl->getSourceRange();
8623         RealDecl->setInvalidDecl();
8624         return;
8625       } else {
8626         DeduceInit = CXXDirectInit->getExpr(0);
8627         if (isa<InitListExpr>(DeduceInit))
8628           Diag(CXXDirectInit->getLocStart(),
8629                diag::err_auto_var_init_paren_braces)
8630             << VDecl->getDeclName() << VDecl->getType()
8631             << VDecl->getSourceRange();
8632       }
8633     }
8634 
8635     // Expressions default to 'id' when we're in a debugger.
8636     bool DefaultedToAuto = false;
8637     if (getLangOpts().DebuggerCastResultToId &&
8638         Init->getType() == Context.UnknownAnyTy) {
8639       ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8640       if (Result.isInvalid()) {
8641         VDecl->setInvalidDecl();
8642         return;
8643       }
8644       Init = Result.get();
8645       DefaultedToAuto = true;
8646     }
8647 
8648     QualType DeducedType;
8649     if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) ==
8650             DAR_Failed)
8651       DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
8652     if (DeducedType.isNull()) {
8653       RealDecl->setInvalidDecl();
8654       return;
8655     }
8656     VDecl->setType(DeducedType);
8657     assert(VDecl->isLinkageValid());
8658 
8659     // In ARC, infer lifetime.
8660     if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
8661       VDecl->setInvalidDecl();
8662 
8663     // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
8664     // 'id' instead of a specific object type prevents most of our usual checks.
8665     // We only want to warn outside of template instantiations, though:
8666     // inside a template, the 'id' could have come from a parameter.
8667     if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto &&
8668         DeducedType->isObjCIdType()) {
8669       SourceLocation Loc =
8670           VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
8671       Diag(Loc, diag::warn_auto_var_is_id)
8672         << VDecl->getDeclName() << DeduceInit->getSourceRange();
8673     }
8674 
8675     // If this is a redeclaration, check that the type we just deduced matches
8676     // the previously declared type.
8677     if (VarDecl *Old = VDecl->getPreviousDecl()) {
8678       // We never need to merge the type, because we cannot form an incomplete
8679       // array of auto, nor deduce such a type.
8680       MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false);
8681     }
8682 
8683     // Check the deduced type is valid for a variable declaration.
8684     CheckVariableDeclarationType(VDecl);
8685     if (VDecl->isInvalidDecl())
8686       return;
8687   }
8688 
8689   // dllimport cannot be used on variable definitions.
8690   if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
8691     Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
8692     VDecl->setInvalidDecl();
8693     return;
8694   }
8695 
8696   if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
8697     // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
8698     Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
8699     VDecl->setInvalidDecl();
8700     return;
8701   }
8702 
8703   if (!VDecl->getType()->isDependentType()) {
8704     // A definition must end up with a complete type, which means it must be
8705     // complete with the restriction that an array type might be completed by
8706     // the initializer; note that later code assumes this restriction.
8707     QualType BaseDeclType = VDecl->getType();
8708     if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
8709       BaseDeclType = Array->getElementType();
8710     if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
8711                             diag::err_typecheck_decl_incomplete_type)) {
8712       RealDecl->setInvalidDecl();
8713       return;
8714     }
8715 
8716     // The variable can not have an abstract class type.
8717     if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
8718                                diag::err_abstract_type_in_decl,
8719                                AbstractVariableType))
8720       VDecl->setInvalidDecl();
8721   }
8722 
8723   const VarDecl *Def;
8724   if ((Def = VDecl->getDefinition()) && Def != VDecl) {
8725     Diag(VDecl->getLocation(), diag::err_redefinition)
8726       << VDecl->getDeclName();
8727     Diag(Def->getLocation(), diag::note_previous_definition);
8728     VDecl->setInvalidDecl();
8729     return;
8730   }
8731 
8732   const VarDecl *PrevInit = nullptr;
8733   if (getLangOpts().CPlusPlus) {
8734     // C++ [class.static.data]p4
8735     //   If a static data member is of const integral or const
8736     //   enumeration type, its declaration in the class definition can
8737     //   specify a constant-initializer which shall be an integral
8738     //   constant expression (5.19). In that case, the member can appear
8739     //   in integral constant expressions. The member shall still be
8740     //   defined in a namespace scope if it is used in the program and the
8741     //   namespace scope definition shall not contain an initializer.
8742     //
8743     // We already performed a redefinition check above, but for static
8744     // data members we also need to check whether there was an in-class
8745     // declaration with an initializer.
8746     if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) {
8747       Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
8748           << VDecl->getDeclName();
8749       Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0;
8750       return;
8751     }
8752 
8753     if (VDecl->hasLocalStorage())
8754       getCurFunction()->setHasBranchProtectedScope();
8755 
8756     if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
8757       VDecl->setInvalidDecl();
8758       return;
8759     }
8760   }
8761 
8762   // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
8763   // a kernel function cannot be initialized."
8764   if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
8765     Diag(VDecl->getLocation(), diag::err_local_cant_init);
8766     VDecl->setInvalidDecl();
8767     return;
8768   }
8769 
8770   // Get the decls type and save a reference for later, since
8771   // CheckInitializerTypes may change it.
8772   QualType DclT = VDecl->getType(), SavT = DclT;
8773 
8774   // Expressions default to 'id' when we're in a debugger
8775   // and we are assigning it to a variable of Objective-C pointer type.
8776   if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
8777       Init->getType() == Context.UnknownAnyTy) {
8778     ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8779     if (Result.isInvalid()) {
8780       VDecl->setInvalidDecl();
8781       return;
8782     }
8783     Init = Result.get();
8784   }
8785 
8786   // Perform the initialization.
8787   if (!VDecl->isInvalidDecl()) {
8788     InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
8789     InitializationKind Kind
8790       = DirectInit ?
8791           CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(),
8792                                                            Init->getLocStart(),
8793                                                            Init->getLocEnd())
8794                         : InitializationKind::CreateDirectList(
8795                                                           VDecl->getLocation())
8796                    : InitializationKind::CreateCopy(VDecl->getLocation(),
8797                                                     Init->getLocStart());
8798 
8799     MultiExprArg Args = Init;
8800     if (CXXDirectInit)
8801       Args = MultiExprArg(CXXDirectInit->getExprs(),
8802                           CXXDirectInit->getNumExprs());
8803 
8804     InitializationSequence InitSeq(*this, Entity, Kind, Args);
8805     ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
8806     if (Result.isInvalid()) {
8807       VDecl->setInvalidDecl();
8808       return;
8809     }
8810 
8811     Init = Result.getAs<Expr>();
8812   }
8813 
8814   // Check for self-references within variable initializers.
8815   // Variables declared within a function/method body (except for references)
8816   // are handled by a dataflow analysis.
8817   if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
8818       VDecl->getType()->isReferenceType()) {
8819     CheckSelfReference(*this, RealDecl, Init, DirectInit);
8820   }
8821 
8822   // If the type changed, it means we had an incomplete type that was
8823   // completed by the initializer. For example:
8824   //   int ary[] = { 1, 3, 5 };
8825   // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
8826   if (!VDecl->isInvalidDecl() && (DclT != SavT))
8827     VDecl->setType(DclT);
8828 
8829   if (!VDecl->isInvalidDecl()) {
8830     checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
8831 
8832     if (VDecl->hasAttr<BlocksAttr>())
8833       checkRetainCycles(VDecl, Init);
8834 
8835     // It is safe to assign a weak reference into a strong variable.
8836     // Although this code can still have problems:
8837     //   id x = self.weakProp;
8838     //   id y = self.weakProp;
8839     // we do not warn to warn spuriously when 'x' and 'y' are on separate
8840     // paths through the function. This should be revisited if
8841     // -Wrepeated-use-of-weak is made flow-sensitive.
8842     if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
8843         !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
8844                          Init->getLocStart()))
8845         getCurFunction()->markSafeWeakUse(Init);
8846   }
8847 
8848   // The initialization is usually a full-expression.
8849   //
8850   // FIXME: If this is a braced initialization of an aggregate, it is not
8851   // an expression, and each individual field initializer is a separate
8852   // full-expression. For instance, in:
8853   //
8854   //   struct Temp { ~Temp(); };
8855   //   struct S { S(Temp); };
8856   //   struct T { S a, b; } t = { Temp(), Temp() }
8857   //
8858   // we should destroy the first Temp before constructing the second.
8859   ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
8860                                           false,
8861                                           VDecl->isConstexpr());
8862   if (Result.isInvalid()) {
8863     VDecl->setInvalidDecl();
8864     return;
8865   }
8866   Init = Result.get();
8867 
8868   // Attach the initializer to the decl.
8869   VDecl->setInit(Init);
8870 
8871   if (VDecl->isLocalVarDecl()) {
8872     // C99 6.7.8p4: All the expressions in an initializer for an object that has
8873     // static storage duration shall be constant expressions or string literals.
8874     // C++ does not have this restriction.
8875     if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
8876       const Expr *Culprit;
8877       if (VDecl->getStorageClass() == SC_Static)
8878         CheckForConstantInitializer(Init, DclT);
8879       // C89 is stricter than C99 for non-static aggregate types.
8880       // C89 6.5.7p3: All the expressions [...] in an initializer list
8881       // for an object that has aggregate or union type shall be
8882       // constant expressions.
8883       else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
8884                isa<InitListExpr>(Init) &&
8885                !Init->isConstantInitializer(Context, false, &Culprit))
8886         Diag(Culprit->getExprLoc(),
8887              diag::ext_aggregate_init_not_constant)
8888           << Culprit->getSourceRange();
8889     }
8890   } else if (VDecl->isStaticDataMember() &&
8891              VDecl->getLexicalDeclContext()->isRecord()) {
8892     // This is an in-class initialization for a static data member, e.g.,
8893     //
8894     // struct S {
8895     //   static const int value = 17;
8896     // };
8897 
8898     // C++ [class.mem]p4:
8899     //   A member-declarator can contain a constant-initializer only
8900     //   if it declares a static member (9.4) of const integral or
8901     //   const enumeration type, see 9.4.2.
8902     //
8903     // C++11 [class.static.data]p3:
8904     //   If a non-volatile const static data member is of integral or
8905     //   enumeration type, its declaration in the class definition can
8906     //   specify a brace-or-equal-initializer in which every initalizer-clause
8907     //   that is an assignment-expression is a constant expression. A static
8908     //   data member of literal type can be declared in the class definition
8909     //   with the constexpr specifier; if so, its declaration shall specify a
8910     //   brace-or-equal-initializer in which every initializer-clause that is
8911     //   an assignment-expression is a constant expression.
8912 
8913     // Do nothing on dependent types.
8914     if (DclT->isDependentType()) {
8915 
8916     // Allow any 'static constexpr' members, whether or not they are of literal
8917     // type. We separately check that every constexpr variable is of literal
8918     // type.
8919     } else if (VDecl->isConstexpr()) {
8920 
8921     // Require constness.
8922     } else if (!DclT.isConstQualified()) {
8923       Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
8924         << Init->getSourceRange();
8925       VDecl->setInvalidDecl();
8926 
8927     // We allow integer constant expressions in all cases.
8928     } else if (DclT->isIntegralOrEnumerationType()) {
8929       // Check whether the expression is a constant expression.
8930       SourceLocation Loc;
8931       if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
8932         // In C++11, a non-constexpr const static data member with an
8933         // in-class initializer cannot be volatile.
8934         Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
8935       else if (Init->isValueDependent())
8936         ; // Nothing to check.
8937       else if (Init->isIntegerConstantExpr(Context, &Loc))
8938         ; // Ok, it's an ICE!
8939       else if (Init->isEvaluatable(Context)) {
8940         // If we can constant fold the initializer through heroics, accept it,
8941         // but report this as a use of an extension for -pedantic.
8942         Diag(Loc, diag::ext_in_class_initializer_non_constant)
8943           << Init->getSourceRange();
8944       } else {
8945         // Otherwise, this is some crazy unknown case.  Report the issue at the
8946         // location provided by the isIntegerConstantExpr failed check.
8947         Diag(Loc, diag::err_in_class_initializer_non_constant)
8948           << Init->getSourceRange();
8949         VDecl->setInvalidDecl();
8950       }
8951 
8952     // We allow foldable floating-point constants as an extension.
8953     } else if (DclT->isFloatingType()) { // also permits complex, which is ok
8954       // In C++98, this is a GNU extension. In C++11, it is not, but we support
8955       // it anyway and provide a fixit to add the 'constexpr'.
8956       if (getLangOpts().CPlusPlus11) {
8957         Diag(VDecl->getLocation(),
8958              diag::ext_in_class_initializer_float_type_cxx11)
8959             << DclT << Init->getSourceRange();
8960         Diag(VDecl->getLocStart(),
8961              diag::note_in_class_initializer_float_type_cxx11)
8962             << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
8963       } else {
8964         Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
8965           << DclT << Init->getSourceRange();
8966 
8967         if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
8968           Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
8969             << Init->getSourceRange();
8970           VDecl->setInvalidDecl();
8971         }
8972       }
8973 
8974     // Suggest adding 'constexpr' in C++11 for literal types.
8975     } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
8976       Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
8977         << DclT << Init->getSourceRange()
8978         << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
8979       VDecl->setConstexpr(true);
8980 
8981     } else {
8982       Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
8983         << DclT << Init->getSourceRange();
8984       VDecl->setInvalidDecl();
8985     }
8986   } else if (VDecl->isFileVarDecl()) {
8987     if (VDecl->getStorageClass() == SC_Extern &&
8988         (!getLangOpts().CPlusPlus ||
8989          !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
8990            VDecl->isExternC())) &&
8991         !isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
8992       Diag(VDecl->getLocation(), diag::warn_extern_init);
8993 
8994     // C99 6.7.8p4. All file scoped initializers need to be constant.
8995     if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
8996       CheckForConstantInitializer(Init, DclT);
8997   }
8998 
8999   // We will represent direct-initialization similarly to copy-initialization:
9000   //    int x(1);  -as-> int x = 1;
9001   //    ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
9002   //
9003   // Clients that want to distinguish between the two forms, can check for
9004   // direct initializer using VarDecl::getInitStyle().
9005   // A major benefit is that clients that don't particularly care about which
9006   // exactly form was it (like the CodeGen) can handle both cases without
9007   // special case code.
9008 
9009   // C++ 8.5p11:
9010   // The form of initialization (using parentheses or '=') is generally
9011   // insignificant, but does matter when the entity being initialized has a
9012   // class type.
9013   if (CXXDirectInit) {
9014     assert(DirectInit && "Call-style initializer must be direct init.");
9015     VDecl->setInitStyle(VarDecl::CallInit);
9016   } else if (DirectInit) {
9017     // This must be list-initialization. No other way is direct-initialization.
9018     VDecl->setInitStyle(VarDecl::ListInit);
9019   }
9020 
9021   CheckCompleteVariableDeclaration(VDecl);
9022 }
9023 
9024 /// ActOnInitializerError - Given that there was an error parsing an
9025 /// initializer for the given declaration, try to return to some form
9026 /// of sanity.
9027 void Sema::ActOnInitializerError(Decl *D) {
9028   // Our main concern here is re-establishing invariants like "a
9029   // variable's type is either dependent or complete".
9030   if (!D || D->isInvalidDecl()) return;
9031 
9032   VarDecl *VD = dyn_cast<VarDecl>(D);
9033   if (!VD) return;
9034 
9035   // Auto types are meaningless if we can't make sense of the initializer.
9036   if (ParsingInitForAutoVars.count(D)) {
9037     D->setInvalidDecl();
9038     return;
9039   }
9040 
9041   QualType Ty = VD->getType();
9042   if (Ty->isDependentType()) return;
9043 
9044   // Require a complete type.
9045   if (RequireCompleteType(VD->getLocation(),
9046                           Context.getBaseElementType(Ty),
9047                           diag::err_typecheck_decl_incomplete_type)) {
9048     VD->setInvalidDecl();
9049     return;
9050   }
9051 
9052   // Require a non-abstract type.
9053   if (RequireNonAbstractType(VD->getLocation(), Ty,
9054                              diag::err_abstract_type_in_decl,
9055                              AbstractVariableType)) {
9056     VD->setInvalidDecl();
9057     return;
9058   }
9059 
9060   // Don't bother complaining about constructors or destructors,
9061   // though.
9062 }
9063 
9064 void Sema::ActOnUninitializedDecl(Decl *RealDecl,
9065                                   bool TypeMayContainAuto) {
9066   // If there is no declaration, there was an error parsing it. Just ignore it.
9067   if (!RealDecl)
9068     return;
9069 
9070   if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
9071     QualType Type = Var->getType();
9072 
9073     // C++11 [dcl.spec.auto]p3
9074     if (TypeMayContainAuto && Type->getContainedAutoType()) {
9075       Diag(Var->getLocation(), diag::err_auto_var_requires_init)
9076         << Var->getDeclName() << Type;
9077       Var->setInvalidDecl();
9078       return;
9079     }
9080 
9081     // C++11 [class.static.data]p3: A static data member can be declared with
9082     // the constexpr specifier; if so, its declaration shall specify
9083     // a brace-or-equal-initializer.
9084     // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
9085     // the definition of a variable [...] or the declaration of a static data
9086     // member.
9087     if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
9088       if (Var->isStaticDataMember())
9089         Diag(Var->getLocation(),
9090              diag::err_constexpr_static_mem_var_requires_init)
9091           << Var->getDeclName();
9092       else
9093         Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
9094       Var->setInvalidDecl();
9095       return;
9096     }
9097 
9098     // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
9099     // be initialized.
9100     if (!Var->isInvalidDecl() &&
9101         Var->getType().getAddressSpace() == LangAS::opencl_constant &&
9102         Var->getStorageClass() != SC_Extern && !Var->getInit()) {
9103       Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
9104       Var->setInvalidDecl();
9105       return;
9106     }
9107 
9108     switch (Var->isThisDeclarationADefinition()) {
9109     case VarDecl::Definition:
9110       if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
9111         break;
9112 
9113       // We have an out-of-line definition of a static data member
9114       // that has an in-class initializer, so we type-check this like
9115       // a declaration.
9116       //
9117       // Fall through
9118 
9119     case VarDecl::DeclarationOnly:
9120       // It's only a declaration.
9121 
9122       // Block scope. C99 6.7p7: If an identifier for an object is
9123       // declared with no linkage (C99 6.2.2p6), the type for the
9124       // object shall be complete.
9125       if (!Type->isDependentType() && Var->isLocalVarDecl() &&
9126           !Var->hasLinkage() && !Var->isInvalidDecl() &&
9127           RequireCompleteType(Var->getLocation(), Type,
9128                               diag::err_typecheck_decl_incomplete_type))
9129         Var->setInvalidDecl();
9130 
9131       // Make sure that the type is not abstract.
9132       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9133           RequireNonAbstractType(Var->getLocation(), Type,
9134                                  diag::err_abstract_type_in_decl,
9135                                  AbstractVariableType))
9136         Var->setInvalidDecl();
9137       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
9138           Var->getStorageClass() == SC_PrivateExtern) {
9139         Diag(Var->getLocation(), diag::warn_private_extern);
9140         Diag(Var->getLocation(), diag::note_private_extern);
9141       }
9142 
9143       return;
9144 
9145     case VarDecl::TentativeDefinition:
9146       // File scope. C99 6.9.2p2: A declaration of an identifier for an
9147       // object that has file scope without an initializer, and without a
9148       // storage-class specifier or with the storage-class specifier "static",
9149       // constitutes a tentative definition. Note: A tentative definition with
9150       // external linkage is valid (C99 6.2.2p5).
9151       if (!Var->isInvalidDecl()) {
9152         if (const IncompleteArrayType *ArrayT
9153                                     = Context.getAsIncompleteArrayType(Type)) {
9154           if (RequireCompleteType(Var->getLocation(),
9155                                   ArrayT->getElementType(),
9156                                   diag::err_illegal_decl_array_incomplete_type))
9157             Var->setInvalidDecl();
9158         } else if (Var->getStorageClass() == SC_Static) {
9159           // C99 6.9.2p3: If the declaration of an identifier for an object is
9160           // a tentative definition and has internal linkage (C99 6.2.2p3), the
9161           // declared type shall not be an incomplete type.
9162           // NOTE: code such as the following
9163           //     static struct s;
9164           //     struct s { int a; };
9165           // is accepted by gcc. Hence here we issue a warning instead of
9166           // an error and we do not invalidate the static declaration.
9167           // NOTE: to avoid multiple warnings, only check the first declaration.
9168           if (Var->isFirstDecl())
9169             RequireCompleteType(Var->getLocation(), Type,
9170                                 diag::ext_typecheck_decl_incomplete_type);
9171         }
9172       }
9173 
9174       // Record the tentative definition; we're done.
9175       if (!Var->isInvalidDecl())
9176         TentativeDefinitions.push_back(Var);
9177       return;
9178     }
9179 
9180     // Provide a specific diagnostic for uninitialized variable
9181     // definitions with incomplete array type.
9182     if (Type->isIncompleteArrayType()) {
9183       Diag(Var->getLocation(),
9184            diag::err_typecheck_incomplete_array_needs_initializer);
9185       Var->setInvalidDecl();
9186       return;
9187     }
9188 
9189     // Provide a specific diagnostic for uninitialized variable
9190     // definitions with reference type.
9191     if (Type->isReferenceType()) {
9192       Diag(Var->getLocation(), diag::err_reference_var_requires_init)
9193         << Var->getDeclName()
9194         << SourceRange(Var->getLocation(), Var->getLocation());
9195       Var->setInvalidDecl();
9196       return;
9197     }
9198 
9199     // Do not attempt to type-check the default initializer for a
9200     // variable with dependent type.
9201     if (Type->isDependentType())
9202       return;
9203 
9204     if (Var->isInvalidDecl())
9205       return;
9206 
9207     if (!Var->hasAttr<AliasAttr>()) {
9208       if (RequireCompleteType(Var->getLocation(),
9209                               Context.getBaseElementType(Type),
9210                               diag::err_typecheck_decl_incomplete_type)) {
9211         Var->setInvalidDecl();
9212         return;
9213       }
9214     }
9215 
9216     // The variable can not have an abstract class type.
9217     if (RequireNonAbstractType(Var->getLocation(), Type,
9218                                diag::err_abstract_type_in_decl,
9219                                AbstractVariableType)) {
9220       Var->setInvalidDecl();
9221       return;
9222     }
9223 
9224     // Check for jumps past the implicit initializer.  C++0x
9225     // clarifies that this applies to a "variable with automatic
9226     // storage duration", not a "local variable".
9227     // C++11 [stmt.dcl]p3
9228     //   A program that jumps from a point where a variable with automatic
9229     //   storage duration is not in scope to a point where it is in scope is
9230     //   ill-formed unless the variable has scalar type, class type with a
9231     //   trivial default constructor and a trivial destructor, a cv-qualified
9232     //   version of one of these types, or an array of one of the preceding
9233     //   types and is declared without an initializer.
9234     if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
9235       if (const RecordType *Record
9236             = Context.getBaseElementType(Type)->getAs<RecordType>()) {
9237         CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
9238         // Mark the function for further checking even if the looser rules of
9239         // C++11 do not require such checks, so that we can diagnose
9240         // incompatibilities with C++98.
9241         if (!CXXRecord->isPOD())
9242           getCurFunction()->setHasBranchProtectedScope();
9243       }
9244     }
9245 
9246     // C++03 [dcl.init]p9:
9247     //   If no initializer is specified for an object, and the
9248     //   object is of (possibly cv-qualified) non-POD class type (or
9249     //   array thereof), the object shall be default-initialized; if
9250     //   the object is of const-qualified type, the underlying class
9251     //   type shall have a user-declared default
9252     //   constructor. Otherwise, if no initializer is specified for
9253     //   a non- static object, the object and its subobjects, if
9254     //   any, have an indeterminate initial value); if the object
9255     //   or any of its subobjects are of const-qualified type, the
9256     //   program is ill-formed.
9257     // C++0x [dcl.init]p11:
9258     //   If no initializer is specified for an object, the object is
9259     //   default-initialized; [...].
9260     InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
9261     InitializationKind Kind
9262       = InitializationKind::CreateDefault(Var->getLocation());
9263 
9264     InitializationSequence InitSeq(*this, Entity, Kind, None);
9265     ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
9266     if (Init.isInvalid())
9267       Var->setInvalidDecl();
9268     else if (Init.get()) {
9269       Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
9270       // This is important for template substitution.
9271       Var->setInitStyle(VarDecl::CallInit);
9272     }
9273 
9274     CheckCompleteVariableDeclaration(Var);
9275   }
9276 }
9277 
9278 void Sema::ActOnCXXForRangeDecl(Decl *D) {
9279   VarDecl *VD = dyn_cast<VarDecl>(D);
9280   if (!VD) {
9281     Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
9282     D->setInvalidDecl();
9283     return;
9284   }
9285 
9286   VD->setCXXForRangeDecl(true);
9287 
9288   // for-range-declaration cannot be given a storage class specifier.
9289   int Error = -1;
9290   switch (VD->getStorageClass()) {
9291   case SC_None:
9292     break;
9293   case SC_Extern:
9294     Error = 0;
9295     break;
9296   case SC_Static:
9297     Error = 1;
9298     break;
9299   case SC_PrivateExtern:
9300     Error = 2;
9301     break;
9302   case SC_Auto:
9303     Error = 3;
9304     break;
9305   case SC_Register:
9306     Error = 4;
9307     break;
9308   case SC_OpenCLWorkGroupLocal:
9309     llvm_unreachable("Unexpected storage class");
9310   }
9311   if (VD->isConstexpr())
9312     Error = 5;
9313   if (Error != -1) {
9314     Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
9315       << VD->getDeclName() << Error;
9316     D->setInvalidDecl();
9317   }
9318 }
9319 
9320 StmtResult
9321 Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
9322                                  IdentifierInfo *Ident,
9323                                  ParsedAttributes &Attrs,
9324                                  SourceLocation AttrEnd) {
9325   // C++1y [stmt.iter]p1:
9326   //   A range-based for statement of the form
9327   //      for ( for-range-identifier : for-range-initializer ) statement
9328   //   is equivalent to
9329   //      for ( auto&& for-range-identifier : for-range-initializer ) statement
9330   DeclSpec DS(Attrs.getPool().getFactory());
9331 
9332   const char *PrevSpec;
9333   unsigned DiagID;
9334   DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
9335                      getPrintingPolicy());
9336 
9337   Declarator D(DS, Declarator::ForContext);
9338   D.SetIdentifier(Ident, IdentLoc);
9339   D.takeAttributes(Attrs, AttrEnd);
9340 
9341   ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
9342   D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
9343                 EmptyAttrs, IdentLoc);
9344   Decl *Var = ActOnDeclarator(S, D);
9345   cast<VarDecl>(Var)->setCXXForRangeDecl(true);
9346   FinalizeDeclaration(Var);
9347   return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
9348                        AttrEnd.isValid() ? AttrEnd : IdentLoc);
9349 }
9350 
9351 void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
9352   if (var->isInvalidDecl()) return;
9353 
9354   // In ARC, don't allow jumps past the implicit initialization of a
9355   // local retaining variable.
9356   if (getLangOpts().ObjCAutoRefCount &&
9357       var->hasLocalStorage()) {
9358     switch (var->getType().getObjCLifetime()) {
9359     case Qualifiers::OCL_None:
9360     case Qualifiers::OCL_ExplicitNone:
9361     case Qualifiers::OCL_Autoreleasing:
9362       break;
9363 
9364     case Qualifiers::OCL_Weak:
9365     case Qualifiers::OCL_Strong:
9366       getCurFunction()->setHasBranchProtectedScope();
9367       break;
9368     }
9369   }
9370 
9371   // Warn about externally-visible variables being defined without a
9372   // prior declaration.  We only want to do this for global
9373   // declarations, but we also specifically need to avoid doing it for
9374   // class members because the linkage of an anonymous class can
9375   // change if it's later given a typedef name.
9376   if (var->isThisDeclarationADefinition() &&
9377       var->getDeclContext()->getRedeclContext()->isFileContext() &&
9378       var->isExternallyVisible() && var->hasLinkage() &&
9379       !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
9380                                   var->getLocation())) {
9381     // Find a previous declaration that's not a definition.
9382     VarDecl *prev = var->getPreviousDecl();
9383     while (prev && prev->isThisDeclarationADefinition())
9384       prev = prev->getPreviousDecl();
9385 
9386     if (!prev)
9387       Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
9388   }
9389 
9390   if (var->getTLSKind() == VarDecl::TLS_Static) {
9391     const Expr *Culprit;
9392     if (var->getType().isDestructedType()) {
9393       // GNU C++98 edits for __thread, [basic.start.term]p3:
9394       //   The type of an object with thread storage duration shall not
9395       //   have a non-trivial destructor.
9396       Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
9397       if (getLangOpts().CPlusPlus11)
9398         Diag(var->getLocation(), diag::note_use_thread_local);
9399     } else if (getLangOpts().CPlusPlus && var->hasInit() &&
9400                !var->getInit()->isConstantInitializer(
9401                    Context, var->getType()->isReferenceType(), &Culprit)) {
9402       // GNU C++98 edits for __thread, [basic.start.init]p4:
9403       //   An object of thread storage duration shall not require dynamic
9404       //   initialization.
9405       // FIXME: Need strict checking here.
9406       Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
9407         << Culprit->getSourceRange();
9408       if (getLangOpts().CPlusPlus11)
9409         Diag(var->getLocation(), diag::note_use_thread_local);
9410     }
9411 
9412   }
9413 
9414   if (var->isThisDeclarationADefinition() &&
9415       ActiveTemplateInstantiations.empty()) {
9416     PragmaStack<StringLiteral *> *Stack = nullptr;
9417     int SectionFlags = ASTContext::PSF_Implicit | ASTContext::PSF_Read;
9418     if (var->getType().isConstQualified())
9419       Stack = &ConstSegStack;
9420     else if (!var->getInit()) {
9421       Stack = &BSSSegStack;
9422       SectionFlags |= ASTContext::PSF_Write;
9423     } else {
9424       Stack = &DataSegStack;
9425       SectionFlags |= ASTContext::PSF_Write;
9426     }
9427     if (!var->hasAttr<SectionAttr>() && Stack->CurrentValue)
9428       var->addAttr(
9429           SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
9430                                       Stack->CurrentValue->getString(),
9431                                       Stack->CurrentPragmaLocation));
9432     if (const SectionAttr *SA = var->getAttr<SectionAttr>())
9433       if (UnifySection(SA->getName(), SectionFlags, var))
9434         var->dropAttr<SectionAttr>();
9435 
9436     // Apply the init_seg attribute if this has an initializer.  If the
9437     // initializer turns out to not be dynamic, we'll end up ignoring this
9438     // attribute.
9439     if (CurInitSeg && var->getInit())
9440       var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
9441                                                CurInitSegLoc));
9442   }
9443 
9444   // All the following checks are C++ only.
9445   if (!getLangOpts().CPlusPlus) return;
9446 
9447   QualType type = var->getType();
9448   if (type->isDependentType()) return;
9449 
9450   // __block variables might require us to capture a copy-initializer.
9451   if (var->hasAttr<BlocksAttr>()) {
9452     // It's currently invalid to ever have a __block variable with an
9453     // array type; should we diagnose that here?
9454 
9455     // Regardless, we don't want to ignore array nesting when
9456     // constructing this copy.
9457     if (type->isStructureOrClassType()) {
9458       EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
9459       SourceLocation poi = var->getLocation();
9460       Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
9461       ExprResult result
9462         = PerformMoveOrCopyInitialization(
9463             InitializedEntity::InitializeBlock(poi, type, false),
9464             var, var->getType(), varRef, /*AllowNRVO=*/true);
9465       if (!result.isInvalid()) {
9466         result = MaybeCreateExprWithCleanups(result);
9467         Expr *init = result.getAs<Expr>();
9468         Context.setBlockVarCopyInits(var, init);
9469       }
9470     }
9471   }
9472 
9473   Expr *Init = var->getInit();
9474   bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal();
9475   QualType baseType = Context.getBaseElementType(type);
9476 
9477   if (!var->getDeclContext()->isDependentContext() &&
9478       Init && !Init->isValueDependent()) {
9479     if (IsGlobal && !var->isConstexpr() &&
9480         !getDiagnostics().isIgnored(diag::warn_global_constructor,
9481                                     var->getLocation())) {
9482       // Warn about globals which don't have a constant initializer.  Don't
9483       // warn about globals with a non-trivial destructor because we already
9484       // warned about them.
9485       CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
9486       if (!(RD && !RD->hasTrivialDestructor()) &&
9487           !Init->isConstantInitializer(Context, baseType->isReferenceType()))
9488         Diag(var->getLocation(), diag::warn_global_constructor)
9489           << Init->getSourceRange();
9490     }
9491 
9492     if (var->isConstexpr()) {
9493       SmallVector<PartialDiagnosticAt, 8> Notes;
9494       if (!var->evaluateValue(Notes) || !var->isInitICE()) {
9495         SourceLocation DiagLoc = var->getLocation();
9496         // If the note doesn't add any useful information other than a source
9497         // location, fold it into the primary diagnostic.
9498         if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
9499               diag::note_invalid_subexpr_in_const_expr) {
9500           DiagLoc = Notes[0].first;
9501           Notes.clear();
9502         }
9503         Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
9504           << var << Init->getSourceRange();
9505         for (unsigned I = 0, N = Notes.size(); I != N; ++I)
9506           Diag(Notes[I].first, Notes[I].second);
9507       }
9508     } else if (var->isUsableInConstantExpressions(Context)) {
9509       // Check whether the initializer of a const variable of integral or
9510       // enumeration type is an ICE now, since we can't tell whether it was
9511       // initialized by a constant expression if we check later.
9512       var->checkInitIsICE();
9513     }
9514   }
9515 
9516   // Require the destructor.
9517   if (const RecordType *recordType = baseType->getAs<RecordType>())
9518     FinalizeVarWithDestructor(var, recordType);
9519 }
9520 
9521 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
9522 /// any semantic actions necessary after any initializer has been attached.
9523 void
9524 Sema::FinalizeDeclaration(Decl *ThisDecl) {
9525   // Note that we are no longer parsing the initializer for this declaration.
9526   ParsingInitForAutoVars.erase(ThisDecl);
9527 
9528   VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
9529   if (!VD)
9530     return;
9531 
9532   checkAttributesAfterMerging(*this, *VD);
9533 
9534   // Static locals inherit dll attributes from their function.
9535   if (VD->isStaticLocal()) {
9536     if (FunctionDecl *FD =
9537             dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
9538       if (Attr *A = getDLLAttr(FD)) {
9539         auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
9540         NewAttr->setInherited(true);
9541         VD->addAttr(NewAttr);
9542       }
9543     }
9544   }
9545 
9546   // Grab the dllimport or dllexport attribute off of the VarDecl.
9547   const InheritableAttr *DLLAttr = getDLLAttr(VD);
9548 
9549   // Imported static data members cannot be defined out-of-line.
9550   if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {
9551     if (VD->isStaticDataMember() && VD->isOutOfLine() &&
9552         VD->isThisDeclarationADefinition()) {
9553       // We allow definitions of dllimport class template static data members
9554       // with a warning.
9555       CXXRecordDecl *Context =
9556         cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
9557       bool IsClassTemplateMember =
9558           isa<ClassTemplatePartialSpecializationDecl>(Context) ||
9559           Context->getDescribedClassTemplate();
9560 
9561       Diag(VD->getLocation(),
9562            IsClassTemplateMember
9563                ? diag::warn_attribute_dllimport_static_field_definition
9564                : diag::err_attribute_dllimport_static_field_definition);
9565       Diag(IA->getLocation(), diag::note_attribute);
9566       if (!IsClassTemplateMember)
9567         VD->setInvalidDecl();
9568     }
9569   }
9570 
9571   // dllimport/dllexport variables cannot be thread local, their TLS index
9572   // isn't exported with the variable.
9573   if (DLLAttr && VD->getTLSKind()) {
9574     Diag(VD->getLocation(), diag::err_attribute_dll_thread_local) << VD
9575                                                                   << DLLAttr;
9576     VD->setInvalidDecl();
9577   }
9578 
9579   if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
9580     if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
9581       Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
9582       VD->dropAttr<UsedAttr>();
9583     }
9584   }
9585 
9586   if (!VD->isInvalidDecl() &&
9587       VD->isThisDeclarationADefinition() == VarDecl::TentativeDefinition) {
9588     if (const VarDecl *Def = VD->getDefinition()) {
9589       if (Def->hasAttr<AliasAttr>()) {
9590         Diag(VD->getLocation(), diag::err_tentative_after_alias)
9591             << VD->getDeclName();
9592         Diag(Def->getLocation(), diag::note_previous_definition);
9593         VD->setInvalidDecl();
9594       }
9595     }
9596   }
9597 
9598   const DeclContext *DC = VD->getDeclContext();
9599   // If there's a #pragma GCC visibility in scope, and this isn't a class
9600   // member, set the visibility of this variable.
9601   if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
9602     AddPushedVisibilityAttribute(VD);
9603 
9604   // FIXME: Warn on unused templates.
9605   if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
9606       !isa<VarTemplatePartialSpecializationDecl>(VD))
9607     MarkUnusedFileScopedDecl(VD);
9608 
9609   // Now we have parsed the initializer and can update the table of magic
9610   // tag values.
9611   if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
9612       !VD->getType()->isIntegralOrEnumerationType())
9613     return;
9614 
9615   for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
9616     const Expr *MagicValueExpr = VD->getInit();
9617     if (!MagicValueExpr) {
9618       continue;
9619     }
9620     llvm::APSInt MagicValueInt;
9621     if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
9622       Diag(I->getRange().getBegin(),
9623            diag::err_type_tag_for_datatype_not_ice)
9624         << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9625       continue;
9626     }
9627     if (MagicValueInt.getActiveBits() > 64) {
9628       Diag(I->getRange().getBegin(),
9629            diag::err_type_tag_for_datatype_too_large)
9630         << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9631       continue;
9632     }
9633     uint64_t MagicValue = MagicValueInt.getZExtValue();
9634     RegisterTypeTagForDatatype(I->getArgumentKind(),
9635                                MagicValue,
9636                                I->getMatchingCType(),
9637                                I->getLayoutCompatible(),
9638                                I->getMustBeNull());
9639   }
9640 }
9641 
9642 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
9643                                                    ArrayRef<Decl *> Group) {
9644   SmallVector<Decl*, 8> Decls;
9645 
9646   if (DS.isTypeSpecOwned())
9647     Decls.push_back(DS.getRepAsDecl());
9648 
9649   DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
9650   for (unsigned i = 0, e = Group.size(); i != e; ++i)
9651     if (Decl *D = Group[i]) {
9652       if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
9653         if (!FirstDeclaratorInGroup)
9654           FirstDeclaratorInGroup = DD;
9655       Decls.push_back(D);
9656     }
9657 
9658   if (DeclSpec::isDeclRep(DS.getTypeSpecType())) {
9659     if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
9660       HandleTagNumbering(*this, Tag, S);
9661       if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl())
9662         Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup);
9663     }
9664   }
9665 
9666   return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
9667 }
9668 
9669 /// BuildDeclaratorGroup - convert a list of declarations into a declaration
9670 /// group, performing any necessary semantic checking.
9671 Sema::DeclGroupPtrTy
9672 Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group,
9673                            bool TypeMayContainAuto) {
9674   // C++0x [dcl.spec.auto]p7:
9675   //   If the type deduced for the template parameter U is not the same in each
9676   //   deduction, the program is ill-formed.
9677   // FIXME: When initializer-list support is added, a distinction is needed
9678   // between the deduced type U and the deduced type which 'auto' stands for.
9679   //   auto a = 0, b = { 1, 2, 3 };
9680   // is legal because the deduced type U is 'int' in both cases.
9681   if (TypeMayContainAuto && Group.size() > 1) {
9682     QualType Deduced;
9683     CanQualType DeducedCanon;
9684     VarDecl *DeducedDecl = nullptr;
9685     for (unsigned i = 0, e = Group.size(); i != e; ++i) {
9686       if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
9687         AutoType *AT = D->getType()->getContainedAutoType();
9688         // Don't reissue diagnostics when instantiating a template.
9689         if (AT && D->isInvalidDecl())
9690           break;
9691         QualType U = AT ? AT->getDeducedType() : QualType();
9692         if (!U.isNull()) {
9693           CanQualType UCanon = Context.getCanonicalType(U);
9694           if (Deduced.isNull()) {
9695             Deduced = U;
9696             DeducedCanon = UCanon;
9697             DeducedDecl = D;
9698           } else if (DeducedCanon != UCanon) {
9699             Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
9700                  diag::err_auto_different_deductions)
9701               << (AT->isDecltypeAuto() ? 1 : 0)
9702               << Deduced << DeducedDecl->getDeclName()
9703               << U << D->getDeclName()
9704               << DeducedDecl->getInit()->getSourceRange()
9705               << D->getInit()->getSourceRange();
9706             D->setInvalidDecl();
9707             break;
9708           }
9709         }
9710       }
9711     }
9712   }
9713 
9714   ActOnDocumentableDecls(Group);
9715 
9716   return DeclGroupPtrTy::make(
9717       DeclGroupRef::Create(Context, Group.data(), Group.size()));
9718 }
9719 
9720 void Sema::ActOnDocumentableDecl(Decl *D) {
9721   ActOnDocumentableDecls(D);
9722 }
9723 
9724 void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) {
9725   // Don't parse the comment if Doxygen diagnostics are ignored.
9726   if (Group.empty() || !Group[0])
9727    return;
9728 
9729   if (Diags.isIgnored(diag::warn_doc_param_not_found, Group[0]->getLocation()))
9730     return;
9731 
9732   if (Group.size() >= 2) {
9733     // This is a decl group.  Normally it will contain only declarations
9734     // produced from declarator list.  But in case we have any definitions or
9735     // additional declaration references:
9736     //   'typedef struct S {} S;'
9737     //   'typedef struct S *S;'
9738     //   'struct S *pS;'
9739     // FinalizeDeclaratorGroup adds these as separate declarations.
9740     Decl *MaybeTagDecl = Group[0];
9741     if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
9742       Group = Group.slice(1);
9743     }
9744   }
9745 
9746   // See if there are any new comments that are not attached to a decl.
9747   ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
9748   if (!Comments.empty() &&
9749       !Comments.back()->isAttached()) {
9750     // There is at least one comment that not attached to a decl.
9751     // Maybe it should be attached to one of these decls?
9752     //
9753     // Note that this way we pick up not only comments that precede the
9754     // declaration, but also comments that *follow* the declaration -- thanks to
9755     // the lookahead in the lexer: we've consumed the semicolon and looked
9756     // ahead through comments.
9757     for (unsigned i = 0, e = Group.size(); i != e; ++i)
9758       Context.getCommentForDecl(Group[i], &PP);
9759   }
9760 }
9761 
9762 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
9763 /// to introduce parameters into function prototype scope.
9764 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
9765   const DeclSpec &DS = D.getDeclSpec();
9766 
9767   // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
9768 
9769   // C++03 [dcl.stc]p2 also permits 'auto'.
9770   StorageClass SC = SC_None;
9771   if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
9772     SC = SC_Register;
9773   } else if (getLangOpts().CPlusPlus &&
9774              DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
9775     SC = SC_Auto;
9776   } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
9777     Diag(DS.getStorageClassSpecLoc(),
9778          diag::err_invalid_storage_class_in_func_decl);
9779     D.getMutableDeclSpec().ClearStorageClassSpecs();
9780   }
9781 
9782   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
9783     Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
9784       << DeclSpec::getSpecifierName(TSCS);
9785   if (DS.isConstexprSpecified())
9786     Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
9787       << 0;
9788 
9789   DiagnoseFunctionSpecifiers(DS);
9790 
9791   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
9792   QualType parmDeclType = TInfo->getType();
9793 
9794   if (getLangOpts().CPlusPlus) {
9795     // Check that there are no default arguments inside the type of this
9796     // parameter.
9797     CheckExtraCXXDefaultArguments(D);
9798 
9799     // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
9800     if (D.getCXXScopeSpec().isSet()) {
9801       Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
9802         << D.getCXXScopeSpec().getRange();
9803       D.getCXXScopeSpec().clear();
9804     }
9805   }
9806 
9807   // Ensure we have a valid name
9808   IdentifierInfo *II = nullptr;
9809   if (D.hasName()) {
9810     II = D.getIdentifier();
9811     if (!II) {
9812       Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
9813         << GetNameForDeclarator(D).getName();
9814       D.setInvalidType(true);
9815     }
9816   }
9817 
9818   // Check for redeclaration of parameters, e.g. int foo(int x, int x);
9819   if (II) {
9820     LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
9821                    ForRedeclaration);
9822     LookupName(R, S);
9823     if (R.isSingleResult()) {
9824       NamedDecl *PrevDecl = R.getFoundDecl();
9825       if (PrevDecl->isTemplateParameter()) {
9826         // Maybe we will complain about the shadowed template parameter.
9827         DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
9828         // Just pretend that we didn't see the previous declaration.
9829         PrevDecl = nullptr;
9830       } else if (S->isDeclScope(PrevDecl)) {
9831         Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
9832         Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
9833 
9834         // Recover by removing the name
9835         II = nullptr;
9836         D.SetIdentifier(nullptr, D.getIdentifierLoc());
9837         D.setInvalidType(true);
9838       }
9839     }
9840   }
9841 
9842   // Temporarily put parameter variables in the translation unit, not
9843   // the enclosing context.  This prevents them from accidentally
9844   // looking like class members in C++.
9845   ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
9846                                     D.getLocStart(),
9847                                     D.getIdentifierLoc(), II,
9848                                     parmDeclType, TInfo,
9849                                     SC);
9850 
9851   if (D.isInvalidType())
9852     New->setInvalidDecl();
9853 
9854   assert(S->isFunctionPrototypeScope());
9855   assert(S->getFunctionPrototypeDepth() >= 1);
9856   New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
9857                     S->getNextFunctionPrototypeIndex());
9858 
9859   // Add the parameter declaration into this scope.
9860   S->AddDecl(New);
9861   if (II)
9862     IdResolver.AddDecl(New);
9863 
9864   ProcessDeclAttributes(S, New, D);
9865 
9866   if (D.getDeclSpec().isModulePrivateSpecified())
9867     Diag(New->getLocation(), diag::err_module_private_local)
9868       << 1 << New->getDeclName()
9869       << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
9870       << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
9871 
9872   if (New->hasAttr<BlocksAttr>()) {
9873     Diag(New->getLocation(), diag::err_block_on_nonlocal);
9874   }
9875   return New;
9876 }
9877 
9878 /// \brief Synthesizes a variable for a parameter arising from a
9879 /// typedef.
9880 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
9881                                               SourceLocation Loc,
9882                                               QualType T) {
9883   /* FIXME: setting StartLoc == Loc.
9884      Would it be worth to modify callers so as to provide proper source
9885      location for the unnamed parameters, embedding the parameter's type? */
9886   ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
9887                                 T, Context.getTrivialTypeSourceInfo(T, Loc),
9888                                            SC_None, nullptr);
9889   Param->setImplicit();
9890   return Param;
9891 }
9892 
9893 void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
9894                                     ParmVarDecl * const *ParamEnd) {
9895   // Don't diagnose unused-parameter errors in template instantiations; we
9896   // will already have done so in the template itself.
9897   if (!ActiveTemplateInstantiations.empty())
9898     return;
9899 
9900   for (; Param != ParamEnd; ++Param) {
9901     if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
9902         !(*Param)->hasAttr<UnusedAttr>()) {
9903       Diag((*Param)->getLocation(), diag::warn_unused_parameter)
9904         << (*Param)->getDeclName();
9905     }
9906   }
9907 }
9908 
9909 void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
9910                                                   ParmVarDecl * const *ParamEnd,
9911                                                   QualType ReturnTy,
9912                                                   NamedDecl *D) {
9913   if (LangOpts.NumLargeByValueCopy == 0) // No check.
9914     return;
9915 
9916   // Warn if the return value is pass-by-value and larger than the specified
9917   // threshold.
9918   if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
9919     unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
9920     if (Size > LangOpts.NumLargeByValueCopy)
9921       Diag(D->getLocation(), diag::warn_return_value_size)
9922           << D->getDeclName() << Size;
9923   }
9924 
9925   // Warn if any parameter is pass-by-value and larger than the specified
9926   // threshold.
9927   for (; Param != ParamEnd; ++Param) {
9928     QualType T = (*Param)->getType();
9929     if (T->isDependentType() || !T.isPODType(Context))
9930       continue;
9931     unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
9932     if (Size > LangOpts.NumLargeByValueCopy)
9933       Diag((*Param)->getLocation(), diag::warn_parameter_size)
9934           << (*Param)->getDeclName() << Size;
9935   }
9936 }
9937 
9938 ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
9939                                   SourceLocation NameLoc, IdentifierInfo *Name,
9940                                   QualType T, TypeSourceInfo *TSInfo,
9941                                   StorageClass SC) {
9942   // In ARC, infer a lifetime qualifier for appropriate parameter types.
9943   if (getLangOpts().ObjCAutoRefCount &&
9944       T.getObjCLifetime() == Qualifiers::OCL_None &&
9945       T->isObjCLifetimeType()) {
9946 
9947     Qualifiers::ObjCLifetime lifetime;
9948 
9949     // Special cases for arrays:
9950     //   - if it's const, use __unsafe_unretained
9951     //   - otherwise, it's an error
9952     if (T->isArrayType()) {
9953       if (!T.isConstQualified()) {
9954         DelayedDiagnostics.add(
9955             sema::DelayedDiagnostic::makeForbiddenType(
9956             NameLoc, diag::err_arc_array_param_no_ownership, T, false));
9957       }
9958       lifetime = Qualifiers::OCL_ExplicitNone;
9959     } else {
9960       lifetime = T->getObjCARCImplicitLifetime();
9961     }
9962     T = Context.getLifetimeQualifiedType(T, lifetime);
9963   }
9964 
9965   ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
9966                                          Context.getAdjustedParameterType(T),
9967                                          TSInfo, SC, nullptr);
9968 
9969   // Parameters can not be abstract class types.
9970   // For record types, this is done by the AbstractClassUsageDiagnoser once
9971   // the class has been completely parsed.
9972   if (!CurContext->isRecord() &&
9973       RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
9974                              AbstractParamType))
9975     New->setInvalidDecl();
9976 
9977   // Parameter declarators cannot be interface types. All ObjC objects are
9978   // passed by reference.
9979   if (T->isObjCObjectType()) {
9980     SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
9981     Diag(NameLoc,
9982          diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
9983       << FixItHint::CreateInsertion(TypeEndLoc, "*");
9984     T = Context.getObjCObjectPointerType(T);
9985     New->setType(T);
9986   }
9987 
9988   // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
9989   // duration shall not be qualified by an address-space qualifier."
9990   // Since all parameters have automatic store duration, they can not have
9991   // an address space.
9992   if (T.getAddressSpace() != 0) {
9993     // OpenCL allows function arguments declared to be an array of a type
9994     // to be qualified with an address space.
9995     if (!(getLangOpts().OpenCL && T->isArrayType())) {
9996       Diag(NameLoc, diag::err_arg_with_address_space);
9997       New->setInvalidDecl();
9998     }
9999   }
10000 
10001   return New;
10002 }
10003 
10004 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
10005                                            SourceLocation LocAfterDecls) {
10006   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
10007 
10008   // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
10009   // for a K&R function.
10010   if (!FTI.hasPrototype) {
10011     for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
10012       --i;
10013       if (FTI.Params[i].Param == nullptr) {
10014         SmallString<256> Code;
10015         llvm::raw_svector_ostream(Code)
10016             << "  int " << FTI.Params[i].Ident->getName() << ";\n";
10017         Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
10018             << FTI.Params[i].Ident
10019             << FixItHint::CreateInsertion(LocAfterDecls, Code.str());
10020 
10021         // Implicitly declare the argument as type 'int' for lack of a better
10022         // type.
10023         AttributeFactory attrs;
10024         DeclSpec DS(attrs);
10025         const char* PrevSpec; // unused
10026         unsigned DiagID; // unused
10027         DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
10028                            DiagID, Context.getPrintingPolicy());
10029         // Use the identifier location for the type source range.
10030         DS.SetRangeStart(FTI.Params[i].IdentLoc);
10031         DS.SetRangeEnd(FTI.Params[i].IdentLoc);
10032         Declarator ParamD(DS, Declarator::KNRTypeListContext);
10033         ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
10034         FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
10035       }
10036     }
10037   }
10038 }
10039 
10040 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
10041   assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
10042   assert(D.isFunctionDeclarator() && "Not a function declarator!");
10043   Scope *ParentScope = FnBodyScope->getParent();
10044 
10045   D.setFunctionDefinitionKind(FDK_Definition);
10046   Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg());
10047   return ActOnStartOfFunctionDef(FnBodyScope, DP);
10048 }
10049 
10050 void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) {
10051   Consumer.HandleInlineMethodDefinition(D);
10052 }
10053 
10054 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
10055                              const FunctionDecl*& PossibleZeroParamPrototype) {
10056   // Don't warn about invalid declarations.
10057   if (FD->isInvalidDecl())
10058     return false;
10059 
10060   // Or declarations that aren't global.
10061   if (!FD->isGlobal())
10062     return false;
10063 
10064   // Don't warn about C++ member functions.
10065   if (isa<CXXMethodDecl>(FD))
10066     return false;
10067 
10068   // Don't warn about 'main'.
10069   if (FD->isMain())
10070     return false;
10071 
10072   // Don't warn about inline functions.
10073   if (FD->isInlined())
10074     return false;
10075 
10076   // Don't warn about function templates.
10077   if (FD->getDescribedFunctionTemplate())
10078     return false;
10079 
10080   // Don't warn about function template specializations.
10081   if (FD->isFunctionTemplateSpecialization())
10082     return false;
10083 
10084   // Don't warn for OpenCL kernels.
10085   if (FD->hasAttr<OpenCLKernelAttr>())
10086     return false;
10087 
10088   bool MissingPrototype = true;
10089   for (const FunctionDecl *Prev = FD->getPreviousDecl();
10090        Prev; Prev = Prev->getPreviousDecl()) {
10091     // Ignore any declarations that occur in function or method
10092     // scope, because they aren't visible from the header.
10093     if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
10094       continue;
10095 
10096     MissingPrototype = !Prev->getType()->isFunctionProtoType();
10097     if (FD->getNumParams() == 0)
10098       PossibleZeroParamPrototype = Prev;
10099     break;
10100   }
10101 
10102   return MissingPrototype;
10103 }
10104 
10105 void
10106 Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
10107                                    const FunctionDecl *EffectiveDefinition) {
10108   // Don't complain if we're in GNU89 mode and the previous definition
10109   // was an extern inline function.
10110   const FunctionDecl *Definition = EffectiveDefinition;
10111   if (!Definition)
10112     if (!FD->isDefined(Definition))
10113       return;
10114 
10115   if (canRedefineFunction(Definition, getLangOpts()))
10116     return;
10117 
10118   if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
10119       Definition->getStorageClass() == SC_Extern)
10120     Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
10121         << FD->getDeclName() << getLangOpts().CPlusPlus;
10122   else
10123     Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
10124 
10125   Diag(Definition->getLocation(), diag::note_previous_definition);
10126   FD->setInvalidDecl();
10127 }
10128 
10129 
10130 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
10131                                    Sema &S) {
10132   CXXRecordDecl *const LambdaClass = CallOperator->getParent();
10133 
10134   LambdaScopeInfo *LSI = S.PushLambdaScope();
10135   LSI->CallOperator = CallOperator;
10136   LSI->Lambda = LambdaClass;
10137   LSI->ReturnType = CallOperator->getReturnType();
10138   const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
10139 
10140   if (LCD == LCD_None)
10141     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
10142   else if (LCD == LCD_ByCopy)
10143     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
10144   else if (LCD == LCD_ByRef)
10145     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;
10146   DeclarationNameInfo DNI = CallOperator->getNameInfo();
10147 
10148   LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
10149   LSI->Mutable = !CallOperator->isConst();
10150 
10151   // Add the captures to the LSI so they can be noted as already
10152   // captured within tryCaptureVar.
10153   auto I = LambdaClass->field_begin();
10154   for (const auto &C : LambdaClass->captures()) {
10155     if (C.capturesVariable()) {
10156       VarDecl *VD = C.getCapturedVar();
10157       if (VD->isInitCapture())
10158         S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
10159       QualType CaptureType = VD->getType();
10160       const bool ByRef = C.getCaptureKind() == LCK_ByRef;
10161       LSI->addCapture(VD, /*IsBlock*/false, ByRef,
10162           /*RefersToEnclosingLocal*/true, C.getLocation(),
10163           /*EllipsisLoc*/C.isPackExpansion()
10164                          ? C.getEllipsisLoc() : SourceLocation(),
10165           CaptureType, /*Expr*/ nullptr);
10166 
10167     } else if (C.capturesThis()) {
10168       LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
10169                               S.getCurrentThisType(), /*Expr*/ nullptr);
10170     } else {
10171       LSI->addVLATypeCapture(C.getLocation(), I->getType());
10172     }
10173     ++I;
10174   }
10175 }
10176 
10177 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
10178   // Clear the last template instantiation error context.
10179   LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
10180 
10181   if (!D)
10182     return D;
10183   FunctionDecl *FD = nullptr;
10184 
10185   if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
10186     FD = FunTmpl->getTemplatedDecl();
10187   else
10188     FD = cast<FunctionDecl>(D);
10189   // If we are instantiating a generic lambda call operator, push
10190   // a LambdaScopeInfo onto the function stack.  But use the information
10191   // that's already been calculated (ActOnLambdaExpr) to prime the current
10192   // LambdaScopeInfo.
10193   // When the template operator is being specialized, the LambdaScopeInfo,
10194   // has to be properly restored so that tryCaptureVariable doesn't try
10195   // and capture any new variables. In addition when calculating potential
10196   // captures during transformation of nested lambdas, it is necessary to
10197   // have the LSI properly restored.
10198   if (isGenericLambdaCallOperatorSpecialization(FD)) {
10199     assert(ActiveTemplateInstantiations.size() &&
10200       "There should be an active template instantiation on the stack "
10201       "when instantiating a generic lambda!");
10202     RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
10203   }
10204   else
10205     // Enter a new function scope
10206     PushFunctionScope();
10207 
10208   // See if this is a redefinition.
10209   if (!FD->isLateTemplateParsed())
10210     CheckForFunctionRedefinition(FD);
10211 
10212   // Builtin functions cannot be defined.
10213   if (unsigned BuiltinID = FD->getBuiltinID()) {
10214     if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
10215         !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
10216       Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
10217       FD->setInvalidDecl();
10218     }
10219   }
10220 
10221   // The return type of a function definition must be complete
10222   // (C99 6.9.1p3, C++ [dcl.fct]p6).
10223   QualType ResultType = FD->getReturnType();
10224   if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
10225       !FD->isInvalidDecl() &&
10226       RequireCompleteType(FD->getLocation(), ResultType,
10227                           diag::err_func_def_incomplete_result))
10228     FD->setInvalidDecl();
10229 
10230   // GNU warning -Wmissing-prototypes:
10231   //   Warn if a global function is defined without a previous
10232   //   prototype declaration. This warning is issued even if the
10233   //   definition itself provides a prototype. The aim is to detect
10234   //   global functions that fail to be declared in header files.
10235   const FunctionDecl *PossibleZeroParamPrototype = nullptr;
10236   if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
10237     Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
10238 
10239     if (PossibleZeroParamPrototype) {
10240       // We found a declaration that is not a prototype,
10241       // but that could be a zero-parameter prototype
10242       if (TypeSourceInfo *TI =
10243               PossibleZeroParamPrototype->getTypeSourceInfo()) {
10244         TypeLoc TL = TI->getTypeLoc();
10245         if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
10246           Diag(PossibleZeroParamPrototype->getLocation(),
10247                diag::note_declaration_not_a_prototype)
10248             << PossibleZeroParamPrototype
10249             << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
10250       }
10251     }
10252   }
10253 
10254   if (FnBodyScope)
10255     PushDeclContext(FnBodyScope, FD);
10256 
10257   // Check the validity of our function parameters
10258   CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
10259                            /*CheckParameterNames=*/true);
10260 
10261   // Introduce our parameters into the function scope
10262   for (auto Param : FD->params()) {
10263     Param->setOwningFunction(FD);
10264 
10265     // If this has an identifier, add it to the scope stack.
10266     if (Param->getIdentifier() && FnBodyScope) {
10267       CheckShadow(FnBodyScope, Param);
10268 
10269       PushOnScopeChains(Param, FnBodyScope);
10270     }
10271   }
10272 
10273   // If we had any tags defined in the function prototype,
10274   // introduce them into the function scope.
10275   if (FnBodyScope) {
10276     for (ArrayRef<NamedDecl *>::iterator
10277              I = FD->getDeclsInPrototypeScope().begin(),
10278              E = FD->getDeclsInPrototypeScope().end();
10279          I != E; ++I) {
10280       NamedDecl *D = *I;
10281 
10282       // Some of these decls (like enums) may have been pinned to the translation unit
10283       // for lack of a real context earlier. If so, remove from the translation unit
10284       // and reattach to the current context.
10285       if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
10286         // Is the decl actually in the context?
10287         for (const auto *DI : Context.getTranslationUnitDecl()->decls()) {
10288           if (DI == D) {
10289             Context.getTranslationUnitDecl()->removeDecl(D);
10290             break;
10291           }
10292         }
10293         // Either way, reassign the lexical decl context to our FunctionDecl.
10294         D->setLexicalDeclContext(CurContext);
10295       }
10296 
10297       // If the decl has a non-null name, make accessible in the current scope.
10298       if (!D->getName().empty())
10299         PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
10300 
10301       // Similarly, dive into enums and fish their constants out, making them
10302       // accessible in this scope.
10303       if (auto *ED = dyn_cast<EnumDecl>(D)) {
10304         for (auto *EI : ED->enumerators())
10305           PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
10306       }
10307     }
10308   }
10309 
10310   // Ensure that the function's exception specification is instantiated.
10311   if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
10312     ResolveExceptionSpec(D->getLocation(), FPT);
10313 
10314   // dllimport cannot be applied to non-inline function definitions.
10315   if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
10316       !FD->isTemplateInstantiation()) {
10317     assert(!FD->hasAttr<DLLExportAttr>());
10318     Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
10319     FD->setInvalidDecl();
10320     return D;
10321   }
10322   // We want to attach documentation to original Decl (which might be
10323   // a function template).
10324   ActOnDocumentableDecl(D);
10325   if (getCurLexicalContext()->isObjCContainer() &&
10326       getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
10327       getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
10328     Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
10329 
10330   return D;
10331 }
10332 
10333 /// \brief Given the set of return statements within a function body,
10334 /// compute the variables that are subject to the named return value
10335 /// optimization.
10336 ///
10337 /// Each of the variables that is subject to the named return value
10338 /// optimization will be marked as NRVO variables in the AST, and any
10339 /// return statement that has a marked NRVO variable as its NRVO candidate can
10340 /// use the named return value optimization.
10341 ///
10342 /// This function applies a very simplistic algorithm for NRVO: if every return
10343 /// statement in the scope of a variable has the same NRVO candidate, that
10344 /// candidate is an NRVO variable.
10345 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
10346   ReturnStmt **Returns = Scope->Returns.data();
10347 
10348   for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
10349     if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
10350       if (!NRVOCandidate->isNRVOVariable())
10351         Returns[I]->setNRVOCandidate(nullptr);
10352     }
10353   }
10354 }
10355 
10356 bool Sema::canDelayFunctionBody(const Declarator &D) {
10357   // We can't delay parsing the body of a constexpr function template (yet).
10358   if (D.getDeclSpec().isConstexprSpecified())
10359     return false;
10360 
10361   // We can't delay parsing the body of a function template with a deduced
10362   // return type (yet).
10363   if (D.getDeclSpec().containsPlaceholderType()) {
10364     // If the placeholder introduces a non-deduced trailing return type,
10365     // we can still delay parsing it.
10366     if (D.getNumTypeObjects()) {
10367       const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
10368       if (Outer.Kind == DeclaratorChunk::Function &&
10369           Outer.Fun.hasTrailingReturnType()) {
10370         QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
10371         return Ty.isNull() || !Ty->isUndeducedType();
10372       }
10373     }
10374     return false;
10375   }
10376 
10377   return true;
10378 }
10379 
10380 bool Sema::canSkipFunctionBody(Decl *D) {
10381   // We cannot skip the body of a function (or function template) which is
10382   // constexpr, since we may need to evaluate its body in order to parse the
10383   // rest of the file.
10384   // We cannot skip the body of a function with an undeduced return type,
10385   // because any callers of that function need to know the type.
10386   if (const FunctionDecl *FD = D->getAsFunction())
10387     if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
10388       return false;
10389   return Consumer.shouldSkipFunctionBody(D);
10390 }
10391 
10392 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
10393   if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
10394     FD->setHasSkippedBody();
10395   else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
10396     MD->setHasSkippedBody();
10397   return ActOnFinishFunctionBody(Decl, nullptr);
10398 }
10399 
10400 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
10401   return ActOnFinishFunctionBody(D, BodyArg, false);
10402 }
10403 
10404 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
10405                                     bool IsInstantiation) {
10406   FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
10407 
10408   sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
10409   sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
10410 
10411   if (FD) {
10412     FD->setBody(Body);
10413 
10414     if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body &&
10415         !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) {
10416       // If the function has a deduced result type but contains no 'return'
10417       // statements, the result type as written must be exactly 'auto', and
10418       // the deduced result type is 'void'.
10419       if (!FD->getReturnType()->getAs<AutoType>()) {
10420         Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
10421             << FD->getReturnType();
10422         FD->setInvalidDecl();
10423       } else {
10424         // Substitute 'void' for the 'auto' in the type.
10425         TypeLoc ResultType = getReturnTypeLoc(FD);
10426         Context.adjustDeducedFunctionResultType(
10427             FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
10428       }
10429     }
10430 
10431     // The only way to be included in UndefinedButUsed is if there is an
10432     // ODR use before the definition. Avoid the expensive map lookup if this
10433     // is the first declaration.
10434     if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
10435       if (!FD->isExternallyVisible())
10436         UndefinedButUsed.erase(FD);
10437       else if (FD->isInlined() &&
10438                (LangOpts.CPlusPlus || !LangOpts.GNUInline) &&
10439                (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
10440         UndefinedButUsed.erase(FD);
10441     }
10442 
10443     // If the function implicitly returns zero (like 'main') or is naked,
10444     // don't complain about missing return statements.
10445     if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
10446       WP.disableCheckFallThrough();
10447 
10448     // MSVC permits the use of pure specifier (=0) on function definition,
10449     // defined at class scope, warn about this non-standard construct.
10450     if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
10451       Diag(FD->getLocation(), diag::ext_pure_function_definition);
10452 
10453     if (!FD->isInvalidDecl()) {
10454       // Don't diagnose unused parameters of defaulted or deleted functions.
10455       if (Body)
10456         DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
10457       DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
10458                                              FD->getReturnType(), FD);
10459 
10460       // If this is a constructor, we need a vtable.
10461       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
10462         MarkVTableUsed(FD->getLocation(), Constructor->getParent());
10463 
10464       // Try to apply the named return value optimization. We have to check
10465       // if we can do this here because lambdas keep return statements around
10466       // to deduce an implicit return type.
10467       if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
10468           !FD->isDependentContext())
10469         computeNRVO(Body, getCurFunction());
10470     }
10471 
10472     assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
10473            "Function parsing confused");
10474   } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
10475     assert(MD == getCurMethodDecl() && "Method parsing confused");
10476     MD->setBody(Body);
10477     if (!MD->isInvalidDecl()) {
10478       DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
10479       DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
10480                                              MD->getReturnType(), MD);
10481 
10482       if (Body)
10483         computeNRVO(Body, getCurFunction());
10484     }
10485     if (getCurFunction()->ObjCShouldCallSuper) {
10486       Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
10487         << MD->getSelector().getAsString();
10488       getCurFunction()->ObjCShouldCallSuper = false;
10489     }
10490     if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
10491       const ObjCMethodDecl *InitMethod = nullptr;
10492       bool isDesignated =
10493           MD->isDesignatedInitializerForTheInterface(&InitMethod);
10494       assert(isDesignated && InitMethod);
10495       (void)isDesignated;
10496 
10497       auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
10498         auto IFace = MD->getClassInterface();
10499         if (!IFace)
10500           return false;
10501         auto SuperD = IFace->getSuperClass();
10502         if (!SuperD)
10503           return false;
10504         return SuperD->getIdentifier() ==
10505             NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
10506       };
10507       // Don't issue this warning for unavailable inits or direct subclasses
10508       // of NSObject.
10509       if (!MD->isUnavailable() && !superIsNSObject(MD)) {
10510         Diag(MD->getLocation(),
10511              diag::warn_objc_designated_init_missing_super_call);
10512         Diag(InitMethod->getLocation(),
10513              diag::note_objc_designated_init_marked_here);
10514       }
10515       getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
10516     }
10517     if (getCurFunction()->ObjCWarnForNoInitDelegation) {
10518       // Don't issue this warning for unavaialable inits.
10519       if (!MD->isUnavailable())
10520         Diag(MD->getLocation(), diag::warn_objc_secondary_init_missing_init_call);
10521       getCurFunction()->ObjCWarnForNoInitDelegation = false;
10522     }
10523   } else {
10524     return nullptr;
10525   }
10526 
10527   assert(!getCurFunction()->ObjCShouldCallSuper &&
10528          "This should only be set for ObjC methods, which should have been "
10529          "handled in the block above.");
10530 
10531   // Verify and clean out per-function state.
10532   if (Body) {
10533     // C++ constructors that have function-try-blocks can't have return
10534     // statements in the handlers of that block. (C++ [except.handle]p14)
10535     // Verify this.
10536     if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
10537       DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
10538 
10539     // Verify that gotos and switch cases don't jump into scopes illegally.
10540     if (getCurFunction()->NeedsScopeChecking() &&
10541         !PP.isCodeCompletionEnabled())
10542       DiagnoseInvalidJumps(Body);
10543 
10544     if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
10545       if (!Destructor->getParent()->isDependentType())
10546         CheckDestructor(Destructor);
10547 
10548       MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
10549                                              Destructor->getParent());
10550     }
10551 
10552     // If any errors have occurred, clear out any temporaries that may have
10553     // been leftover. This ensures that these temporaries won't be picked up for
10554     // deletion in some later function.
10555     if (getDiagnostics().hasErrorOccurred() ||
10556         getDiagnostics().getSuppressAllDiagnostics()) {
10557       DiscardCleanupsInEvaluationContext();
10558     }
10559     if (!getDiagnostics().hasUncompilableErrorOccurred() &&
10560         !isa<FunctionTemplateDecl>(dcl)) {
10561       // Since the body is valid, issue any analysis-based warnings that are
10562       // enabled.
10563       ActivePolicy = &WP;
10564     }
10565 
10566     if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
10567         (!CheckConstexprFunctionDecl(FD) ||
10568          !CheckConstexprFunctionBody(FD, Body)))
10569       FD->setInvalidDecl();
10570 
10571     if (FD && FD->hasAttr<NakedAttr>()) {
10572       for (const Stmt *S : Body->children()) {
10573         if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {
10574           Diag(S->getLocStart(), diag::err_non_asm_stmt_in_naked_function);
10575           Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);
10576           FD->setInvalidDecl();
10577           break;
10578         }
10579       }
10580     }
10581 
10582     assert(ExprCleanupObjects.size() == ExprEvalContexts.back().NumCleanupObjects
10583            && "Leftover temporaries in function");
10584     assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
10585     assert(MaybeODRUseExprs.empty() &&
10586            "Leftover expressions for odr-use checking");
10587   }
10588 
10589   if (!IsInstantiation)
10590     PopDeclContext();
10591 
10592   PopFunctionScopeInfo(ActivePolicy, dcl);
10593   // If any errors have occurred, clear out any temporaries that may have
10594   // been leftover. This ensures that these temporaries won't be picked up for
10595   // deletion in some later function.
10596   if (getDiagnostics().hasErrorOccurred()) {
10597     DiscardCleanupsInEvaluationContext();
10598   }
10599 
10600   return dcl;
10601 }
10602 
10603 
10604 /// When we finish delayed parsing of an attribute, we must attach it to the
10605 /// relevant Decl.
10606 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
10607                                        ParsedAttributes &Attrs) {
10608   // Always attach attributes to the underlying decl.
10609   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
10610     D = TD->getTemplatedDecl();
10611   ProcessDeclAttributeList(S, D, Attrs.getList());
10612 
10613   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
10614     if (Method->isStatic())
10615       checkThisInStaticMemberFunctionAttributes(Method);
10616 }
10617 
10618 
10619 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
10620 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
10621 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
10622                                           IdentifierInfo &II, Scope *S) {
10623   // Before we produce a declaration for an implicitly defined
10624   // function, see whether there was a locally-scoped declaration of
10625   // this name as a function or variable. If so, use that
10626   // (non-visible) declaration, and complain about it.
10627   if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
10628     Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
10629     Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
10630     return ExternCPrev;
10631   }
10632 
10633   // Extension in C99.  Legal in C90, but warn about it.
10634   unsigned diag_id;
10635   if (II.getName().startswith("__builtin_"))
10636     diag_id = diag::warn_builtin_unknown;
10637   else if (getLangOpts().C99)
10638     diag_id = diag::ext_implicit_function_decl;
10639   else
10640     diag_id = diag::warn_implicit_function_decl;
10641   Diag(Loc, diag_id) << &II;
10642 
10643   // Because typo correction is expensive, only do it if the implicit
10644   // function declaration is going to be treated as an error.
10645   if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
10646     TypoCorrection Corrected;
10647     if (S &&
10648         (Corrected = CorrectTypo(
10649              DeclarationNameInfo(&II, Loc), LookupOrdinaryName, S, nullptr,
10650              llvm::make_unique<DeclFilterCCC<FunctionDecl>>(), CTK_NonError)))
10651       diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
10652                    /*ErrorRecovery*/false);
10653   }
10654 
10655   // Set a Declarator for the implicit definition: int foo();
10656   const char *Dummy;
10657   AttributeFactory attrFactory;
10658   DeclSpec DS(attrFactory);
10659   unsigned DiagID;
10660   bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
10661                                   Context.getPrintingPolicy());
10662   (void)Error; // Silence warning.
10663   assert(!Error && "Error setting up implicit decl!");
10664   SourceLocation NoLoc;
10665   Declarator D(DS, Declarator::BlockContext);
10666   D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
10667                                              /*IsAmbiguous=*/false,
10668                                              /*LParenLoc=*/NoLoc,
10669                                              /*Params=*/nullptr,
10670                                              /*NumParams=*/0,
10671                                              /*EllipsisLoc=*/NoLoc,
10672                                              /*RParenLoc=*/NoLoc,
10673                                              /*TypeQuals=*/0,
10674                                              /*RefQualifierIsLvalueRef=*/true,
10675                                              /*RefQualifierLoc=*/NoLoc,
10676                                              /*ConstQualifierLoc=*/NoLoc,
10677                                              /*VolatileQualifierLoc=*/NoLoc,
10678                                              /*RestrictQualifierLoc=*/NoLoc,
10679                                              /*MutableLoc=*/NoLoc,
10680                                              EST_None,
10681                                              /*ESpecLoc=*/NoLoc,
10682                                              /*Exceptions=*/nullptr,
10683                                              /*ExceptionRanges=*/nullptr,
10684                                              /*NumExceptions=*/0,
10685                                              /*NoexceptExpr=*/nullptr,
10686                                              /*ExceptionSpecTokens=*/nullptr,
10687                                              Loc, Loc, D),
10688                 DS.getAttributes(),
10689                 SourceLocation());
10690   D.SetIdentifier(&II, Loc);
10691 
10692   // Insert this function into translation-unit scope.
10693 
10694   DeclContext *PrevDC = CurContext;
10695   CurContext = Context.getTranslationUnitDecl();
10696 
10697   FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
10698   FD->setImplicit();
10699 
10700   CurContext = PrevDC;
10701 
10702   AddKnownFunctionAttributes(FD);
10703 
10704   return FD;
10705 }
10706 
10707 /// \brief Adds any function attributes that we know a priori based on
10708 /// the declaration of this function.
10709 ///
10710 /// These attributes can apply both to implicitly-declared builtins
10711 /// (like __builtin___printf_chk) or to library-declared functions
10712 /// like NSLog or printf.
10713 ///
10714 /// We need to check for duplicate attributes both here and where user-written
10715 /// attributes are applied to declarations.
10716 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
10717   if (FD->isInvalidDecl())
10718     return;
10719 
10720   // If this is a built-in function, map its builtin attributes to
10721   // actual attributes.
10722   if (unsigned BuiltinID = FD->getBuiltinID()) {
10723     // Handle printf-formatting attributes.
10724     unsigned FormatIdx;
10725     bool HasVAListArg;
10726     if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
10727       if (!FD->hasAttr<FormatAttr>()) {
10728         const char *fmt = "printf";
10729         unsigned int NumParams = FD->getNumParams();
10730         if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
10731             FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
10732           fmt = "NSString";
10733         FD->addAttr(FormatAttr::CreateImplicit(Context,
10734                                                &Context.Idents.get(fmt),
10735                                                FormatIdx+1,
10736                                                HasVAListArg ? 0 : FormatIdx+2,
10737                                                FD->getLocation()));
10738       }
10739     }
10740     if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
10741                                              HasVAListArg)) {
10742      if (!FD->hasAttr<FormatAttr>())
10743        FD->addAttr(FormatAttr::CreateImplicit(Context,
10744                                               &Context.Idents.get("scanf"),
10745                                               FormatIdx+1,
10746                                               HasVAListArg ? 0 : FormatIdx+2,
10747                                               FD->getLocation()));
10748     }
10749 
10750     // Mark const if we don't care about errno and that is the only
10751     // thing preventing the function from being const. This allows
10752     // IRgen to use LLVM intrinsics for such functions.
10753     if (!getLangOpts().MathErrno &&
10754         Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
10755       if (!FD->hasAttr<ConstAttr>())
10756         FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
10757     }
10758 
10759     if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
10760         !FD->hasAttr<ReturnsTwiceAttr>())
10761       FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
10762                                          FD->getLocation()));
10763     if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
10764       FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
10765     if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
10766       FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
10767   }
10768 
10769   IdentifierInfo *Name = FD->getIdentifier();
10770   if (!Name)
10771     return;
10772   if ((!getLangOpts().CPlusPlus &&
10773        FD->getDeclContext()->isTranslationUnit()) ||
10774       (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
10775        cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
10776        LinkageSpecDecl::lang_c)) {
10777     // Okay: this could be a libc/libm/Objective-C function we know
10778     // about.
10779   } else
10780     return;
10781 
10782   if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
10783     // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
10784     // target-specific builtins, perhaps?
10785     if (!FD->hasAttr<FormatAttr>())
10786       FD->addAttr(FormatAttr::CreateImplicit(Context,
10787                                              &Context.Idents.get("printf"), 2,
10788                                              Name->isStr("vasprintf") ? 0 : 3,
10789                                              FD->getLocation()));
10790   }
10791 
10792   if (Name->isStr("__CFStringMakeConstantString")) {
10793     // We already have a __builtin___CFStringMakeConstantString,
10794     // but builds that use -fno-constant-cfstrings don't go through that.
10795     if (!FD->hasAttr<FormatArgAttr>())
10796       FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
10797                                                 FD->getLocation()));
10798   }
10799 }
10800 
10801 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
10802                                     TypeSourceInfo *TInfo) {
10803   assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
10804   assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
10805 
10806   if (!TInfo) {
10807     assert(D.isInvalidType() && "no declarator info for valid type");
10808     TInfo = Context.getTrivialTypeSourceInfo(T);
10809   }
10810 
10811   // Scope manipulation handled by caller.
10812   TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
10813                                            D.getLocStart(),
10814                                            D.getIdentifierLoc(),
10815                                            D.getIdentifier(),
10816                                            TInfo);
10817 
10818   // Bail out immediately if we have an invalid declaration.
10819   if (D.isInvalidType()) {
10820     NewTD->setInvalidDecl();
10821     return NewTD;
10822   }
10823 
10824   if (D.getDeclSpec().isModulePrivateSpecified()) {
10825     if (CurContext->isFunctionOrMethod())
10826       Diag(NewTD->getLocation(), diag::err_module_private_local)
10827         << 2 << NewTD->getDeclName()
10828         << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
10829         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
10830     else
10831       NewTD->setModulePrivate();
10832   }
10833 
10834   // C++ [dcl.typedef]p8:
10835   //   If the typedef declaration defines an unnamed class (or
10836   //   enum), the first typedef-name declared by the declaration
10837   //   to be that class type (or enum type) is used to denote the
10838   //   class type (or enum type) for linkage purposes only.
10839   // We need to check whether the type was declared in the declaration.
10840   switch (D.getDeclSpec().getTypeSpecType()) {
10841   case TST_enum:
10842   case TST_struct:
10843   case TST_interface:
10844   case TST_union:
10845   case TST_class: {
10846     TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
10847 
10848     // Do nothing if the tag is not anonymous or already has an
10849     // associated typedef (from an earlier typedef in this decl group).
10850     if (tagFromDeclSpec->getIdentifier()) break;
10851     if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break;
10852 
10853     // A well-formed anonymous tag must always be a TUK_Definition.
10854     assert(tagFromDeclSpec->isThisDeclarationADefinition());
10855 
10856     // The type must match the tag exactly;  no qualifiers allowed.
10857     if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec)))
10858       break;
10859 
10860     // If we've already computed linkage for the anonymous tag, then
10861     // adding a typedef name for the anonymous decl can change that
10862     // linkage, which might be a serious problem.  Diagnose this as
10863     // unsupported and ignore the typedef name.  TODO: we should
10864     // pursue this as a language defect and establish a formal rule
10865     // for how to handle it.
10866     if (tagFromDeclSpec->hasLinkageBeenComputed()) {
10867       Diag(D.getIdentifierLoc(), diag::err_typedef_changes_linkage);
10868 
10869       SourceLocation tagLoc = D.getDeclSpec().getTypeSpecTypeLoc();
10870       tagLoc = getLocForEndOfToken(tagLoc);
10871 
10872       llvm::SmallString<40> textToInsert;
10873       textToInsert += ' ';
10874       textToInsert += D.getIdentifier()->getName();
10875       Diag(tagLoc, diag::note_typedef_changes_linkage)
10876         << FixItHint::CreateInsertion(tagLoc, textToInsert);
10877       break;
10878     }
10879 
10880     // Otherwise, set this is the anon-decl typedef for the tag.
10881     tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
10882     break;
10883   }
10884 
10885   default:
10886     break;
10887   }
10888 
10889   return NewTD;
10890 }
10891 
10892 
10893 /// \brief Check that this is a valid underlying type for an enum declaration.
10894 bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
10895   SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
10896   QualType T = TI->getType();
10897 
10898   if (T->isDependentType())
10899     return false;
10900 
10901   if (const BuiltinType *BT = T->getAs<BuiltinType>())
10902     if (BT->isInteger())
10903       return false;
10904 
10905   Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
10906   return true;
10907 }
10908 
10909 /// Check whether this is a valid redeclaration of a previous enumeration.
10910 /// \return true if the redeclaration was invalid.
10911 bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
10912                                   QualType EnumUnderlyingTy,
10913                                   const EnumDecl *Prev) {
10914   bool IsFixed = !EnumUnderlyingTy.isNull();
10915 
10916   if (IsScoped != Prev->isScoped()) {
10917     Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
10918       << Prev->isScoped();
10919     Diag(Prev->getLocation(), diag::note_previous_declaration);
10920     return true;
10921   }
10922 
10923   if (IsFixed && Prev->isFixed()) {
10924     if (!EnumUnderlyingTy->isDependentType() &&
10925         !Prev->getIntegerType()->isDependentType() &&
10926         !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
10927                                         Prev->getIntegerType())) {
10928       // TODO: Highlight the underlying type of the redeclaration.
10929       Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
10930         << EnumUnderlyingTy << Prev->getIntegerType();
10931       Diag(Prev->getLocation(), diag::note_previous_declaration)
10932           << Prev->getIntegerTypeRange();
10933       return true;
10934     }
10935   } else if (IsFixed != Prev->isFixed()) {
10936     Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
10937       << Prev->isFixed();
10938     Diag(Prev->getLocation(), diag::note_previous_declaration);
10939     return true;
10940   }
10941 
10942   return false;
10943 }
10944 
10945 /// \brief Get diagnostic %select index for tag kind for
10946 /// redeclaration diagnostic message.
10947 /// WARNING: Indexes apply to particular diagnostics only!
10948 ///
10949 /// \returns diagnostic %select index.
10950 static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
10951   switch (Tag) {
10952   case TTK_Struct: return 0;
10953   case TTK_Interface: return 1;
10954   case TTK_Class:  return 2;
10955   default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
10956   }
10957 }
10958 
10959 /// \brief Determine if tag kind is a class-key compatible with
10960 /// class for redeclaration (class, struct, or __interface).
10961 ///
10962 /// \returns true iff the tag kind is compatible.
10963 static bool isClassCompatTagKind(TagTypeKind Tag)
10964 {
10965   return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
10966 }
10967 
10968 /// \brief Determine whether a tag with a given kind is acceptable
10969 /// as a redeclaration of the given tag declaration.
10970 ///
10971 /// \returns true if the new tag kind is acceptable, false otherwise.
10972 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
10973                                         TagTypeKind NewTag, bool isDefinition,
10974                                         SourceLocation NewTagLoc,
10975                                         const IdentifierInfo &Name) {
10976   // C++ [dcl.type.elab]p3:
10977   //   The class-key or enum keyword present in the
10978   //   elaborated-type-specifier shall agree in kind with the
10979   //   declaration to which the name in the elaborated-type-specifier
10980   //   refers. This rule also applies to the form of
10981   //   elaborated-type-specifier that declares a class-name or
10982   //   friend class since it can be construed as referring to the
10983   //   definition of the class. Thus, in any
10984   //   elaborated-type-specifier, the enum keyword shall be used to
10985   //   refer to an enumeration (7.2), the union class-key shall be
10986   //   used to refer to a union (clause 9), and either the class or
10987   //   struct class-key shall be used to refer to a class (clause 9)
10988   //   declared using the class or struct class-key.
10989   TagTypeKind OldTag = Previous->getTagKind();
10990   if (!isDefinition || !isClassCompatTagKind(NewTag))
10991     if (OldTag == NewTag)
10992       return true;
10993 
10994   if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
10995     // Warn about the struct/class tag mismatch.
10996     bool isTemplate = false;
10997     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
10998       isTemplate = Record->getDescribedClassTemplate();
10999 
11000     if (!ActiveTemplateInstantiations.empty()) {
11001       // In a template instantiation, do not offer fix-its for tag mismatches
11002       // since they usually mess up the template instead of fixing the problem.
11003       Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
11004         << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11005         << getRedeclDiagFromTagKind(OldTag);
11006       return true;
11007     }
11008 
11009     if (isDefinition) {
11010       // On definitions, check previous tags and issue a fix-it for each
11011       // one that doesn't match the current tag.
11012       if (Previous->getDefinition()) {
11013         // Don't suggest fix-its for redefinitions.
11014         return true;
11015       }
11016 
11017       bool previousMismatch = false;
11018       for (auto I : Previous->redecls()) {
11019         if (I->getTagKind() != NewTag) {
11020           if (!previousMismatch) {
11021             previousMismatch = true;
11022             Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
11023               << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11024               << getRedeclDiagFromTagKind(I->getTagKind());
11025           }
11026           Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
11027             << getRedeclDiagFromTagKind(NewTag)
11028             << FixItHint::CreateReplacement(I->getInnerLocStart(),
11029                  TypeWithKeyword::getTagTypeKindName(NewTag));
11030         }
11031       }
11032       return true;
11033     }
11034 
11035     // Check for a previous definition.  If current tag and definition
11036     // are same type, do nothing.  If no definition, but disagree with
11037     // with previous tag type, give a warning, but no fix-it.
11038     const TagDecl *Redecl = Previous->getDefinition() ?
11039                             Previous->getDefinition() : Previous;
11040     if (Redecl->getTagKind() == NewTag) {
11041       return true;
11042     }
11043 
11044     Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
11045       << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
11046       << getRedeclDiagFromTagKind(OldTag);
11047     Diag(Redecl->getLocation(), diag::note_previous_use);
11048 
11049     // If there is a previous definition, suggest a fix-it.
11050     if (Previous->getDefinition()) {
11051         Diag(NewTagLoc, diag::note_struct_class_suggestion)
11052           << getRedeclDiagFromTagKind(Redecl->getTagKind())
11053           << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
11054                TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
11055     }
11056 
11057     return true;
11058   }
11059   return false;
11060 }
11061 
11062 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
11063 /// from an outer enclosing namespace or file scope inside a friend declaration.
11064 /// This should provide the commented out code in the following snippet:
11065 ///   namespace N {
11066 ///     struct X;
11067 ///     namespace M {
11068 ///       struct Y { friend struct /*N::*/ X; };
11069 ///     }
11070 ///   }
11071 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S,
11072                                          SourceLocation NameLoc) {
11073   // While the decl is in a namespace, do repeated lookup of that name and see
11074   // if we get the same namespace back.  If we do not, continue until
11075   // translation unit scope, at which point we have a fully qualified NNS.
11076   SmallVector<IdentifierInfo *, 4> Namespaces;
11077   DeclContext *DC = ND->getDeclContext()->getRedeclContext();
11078   for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
11079     // This tag should be declared in a namespace, which can only be enclosed by
11080     // other namespaces.  Bail if there's an anonymous namespace in the chain.
11081     NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
11082     if (!Namespace || Namespace->isAnonymousNamespace())
11083       return FixItHint();
11084     IdentifierInfo *II = Namespace->getIdentifier();
11085     Namespaces.push_back(II);
11086     NamedDecl *Lookup = SemaRef.LookupSingleName(
11087         S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
11088     if (Lookup == Namespace)
11089       break;
11090   }
11091 
11092   // Once we have all the namespaces, reverse them to go outermost first, and
11093   // build an NNS.
11094   SmallString<64> Insertion;
11095   llvm::raw_svector_ostream OS(Insertion);
11096   if (DC->isTranslationUnit())
11097     OS << "::";
11098   std::reverse(Namespaces.begin(), Namespaces.end());
11099   for (auto *II : Namespaces)
11100     OS << II->getName() << "::";
11101   OS.flush();
11102   return FixItHint::CreateInsertion(NameLoc, Insertion);
11103 }
11104 
11105 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'.  In the
11106 /// former case, Name will be non-null.  In the later case, Name will be null.
11107 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
11108 /// reference/declaration/definition of a tag.
11109 ///
11110 /// IsTypeSpecifier is true if this is a type-specifier (or
11111 /// trailing-type-specifier) other than one in an alias-declaration.
11112 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
11113                      SourceLocation KWLoc, CXXScopeSpec &SS,
11114                      IdentifierInfo *Name, SourceLocation NameLoc,
11115                      AttributeList *Attr, AccessSpecifier AS,
11116                      SourceLocation ModulePrivateLoc,
11117                      MultiTemplateParamsArg TemplateParameterLists,
11118                      bool &OwnedDecl, bool &IsDependent,
11119                      SourceLocation ScopedEnumKWLoc,
11120                      bool ScopedEnumUsesClassTag,
11121                      TypeResult UnderlyingType,
11122                      bool IsTypeSpecifier) {
11123   // If this is not a definition, it must have a name.
11124   IdentifierInfo *OrigName = Name;
11125   assert((Name != nullptr || TUK == TUK_Definition) &&
11126          "Nameless record must be a definition!");
11127   assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
11128 
11129   OwnedDecl = false;
11130   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
11131   bool ScopedEnum = ScopedEnumKWLoc.isValid();
11132 
11133   // FIXME: Check explicit specializations more carefully.
11134   bool isExplicitSpecialization = false;
11135   bool Invalid = false;
11136 
11137   // We only need to do this matching if we have template parameters
11138   // or a scope specifier, which also conveniently avoids this work
11139   // for non-C++ cases.
11140   if (TemplateParameterLists.size() > 0 ||
11141       (SS.isNotEmpty() && TUK != TUK_Reference)) {
11142     if (TemplateParameterList *TemplateParams =
11143             MatchTemplateParametersToScopeSpecifier(
11144                 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
11145                 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
11146       if (Kind == TTK_Enum) {
11147         Diag(KWLoc, diag::err_enum_template);
11148         return nullptr;
11149       }
11150 
11151       if (TemplateParams->size() > 0) {
11152         // This is a declaration or definition of a class template (which may
11153         // be a member of another template).
11154 
11155         if (Invalid)
11156           return nullptr;
11157 
11158         OwnedDecl = false;
11159         DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
11160                                                SS, Name, NameLoc, Attr,
11161                                                TemplateParams, AS,
11162                                                ModulePrivateLoc,
11163                                                /*FriendLoc*/SourceLocation(),
11164                                                TemplateParameterLists.size()-1,
11165                                                TemplateParameterLists.data());
11166         return Result.get();
11167       } else {
11168         // The "template<>" header is extraneous.
11169         Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
11170           << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
11171         isExplicitSpecialization = true;
11172       }
11173     }
11174   }
11175 
11176   // Figure out the underlying type if this a enum declaration. We need to do
11177   // this early, because it's needed to detect if this is an incompatible
11178   // redeclaration.
11179   llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
11180 
11181   if (Kind == TTK_Enum) {
11182     if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
11183       // No underlying type explicitly specified, or we failed to parse the
11184       // type, default to int.
11185       EnumUnderlying = Context.IntTy.getTypePtr();
11186     else if (UnderlyingType.get()) {
11187       // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
11188       // integral type; any cv-qualification is ignored.
11189       TypeSourceInfo *TI = nullptr;
11190       GetTypeFromParser(UnderlyingType.get(), &TI);
11191       EnumUnderlying = TI;
11192 
11193       if (CheckEnumUnderlyingType(TI))
11194         // Recover by falling back to int.
11195         EnumUnderlying = Context.IntTy.getTypePtr();
11196 
11197       if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
11198                                           UPPC_FixedUnderlyingType))
11199         EnumUnderlying = Context.IntTy.getTypePtr();
11200 
11201     } else if (getLangOpts().MSVCCompat)
11202       // Microsoft enums are always of int type.
11203       EnumUnderlying = Context.IntTy.getTypePtr();
11204   }
11205 
11206   DeclContext *SearchDC = CurContext;
11207   DeclContext *DC = CurContext;
11208   bool isStdBadAlloc = false;
11209 
11210   RedeclarationKind Redecl = ForRedeclaration;
11211   if (TUK == TUK_Friend || TUK == TUK_Reference)
11212     Redecl = NotForRedeclaration;
11213 
11214   LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
11215   if (Name && SS.isNotEmpty()) {
11216     // We have a nested-name tag ('struct foo::bar').
11217 
11218     // Check for invalid 'foo::'.
11219     if (SS.isInvalid()) {
11220       Name = nullptr;
11221       goto CreateNewDecl;
11222     }
11223 
11224     // If this is a friend or a reference to a class in a dependent
11225     // context, don't try to make a decl for it.
11226     if (TUK == TUK_Friend || TUK == TUK_Reference) {
11227       DC = computeDeclContext(SS, false);
11228       if (!DC) {
11229         IsDependent = true;
11230         return nullptr;
11231       }
11232     } else {
11233       DC = computeDeclContext(SS, true);
11234       if (!DC) {
11235         Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
11236           << SS.getRange();
11237         return nullptr;
11238       }
11239     }
11240 
11241     if (RequireCompleteDeclContext(SS, DC))
11242       return nullptr;
11243 
11244     SearchDC = DC;
11245     // Look-up name inside 'foo::'.
11246     LookupQualifiedName(Previous, DC);
11247 
11248     if (Previous.isAmbiguous())
11249       return nullptr;
11250 
11251     if (Previous.empty()) {
11252       // Name lookup did not find anything. However, if the
11253       // nested-name-specifier refers to the current instantiation,
11254       // and that current instantiation has any dependent base
11255       // classes, we might find something at instantiation time: treat
11256       // this as a dependent elaborated-type-specifier.
11257       // But this only makes any sense for reference-like lookups.
11258       if (Previous.wasNotFoundInCurrentInstantiation() &&
11259           (TUK == TUK_Reference || TUK == TUK_Friend)) {
11260         IsDependent = true;
11261         return nullptr;
11262       }
11263 
11264       // A tag 'foo::bar' must already exist.
11265       Diag(NameLoc, diag::err_not_tag_in_scope)
11266         << Kind << Name << DC << SS.getRange();
11267       Name = nullptr;
11268       Invalid = true;
11269       goto CreateNewDecl;
11270     }
11271   } else if (Name) {
11272     // If this is a named struct, check to see if there was a previous forward
11273     // declaration or definition.
11274     // FIXME: We're looking into outer scopes here, even when we
11275     // shouldn't be. Doing so can result in ambiguities that we
11276     // shouldn't be diagnosing.
11277     LookupName(Previous, S);
11278 
11279     // When declaring or defining a tag, ignore ambiguities introduced
11280     // by types using'ed into this scope.
11281     if (Previous.isAmbiguous() &&
11282         (TUK == TUK_Definition || TUK == TUK_Declaration)) {
11283       LookupResult::Filter F = Previous.makeFilter();
11284       while (F.hasNext()) {
11285         NamedDecl *ND = F.next();
11286         if (ND->getDeclContext()->getRedeclContext() != SearchDC)
11287           F.erase();
11288       }
11289       F.done();
11290     }
11291 
11292     // C++11 [namespace.memdef]p3:
11293     //   If the name in a friend declaration is neither qualified nor
11294     //   a template-id and the declaration is a function or an
11295     //   elaborated-type-specifier, the lookup to determine whether
11296     //   the entity has been previously declared shall not consider
11297     //   any scopes outside the innermost enclosing namespace.
11298     //
11299     // MSVC doesn't implement the above rule for types, so a friend tag
11300     // declaration may be a redeclaration of a type declared in an enclosing
11301     // scope.  They do implement this rule for friend functions.
11302     //
11303     // Does it matter that this should be by scope instead of by
11304     // semantic context?
11305     if (!Previous.empty() && TUK == TUK_Friend) {
11306       DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
11307       LookupResult::Filter F = Previous.makeFilter();
11308       bool FriendSawTagOutsideEnclosingNamespace = false;
11309       while (F.hasNext()) {
11310         NamedDecl *ND = F.next();
11311         DeclContext *DC = ND->getDeclContext()->getRedeclContext();
11312         if (DC->isFileContext() &&
11313             !EnclosingNS->Encloses(ND->getDeclContext())) {
11314           if (getLangOpts().MSVCCompat)
11315             FriendSawTagOutsideEnclosingNamespace = true;
11316           else
11317             F.erase();
11318         }
11319       }
11320       F.done();
11321 
11322       // Diagnose this MSVC extension in the easy case where lookup would have
11323       // unambiguously found something outside the enclosing namespace.
11324       if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
11325         NamedDecl *ND = Previous.getFoundDecl();
11326         Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
11327             << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
11328       }
11329     }
11330 
11331     // Note:  there used to be some attempt at recovery here.
11332     if (Previous.isAmbiguous())
11333       return nullptr;
11334 
11335     if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
11336       // FIXME: This makes sure that we ignore the contexts associated
11337       // with C structs, unions, and enums when looking for a matching
11338       // tag declaration or definition. See the similar lookup tweak
11339       // in Sema::LookupName; is there a better way to deal with this?
11340       while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
11341         SearchDC = SearchDC->getParent();
11342     }
11343   }
11344 
11345   if (Previous.isSingleResult() &&
11346       Previous.getFoundDecl()->isTemplateParameter()) {
11347     // Maybe we will complain about the shadowed template parameter.
11348     DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
11349     // Just pretend that we didn't see the previous declaration.
11350     Previous.clear();
11351   }
11352 
11353   if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
11354       DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
11355     // This is a declaration of or a reference to "std::bad_alloc".
11356     isStdBadAlloc = true;
11357 
11358     if (Previous.empty() && StdBadAlloc) {
11359       // std::bad_alloc has been implicitly declared (but made invisible to
11360       // name lookup). Fill in this implicit declaration as the previous
11361       // declaration, so that the declarations get chained appropriately.
11362       Previous.addDecl(getStdBadAlloc());
11363     }
11364   }
11365 
11366   // If we didn't find a previous declaration, and this is a reference
11367   // (or friend reference), move to the correct scope.  In C++, we
11368   // also need to do a redeclaration lookup there, just in case
11369   // there's a shadow friend decl.
11370   if (Name && Previous.empty() &&
11371       (TUK == TUK_Reference || TUK == TUK_Friend)) {
11372     if (Invalid) goto CreateNewDecl;
11373     assert(SS.isEmpty());
11374 
11375     if (TUK == TUK_Reference) {
11376       // C++ [basic.scope.pdecl]p5:
11377       //   -- for an elaborated-type-specifier of the form
11378       //
11379       //          class-key identifier
11380       //
11381       //      if the elaborated-type-specifier is used in the
11382       //      decl-specifier-seq or parameter-declaration-clause of a
11383       //      function defined in namespace scope, the identifier is
11384       //      declared as a class-name in the namespace that contains
11385       //      the declaration; otherwise, except as a friend
11386       //      declaration, the identifier is declared in the smallest
11387       //      non-class, non-function-prototype scope that contains the
11388       //      declaration.
11389       //
11390       // C99 6.7.2.3p8 has a similar (but not identical!) provision for
11391       // C structs and unions.
11392       //
11393       // It is an error in C++ to declare (rather than define) an enum
11394       // type, including via an elaborated type specifier.  We'll
11395       // diagnose that later; for now, declare the enum in the same
11396       // scope as we would have picked for any other tag type.
11397       //
11398       // GNU C also supports this behavior as part of its incomplete
11399       // enum types extension, while GNU C++ does not.
11400       //
11401       // Find the context where we'll be declaring the tag.
11402       // FIXME: We would like to maintain the current DeclContext as the
11403       // lexical context,
11404       while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod())
11405         SearchDC = SearchDC->getParent();
11406 
11407       // Find the scope where we'll be declaring the tag.
11408       while (S->isClassScope() ||
11409              (getLangOpts().CPlusPlus &&
11410               S->isFunctionPrototypeScope()) ||
11411              ((S->getFlags() & Scope::DeclScope) == 0) ||
11412              (S->getEntity() && S->getEntity()->isTransparentContext()))
11413         S = S->getParent();
11414     } else {
11415       assert(TUK == TUK_Friend);
11416       // C++ [namespace.memdef]p3:
11417       //   If a friend declaration in a non-local class first declares a
11418       //   class or function, the friend class or function is a member of
11419       //   the innermost enclosing namespace.
11420       SearchDC = SearchDC->getEnclosingNamespaceContext();
11421     }
11422 
11423     // In C++, we need to do a redeclaration lookup to properly
11424     // diagnose some problems.
11425     if (getLangOpts().CPlusPlus) {
11426       Previous.setRedeclarationKind(ForRedeclaration);
11427       LookupQualifiedName(Previous, SearchDC);
11428     }
11429   }
11430 
11431   if (!Previous.empty()) {
11432     NamedDecl *PrevDecl = Previous.getFoundDecl();
11433     NamedDecl *DirectPrevDecl =
11434         getLangOpts().MSVCCompat ? *Previous.begin() : PrevDecl;
11435 
11436     // It's okay to have a tag decl in the same scope as a typedef
11437     // which hides a tag decl in the same scope.  Finding this
11438     // insanity with a redeclaration lookup can only actually happen
11439     // in C++.
11440     //
11441     // This is also okay for elaborated-type-specifiers, which is
11442     // technically forbidden by the current standard but which is
11443     // okay according to the likely resolution of an open issue;
11444     // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
11445     if (getLangOpts().CPlusPlus) {
11446       if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
11447         if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
11448           TagDecl *Tag = TT->getDecl();
11449           if (Tag->getDeclName() == Name &&
11450               Tag->getDeclContext()->getRedeclContext()
11451                           ->Equals(TD->getDeclContext()->getRedeclContext())) {
11452             PrevDecl = Tag;
11453             Previous.clear();
11454             Previous.addDecl(Tag);
11455             Previous.resolveKind();
11456           }
11457         }
11458       }
11459     }
11460 
11461     if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
11462       // If this is a use of a previous tag, or if the tag is already declared
11463       // in the same scope (so that the definition/declaration completes or
11464       // rementions the tag), reuse the decl.
11465       if (TUK == TUK_Reference || TUK == TUK_Friend ||
11466           isDeclInScope(DirectPrevDecl, SearchDC, S,
11467                         SS.isNotEmpty() || isExplicitSpecialization)) {
11468         // Make sure that this wasn't declared as an enum and now used as a
11469         // struct or something similar.
11470         if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
11471                                           TUK == TUK_Definition, KWLoc,
11472                                           *Name)) {
11473           bool SafeToContinue
11474             = (PrevTagDecl->getTagKind() != TTK_Enum &&
11475                Kind != TTK_Enum);
11476           if (SafeToContinue)
11477             Diag(KWLoc, diag::err_use_with_wrong_tag)
11478               << Name
11479               << FixItHint::CreateReplacement(SourceRange(KWLoc),
11480                                               PrevTagDecl->getKindName());
11481           else
11482             Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
11483           Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
11484 
11485           if (SafeToContinue)
11486             Kind = PrevTagDecl->getTagKind();
11487           else {
11488             // Recover by making this an anonymous redefinition.
11489             Name = nullptr;
11490             Previous.clear();
11491             Invalid = true;
11492           }
11493         }
11494 
11495         if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
11496           const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
11497 
11498           // If this is an elaborated-type-specifier for a scoped enumeration,
11499           // the 'class' keyword is not necessary and not permitted.
11500           if (TUK == TUK_Reference || TUK == TUK_Friend) {
11501             if (ScopedEnum)
11502               Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
11503                 << PrevEnum->isScoped()
11504                 << FixItHint::CreateRemoval(ScopedEnumKWLoc);
11505             return PrevTagDecl;
11506           }
11507 
11508           QualType EnumUnderlyingTy;
11509           if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
11510             EnumUnderlyingTy = TI->getType().getUnqualifiedType();
11511           else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
11512             EnumUnderlyingTy = QualType(T, 0);
11513 
11514           // All conflicts with previous declarations are recovered by
11515           // returning the previous declaration, unless this is a definition,
11516           // in which case we want the caller to bail out.
11517           if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
11518                                      ScopedEnum, EnumUnderlyingTy, PrevEnum))
11519             return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
11520         }
11521 
11522         // C++11 [class.mem]p1:
11523         //   A member shall not be declared twice in the member-specification,
11524         //   except that a nested class or member class template can be declared
11525         //   and then later defined.
11526         if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
11527             S->isDeclScope(PrevDecl)) {
11528           Diag(NameLoc, diag::ext_member_redeclared);
11529           Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
11530         }
11531 
11532         if (!Invalid) {
11533           // If this is a use, just return the declaration we found, unless
11534           // we have attributes.
11535 
11536           // FIXME: In the future, return a variant or some other clue
11537           // for the consumer of this Decl to know it doesn't own it.
11538           // For our current ASTs this shouldn't be a problem, but will
11539           // need to be changed with DeclGroups.
11540           if (!Attr &&
11541               ((TUK == TUK_Reference &&
11542                 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt))
11543                || TUK == TUK_Friend))
11544             return PrevTagDecl;
11545 
11546           // Diagnose attempts to redefine a tag.
11547           if (TUK == TUK_Definition) {
11548             if (TagDecl *Def = PrevTagDecl->getDefinition()) {
11549               // If we're defining a specialization and the previous definition
11550               // is from an implicit instantiation, don't emit an error
11551               // here; we'll catch this in the general case below.
11552               bool IsExplicitSpecializationAfterInstantiation = false;
11553               if (isExplicitSpecialization) {
11554                 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
11555                   IsExplicitSpecializationAfterInstantiation =
11556                     RD->getTemplateSpecializationKind() !=
11557                     TSK_ExplicitSpecialization;
11558                 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
11559                   IsExplicitSpecializationAfterInstantiation =
11560                     ED->getTemplateSpecializationKind() !=
11561                     TSK_ExplicitSpecialization;
11562               }
11563 
11564               if (!IsExplicitSpecializationAfterInstantiation) {
11565                 // A redeclaration in function prototype scope in C isn't
11566                 // visible elsewhere, so merely issue a warning.
11567                 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
11568                   Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
11569                 else
11570                   Diag(NameLoc, diag::err_redefinition) << Name;
11571                 Diag(Def->getLocation(), diag::note_previous_definition);
11572                 // If this is a redefinition, recover by making this
11573                 // struct be anonymous, which will make any later
11574                 // references get the previous definition.
11575                 Name = nullptr;
11576                 Previous.clear();
11577                 Invalid = true;
11578               }
11579             } else {
11580               // If the type is currently being defined, complain
11581               // about a nested redefinition.
11582               const TagType *Tag
11583                 = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
11584               if (Tag->isBeingDefined()) {
11585                 Diag(NameLoc, diag::err_nested_redefinition) << Name;
11586                 Diag(PrevTagDecl->getLocation(),
11587                      diag::note_previous_definition);
11588                 Name = nullptr;
11589                 Previous.clear();
11590                 Invalid = true;
11591               }
11592             }
11593 
11594             // Okay, this is definition of a previously declared or referenced
11595             // tag. We're going to create a new Decl for it.
11596           }
11597 
11598           // Okay, we're going to make a redeclaration.  If this is some kind
11599           // of reference, make sure we build the redeclaration in the same DC
11600           // as the original, and ignore the current access specifier.
11601           if (TUK == TUK_Friend || TUK == TUK_Reference) {
11602             SearchDC = PrevTagDecl->getDeclContext();
11603             AS = AS_none;
11604           }
11605         }
11606         // If we get here we have (another) forward declaration or we
11607         // have a definition.  Just create a new decl.
11608 
11609       } else {
11610         // If we get here, this is a definition of a new tag type in a nested
11611         // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
11612         // new decl/type.  We set PrevDecl to NULL so that the entities
11613         // have distinct types.
11614         Previous.clear();
11615       }
11616       // If we get here, we're going to create a new Decl. If PrevDecl
11617       // is non-NULL, it's a definition of the tag declared by
11618       // PrevDecl. If it's NULL, we have a new definition.
11619 
11620 
11621     // Otherwise, PrevDecl is not a tag, but was found with tag
11622     // lookup.  This is only actually possible in C++, where a few
11623     // things like templates still live in the tag namespace.
11624     } else {
11625       // Use a better diagnostic if an elaborated-type-specifier
11626       // found the wrong kind of type on the first
11627       // (non-redeclaration) lookup.
11628       if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
11629           !Previous.isForRedeclaration()) {
11630         unsigned Kind = 0;
11631         if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
11632         else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11633         else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
11634         Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
11635         Diag(PrevDecl->getLocation(), diag::note_declared_at);
11636         Invalid = true;
11637 
11638       // Otherwise, only diagnose if the declaration is in scope.
11639       } else if (!isDeclInScope(PrevDecl, SearchDC, S,
11640                                 SS.isNotEmpty() || isExplicitSpecialization)) {
11641         // do nothing
11642 
11643       // Diagnose implicit declarations introduced by elaborated types.
11644       } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
11645         unsigned Kind = 0;
11646         if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
11647         else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11648         else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
11649         Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
11650         Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11651         Invalid = true;
11652 
11653       // Otherwise it's a declaration.  Call out a particularly common
11654       // case here.
11655       } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
11656         unsigned Kind = 0;
11657         if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
11658         Diag(NameLoc, diag::err_tag_definition_of_typedef)
11659           << Name << Kind << TND->getUnderlyingType();
11660         Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11661         Invalid = true;
11662 
11663       // Otherwise, diagnose.
11664       } else {
11665         // The tag name clashes with something else in the target scope,
11666         // issue an error and recover by making this tag be anonymous.
11667         Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
11668         Diag(PrevDecl->getLocation(), diag::note_previous_definition);
11669         Name = nullptr;
11670         Invalid = true;
11671       }
11672 
11673       // The existing declaration isn't relevant to us; we're in a
11674       // new scope, so clear out the previous declaration.
11675       Previous.clear();
11676     }
11677   }
11678 
11679 CreateNewDecl:
11680 
11681   TagDecl *PrevDecl = nullptr;
11682   if (Previous.isSingleResult())
11683     PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
11684 
11685   // If there is an identifier, use the location of the identifier as the
11686   // location of the decl, otherwise use the location of the struct/union
11687   // keyword.
11688   SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
11689 
11690   // Otherwise, create a new declaration. If there is a previous
11691   // declaration of the same entity, the two will be linked via
11692   // PrevDecl.
11693   TagDecl *New;
11694 
11695   bool IsForwardReference = false;
11696   if (Kind == TTK_Enum) {
11697     // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
11698     // enum X { A, B, C } D;    D should chain to X.
11699     New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
11700                            cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
11701                            ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
11702     // If this is an undefined enum, warn.
11703     if (TUK != TUK_Definition && !Invalid) {
11704       TagDecl *Def;
11705       if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
11706           cast<EnumDecl>(New)->isFixed()) {
11707         // C++0x: 7.2p2: opaque-enum-declaration.
11708         // Conflicts are diagnosed above. Do nothing.
11709       }
11710       else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
11711         Diag(Loc, diag::ext_forward_ref_enum_def)
11712           << New;
11713         Diag(Def->getLocation(), diag::note_previous_definition);
11714       } else {
11715         unsigned DiagID = diag::ext_forward_ref_enum;
11716         if (getLangOpts().MSVCCompat)
11717           DiagID = diag::ext_ms_forward_ref_enum;
11718         else if (getLangOpts().CPlusPlus)
11719           DiagID = diag::err_forward_ref_enum;
11720         Diag(Loc, DiagID);
11721 
11722         // If this is a forward-declared reference to an enumeration, make a
11723         // note of it; we won't actually be introducing the declaration into
11724         // the declaration context.
11725         if (TUK == TUK_Reference)
11726           IsForwardReference = true;
11727       }
11728     }
11729 
11730     if (EnumUnderlying) {
11731       EnumDecl *ED = cast<EnumDecl>(New);
11732       if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
11733         ED->setIntegerTypeSourceInfo(TI);
11734       else
11735         ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
11736       ED->setPromotionType(ED->getIntegerType());
11737     }
11738 
11739   } else {
11740     // struct/union/class
11741 
11742     // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
11743     // struct X { int A; } D;    D should chain to X.
11744     if (getLangOpts().CPlusPlus) {
11745       // FIXME: Look for a way to use RecordDecl for simple structs.
11746       New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
11747                                   cast_or_null<CXXRecordDecl>(PrevDecl));
11748 
11749       if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
11750         StdBadAlloc = cast<CXXRecordDecl>(New);
11751     } else
11752       New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
11753                                cast_or_null<RecordDecl>(PrevDecl));
11754   }
11755 
11756   // C++11 [dcl.type]p3:
11757   //   A type-specifier-seq shall not define a class or enumeration [...].
11758   if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
11759     Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
11760       << Context.getTagDeclType(New);
11761     Invalid = true;
11762   }
11763 
11764   // Maybe add qualifier info.
11765   if (SS.isNotEmpty()) {
11766     if (SS.isSet()) {
11767       // If this is either a declaration or a definition, check the
11768       // nested-name-specifier against the current context. We don't do this
11769       // for explicit specializations, because they have similar checking
11770       // (with more specific diagnostics) in the call to
11771       // CheckMemberSpecialization, below.
11772       if (!isExplicitSpecialization &&
11773           (TUK == TUK_Definition || TUK == TUK_Declaration) &&
11774           diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc))
11775         Invalid = true;
11776 
11777       New->setQualifierInfo(SS.getWithLocInContext(Context));
11778       if (TemplateParameterLists.size() > 0) {
11779         New->setTemplateParameterListsInfo(Context,
11780                                            TemplateParameterLists.size(),
11781                                            TemplateParameterLists.data());
11782       }
11783     }
11784     else
11785       Invalid = true;
11786   }
11787 
11788   if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
11789     // Add alignment attributes if necessary; these attributes are checked when
11790     // the ASTContext lays out the structure.
11791     //
11792     // It is important for implementing the correct semantics that this
11793     // happen here (in act on tag decl). The #pragma pack stack is
11794     // maintained as a result of parser callbacks which can occur at
11795     // many points during the parsing of a struct declaration (because
11796     // the #pragma tokens are effectively skipped over during the
11797     // parsing of the struct).
11798     if (TUK == TUK_Definition) {
11799       AddAlignmentAttributesForRecord(RD);
11800       AddMsStructLayoutForRecord(RD);
11801     }
11802   }
11803 
11804   if (ModulePrivateLoc.isValid()) {
11805     if (isExplicitSpecialization)
11806       Diag(New->getLocation(), diag::err_module_private_specialization)
11807         << 2
11808         << FixItHint::CreateRemoval(ModulePrivateLoc);
11809     // __module_private__ does not apply to local classes. However, we only
11810     // diagnose this as an error when the declaration specifiers are
11811     // freestanding. Here, we just ignore the __module_private__.
11812     else if (!SearchDC->isFunctionOrMethod())
11813       New->setModulePrivate();
11814   }
11815 
11816   // If this is a specialization of a member class (of a class template),
11817   // check the specialization.
11818   if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
11819     Invalid = true;
11820 
11821   // If we're declaring or defining a tag in function prototype scope in C,
11822   // note that this type can only be used within the function and add it to
11823   // the list of decls to inject into the function definition scope.
11824   if ((Name || Kind == TTK_Enum) &&
11825       getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
11826     if (getLangOpts().CPlusPlus) {
11827       // C++ [dcl.fct]p6:
11828       //   Types shall not be defined in return or parameter types.
11829       if (TUK == TUK_Definition && !IsTypeSpecifier) {
11830         Diag(Loc, diag::err_type_defined_in_param_type)
11831             << Name;
11832         Invalid = true;
11833       }
11834     } else {
11835       Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
11836     }
11837     DeclsInPrototypeScope.push_back(New);
11838   }
11839 
11840   if (Invalid)
11841     New->setInvalidDecl();
11842 
11843   if (Attr)
11844     ProcessDeclAttributeList(S, New, Attr);
11845 
11846   // Set the lexical context. If the tag has a C++ scope specifier, the
11847   // lexical context will be different from the semantic context.
11848   New->setLexicalDeclContext(CurContext);
11849 
11850   // Mark this as a friend decl if applicable.
11851   // In Microsoft mode, a friend declaration also acts as a forward
11852   // declaration so we always pass true to setObjectOfFriendDecl to make
11853   // the tag name visible.
11854   if (TUK == TUK_Friend)
11855     New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
11856 
11857   // Set the access specifier.
11858   if (!Invalid && SearchDC->isRecord())
11859     SetMemberAccessSpecifier(New, PrevDecl, AS);
11860 
11861   if (TUK == TUK_Definition)
11862     New->startDefinition();
11863 
11864   // If this has an identifier, add it to the scope stack.
11865   if (TUK == TUK_Friend) {
11866     // We might be replacing an existing declaration in the lookup tables;
11867     // if so, borrow its access specifier.
11868     if (PrevDecl)
11869       New->setAccess(PrevDecl->getAccess());
11870 
11871     DeclContext *DC = New->getDeclContext()->getRedeclContext();
11872     DC->makeDeclVisibleInContext(New);
11873     if (Name) // can be null along some error paths
11874       if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
11875         PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
11876   } else if (Name) {
11877     S = getNonFieldDeclScope(S);
11878     PushOnScopeChains(New, S, !IsForwardReference);
11879     if (IsForwardReference)
11880       SearchDC->makeDeclVisibleInContext(New);
11881 
11882   } else {
11883     CurContext->addDecl(New);
11884   }
11885 
11886   // If this is the C FILE type, notify the AST context.
11887   if (IdentifierInfo *II = New->getIdentifier())
11888     if (!New->isInvalidDecl() &&
11889         New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
11890         II->isStr("FILE"))
11891       Context.setFILEDecl(New);
11892 
11893   if (PrevDecl)
11894     mergeDeclAttributes(New, PrevDecl);
11895 
11896   // If there's a #pragma GCC visibility in scope, set the visibility of this
11897   // record.
11898   AddPushedVisibilityAttribute(New);
11899 
11900   OwnedDecl = true;
11901   // In C++, don't return an invalid declaration. We can't recover well from
11902   // the cases where we make the type anonymous.
11903   return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
11904 }
11905 
11906 void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
11907   AdjustDeclIfTemplate(TagD);
11908   TagDecl *Tag = cast<TagDecl>(TagD);
11909 
11910   // Enter the tag context.
11911   PushDeclContext(S, Tag);
11912 
11913   ActOnDocumentableDecl(TagD);
11914 
11915   // If there's a #pragma GCC visibility in scope, set the visibility of this
11916   // record.
11917   AddPushedVisibilityAttribute(Tag);
11918 }
11919 
11920 Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
11921   assert(isa<ObjCContainerDecl>(IDecl) &&
11922          "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
11923   DeclContext *OCD = cast<DeclContext>(IDecl);
11924   assert(getContainingDC(OCD) == CurContext &&
11925       "The next DeclContext should be lexically contained in the current one.");
11926   CurContext = OCD;
11927   return IDecl;
11928 }
11929 
11930 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
11931                                            SourceLocation FinalLoc,
11932                                            bool IsFinalSpelledSealed,
11933                                            SourceLocation LBraceLoc) {
11934   AdjustDeclIfTemplate(TagD);
11935   CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
11936 
11937   FieldCollector->StartClass();
11938 
11939   if (!Record->getIdentifier())
11940     return;
11941 
11942   if (FinalLoc.isValid())
11943     Record->addAttr(new (Context)
11944                     FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
11945 
11946   // C++ [class]p2:
11947   //   [...] The class-name is also inserted into the scope of the
11948   //   class itself; this is known as the injected-class-name. For
11949   //   purposes of access checking, the injected-class-name is treated
11950   //   as if it were a public member name.
11951   CXXRecordDecl *InjectedClassName
11952     = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
11953                             Record->getLocStart(), Record->getLocation(),
11954                             Record->getIdentifier(),
11955                             /*PrevDecl=*/nullptr,
11956                             /*DelayTypeCreation=*/true);
11957   Context.getTypeDeclType(InjectedClassName, Record);
11958   InjectedClassName->setImplicit();
11959   InjectedClassName->setAccess(AS_public);
11960   if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
11961       InjectedClassName->setDescribedClassTemplate(Template);
11962   PushOnScopeChains(InjectedClassName, S);
11963   assert(InjectedClassName->isInjectedClassName() &&
11964          "Broken injected-class-name");
11965 }
11966 
11967 void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
11968                                     SourceLocation RBraceLoc) {
11969   AdjustDeclIfTemplate(TagD);
11970   TagDecl *Tag = cast<TagDecl>(TagD);
11971   Tag->setRBraceLoc(RBraceLoc);
11972 
11973   // Make sure we "complete" the definition even it is invalid.
11974   if (Tag->isBeingDefined()) {
11975     assert(Tag->isInvalidDecl() && "We should already have completed it");
11976     if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
11977       RD->completeDefinition();
11978   }
11979 
11980   if (isa<CXXRecordDecl>(Tag))
11981     FieldCollector->FinishClass();
11982 
11983   // Exit this scope of this tag's definition.
11984   PopDeclContext();
11985 
11986   if (getCurLexicalContext()->isObjCContainer() &&
11987       Tag->getDeclContext()->isFileContext())
11988     Tag->setTopLevelDeclInObjCContainer();
11989 
11990   // Notify the consumer that we've defined a tag.
11991   if (!Tag->isInvalidDecl())
11992     Consumer.HandleTagDeclDefinition(Tag);
11993 }
11994 
11995 void Sema::ActOnObjCContainerFinishDefinition() {
11996   // Exit this scope of this interface definition.
11997   PopDeclContext();
11998 }
11999 
12000 void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
12001   assert(DC == CurContext && "Mismatch of container contexts");
12002   OriginalLexicalContext = DC;
12003   ActOnObjCContainerFinishDefinition();
12004 }
12005 
12006 void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
12007   ActOnObjCContainerStartDefinition(cast<Decl>(DC));
12008   OriginalLexicalContext = nullptr;
12009 }
12010 
12011 void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
12012   AdjustDeclIfTemplate(TagD);
12013   TagDecl *Tag = cast<TagDecl>(TagD);
12014   Tag->setInvalidDecl();
12015 
12016   // Make sure we "complete" the definition even it is invalid.
12017   if (Tag->isBeingDefined()) {
12018     if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
12019       RD->completeDefinition();
12020   }
12021 
12022   // We're undoing ActOnTagStartDefinition here, not
12023   // ActOnStartCXXMemberDeclarations, so we don't have to mess with
12024   // the FieldCollector.
12025 
12026   PopDeclContext();
12027 }
12028 
12029 // Note that FieldName may be null for anonymous bitfields.
12030 ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
12031                                 IdentifierInfo *FieldName,
12032                                 QualType FieldTy, bool IsMsStruct,
12033                                 Expr *BitWidth, bool *ZeroWidth) {
12034   // Default to true; that shouldn't confuse checks for emptiness
12035   if (ZeroWidth)
12036     *ZeroWidth = true;
12037 
12038   // C99 6.7.2.1p4 - verify the field type.
12039   // C++ 9.6p3: A bit-field shall have integral or enumeration type.
12040   if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
12041     // Handle incomplete types with specific error.
12042     if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
12043       return ExprError();
12044     if (FieldName)
12045       return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
12046         << FieldName << FieldTy << BitWidth->getSourceRange();
12047     return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
12048       << FieldTy << BitWidth->getSourceRange();
12049   } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
12050                                              UPPC_BitFieldWidth))
12051     return ExprError();
12052 
12053   // If the bit-width is type- or value-dependent, don't try to check
12054   // it now.
12055   if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
12056     return BitWidth;
12057 
12058   llvm::APSInt Value;
12059   ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
12060   if (ICE.isInvalid())
12061     return ICE;
12062   BitWidth = ICE.get();
12063 
12064   if (Value != 0 && ZeroWidth)
12065     *ZeroWidth = false;
12066 
12067   // Zero-width bitfield is ok for anonymous field.
12068   if (Value == 0 && FieldName)
12069     return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
12070 
12071   if (Value.isSigned() && Value.isNegative()) {
12072     if (FieldName)
12073       return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
12074                << FieldName << Value.toString(10);
12075     return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
12076       << Value.toString(10);
12077   }
12078 
12079   if (!FieldTy->isDependentType()) {
12080     uint64_t TypeSize = Context.getTypeSize(FieldTy);
12081     if (Value.getZExtValue() > TypeSize) {
12082       if (!getLangOpts().CPlusPlus || IsMsStruct ||
12083           Context.getTargetInfo().getCXXABI().isMicrosoft()) {
12084         if (FieldName)
12085           return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
12086             << FieldName << (unsigned)Value.getZExtValue()
12087             << (unsigned)TypeSize;
12088 
12089         return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
12090           << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
12091       }
12092 
12093       if (FieldName)
12094         Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
12095           << FieldName << (unsigned)Value.getZExtValue()
12096           << (unsigned)TypeSize;
12097       else
12098         Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
12099           << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
12100     }
12101   }
12102 
12103   return BitWidth;
12104 }
12105 
12106 /// ActOnField - Each field of a C struct/union is passed into this in order
12107 /// to create a FieldDecl object for it.
12108 Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
12109                        Declarator &D, Expr *BitfieldWidth) {
12110   FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
12111                                DeclStart, D, static_cast<Expr*>(BitfieldWidth),
12112                                /*InitStyle=*/ICIS_NoInit, AS_public);
12113   return Res;
12114 }
12115 
12116 /// HandleField - Analyze a field of a C struct or a C++ data member.
12117 ///
12118 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
12119                              SourceLocation DeclStart,
12120                              Declarator &D, Expr *BitWidth,
12121                              InClassInitStyle InitStyle,
12122                              AccessSpecifier AS) {
12123   IdentifierInfo *II = D.getIdentifier();
12124   SourceLocation Loc = DeclStart;
12125   if (II) Loc = D.getIdentifierLoc();
12126 
12127   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12128   QualType T = TInfo->getType();
12129   if (getLangOpts().CPlusPlus) {
12130     CheckExtraCXXDefaultArguments(D);
12131 
12132     if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
12133                                         UPPC_DataMemberType)) {
12134       D.setInvalidType();
12135       T = Context.IntTy;
12136       TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
12137     }
12138   }
12139 
12140   // TR 18037 does not allow fields to be declared with address spaces.
12141   if (T.getQualifiers().hasAddressSpace()) {
12142     Diag(Loc, diag::err_field_with_address_space);
12143     D.setInvalidType();
12144   }
12145 
12146   // OpenCL 1.2 spec, s6.9 r:
12147   // The event type cannot be used to declare a structure or union field.
12148   if (LangOpts.OpenCL && T->isEventT()) {
12149     Diag(Loc, diag::err_event_t_struct_field);
12150     D.setInvalidType();
12151   }
12152 
12153   DiagnoseFunctionSpecifiers(D.getDeclSpec());
12154 
12155   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
12156     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
12157          diag::err_invalid_thread)
12158       << DeclSpec::getSpecifierName(TSCS);
12159 
12160   // Check to see if this name was declared as a member previously
12161   NamedDecl *PrevDecl = nullptr;
12162   LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
12163   LookupName(Previous, S);
12164   switch (Previous.getResultKind()) {
12165     case LookupResult::Found:
12166     case LookupResult::FoundUnresolvedValue:
12167       PrevDecl = Previous.getAsSingle<NamedDecl>();
12168       break;
12169 
12170     case LookupResult::FoundOverloaded:
12171       PrevDecl = Previous.getRepresentativeDecl();
12172       break;
12173 
12174     case LookupResult::NotFound:
12175     case LookupResult::NotFoundInCurrentInstantiation:
12176     case LookupResult::Ambiguous:
12177       break;
12178   }
12179   Previous.suppressDiagnostics();
12180 
12181   if (PrevDecl && PrevDecl->isTemplateParameter()) {
12182     // Maybe we will complain about the shadowed template parameter.
12183     DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
12184     // Just pretend that we didn't see the previous declaration.
12185     PrevDecl = nullptr;
12186   }
12187 
12188   if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
12189     PrevDecl = nullptr;
12190 
12191   bool Mutable
12192     = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
12193   SourceLocation TSSL = D.getLocStart();
12194   FieldDecl *NewFD
12195     = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
12196                      TSSL, AS, PrevDecl, &D);
12197 
12198   if (NewFD->isInvalidDecl())
12199     Record->setInvalidDecl();
12200 
12201   if (D.getDeclSpec().isModulePrivateSpecified())
12202     NewFD->setModulePrivate();
12203 
12204   if (NewFD->isInvalidDecl() && PrevDecl) {
12205     // Don't introduce NewFD into scope; there's already something
12206     // with the same name in the same scope.
12207   } else if (II) {
12208     PushOnScopeChains(NewFD, S);
12209   } else
12210     Record->addDecl(NewFD);
12211 
12212   return NewFD;
12213 }
12214 
12215 /// \brief Build a new FieldDecl and check its well-formedness.
12216 ///
12217 /// This routine builds a new FieldDecl given the fields name, type,
12218 /// record, etc. \p PrevDecl should refer to any previous declaration
12219 /// with the same name and in the same scope as the field to be
12220 /// created.
12221 ///
12222 /// \returns a new FieldDecl.
12223 ///
12224 /// \todo The Declarator argument is a hack. It will be removed once
12225 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
12226                                 TypeSourceInfo *TInfo,
12227                                 RecordDecl *Record, SourceLocation Loc,
12228                                 bool Mutable, Expr *BitWidth,
12229                                 InClassInitStyle InitStyle,
12230                                 SourceLocation TSSL,
12231                                 AccessSpecifier AS, NamedDecl *PrevDecl,
12232                                 Declarator *D) {
12233   IdentifierInfo *II = Name.getAsIdentifierInfo();
12234   bool InvalidDecl = false;
12235   if (D) InvalidDecl = D->isInvalidType();
12236 
12237   // If we receive a broken type, recover by assuming 'int' and
12238   // marking this declaration as invalid.
12239   if (T.isNull()) {
12240     InvalidDecl = true;
12241     T = Context.IntTy;
12242   }
12243 
12244   QualType EltTy = Context.getBaseElementType(T);
12245   if (!EltTy->isDependentType()) {
12246     if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
12247       // Fields of incomplete type force their record to be invalid.
12248       Record->setInvalidDecl();
12249       InvalidDecl = true;
12250     } else {
12251       NamedDecl *Def;
12252       EltTy->isIncompleteType(&Def);
12253       if (Def && Def->isInvalidDecl()) {
12254         Record->setInvalidDecl();
12255         InvalidDecl = true;
12256       }
12257     }
12258   }
12259 
12260   // OpenCL v1.2 s6.9.c: bitfields are not supported.
12261   if (BitWidth && getLangOpts().OpenCL) {
12262     Diag(Loc, diag::err_opencl_bitfields);
12263     InvalidDecl = true;
12264   }
12265 
12266   // C99 6.7.2.1p8: A member of a structure or union may have any type other
12267   // than a variably modified type.
12268   if (!InvalidDecl && T->isVariablyModifiedType()) {
12269     bool SizeIsNegative;
12270     llvm::APSInt Oversized;
12271 
12272     TypeSourceInfo *FixedTInfo =
12273       TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
12274                                                     SizeIsNegative,
12275                                                     Oversized);
12276     if (FixedTInfo) {
12277       Diag(Loc, diag::warn_illegal_constant_array_size);
12278       TInfo = FixedTInfo;
12279       T = FixedTInfo->getType();
12280     } else {
12281       if (SizeIsNegative)
12282         Diag(Loc, diag::err_typecheck_negative_array_size);
12283       else if (Oversized.getBoolValue())
12284         Diag(Loc, diag::err_array_too_large)
12285           << Oversized.toString(10);
12286       else
12287         Diag(Loc, diag::err_typecheck_field_variable_size);
12288       InvalidDecl = true;
12289     }
12290   }
12291 
12292   // Fields can not have abstract class types
12293   if (!InvalidDecl && RequireNonAbstractType(Loc, T,
12294                                              diag::err_abstract_type_in_decl,
12295                                              AbstractFieldType))
12296     InvalidDecl = true;
12297 
12298   bool ZeroWidth = false;
12299   // If this is declared as a bit-field, check the bit-field.
12300   if (!InvalidDecl && BitWidth) {
12301     BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
12302                               &ZeroWidth).get();
12303     if (!BitWidth) {
12304       InvalidDecl = true;
12305       BitWidth = nullptr;
12306       ZeroWidth = false;
12307     }
12308   }
12309 
12310   // Check that 'mutable' is consistent with the type of the declaration.
12311   if (!InvalidDecl && Mutable) {
12312     unsigned DiagID = 0;
12313     if (T->isReferenceType())
12314       DiagID = diag::err_mutable_reference;
12315     else if (T.isConstQualified())
12316       DiagID = diag::err_mutable_const;
12317 
12318     if (DiagID) {
12319       SourceLocation ErrLoc = Loc;
12320       if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
12321         ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
12322       Diag(ErrLoc, DiagID);
12323       Mutable = false;
12324       InvalidDecl = true;
12325     }
12326   }
12327 
12328   // C++11 [class.union]p8 (DR1460):
12329   //   At most one variant member of a union may have a
12330   //   brace-or-equal-initializer.
12331   if (InitStyle != ICIS_NoInit)
12332     checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
12333 
12334   FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
12335                                        BitWidth, Mutable, InitStyle);
12336   if (InvalidDecl)
12337     NewFD->setInvalidDecl();
12338 
12339   if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
12340     Diag(Loc, diag::err_duplicate_member) << II;
12341     Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12342     NewFD->setInvalidDecl();
12343   }
12344 
12345   if (!InvalidDecl && getLangOpts().CPlusPlus) {
12346     if (Record->isUnion()) {
12347       if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12348         CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
12349         if (RDecl->getDefinition()) {
12350           // C++ [class.union]p1: An object of a class with a non-trivial
12351           // constructor, a non-trivial copy constructor, a non-trivial
12352           // destructor, or a non-trivial copy assignment operator
12353           // cannot be a member of a union, nor can an array of such
12354           // objects.
12355           if (CheckNontrivialField(NewFD))
12356             NewFD->setInvalidDecl();
12357         }
12358       }
12359 
12360       // C++ [class.union]p1: If a union contains a member of reference type,
12361       // the program is ill-formed, except when compiling with MSVC extensions
12362       // enabled.
12363       if (EltTy->isReferenceType()) {
12364         Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
12365                                     diag::ext_union_member_of_reference_type :
12366                                     diag::err_union_member_of_reference_type)
12367           << NewFD->getDeclName() << EltTy;
12368         if (!getLangOpts().MicrosoftExt)
12369           NewFD->setInvalidDecl();
12370       }
12371     }
12372   }
12373 
12374   // FIXME: We need to pass in the attributes given an AST
12375   // representation, not a parser representation.
12376   if (D) {
12377     // FIXME: The current scope is almost... but not entirely... correct here.
12378     ProcessDeclAttributes(getCurScope(), NewFD, *D);
12379 
12380     if (NewFD->hasAttrs())
12381       CheckAlignasUnderalignment(NewFD);
12382   }
12383 
12384   // In auto-retain/release, infer strong retension for fields of
12385   // retainable type.
12386   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
12387     NewFD->setInvalidDecl();
12388 
12389   if (T.isObjCGCWeak())
12390     Diag(Loc, diag::warn_attribute_weak_on_field);
12391 
12392   NewFD->setAccess(AS);
12393   return NewFD;
12394 }
12395 
12396 bool Sema::CheckNontrivialField(FieldDecl *FD) {
12397   assert(FD);
12398   assert(getLangOpts().CPlusPlus && "valid check only for C++");
12399 
12400   if (FD->isInvalidDecl() || FD->getType()->isDependentType())
12401     return false;
12402 
12403   QualType EltTy = Context.getBaseElementType(FD->getType());
12404   if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12405     CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
12406     if (RDecl->getDefinition()) {
12407       // We check for copy constructors before constructors
12408       // because otherwise we'll never get complaints about
12409       // copy constructors.
12410 
12411       CXXSpecialMember member = CXXInvalid;
12412       // We're required to check for any non-trivial constructors. Since the
12413       // implicit default constructor is suppressed if there are any
12414       // user-declared constructors, we just need to check that there is a
12415       // trivial default constructor and a trivial copy constructor. (We don't
12416       // worry about move constructors here, since this is a C++98 check.)
12417       if (RDecl->hasNonTrivialCopyConstructor())
12418         member = CXXCopyConstructor;
12419       else if (!RDecl->hasTrivialDefaultConstructor())
12420         member = CXXDefaultConstructor;
12421       else if (RDecl->hasNonTrivialCopyAssignment())
12422         member = CXXCopyAssignment;
12423       else if (RDecl->hasNonTrivialDestructor())
12424         member = CXXDestructor;
12425 
12426       if (member != CXXInvalid) {
12427         if (!getLangOpts().CPlusPlus11 &&
12428             getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
12429           // Objective-C++ ARC: it is an error to have a non-trivial field of
12430           // a union. However, system headers in Objective-C programs
12431           // occasionally have Objective-C lifetime objects within unions,
12432           // and rather than cause the program to fail, we make those
12433           // members unavailable.
12434           SourceLocation Loc = FD->getLocation();
12435           if (getSourceManager().isInSystemHeader(Loc)) {
12436             if (!FD->hasAttr<UnavailableAttr>())
12437               FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12438                                   "this system field has retaining ownership",
12439                                   Loc));
12440             return false;
12441           }
12442         }
12443 
12444         Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
12445                diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
12446                diag::err_illegal_union_or_anon_struct_member)
12447           << (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
12448         DiagnoseNontrivial(RDecl, member);
12449         return !getLangOpts().CPlusPlus11;
12450       }
12451     }
12452   }
12453 
12454   return false;
12455 }
12456 
12457 /// TranslateIvarVisibility - Translate visibility from a token ID to an
12458 ///  AST enum value.
12459 static ObjCIvarDecl::AccessControl
12460 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
12461   switch (ivarVisibility) {
12462   default: llvm_unreachable("Unknown visitibility kind");
12463   case tok::objc_private: return ObjCIvarDecl::Private;
12464   case tok::objc_public: return ObjCIvarDecl::Public;
12465   case tok::objc_protected: return ObjCIvarDecl::Protected;
12466   case tok::objc_package: return ObjCIvarDecl::Package;
12467   }
12468 }
12469 
12470 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
12471 /// in order to create an IvarDecl object for it.
12472 Decl *Sema::ActOnIvar(Scope *S,
12473                                 SourceLocation DeclStart,
12474                                 Declarator &D, Expr *BitfieldWidth,
12475                                 tok::ObjCKeywordKind Visibility) {
12476 
12477   IdentifierInfo *II = D.getIdentifier();
12478   Expr *BitWidth = (Expr*)BitfieldWidth;
12479   SourceLocation Loc = DeclStart;
12480   if (II) Loc = D.getIdentifierLoc();
12481 
12482   // FIXME: Unnamed fields can be handled in various different ways, for
12483   // example, unnamed unions inject all members into the struct namespace!
12484 
12485   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12486   QualType T = TInfo->getType();
12487 
12488   if (BitWidth) {
12489     // 6.7.2.1p3, 6.7.2.1p4
12490     BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
12491     if (!BitWidth)
12492       D.setInvalidType();
12493   } else {
12494     // Not a bitfield.
12495 
12496     // validate II.
12497 
12498   }
12499   if (T->isReferenceType()) {
12500     Diag(Loc, diag::err_ivar_reference_type);
12501     D.setInvalidType();
12502   }
12503   // C99 6.7.2.1p8: A member of a structure or union may have any type other
12504   // than a variably modified type.
12505   else if (T->isVariablyModifiedType()) {
12506     Diag(Loc, diag::err_typecheck_ivar_variable_size);
12507     D.setInvalidType();
12508   }
12509 
12510   // Get the visibility (access control) for this ivar.
12511   ObjCIvarDecl::AccessControl ac =
12512     Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
12513                                         : ObjCIvarDecl::None;
12514   // Must set ivar's DeclContext to its enclosing interface.
12515   ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
12516   if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
12517     return nullptr;
12518   ObjCContainerDecl *EnclosingContext;
12519   if (ObjCImplementationDecl *IMPDecl =
12520       dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
12521     if (LangOpts.ObjCRuntime.isFragile()) {
12522     // Case of ivar declared in an implementation. Context is that of its class.
12523       EnclosingContext = IMPDecl->getClassInterface();
12524       assert(EnclosingContext && "Implementation has no class interface!");
12525     }
12526     else
12527       EnclosingContext = EnclosingDecl;
12528   } else {
12529     if (ObjCCategoryDecl *CDecl =
12530         dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
12531       if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
12532         Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
12533         return nullptr;
12534       }
12535     }
12536     EnclosingContext = EnclosingDecl;
12537   }
12538 
12539   // Construct the decl.
12540   ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
12541                                              DeclStart, Loc, II, T,
12542                                              TInfo, ac, (Expr *)BitfieldWidth);
12543 
12544   if (II) {
12545     NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
12546                                            ForRedeclaration);
12547     if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
12548         && !isa<TagDecl>(PrevDecl)) {
12549       Diag(Loc, diag::err_duplicate_member) << II;
12550       Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12551       NewID->setInvalidDecl();
12552     }
12553   }
12554 
12555   // Process attributes attached to the ivar.
12556   ProcessDeclAttributes(S, NewID, D);
12557 
12558   if (D.isInvalidType())
12559     NewID->setInvalidDecl();
12560 
12561   // In ARC, infer 'retaining' for ivars of retainable type.
12562   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
12563     NewID->setInvalidDecl();
12564 
12565   if (D.getDeclSpec().isModulePrivateSpecified())
12566     NewID->setModulePrivate();
12567 
12568   if (II) {
12569     // FIXME: When interfaces are DeclContexts, we'll need to add
12570     // these to the interface.
12571     S->AddDecl(NewID);
12572     IdResolver.AddDecl(NewID);
12573   }
12574 
12575   if (LangOpts.ObjCRuntime.isNonFragile() &&
12576       !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
12577     Diag(Loc, diag::warn_ivars_in_interface);
12578 
12579   return NewID;
12580 }
12581 
12582 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for
12583 /// class and class extensions. For every class \@interface and class
12584 /// extension \@interface, if the last ivar is a bitfield of any type,
12585 /// then add an implicit `char :0` ivar to the end of that interface.
12586 void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
12587                              SmallVectorImpl<Decl *> &AllIvarDecls) {
12588   if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
12589     return;
12590 
12591   Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
12592   ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
12593 
12594   if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
12595     return;
12596   ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
12597   if (!ID) {
12598     if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
12599       if (!CD->IsClassExtension())
12600         return;
12601     }
12602     // No need to add this to end of @implementation.
12603     else
12604       return;
12605   }
12606   // All conditions are met. Add a new bitfield to the tail end of ivars.
12607   llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
12608   Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
12609 
12610   Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
12611                               DeclLoc, DeclLoc, nullptr,
12612                               Context.CharTy,
12613                               Context.getTrivialTypeSourceInfo(Context.CharTy,
12614                                                                DeclLoc),
12615                               ObjCIvarDecl::Private, BW,
12616                               true);
12617   AllIvarDecls.push_back(Ivar);
12618 }
12619 
12620 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
12621                        ArrayRef<Decl *> Fields, SourceLocation LBrac,
12622                        SourceLocation RBrac, AttributeList *Attr) {
12623   assert(EnclosingDecl && "missing record or interface decl");
12624 
12625   // If this is an Objective-C @implementation or category and we have
12626   // new fields here we should reset the layout of the interface since
12627   // it will now change.
12628   if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
12629     ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
12630     switch (DC->getKind()) {
12631     default: break;
12632     case Decl::ObjCCategory:
12633       Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
12634       break;
12635     case Decl::ObjCImplementation:
12636       Context.
12637         ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
12638       break;
12639     }
12640   }
12641 
12642   RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
12643 
12644   // Start counting up the number of named members; make sure to include
12645   // members of anonymous structs and unions in the total.
12646   unsigned NumNamedMembers = 0;
12647   if (Record) {
12648     for (const auto *I : Record->decls()) {
12649       if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
12650         if (IFD->getDeclName())
12651           ++NumNamedMembers;
12652     }
12653   }
12654 
12655   // Verify that all the fields are okay.
12656   SmallVector<FieldDecl*, 32> RecFields;
12657 
12658   bool ARCErrReported = false;
12659   for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
12660        i != end; ++i) {
12661     FieldDecl *FD = cast<FieldDecl>(*i);
12662 
12663     // Get the type for the field.
12664     const Type *FDTy = FD->getType().getTypePtr();
12665 
12666     if (!FD->isAnonymousStructOrUnion()) {
12667       // Remember all fields written by the user.
12668       RecFields.push_back(FD);
12669     }
12670 
12671     // If the field is already invalid for some reason, don't emit more
12672     // diagnostics about it.
12673     if (FD->isInvalidDecl()) {
12674       EnclosingDecl->setInvalidDecl();
12675       continue;
12676     }
12677 
12678     // C99 6.7.2.1p2:
12679     //   A structure or union shall not contain a member with
12680     //   incomplete or function type (hence, a structure shall not
12681     //   contain an instance of itself, but may contain a pointer to
12682     //   an instance of itself), except that the last member of a
12683     //   structure with more than one named member may have incomplete
12684     //   array type; such a structure (and any union containing,
12685     //   possibly recursively, a member that is such a structure)
12686     //   shall not be a member of a structure or an element of an
12687     //   array.
12688     if (FDTy->isFunctionType()) {
12689       // Field declared as a function.
12690       Diag(FD->getLocation(), diag::err_field_declared_as_function)
12691         << FD->getDeclName();
12692       FD->setInvalidDecl();
12693       EnclosingDecl->setInvalidDecl();
12694       continue;
12695     } else if (FDTy->isIncompleteArrayType() && Record &&
12696                ((i + 1 == Fields.end() && !Record->isUnion()) ||
12697                 ((getLangOpts().MicrosoftExt ||
12698                   getLangOpts().CPlusPlus) &&
12699                  (i + 1 == Fields.end() || Record->isUnion())))) {
12700       // Flexible array member.
12701       // Microsoft and g++ is more permissive regarding flexible array.
12702       // It will accept flexible array in union and also
12703       // as the sole element of a struct/class.
12704       unsigned DiagID = 0;
12705       if (Record->isUnion())
12706         DiagID = getLangOpts().MicrosoftExt
12707                      ? diag::ext_flexible_array_union_ms
12708                      : getLangOpts().CPlusPlus
12709                            ? diag::ext_flexible_array_union_gnu
12710                            : diag::err_flexible_array_union;
12711       else if (Fields.size() == 1)
12712         DiagID = getLangOpts().MicrosoftExt
12713                      ? diag::ext_flexible_array_empty_aggregate_ms
12714                      : getLangOpts().CPlusPlus
12715                            ? diag::ext_flexible_array_empty_aggregate_gnu
12716                            : NumNamedMembers < 1
12717                                  ? diag::err_flexible_array_empty_aggregate
12718                                  : 0;
12719 
12720       if (DiagID)
12721         Diag(FD->getLocation(), DiagID) << FD->getDeclName()
12722                                         << Record->getTagKind();
12723       // While the layout of types that contain virtual bases is not specified
12724       // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
12725       // virtual bases after the derived members.  This would make a flexible
12726       // array member declared at the end of an object not adjacent to the end
12727       // of the type.
12728       if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
12729         if (RD->getNumVBases() != 0)
12730           Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
12731             << FD->getDeclName() << Record->getTagKind();
12732       if (!getLangOpts().C99)
12733         Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
12734           << FD->getDeclName() << Record->getTagKind();
12735 
12736       // If the element type has a non-trivial destructor, we would not
12737       // implicitly destroy the elements, so disallow it for now.
12738       //
12739       // FIXME: GCC allows this. We should probably either implicitly delete
12740       // the destructor of the containing class, or just allow this.
12741       QualType BaseElem = Context.getBaseElementType(FD->getType());
12742       if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
12743         Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
12744           << FD->getDeclName() << FD->getType();
12745         FD->setInvalidDecl();
12746         EnclosingDecl->setInvalidDecl();
12747         continue;
12748       }
12749       // Okay, we have a legal flexible array member at the end of the struct.
12750       Record->setHasFlexibleArrayMember(true);
12751     } else if (!FDTy->isDependentType() &&
12752                RequireCompleteType(FD->getLocation(), FD->getType(),
12753                                    diag::err_field_incomplete)) {
12754       // Incomplete type
12755       FD->setInvalidDecl();
12756       EnclosingDecl->setInvalidDecl();
12757       continue;
12758     } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
12759       if (Record && FDTTy->getDecl()->hasFlexibleArrayMember()) {
12760         // A type which contains a flexible array member is considered to be a
12761         // flexible array member.
12762         Record->setHasFlexibleArrayMember(true);
12763         if (!Record->isUnion()) {
12764           // If this is a struct/class and this is not the last element, reject
12765           // it.  Note that GCC supports variable sized arrays in the middle of
12766           // structures.
12767           if (i + 1 != Fields.end())
12768             Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
12769               << FD->getDeclName() << FD->getType();
12770           else {
12771             // We support flexible arrays at the end of structs in
12772             // other structs as an extension.
12773             Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
12774               << FD->getDeclName();
12775           }
12776         }
12777       }
12778       if (isa<ObjCContainerDecl>(EnclosingDecl) &&
12779           RequireNonAbstractType(FD->getLocation(), FD->getType(),
12780                                  diag::err_abstract_type_in_decl,
12781                                  AbstractIvarType)) {
12782         // Ivars can not have abstract class types
12783         FD->setInvalidDecl();
12784       }
12785       if (Record && FDTTy->getDecl()->hasObjectMember())
12786         Record->setHasObjectMember(true);
12787       if (Record && FDTTy->getDecl()->hasVolatileMember())
12788         Record->setHasVolatileMember(true);
12789     } else if (FDTy->isObjCObjectType()) {
12790       /// A field cannot be an Objective-c object
12791       Diag(FD->getLocation(), diag::err_statically_allocated_object)
12792         << FixItHint::CreateInsertion(FD->getLocation(), "*");
12793       QualType T = Context.getObjCObjectPointerType(FD->getType());
12794       FD->setType(T);
12795     } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
12796                (!getLangOpts().CPlusPlus || Record->isUnion())) {
12797       // It's an error in ARC if a field has lifetime.
12798       // We don't want to report this in a system header, though,
12799       // so we just make the field unavailable.
12800       // FIXME: that's really not sufficient; we need to make the type
12801       // itself invalid to, say, initialize or copy.
12802       QualType T = FD->getType();
12803       Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
12804       if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
12805         SourceLocation loc = FD->getLocation();
12806         if (getSourceManager().isInSystemHeader(loc)) {
12807           if (!FD->hasAttr<UnavailableAttr>()) {
12808             FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12809                               "this system field has retaining ownership",
12810                               loc));
12811           }
12812         } else {
12813           Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
12814             << T->isBlockPointerType() << Record->getTagKind();
12815         }
12816         ARCErrReported = true;
12817       }
12818     } else if (getLangOpts().ObjC1 &&
12819                getLangOpts().getGC() != LangOptions::NonGC &&
12820                Record && !Record->hasObjectMember()) {
12821       if (FD->getType()->isObjCObjectPointerType() ||
12822           FD->getType().isObjCGCStrong())
12823         Record->setHasObjectMember(true);
12824       else if (Context.getAsArrayType(FD->getType())) {
12825         QualType BaseType = Context.getBaseElementType(FD->getType());
12826         if (BaseType->isRecordType() &&
12827             BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
12828           Record->setHasObjectMember(true);
12829         else if (BaseType->isObjCObjectPointerType() ||
12830                  BaseType.isObjCGCStrong())
12831                Record->setHasObjectMember(true);
12832       }
12833     }
12834     if (Record && FD->getType().isVolatileQualified())
12835       Record->setHasVolatileMember(true);
12836     // Keep track of the number of named members.
12837     if (FD->getIdentifier())
12838       ++NumNamedMembers;
12839   }
12840 
12841   // Okay, we successfully defined 'Record'.
12842   if (Record) {
12843     bool Completed = false;
12844     if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
12845       if (!CXXRecord->isInvalidDecl()) {
12846         // Set access bits correctly on the directly-declared conversions.
12847         for (CXXRecordDecl::conversion_iterator
12848                I = CXXRecord->conversion_begin(),
12849                E = CXXRecord->conversion_end(); I != E; ++I)
12850           I.setAccess((*I)->getAccess());
12851 
12852         if (!CXXRecord->isDependentType()) {
12853           if (CXXRecord->hasUserDeclaredDestructor()) {
12854             // Adjust user-defined destructor exception spec.
12855             if (getLangOpts().CPlusPlus11)
12856               AdjustDestructorExceptionSpec(CXXRecord,
12857                                             CXXRecord->getDestructor());
12858           }
12859 
12860           // Add any implicitly-declared members to this class.
12861           AddImplicitlyDeclaredMembersToClass(CXXRecord);
12862 
12863           // If we have virtual base classes, we may end up finding multiple
12864           // final overriders for a given virtual function. Check for this
12865           // problem now.
12866           if (CXXRecord->getNumVBases()) {
12867             CXXFinalOverriderMap FinalOverriders;
12868             CXXRecord->getFinalOverriders(FinalOverriders);
12869 
12870             for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
12871                                              MEnd = FinalOverriders.end();
12872                  M != MEnd; ++M) {
12873               for (OverridingMethods::iterator SO = M->second.begin(),
12874                                             SOEnd = M->second.end();
12875                    SO != SOEnd; ++SO) {
12876                 assert(SO->second.size() > 0 &&
12877                        "Virtual function without overridding functions?");
12878                 if (SO->second.size() == 1)
12879                   continue;
12880 
12881                 // C++ [class.virtual]p2:
12882                 //   In a derived class, if a virtual member function of a base
12883                 //   class subobject has more than one final overrider the
12884                 //   program is ill-formed.
12885                 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
12886                   << (const NamedDecl *)M->first << Record;
12887                 Diag(M->first->getLocation(),
12888                      diag::note_overridden_virtual_function);
12889                 for (OverridingMethods::overriding_iterator
12890                           OM = SO->second.begin(),
12891                        OMEnd = SO->second.end();
12892                      OM != OMEnd; ++OM)
12893                   Diag(OM->Method->getLocation(), diag::note_final_overrider)
12894                     << (const NamedDecl *)M->first << OM->Method->getParent();
12895 
12896                 Record->setInvalidDecl();
12897               }
12898             }
12899             CXXRecord->completeDefinition(&FinalOverriders);
12900             Completed = true;
12901           }
12902         }
12903       }
12904     }
12905 
12906     if (!Completed)
12907       Record->completeDefinition();
12908 
12909     if (Record->hasAttrs()) {
12910       CheckAlignasUnderalignment(Record);
12911 
12912       if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
12913         checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
12914                                            IA->getRange(), IA->getBestCase(),
12915                                            IA->getSemanticSpelling());
12916     }
12917 
12918     // Check if the structure/union declaration is a type that can have zero
12919     // size in C. For C this is a language extension, for C++ it may cause
12920     // compatibility problems.
12921     bool CheckForZeroSize;
12922     if (!getLangOpts().CPlusPlus) {
12923       CheckForZeroSize = true;
12924     } else {
12925       // For C++ filter out types that cannot be referenced in C code.
12926       CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
12927       CheckForZeroSize =
12928           CXXRecord->getLexicalDeclContext()->isExternCContext() &&
12929           !CXXRecord->isDependentType() &&
12930           CXXRecord->isCLike();
12931     }
12932     if (CheckForZeroSize) {
12933       bool ZeroSize = true;
12934       bool IsEmpty = true;
12935       unsigned NonBitFields = 0;
12936       for (RecordDecl::field_iterator I = Record->field_begin(),
12937                                       E = Record->field_end();
12938            (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
12939         IsEmpty = false;
12940         if (I->isUnnamedBitfield()) {
12941           if (I->getBitWidthValue(Context) > 0)
12942             ZeroSize = false;
12943         } else {
12944           ++NonBitFields;
12945           QualType FieldType = I->getType();
12946           if (FieldType->isIncompleteType() ||
12947               !Context.getTypeSizeInChars(FieldType).isZero())
12948             ZeroSize = false;
12949         }
12950       }
12951 
12952       // Empty structs are an extension in C (C99 6.7.2.1p7). They are
12953       // allowed in C++, but warn if its declaration is inside
12954       // extern "C" block.
12955       if (ZeroSize) {
12956         Diag(RecLoc, getLangOpts().CPlusPlus ?
12957                          diag::warn_zero_size_struct_union_in_extern_c :
12958                          diag::warn_zero_size_struct_union_compat)
12959           << IsEmpty << Record->isUnion() << (NonBitFields > 1);
12960       }
12961 
12962       // Structs without named members are extension in C (C99 6.7.2.1p7),
12963       // but are accepted by GCC.
12964       if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
12965         Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
12966                                diag::ext_no_named_members_in_struct_union)
12967           << Record->isUnion();
12968       }
12969     }
12970   } else {
12971     ObjCIvarDecl **ClsFields =
12972       reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
12973     if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
12974       ID->setEndOfDefinitionLoc(RBrac);
12975       // Add ivar's to class's DeclContext.
12976       for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
12977         ClsFields[i]->setLexicalDeclContext(ID);
12978         ID->addDecl(ClsFields[i]);
12979       }
12980       // Must enforce the rule that ivars in the base classes may not be
12981       // duplicates.
12982       if (ID->getSuperClass())
12983         DiagnoseDuplicateIvars(ID, ID->getSuperClass());
12984     } else if (ObjCImplementationDecl *IMPDecl =
12985                   dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
12986       assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
12987       for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
12988         // Ivar declared in @implementation never belongs to the implementation.
12989         // Only it is in implementation's lexical context.
12990         ClsFields[I]->setLexicalDeclContext(IMPDecl);
12991       CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
12992       IMPDecl->setIvarLBraceLoc(LBrac);
12993       IMPDecl->setIvarRBraceLoc(RBrac);
12994     } else if (ObjCCategoryDecl *CDecl =
12995                 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
12996       // case of ivars in class extension; all other cases have been
12997       // reported as errors elsewhere.
12998       // FIXME. Class extension does not have a LocEnd field.
12999       // CDecl->setLocEnd(RBrac);
13000       // Add ivar's to class extension's DeclContext.
13001       // Diagnose redeclaration of private ivars.
13002       ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
13003       for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
13004         if (IDecl) {
13005           if (const ObjCIvarDecl *ClsIvar =
13006               IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
13007             Diag(ClsFields[i]->getLocation(),
13008                  diag::err_duplicate_ivar_declaration);
13009             Diag(ClsIvar->getLocation(), diag::note_previous_definition);
13010             continue;
13011           }
13012           for (const auto *Ext : IDecl->known_extensions()) {
13013             if (const ObjCIvarDecl *ClsExtIvar
13014                   = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
13015               Diag(ClsFields[i]->getLocation(),
13016                    diag::err_duplicate_ivar_declaration);
13017               Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
13018               continue;
13019             }
13020           }
13021         }
13022         ClsFields[i]->setLexicalDeclContext(CDecl);
13023         CDecl->addDecl(ClsFields[i]);
13024       }
13025       CDecl->setIvarLBraceLoc(LBrac);
13026       CDecl->setIvarRBraceLoc(RBrac);
13027     }
13028   }
13029 
13030   if (Attr)
13031     ProcessDeclAttributeList(S, Record, Attr);
13032 }
13033 
13034 /// \brief Determine whether the given integral value is representable within
13035 /// the given type T.
13036 static bool isRepresentableIntegerValue(ASTContext &Context,
13037                                         llvm::APSInt &Value,
13038                                         QualType T) {
13039   assert(T->isIntegralType(Context) && "Integral type required!");
13040   unsigned BitWidth = Context.getIntWidth(T);
13041 
13042   if (Value.isUnsigned() || Value.isNonNegative()) {
13043     if (T->isSignedIntegerOrEnumerationType())
13044       --BitWidth;
13045     return Value.getActiveBits() <= BitWidth;
13046   }
13047   return Value.getMinSignedBits() <= BitWidth;
13048 }
13049 
13050 // \brief Given an integral type, return the next larger integral type
13051 // (or a NULL type of no such type exists).
13052 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
13053   // FIXME: Int128/UInt128 support, which also needs to be introduced into
13054   // enum checking below.
13055   assert(T->isIntegralType(Context) && "Integral type required!");
13056   const unsigned NumTypes = 4;
13057   QualType SignedIntegralTypes[NumTypes] = {
13058     Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
13059   };
13060   QualType UnsignedIntegralTypes[NumTypes] = {
13061     Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
13062     Context.UnsignedLongLongTy
13063   };
13064 
13065   unsigned BitWidth = Context.getTypeSize(T);
13066   QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
13067                                                         : UnsignedIntegralTypes;
13068   for (unsigned I = 0; I != NumTypes; ++I)
13069     if (Context.getTypeSize(Types[I]) > BitWidth)
13070       return Types[I];
13071 
13072   return QualType();
13073 }
13074 
13075 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
13076                                           EnumConstantDecl *LastEnumConst,
13077                                           SourceLocation IdLoc,
13078                                           IdentifierInfo *Id,
13079                                           Expr *Val) {
13080   unsigned IntWidth = Context.getTargetInfo().getIntWidth();
13081   llvm::APSInt EnumVal(IntWidth);
13082   QualType EltTy;
13083 
13084   if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
13085     Val = nullptr;
13086 
13087   if (Val)
13088     Val = DefaultLvalueConversion(Val).get();
13089 
13090   if (Val) {
13091     if (Enum->isDependentType() || Val->isTypeDependent())
13092       EltTy = Context.DependentTy;
13093     else {
13094       SourceLocation ExpLoc;
13095       if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
13096           !getLangOpts().MSVCCompat) {
13097         // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
13098         // constant-expression in the enumerator-definition shall be a converted
13099         // constant expression of the underlying type.
13100         EltTy = Enum->getIntegerType();
13101         ExprResult Converted =
13102           CheckConvertedConstantExpression(Val, EltTy, EnumVal,
13103                                            CCEK_Enumerator);
13104         if (Converted.isInvalid())
13105           Val = nullptr;
13106         else
13107           Val = Converted.get();
13108       } else if (!Val->isValueDependent() &&
13109                  !(Val = VerifyIntegerConstantExpression(Val,
13110                                                          &EnumVal).get())) {
13111         // C99 6.7.2.2p2: Make sure we have an integer constant expression.
13112       } else {
13113         if (Enum->isFixed()) {
13114           EltTy = Enum->getIntegerType();
13115 
13116           // In Obj-C and Microsoft mode, require the enumeration value to be
13117           // representable in the underlying type of the enumeration. In C++11,
13118           // we perform a non-narrowing conversion as part of converted constant
13119           // expression checking.
13120           if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13121             if (getLangOpts().MSVCCompat) {
13122               Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
13123               Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
13124             } else
13125               Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
13126           } else
13127             Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
13128         } else if (getLangOpts().CPlusPlus) {
13129           // C++11 [dcl.enum]p5:
13130           //   If the underlying type is not fixed, the type of each enumerator
13131           //   is the type of its initializing value:
13132           //     - If an initializer is specified for an enumerator, the
13133           //       initializing value has the same type as the expression.
13134           EltTy = Val->getType();
13135         } else {
13136           // C99 6.7.2.2p2:
13137           //   The expression that defines the value of an enumeration constant
13138           //   shall be an integer constant expression that has a value
13139           //   representable as an int.
13140 
13141           // Complain if the value is not representable in an int.
13142           if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
13143             Diag(IdLoc, diag::ext_enum_value_not_int)
13144               << EnumVal.toString(10) << Val->getSourceRange()
13145               << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
13146           else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
13147             // Force the type of the expression to 'int'.
13148             Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
13149           }
13150           EltTy = Val->getType();
13151         }
13152       }
13153     }
13154   }
13155 
13156   if (!Val) {
13157     if (Enum->isDependentType())
13158       EltTy = Context.DependentTy;
13159     else if (!LastEnumConst) {
13160       // C++0x [dcl.enum]p5:
13161       //   If the underlying type is not fixed, the type of each enumerator
13162       //   is the type of its initializing value:
13163       //     - If no initializer is specified for the first enumerator, the
13164       //       initializing value has an unspecified integral type.
13165       //
13166       // GCC uses 'int' for its unspecified integral type, as does
13167       // C99 6.7.2.2p3.
13168       if (Enum->isFixed()) {
13169         EltTy = Enum->getIntegerType();
13170       }
13171       else {
13172         EltTy = Context.IntTy;
13173       }
13174     } else {
13175       // Assign the last value + 1.
13176       EnumVal = LastEnumConst->getInitVal();
13177       ++EnumVal;
13178       EltTy = LastEnumConst->getType();
13179 
13180       // Check for overflow on increment.
13181       if (EnumVal < LastEnumConst->getInitVal()) {
13182         // C++0x [dcl.enum]p5:
13183         //   If the underlying type is not fixed, the type of each enumerator
13184         //   is the type of its initializing value:
13185         //
13186         //     - Otherwise the type of the initializing value is the same as
13187         //       the type of the initializing value of the preceding enumerator
13188         //       unless the incremented value is not representable in that type,
13189         //       in which case the type is an unspecified integral type
13190         //       sufficient to contain the incremented value. If no such type
13191         //       exists, the program is ill-formed.
13192         QualType T = getNextLargerIntegralType(Context, EltTy);
13193         if (T.isNull() || Enum->isFixed()) {
13194           // There is no integral type larger enough to represent this
13195           // value. Complain, then allow the value to wrap around.
13196           EnumVal = LastEnumConst->getInitVal();
13197           EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
13198           ++EnumVal;
13199           if (Enum->isFixed())
13200             // When the underlying type is fixed, this is ill-formed.
13201             Diag(IdLoc, diag::err_enumerator_wrapped)
13202               << EnumVal.toString(10)
13203               << EltTy;
13204           else
13205             Diag(IdLoc, diag::ext_enumerator_increment_too_large)
13206               << EnumVal.toString(10);
13207         } else {
13208           EltTy = T;
13209         }
13210 
13211         // Retrieve the last enumerator's value, extent that type to the
13212         // type that is supposed to be large enough to represent the incremented
13213         // value, then increment.
13214         EnumVal = LastEnumConst->getInitVal();
13215         EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
13216         EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
13217         ++EnumVal;
13218 
13219         // If we're not in C++, diagnose the overflow of enumerator values,
13220         // which in C99 means that the enumerator value is not representable in
13221         // an int (C99 6.7.2.2p2). However, we support GCC's extension that
13222         // permits enumerator values that are representable in some larger
13223         // integral type.
13224         if (!getLangOpts().CPlusPlus && !T.isNull())
13225           Diag(IdLoc, diag::warn_enum_value_overflow);
13226       } else if (!getLangOpts().CPlusPlus &&
13227                  !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13228         // Enforce C99 6.7.2.2p2 even when we compute the next value.
13229         Diag(IdLoc, diag::ext_enum_value_not_int)
13230           << EnumVal.toString(10) << 1;
13231       }
13232     }
13233   }
13234 
13235   if (!EltTy->isDependentType()) {
13236     // Make the enumerator value match the signedness and size of the
13237     // enumerator's type.
13238     EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
13239     EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
13240   }
13241 
13242   return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
13243                                   Val, EnumVal);
13244 }
13245 
13246 
13247 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
13248                               SourceLocation IdLoc, IdentifierInfo *Id,
13249                               AttributeList *Attr,
13250                               SourceLocation EqualLoc, Expr *Val) {
13251   EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
13252   EnumConstantDecl *LastEnumConst =
13253     cast_or_null<EnumConstantDecl>(lastEnumConst);
13254 
13255   // The scope passed in may not be a decl scope.  Zip up the scope tree until
13256   // we find one that is.
13257   S = getNonFieldDeclScope(S);
13258 
13259   // Verify that there isn't already something declared with this name in this
13260   // scope.
13261   NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
13262                                          ForRedeclaration);
13263   if (PrevDecl && PrevDecl->isTemplateParameter()) {
13264     // Maybe we will complain about the shadowed template parameter.
13265     DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
13266     // Just pretend that we didn't see the previous declaration.
13267     PrevDecl = nullptr;
13268   }
13269 
13270   if (PrevDecl) {
13271     // When in C++, we may get a TagDecl with the same name; in this case the
13272     // enum constant will 'hide' the tag.
13273     assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
13274            "Received TagDecl when not in C++!");
13275     if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
13276       if (isa<EnumConstantDecl>(PrevDecl))
13277         Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
13278       else
13279         Diag(IdLoc, diag::err_redefinition) << Id;
13280       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13281       return nullptr;
13282     }
13283   }
13284 
13285   // C++ [class.mem]p15:
13286   // If T is the name of a class, then each of the following shall have a name
13287   // different from T:
13288   // - every enumerator of every member of class T that is an unscoped
13289   // enumerated type
13290   if (CXXRecordDecl *Record
13291                       = dyn_cast<CXXRecordDecl>(
13292                              TheEnumDecl->getDeclContext()->getRedeclContext()))
13293     if (!TheEnumDecl->isScoped() &&
13294         Record->getIdentifier() && Record->getIdentifier() == Id)
13295       Diag(IdLoc, diag::err_member_name_of_class) << Id;
13296 
13297   EnumConstantDecl *New =
13298     CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
13299 
13300   if (New) {
13301     // Process attributes.
13302     if (Attr) ProcessDeclAttributeList(S, New, Attr);
13303 
13304     // Register this decl in the current scope stack.
13305     New->setAccess(TheEnumDecl->getAccess());
13306     PushOnScopeChains(New, S);
13307   }
13308 
13309   ActOnDocumentableDecl(New);
13310 
13311   return New;
13312 }
13313 
13314 // Returns true when the enum initial expression does not trigger the
13315 // duplicate enum warning.  A few common cases are exempted as follows:
13316 // Element2 = Element1
13317 // Element2 = Element1 + 1
13318 // Element2 = Element1 - 1
13319 // Where Element2 and Element1 are from the same enum.
13320 static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) {
13321   Expr *InitExpr = ECD->getInitExpr();
13322   if (!InitExpr)
13323     return true;
13324   InitExpr = InitExpr->IgnoreImpCasts();
13325 
13326   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
13327     if (!BO->isAdditiveOp())
13328       return true;
13329     IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
13330     if (!IL)
13331       return true;
13332     if (IL->getValue() != 1)
13333       return true;
13334 
13335     InitExpr = BO->getLHS();
13336   }
13337 
13338   // This checks if the elements are from the same enum.
13339   DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
13340   if (!DRE)
13341     return true;
13342 
13343   EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
13344   if (!EnumConstant)
13345     return true;
13346 
13347   if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
13348       Enum)
13349     return true;
13350 
13351   return false;
13352 }
13353 
13354 struct DupKey {
13355   int64_t val;
13356   bool isTombstoneOrEmptyKey;
13357   DupKey(int64_t val, bool isTombstoneOrEmptyKey)
13358     : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
13359 };
13360 
13361 static DupKey GetDupKey(const llvm::APSInt& Val) {
13362   return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
13363                 false);
13364 }
13365 
13366 struct DenseMapInfoDupKey {
13367   static DupKey getEmptyKey() { return DupKey(0, true); }
13368   static DupKey getTombstoneKey() { return DupKey(1, true); }
13369   static unsigned getHashValue(const DupKey Key) {
13370     return (unsigned)(Key.val * 37);
13371   }
13372   static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
13373     return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
13374            LHS.val == RHS.val;
13375   }
13376 };
13377 
13378 // Emits a warning when an element is implicitly set a value that
13379 // a previous element has already been set to.
13380 static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
13381                                         EnumDecl *Enum,
13382                                         QualType EnumType) {
13383   if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
13384     return;
13385   // Avoid anonymous enums
13386   if (!Enum->getIdentifier())
13387     return;
13388 
13389   // Only check for small enums.
13390   if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
13391     return;
13392 
13393   typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
13394   typedef SmallVector<ECDVector *, 3> DuplicatesVector;
13395 
13396   typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
13397   typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
13398           ValueToVectorMap;
13399 
13400   DuplicatesVector DupVector;
13401   ValueToVectorMap EnumMap;
13402 
13403   // Populate the EnumMap with all values represented by enum constants without
13404   // an initialier.
13405   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13406     EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
13407 
13408     // Null EnumConstantDecl means a previous diagnostic has been emitted for
13409     // this constant.  Skip this enum since it may be ill-formed.
13410     if (!ECD) {
13411       return;
13412     }
13413 
13414     if (ECD->getInitExpr())
13415       continue;
13416 
13417     DupKey Key = GetDupKey(ECD->getInitVal());
13418     DeclOrVector &Entry = EnumMap[Key];
13419 
13420     // First time encountering this value.
13421     if (Entry.isNull())
13422       Entry = ECD;
13423   }
13424 
13425   // Create vectors for any values that has duplicates.
13426   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13427     EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
13428     if (!ValidDuplicateEnum(ECD, Enum))
13429       continue;
13430 
13431     DupKey Key = GetDupKey(ECD->getInitVal());
13432 
13433     DeclOrVector& Entry = EnumMap[Key];
13434     if (Entry.isNull())
13435       continue;
13436 
13437     if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
13438       // Ensure constants are different.
13439       if (D == ECD)
13440         continue;
13441 
13442       // Create new vector and push values onto it.
13443       ECDVector *Vec = new ECDVector();
13444       Vec->push_back(D);
13445       Vec->push_back(ECD);
13446 
13447       // Update entry to point to the duplicates vector.
13448       Entry = Vec;
13449 
13450       // Store the vector somewhere we can consult later for quick emission of
13451       // diagnostics.
13452       DupVector.push_back(Vec);
13453       continue;
13454     }
13455 
13456     ECDVector *Vec = Entry.get<ECDVector*>();
13457     // Make sure constants are not added more than once.
13458     if (*Vec->begin() == ECD)
13459       continue;
13460 
13461     Vec->push_back(ECD);
13462   }
13463 
13464   // Emit diagnostics.
13465   for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
13466                                   DupVectorEnd = DupVector.end();
13467        DupVectorIter != DupVectorEnd; ++DupVectorIter) {
13468     ECDVector *Vec = *DupVectorIter;
13469     assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
13470 
13471     // Emit warning for one enum constant.
13472     ECDVector::iterator I = Vec->begin();
13473     S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
13474       << (*I)->getName() << (*I)->getInitVal().toString(10)
13475       << (*I)->getSourceRange();
13476     ++I;
13477 
13478     // Emit one note for each of the remaining enum constants with
13479     // the same value.
13480     for (ECDVector::iterator E = Vec->end(); I != E; ++I)
13481       S.Diag((*I)->getLocation(), diag::note_duplicate_element)
13482         << (*I)->getName() << (*I)->getInitVal().toString(10)
13483         << (*I)->getSourceRange();
13484     delete Vec;
13485   }
13486 }
13487 
13488 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
13489                          SourceLocation RBraceLoc, Decl *EnumDeclX,
13490                          ArrayRef<Decl *> Elements,
13491                          Scope *S, AttributeList *Attr) {
13492   EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
13493   QualType EnumType = Context.getTypeDeclType(Enum);
13494 
13495   if (Attr)
13496     ProcessDeclAttributeList(S, Enum, Attr);
13497 
13498   if (Enum->isDependentType()) {
13499     for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13500       EnumConstantDecl *ECD =
13501         cast_or_null<EnumConstantDecl>(Elements[i]);
13502       if (!ECD) continue;
13503 
13504       ECD->setType(EnumType);
13505     }
13506 
13507     Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
13508     return;
13509   }
13510 
13511   // TODO: If the result value doesn't fit in an int, it must be a long or long
13512   // long value.  ISO C does not support this, but GCC does as an extension,
13513   // emit a warning.
13514   unsigned IntWidth = Context.getTargetInfo().getIntWidth();
13515   unsigned CharWidth = Context.getTargetInfo().getCharWidth();
13516   unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
13517 
13518   // Verify that all the values are okay, compute the size of the values, and
13519   // reverse the list.
13520   unsigned NumNegativeBits = 0;
13521   unsigned NumPositiveBits = 0;
13522 
13523   // Keep track of whether all elements have type int.
13524   bool AllElementsInt = true;
13525 
13526   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13527     EnumConstantDecl *ECD =
13528       cast_or_null<EnumConstantDecl>(Elements[i]);
13529     if (!ECD) continue;  // Already issued a diagnostic.
13530 
13531     const llvm::APSInt &InitVal = ECD->getInitVal();
13532 
13533     // Keep track of the size of positive and negative values.
13534     if (InitVal.isUnsigned() || InitVal.isNonNegative())
13535       NumPositiveBits = std::max(NumPositiveBits,
13536                                  (unsigned)InitVal.getActiveBits());
13537     else
13538       NumNegativeBits = std::max(NumNegativeBits,
13539                                  (unsigned)InitVal.getMinSignedBits());
13540 
13541     // Keep track of whether every enum element has type int (very commmon).
13542     if (AllElementsInt)
13543       AllElementsInt = ECD->getType() == Context.IntTy;
13544   }
13545 
13546   // Figure out the type that should be used for this enum.
13547   QualType BestType;
13548   unsigned BestWidth;
13549 
13550   // C++0x N3000 [conv.prom]p3:
13551   //   An rvalue of an unscoped enumeration type whose underlying
13552   //   type is not fixed can be converted to an rvalue of the first
13553   //   of the following types that can represent all the values of
13554   //   the enumeration: int, unsigned int, long int, unsigned long
13555   //   int, long long int, or unsigned long long int.
13556   // C99 6.4.4.3p2:
13557   //   An identifier declared as an enumeration constant has type int.
13558   // The C99 rule is modified by a gcc extension
13559   QualType BestPromotionType;
13560 
13561   bool Packed = Enum->hasAttr<PackedAttr>();
13562   // -fshort-enums is the equivalent to specifying the packed attribute on all
13563   // enum definitions.
13564   if (LangOpts.ShortEnums)
13565     Packed = true;
13566 
13567   if (Enum->isFixed()) {
13568     BestType = Enum->getIntegerType();
13569     if (BestType->isPromotableIntegerType())
13570       BestPromotionType = Context.getPromotedIntegerType(BestType);
13571     else
13572       BestPromotionType = BestType;
13573     // We don't need to set BestWidth, because BestType is going to be the type
13574     // of the enumerators, but we do anyway because otherwise some compilers
13575     // warn that it might be used uninitialized.
13576     BestWidth = CharWidth;
13577   }
13578   else if (NumNegativeBits) {
13579     // If there is a negative value, figure out the smallest integer type (of
13580     // int/long/longlong) that fits.
13581     // If it's packed, check also if it fits a char or a short.
13582     if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
13583       BestType = Context.SignedCharTy;
13584       BestWidth = CharWidth;
13585     } else if (Packed && NumNegativeBits <= ShortWidth &&
13586                NumPositiveBits < ShortWidth) {
13587       BestType = Context.ShortTy;
13588       BestWidth = ShortWidth;
13589     } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
13590       BestType = Context.IntTy;
13591       BestWidth = IntWidth;
13592     } else {
13593       BestWidth = Context.getTargetInfo().getLongWidth();
13594 
13595       if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
13596         BestType = Context.LongTy;
13597       } else {
13598         BestWidth = Context.getTargetInfo().getLongLongWidth();
13599 
13600         if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
13601           Diag(Enum->getLocation(), diag::ext_enum_too_large);
13602         BestType = Context.LongLongTy;
13603       }
13604     }
13605     BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
13606   } else {
13607     // If there is no negative value, figure out the smallest type that fits
13608     // all of the enumerator values.
13609     // If it's packed, check also if it fits a char or a short.
13610     if (Packed && NumPositiveBits <= CharWidth) {
13611       BestType = Context.UnsignedCharTy;
13612       BestPromotionType = Context.IntTy;
13613       BestWidth = CharWidth;
13614     } else if (Packed && NumPositiveBits <= ShortWidth) {
13615       BestType = Context.UnsignedShortTy;
13616       BestPromotionType = Context.IntTy;
13617       BestWidth = ShortWidth;
13618     } else if (NumPositiveBits <= IntWidth) {
13619       BestType = Context.UnsignedIntTy;
13620       BestWidth = IntWidth;
13621       BestPromotionType
13622         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13623                            ? Context.UnsignedIntTy : Context.IntTy;
13624     } else if (NumPositiveBits <=
13625                (BestWidth = Context.getTargetInfo().getLongWidth())) {
13626       BestType = Context.UnsignedLongTy;
13627       BestPromotionType
13628         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13629                            ? Context.UnsignedLongTy : Context.LongTy;
13630     } else {
13631       BestWidth = Context.getTargetInfo().getLongLongWidth();
13632       assert(NumPositiveBits <= BestWidth &&
13633              "How could an initializer get larger than ULL?");
13634       BestType = Context.UnsignedLongLongTy;
13635       BestPromotionType
13636         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13637                            ? Context.UnsignedLongLongTy : Context.LongLongTy;
13638     }
13639   }
13640 
13641   // Loop over all of the enumerator constants, changing their types to match
13642   // the type of the enum if needed.
13643   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13644     EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
13645     if (!ECD) continue;  // Already issued a diagnostic.
13646 
13647     // Standard C says the enumerators have int type, but we allow, as an
13648     // extension, the enumerators to be larger than int size.  If each
13649     // enumerator value fits in an int, type it as an int, otherwise type it the
13650     // same as the enumerator decl itself.  This means that in "enum { X = 1U }"
13651     // that X has type 'int', not 'unsigned'.
13652 
13653     // Determine whether the value fits into an int.
13654     llvm::APSInt InitVal = ECD->getInitVal();
13655 
13656     // If it fits into an integer type, force it.  Otherwise force it to match
13657     // the enum decl type.
13658     QualType NewTy;
13659     unsigned NewWidth;
13660     bool NewSign;
13661     if (!getLangOpts().CPlusPlus &&
13662         !Enum->isFixed() &&
13663         isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
13664       NewTy = Context.IntTy;
13665       NewWidth = IntWidth;
13666       NewSign = true;
13667     } else if (ECD->getType() == BestType) {
13668       // Already the right type!
13669       if (getLangOpts().CPlusPlus)
13670         // C++ [dcl.enum]p4: Following the closing brace of an
13671         // enum-specifier, each enumerator has the type of its
13672         // enumeration.
13673         ECD->setType(EnumType);
13674       continue;
13675     } else {
13676       NewTy = BestType;
13677       NewWidth = BestWidth;
13678       NewSign = BestType->isSignedIntegerOrEnumerationType();
13679     }
13680 
13681     // Adjust the APSInt value.
13682     InitVal = InitVal.extOrTrunc(NewWidth);
13683     InitVal.setIsSigned(NewSign);
13684     ECD->setInitVal(InitVal);
13685 
13686     // Adjust the Expr initializer and type.
13687     if (ECD->getInitExpr() &&
13688         !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
13689       ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
13690                                                 CK_IntegralCast,
13691                                                 ECD->getInitExpr(),
13692                                                 /*base paths*/ nullptr,
13693                                                 VK_RValue));
13694     if (getLangOpts().CPlusPlus)
13695       // C++ [dcl.enum]p4: Following the closing brace of an
13696       // enum-specifier, each enumerator has the type of its
13697       // enumeration.
13698       ECD->setType(EnumType);
13699     else
13700       ECD->setType(NewTy);
13701   }
13702 
13703   Enum->completeDefinition(BestType, BestPromotionType,
13704                            NumPositiveBits, NumNegativeBits);
13705 
13706   CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
13707 
13708   // Now that the enum type is defined, ensure it's not been underaligned.
13709   if (Enum->hasAttrs())
13710     CheckAlignasUnderalignment(Enum);
13711 }
13712 
13713 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
13714                                   SourceLocation StartLoc,
13715                                   SourceLocation EndLoc) {
13716   StringLiteral *AsmString = cast<StringLiteral>(expr);
13717 
13718   FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
13719                                                    AsmString, StartLoc,
13720                                                    EndLoc);
13721   CurContext->addDecl(New);
13722   return New;
13723 }
13724 
13725 static void checkModuleImportContext(Sema &S, Module *M,
13726                                      SourceLocation ImportLoc,
13727                                      DeclContext *DC) {
13728   if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
13729     switch (LSD->getLanguage()) {
13730     case LinkageSpecDecl::lang_c:
13731       if (!M->IsExternC) {
13732         S.Diag(ImportLoc, diag::err_module_import_in_extern_c)
13733           << M->getFullModuleName();
13734         S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c);
13735         return;
13736       }
13737       break;
13738     case LinkageSpecDecl::lang_cxx:
13739       break;
13740     }
13741     DC = LSD->getParent();
13742   }
13743 
13744   while (isa<LinkageSpecDecl>(DC))
13745     DC = DC->getParent();
13746   if (!isa<TranslationUnitDecl>(DC)) {
13747     S.Diag(ImportLoc, diag::err_module_import_not_at_top_level)
13748       << M->getFullModuleName() << DC;
13749     S.Diag(cast<Decl>(DC)->getLocStart(),
13750            diag::note_module_import_not_at_top_level)
13751       << DC;
13752   }
13753 }
13754 
13755 DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc,
13756                                    SourceLocation ImportLoc,
13757                                    ModuleIdPath Path) {
13758   Module *Mod =
13759       getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
13760                                    /*IsIncludeDirective=*/false);
13761   if (!Mod)
13762     return true;
13763 
13764   checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
13765 
13766   // FIXME: we should support importing a submodule within a different submodule
13767   // of the same top-level module. Until we do, make it an error rather than
13768   // silently ignoring the import.
13769   if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule)
13770     Diag(ImportLoc, diag::err_module_self_import)
13771         << Mod->getFullModuleName() << getLangOpts().CurrentModule;
13772   else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule)
13773     Diag(ImportLoc, diag::err_module_import_in_implementation)
13774         << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule;
13775 
13776   SmallVector<SourceLocation, 2> IdentifierLocs;
13777   Module *ModCheck = Mod;
13778   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
13779     // If we've run out of module parents, just drop the remaining identifiers.
13780     // We need the length to be consistent.
13781     if (!ModCheck)
13782       break;
13783     ModCheck = ModCheck->Parent;
13784 
13785     IdentifierLocs.push_back(Path[I].second);
13786   }
13787 
13788   ImportDecl *Import = ImportDecl::Create(Context,
13789                                           Context.getTranslationUnitDecl(),
13790                                           AtLoc.isValid()? AtLoc : ImportLoc,
13791                                           Mod, IdentifierLocs);
13792   Context.getTranslationUnitDecl()->addDecl(Import);
13793   return Import;
13794 }
13795 
13796 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
13797   checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
13798 
13799   // FIXME: Should we synthesize an ImportDecl here?
13800   getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc,
13801                                       /*Complain=*/true);
13802 }
13803 
13804 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
13805                                                       Module *Mod) {
13806   // Bail if we're not allowed to implicitly import a module here.
13807   if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
13808     return;
13809 
13810   // Create the implicit import declaration.
13811   TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
13812   ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
13813                                                    Loc, Mod, Loc);
13814   TU->addDecl(ImportD);
13815   Consumer.HandleImplicitImportDecl(ImportD);
13816 
13817   // Make the module visible.
13818   getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc,
13819                                       /*Complain=*/false);
13820 }
13821 
13822 void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
13823                                       IdentifierInfo* AliasName,
13824                                       SourceLocation PragmaLoc,
13825                                       SourceLocation NameLoc,
13826                                       SourceLocation AliasNameLoc) {
13827   Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
13828                                     LookupOrdinaryName);
13829   AsmLabelAttr *Attr = ::new (Context) AsmLabelAttr(AliasNameLoc, Context,
13830                                                     AliasName->getName(), 0);
13831 
13832   if (PrevDecl)
13833     PrevDecl->addAttr(Attr);
13834   else
13835     (void)ExtnameUndeclaredIdentifiers.insert(
13836       std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr));
13837 }
13838 
13839 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
13840                              SourceLocation PragmaLoc,
13841                              SourceLocation NameLoc) {
13842   Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
13843 
13844   if (PrevDecl) {
13845     PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
13846   } else {
13847     (void)WeakUndeclaredIdentifiers.insert(
13848       std::pair<IdentifierInfo*,WeakInfo>
13849         (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
13850   }
13851 }
13852 
13853 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
13854                                 IdentifierInfo* AliasName,
13855                                 SourceLocation PragmaLoc,
13856                                 SourceLocation NameLoc,
13857                                 SourceLocation AliasNameLoc) {
13858   Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
13859                                     LookupOrdinaryName);
13860   WeakInfo W = WeakInfo(Name, NameLoc);
13861 
13862   if (PrevDecl) {
13863     if (!PrevDecl->hasAttr<AliasAttr>())
13864       if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
13865         DeclApplyPragmaWeak(TUScope, ND, W);
13866   } else {
13867     (void)WeakUndeclaredIdentifiers.insert(
13868       std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
13869   }
13870 }
13871 
13872 Decl *Sema::getObjCDeclContext() const {
13873   return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
13874 }
13875 
13876 AvailabilityResult Sema::getCurContextAvailability() const {
13877   const Decl *D = cast<Decl>(getCurObjCLexicalContext());
13878   // If we are within an Objective-C method, we should consult
13879   // both the availability of the method as well as the
13880   // enclosing class.  If the class is (say) deprecated,
13881   // the entire method is considered deprecated from the
13882   // purpose of checking if the current context is deprecated.
13883   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
13884     AvailabilityResult R = MD->getAvailability();
13885     if (R != AR_Available)
13886       return R;
13887     D = MD->getClassInterface();
13888   }
13889   // If we are within an Objective-c @implementation, it
13890   // gets the same availability context as the @interface.
13891   else if (const ObjCImplementationDecl *ID =
13892             dyn_cast<ObjCImplementationDecl>(D)) {
13893     D = ID->getClassInterface();
13894   }
13895   // Recover from user error.
13896   return D ? D->getAvailability() : AR_Available;
13897 }
13898