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       TypeNameValidatorCCC Validator(true, isClassName);
290       TypoCorrection Correction = CorrectTypo(Result.getLookupNameInfo(),
291                                               Kind, S, SS, Validator,
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 
384     // NOTE: avoid constructing an ElaboratedType(Loc) if this is a
385     // constructor or destructor name (in such a case, the scope specifier
386     // will be attached to the enclosing Expr or Decl node).
387     if (SS && SS->isNotEmpty() && !IsCtorOrDtorName) {
388       if (WantNontrivialTypeSourceInfo) {
389         // Construct a type with type-source information.
390         TypeLocBuilder Builder;
391         Builder.pushTypeSpec(T).setNameLoc(NameLoc);
392 
393         T = getElaboratedType(ETK_None, *SS, T);
394         ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
395         ElabTL.setElaboratedKeywordLoc(SourceLocation());
396         ElabTL.setQualifierLoc(SS->getWithLocInContext(Context));
397         return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
398       } else {
399         T = getElaboratedType(ETK_None, *SS, T);
400       }
401     }
402   } else if (ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(IIDecl)) {
403     (void)DiagnoseUseOfDecl(IDecl, NameLoc);
404     if (!HasTrailingDot)
405       T = Context.getObjCInterfaceType(IDecl);
406   }
407 
408   if (T.isNull()) {
409     // If it's not plausibly a type, suppress diagnostics.
410     Result.suppressDiagnostics();
411     return ParsedType();
412   }
413   return ParsedType::make(T);
414 }
415 
416 // Builds a fake NNS for the given decl context.
417 static NestedNameSpecifier *
418 synthesizeCurrentNestedNameSpecifier(ASTContext &Context, DeclContext *DC) {
419   for (;; DC = DC->getLookupParent()) {
420     DC = DC->getPrimaryContext();
421     auto *ND = dyn_cast<NamespaceDecl>(DC);
422     if (ND && !ND->isInline() && !ND->isAnonymousNamespace())
423       return NestedNameSpecifier::Create(Context, nullptr, ND);
424     else if (auto *RD = dyn_cast<CXXRecordDecl>(DC))
425       return NestedNameSpecifier::Create(Context, nullptr, RD->isTemplateDecl(),
426                                          RD->getTypeForDecl());
427     else if (isa<TranslationUnitDecl>(DC))
428       return NestedNameSpecifier::GlobalSpecifier(Context);
429   }
430   llvm_unreachable("something isn't in TU scope?");
431 }
432 
433 ParsedType Sema::ActOnDelayedDefaultTemplateArg(const IdentifierInfo &II,
434                                                 SourceLocation NameLoc) {
435   // Accepting an undeclared identifier as a default argument for a template
436   // type parameter is a Microsoft extension.
437   Diag(NameLoc, diag::ext_ms_delayed_template_argument) << &II;
438 
439   // Build a fake DependentNameType that will perform lookup into CurContext at
440   // instantiation time.  The name specifier isn't dependent, so template
441   // instantiation won't transform it.  It will retry the lookup, however.
442   NestedNameSpecifier *NNS =
443       synthesizeCurrentNestedNameSpecifier(Context, CurContext);
444   QualType T = Context.getDependentNameType(ETK_None, NNS, &II);
445 
446   // Build type location information.  We synthesized the qualifier, so we have
447   // to build a fake NestedNameSpecifierLoc.
448   NestedNameSpecifierLocBuilder NNSLocBuilder;
449   NNSLocBuilder.MakeTrivial(Context, NNS, SourceRange(NameLoc));
450   NestedNameSpecifierLoc QualifierLoc = NNSLocBuilder.getWithLocInContext(Context);
451 
452   TypeLocBuilder Builder;
453   DependentNameTypeLoc DepTL = Builder.push<DependentNameTypeLoc>(T);
454   DepTL.setNameLoc(NameLoc);
455   DepTL.setElaboratedKeywordLoc(SourceLocation());
456   DepTL.setQualifierLoc(QualifierLoc);
457   return CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
458 }
459 
460 /// isTagName() - This method is called *for error recovery purposes only*
461 /// to determine if the specified name is a valid tag name ("struct foo").  If
462 /// so, this returns the TST for the tag corresponding to it (TST_enum,
463 /// TST_union, TST_struct, TST_interface, TST_class).  This is used to diagnose
464 /// cases in C where the user forgot to specify the tag.
465 DeclSpec::TST Sema::isTagName(IdentifierInfo &II, Scope *S) {
466   // Do a tag name lookup in this scope.
467   LookupResult R(*this, &II, SourceLocation(), LookupTagName);
468   LookupName(R, S, false);
469   R.suppressDiagnostics();
470   if (R.getResultKind() == LookupResult::Found)
471     if (const TagDecl *TD = R.getAsSingle<TagDecl>()) {
472       switch (TD->getTagKind()) {
473       case TTK_Struct: return DeclSpec::TST_struct;
474       case TTK_Interface: return DeclSpec::TST_interface;
475       case TTK_Union:  return DeclSpec::TST_union;
476       case TTK_Class:  return DeclSpec::TST_class;
477       case TTK_Enum:   return DeclSpec::TST_enum;
478       }
479     }
480 
481   return DeclSpec::TST_unspecified;
482 }
483 
484 /// isMicrosoftMissingTypename - In Microsoft mode, within class scope,
485 /// if a CXXScopeSpec's type is equal to the type of one of the base classes
486 /// then downgrade the missing typename error to a warning.
487 /// This is needed for MSVC compatibility; Example:
488 /// @code
489 /// template<class T> class A {
490 /// public:
491 ///   typedef int TYPE;
492 /// };
493 /// template<class T> class B : public A<T> {
494 /// public:
495 ///   A<T>::TYPE a; // no typename required because A<T> is a base class.
496 /// };
497 /// @endcode
498 bool Sema::isMicrosoftMissingTypename(const CXXScopeSpec *SS, Scope *S) {
499   if (CurContext->isRecord()) {
500     const Type *Ty = SS->getScopeRep()->getAsType();
501 
502     CXXRecordDecl *RD = cast<CXXRecordDecl>(CurContext);
503     for (const auto &Base : RD->bases())
504       if (Context.hasSameUnqualifiedType(QualType(Ty, 1), Base.getType()))
505         return true;
506     return S->isFunctionPrototypeScope();
507   }
508   return CurContext->isFunctionOrMethod() || S->isFunctionPrototypeScope();
509 }
510 
511 void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
512                                    SourceLocation IILoc,
513                                    Scope *S,
514                                    CXXScopeSpec *SS,
515                                    ParsedType &SuggestedType,
516                                    bool AllowClassTemplates) {
517   // We don't have anything to suggest (yet).
518   SuggestedType = ParsedType();
519 
520   // There may have been a typo in the name of the type. Look up typo
521   // results, in case we have something that we can suggest.
522   TypeNameValidatorCCC Validator(false, false, AllowClassTemplates);
523   if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc),
524                                              LookupOrdinaryName, S, SS,
525                                              Validator, CTK_ErrorRecovery)) {
526     if (Corrected.isKeyword()) {
527       // We corrected to a keyword.
528       diagnoseTypo(Corrected, PDiag(diag::err_unknown_typename_suggest) << II);
529       II = Corrected.getCorrectionAsIdentifierInfo();
530     } else {
531       // We found a similarly-named type or interface; suggest that.
532       if (!SS || !SS->isSet()) {
533         diagnoseTypo(Corrected,
534                      PDiag(diag::err_unknown_typename_suggest) << II);
535       } else if (DeclContext *DC = computeDeclContext(*SS, false)) {
536         std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
537         bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
538                                 II->getName().equals(CorrectedStr);
539         diagnoseTypo(Corrected,
540                      PDiag(diag::err_unknown_nested_typename_suggest)
541                        << II << DC << DroppedSpecifier << SS->getRange());
542       } else {
543         llvm_unreachable("could not have corrected a typo here");
544       }
545 
546       CXXScopeSpec tmpSS;
547       if (Corrected.getCorrectionSpecifier())
548         tmpSS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
549                           SourceRange(IILoc));
550       SuggestedType = getTypeName(*Corrected.getCorrectionAsIdentifierInfo(),
551                                   IILoc, S, tmpSS.isSet() ? &tmpSS : SS, false,
552                                   false, ParsedType(),
553                                   /*IsCtorOrDtorName=*/false,
554                                   /*NonTrivialTypeSourceInfo=*/true);
555     }
556     return;
557   }
558 
559   if (getLangOpts().CPlusPlus) {
560     // See if II is a class template that the user forgot to pass arguments to.
561     UnqualifiedId Name;
562     Name.setIdentifier(II, IILoc);
563     CXXScopeSpec EmptySS;
564     TemplateTy TemplateResult;
565     bool MemberOfUnknownSpecialization;
566     if (isTemplateName(S, SS ? *SS : EmptySS, /*hasTemplateKeyword=*/false,
567                        Name, ParsedType(), true, TemplateResult,
568                        MemberOfUnknownSpecialization) == TNK_Type_template) {
569       TemplateName TplName = TemplateResult.get();
570       Diag(IILoc, diag::err_template_missing_args) << TplName;
571       if (TemplateDecl *TplDecl = TplName.getAsTemplateDecl()) {
572         Diag(TplDecl->getLocation(), diag::note_template_decl_here)
573           << TplDecl->getTemplateParameters()->getSourceRange();
574       }
575       return;
576     }
577   }
578 
579   // FIXME: Should we move the logic that tries to recover from a missing tag
580   // (struct, union, enum) from Parser::ParseImplicitInt here, instead?
581 
582   if (!SS || (!SS->isSet() && !SS->isInvalid()))
583     Diag(IILoc, diag::err_unknown_typename) << II;
584   else if (DeclContext *DC = computeDeclContext(*SS, false))
585     Diag(IILoc, diag::err_typename_nested_not_found)
586       << II << DC << SS->getRange();
587   else if (isDependentScopeSpecifier(*SS)) {
588     unsigned DiagID = diag::err_typename_missing;
589     if (getLangOpts().MSVCCompat && isMicrosoftMissingTypename(SS, S))
590       DiagID = diag::ext_typename_missing;
591 
592     Diag(SS->getRange().getBegin(), DiagID)
593       << SS->getScopeRep() << II->getName()
594       << SourceRange(SS->getRange().getBegin(), IILoc)
595       << FixItHint::CreateInsertion(SS->getRange().getBegin(), "typename ");
596     SuggestedType = ActOnTypenameType(S, SourceLocation(),
597                                       *SS, *II, IILoc).get();
598   } else {
599     assert(SS && SS->isInvalid() &&
600            "Invalid scope specifier has already been diagnosed");
601   }
602 }
603 
604 /// \brief Determine whether the given result set contains either a type name
605 /// or
606 static bool isResultTypeOrTemplate(LookupResult &R, const Token &NextToken) {
607   bool CheckTemplate = R.getSema().getLangOpts().CPlusPlus &&
608                        NextToken.is(tok::less);
609 
610   for (LookupResult::iterator I = R.begin(), IEnd = R.end(); I != IEnd; ++I) {
611     if (isa<TypeDecl>(*I) || isa<ObjCInterfaceDecl>(*I))
612       return true;
613 
614     if (CheckTemplate && isa<TemplateDecl>(*I))
615       return true;
616   }
617 
618   return false;
619 }
620 
621 static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result,
622                                     Scope *S, CXXScopeSpec &SS,
623                                     IdentifierInfo *&Name,
624                                     SourceLocation NameLoc) {
625   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupTagName);
626   SemaRef.LookupParsedName(R, S, &SS);
627   if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {
628     StringRef FixItTagName;
629     switch (Tag->getTagKind()) {
630       case TTK_Class:
631         FixItTagName = "class ";
632         break;
633 
634       case TTK_Enum:
635         FixItTagName = "enum ";
636         break;
637 
638       case TTK_Struct:
639         FixItTagName = "struct ";
640         break;
641 
642       case TTK_Interface:
643         FixItTagName = "__interface ";
644         break;
645 
646       case TTK_Union:
647         FixItTagName = "union ";
648         break;
649     }
650 
651     StringRef TagName = FixItTagName.drop_back();
652     SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag)
653       << Name << TagName << SemaRef.getLangOpts().CPlusPlus
654       << FixItHint::CreateInsertion(NameLoc, FixItTagName);
655 
656     for (LookupResult::iterator I = Result.begin(), IEnd = Result.end();
657          I != IEnd; ++I)
658       SemaRef.Diag((*I)->getLocation(), diag::note_decl_hiding_tag_type)
659         << Name << TagName;
660 
661     // Replace lookup results with just the tag decl.
662     Result.clear(Sema::LookupTagName);
663     SemaRef.LookupParsedName(Result, S, &SS);
664     return true;
665   }
666 
667   return false;
668 }
669 
670 /// Build a ParsedType for a simple-type-specifier with a nested-name-specifier.
671 static ParsedType buildNestedType(Sema &S, CXXScopeSpec &SS,
672                                   QualType T, SourceLocation NameLoc) {
673   ASTContext &Context = S.Context;
674 
675   TypeLocBuilder Builder;
676   Builder.pushTypeSpec(T).setNameLoc(NameLoc);
677 
678   T = S.getElaboratedType(ETK_None, SS, T);
679   ElaboratedTypeLoc ElabTL = Builder.push<ElaboratedTypeLoc>(T);
680   ElabTL.setElaboratedKeywordLoc(SourceLocation());
681   ElabTL.setQualifierLoc(SS.getWithLocInContext(Context));
682   return S.CreateParsedType(T, Builder.getTypeSourceInfo(Context, T));
683 }
684 
685 Sema::NameClassification Sema::ClassifyName(Scope *S,
686                                             CXXScopeSpec &SS,
687                                             IdentifierInfo *&Name,
688                                             SourceLocation NameLoc,
689                                             const Token &NextToken,
690                                             bool IsAddressOfOperand,
691                                             CorrectionCandidateCallback *CCC) {
692   DeclarationNameInfo NameInfo(Name, NameLoc);
693   ObjCMethodDecl *CurMethod = getCurMethodDecl();
694 
695   if (NextToken.is(tok::coloncolon)) {
696     BuildCXXNestedNameSpecifier(S, *Name, NameLoc, NextToken.getLocation(),
697                                 QualType(), false, SS, nullptr, false);
698   }
699 
700   LookupResult Result(*this, Name, NameLoc, LookupOrdinaryName);
701   LookupParsedName(Result, S, &SS, !CurMethod);
702 
703   // For unqualified lookup in a class template in MSVC mode, look into
704   // dependent base classes where the primary class template is known.
705   if (Result.empty() && SS.isEmpty() && getLangOpts().MSVCCompat) {
706     if (ParsedType TypeInBase =
707             recoverFromTypeInKnownDependentBase(*this, *Name, NameLoc))
708       return TypeInBase;
709   }
710 
711   // Perform lookup for Objective-C instance variables (including automatically
712   // synthesized instance variables), if we're in an Objective-C method.
713   // FIXME: This lookup really, really needs to be folded in to the normal
714   // unqualified lookup mechanism.
715   if (!SS.isSet() && CurMethod && !isResultTypeOrTemplate(Result, NextToken)) {
716     ExprResult E = LookupInObjCMethod(Result, S, Name, true);
717     if (E.get() || E.isInvalid())
718       return E;
719   }
720 
721   bool SecondTry = false;
722   bool IsFilteredTemplateName = false;
723 
724 Corrected:
725   switch (Result.getResultKind()) {
726   case LookupResult::NotFound:
727     // If an unqualified-id is followed by a '(', then we have a function
728     // call.
729     if (!SS.isSet() && NextToken.is(tok::l_paren)) {
730       // In C++, this is an ADL-only call.
731       // FIXME: Reference?
732       if (getLangOpts().CPlusPlus)
733         return BuildDeclarationNameExpr(SS, Result, /*ADL=*/true);
734 
735       // C90 6.3.2.2:
736       //   If the expression that precedes the parenthesized argument list in a
737       //   function call consists solely of an identifier, and if no
738       //   declaration is visible for this identifier, the identifier is
739       //   implicitly declared exactly as if, in the innermost block containing
740       //   the function call, the declaration
741       //
742       //     extern int identifier ();
743       //
744       //   appeared.
745       //
746       // We also allow this in C99 as an extension.
747       if (NamedDecl *D = ImplicitlyDefineFunction(NameLoc, *Name, S)) {
748         Result.addDecl(D);
749         Result.resolveKind();
750         return BuildDeclarationNameExpr(SS, Result, /*ADL=*/false);
751       }
752     }
753 
754     // In C, we first see whether there is a tag type by the same name, in
755     // which case it's likely that the user just forget to write "enum",
756     // "struct", or "union".
757     if (!getLangOpts().CPlusPlus && !SecondTry &&
758         isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
759       break;
760     }
761 
762     // Perform typo correction to determine if there is another name that is
763     // close to this name.
764     if (!SecondTry && CCC) {
765       SecondTry = true;
766       if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(),
767                                                  Result.getLookupKind(), S,
768                                                  &SS, *CCC,
769                                                  CTK_ErrorRecovery)) {
770         unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;
771         unsigned QualifiedDiag = diag::err_no_member_suggest;
772 
773         NamedDecl *FirstDecl = Corrected.getCorrectionDecl();
774         NamedDecl *UnderlyingFirstDecl
775           = FirstDecl? FirstDecl->getUnderlyingDecl() : nullptr;
776         if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
777             UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {
778           UnqualifiedDiag = diag::err_no_template_suggest;
779           QualifiedDiag = diag::err_no_member_template_suggest;
780         } else if (UnderlyingFirstDecl &&
781                    (isa<TypeDecl>(UnderlyingFirstDecl) ||
782                     isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) ||
783                     isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {
784           UnqualifiedDiag = diag::err_unknown_typename_suggest;
785           QualifiedDiag = diag::err_unknown_nested_typename_suggest;
786         }
787 
788         if (SS.isEmpty()) {
789           diagnoseTypo(Corrected, PDiag(UnqualifiedDiag) << Name);
790         } else {// FIXME: is this even reachable? Test it.
791           std::string CorrectedStr(Corrected.getAsString(getLangOpts()));
792           bool DroppedSpecifier = Corrected.WillReplaceSpecifier() &&
793                                   Name->getName().equals(CorrectedStr);
794           diagnoseTypo(Corrected, PDiag(QualifiedDiag)
795                                     << Name << computeDeclContext(SS, false)
796                                     << DroppedSpecifier << SS.getRange());
797         }
798 
799         // Update the name, so that the caller has the new name.
800         Name = Corrected.getCorrectionAsIdentifierInfo();
801 
802         // Typo correction corrected to a keyword.
803         if (Corrected.isKeyword())
804           return Name;
805 
806         // Also update the LookupResult...
807         // FIXME: This should probably go away at some point
808         Result.clear();
809         Result.setLookupName(Corrected.getCorrection());
810         if (FirstDecl)
811           Result.addDecl(FirstDecl);
812 
813         // If we found an Objective-C instance variable, let
814         // LookupInObjCMethod build the appropriate expression to
815         // reference the ivar.
816         // FIXME: This is a gross hack.
817         if (ObjCIvarDecl *Ivar = Result.getAsSingle<ObjCIvarDecl>()) {
818           Result.clear();
819           ExprResult E(LookupInObjCMethod(Result, S, Ivar->getIdentifier()));
820           return E;
821         }
822 
823         goto Corrected;
824       }
825     }
826 
827     // We failed to correct; just fall through and let the parser deal with it.
828     Result.suppressDiagnostics();
829     return NameClassification::Unknown();
830 
831   case LookupResult::NotFoundInCurrentInstantiation: {
832     // We performed name lookup into the current instantiation, and there were
833     // dependent bases, so we treat this result the same way as any other
834     // dependent nested-name-specifier.
835 
836     // C++ [temp.res]p2:
837     //   A name used in a template declaration or definition and that is
838     //   dependent on a template-parameter is assumed not to name a type
839     //   unless the applicable name lookup finds a type name or the name is
840     //   qualified by the keyword typename.
841     //
842     // FIXME: If the next token is '<', we might want to ask the parser to
843     // perform some heroics to see if we actually have a
844     // template-argument-list, which would indicate a missing 'template'
845     // keyword here.
846     return ActOnDependentIdExpression(SS, /*TemplateKWLoc=*/SourceLocation(),
847                                       NameInfo, IsAddressOfOperand,
848                                       /*TemplateArgs=*/nullptr);
849   }
850 
851   case LookupResult::Found:
852   case LookupResult::FoundOverloaded:
853   case LookupResult::FoundUnresolvedValue:
854     break;
855 
856   case LookupResult::Ambiguous:
857     if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
858         hasAnyAcceptableTemplateNames(Result)) {
859       // C++ [temp.local]p3:
860       //   A lookup that finds an injected-class-name (10.2) can result in an
861       //   ambiguity in certain cases (for example, if it is found in more than
862       //   one base class). If all of the injected-class-names that are found
863       //   refer to specializations of the same class template, and if the name
864       //   is followed by a template-argument-list, the reference refers to the
865       //   class template itself and not a specialization thereof, and is not
866       //   ambiguous.
867       //
868       // This filtering can make an ambiguous result into an unambiguous one,
869       // so try again after filtering out template names.
870       FilterAcceptableTemplateNames(Result);
871       if (!Result.isAmbiguous()) {
872         IsFilteredTemplateName = true;
873         break;
874       }
875     }
876 
877     // Diagnose the ambiguity and return an error.
878     return NameClassification::Error();
879   }
880 
881   if (getLangOpts().CPlusPlus && NextToken.is(tok::less) &&
882       (IsFilteredTemplateName || hasAnyAcceptableTemplateNames(Result))) {
883     // C++ [temp.names]p3:
884     //   After name lookup (3.4) finds that a name is a template-name or that
885     //   an operator-function-id or a literal- operator-id refers to a set of
886     //   overloaded functions any member of which is a function template if
887     //   this is followed by a <, the < is always taken as the delimiter of a
888     //   template-argument-list and never as the less-than operator.
889     if (!IsFilteredTemplateName)
890       FilterAcceptableTemplateNames(Result);
891 
892     if (!Result.empty()) {
893       bool IsFunctionTemplate;
894       bool IsVarTemplate;
895       TemplateName Template;
896       if (Result.end() - Result.begin() > 1) {
897         IsFunctionTemplate = true;
898         Template = Context.getOverloadedTemplateName(Result.begin(),
899                                                      Result.end());
900       } else {
901         TemplateDecl *TD
902           = cast<TemplateDecl>((*Result.begin())->getUnderlyingDecl());
903         IsFunctionTemplate = isa<FunctionTemplateDecl>(TD);
904         IsVarTemplate = isa<VarTemplateDecl>(TD);
905 
906         if (SS.isSet() && !SS.isInvalid())
907           Template = Context.getQualifiedTemplateName(SS.getScopeRep(),
908                                                     /*TemplateKeyword=*/false,
909                                                       TD);
910         else
911           Template = TemplateName(TD);
912       }
913 
914       if (IsFunctionTemplate) {
915         // Function templates always go through overload resolution, at which
916         // point we'll perform the various checks (e.g., accessibility) we need
917         // to based on which function we selected.
918         Result.suppressDiagnostics();
919 
920         return NameClassification::FunctionTemplate(Template);
921       }
922 
923       return IsVarTemplate ? NameClassification::VarTemplate(Template)
924                            : NameClassification::TypeTemplate(Template);
925     }
926   }
927 
928   NamedDecl *FirstDecl = (*Result.begin())->getUnderlyingDecl();
929   if (TypeDecl *Type = dyn_cast<TypeDecl>(FirstDecl)) {
930     DiagnoseUseOfDecl(Type, NameLoc);
931     QualType T = Context.getTypeDeclType(Type);
932     if (SS.isNotEmpty())
933       return buildNestedType(*this, SS, T, NameLoc);
934     return ParsedType::make(T);
935   }
936 
937   ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(FirstDecl);
938   if (!Class) {
939     // FIXME: It's unfortunate that we don't have a Type node for handling this.
940     if (ObjCCompatibleAliasDecl *Alias =
941             dyn_cast<ObjCCompatibleAliasDecl>(FirstDecl))
942       Class = Alias->getClassInterface();
943   }
944 
945   if (Class) {
946     DiagnoseUseOfDecl(Class, NameLoc);
947 
948     if (NextToken.is(tok::period)) {
949       // Interface. <something> is parsed as a property reference expression.
950       // Just return "unknown" as a fall-through for now.
951       Result.suppressDiagnostics();
952       return NameClassification::Unknown();
953     }
954 
955     QualType T = Context.getObjCInterfaceType(Class);
956     return ParsedType::make(T);
957   }
958 
959   // We can have a type template here if we're classifying a template argument.
960   if (isa<TemplateDecl>(FirstDecl) && !isa<FunctionTemplateDecl>(FirstDecl))
961     return NameClassification::TypeTemplate(
962         TemplateName(cast<TemplateDecl>(FirstDecl)));
963 
964   // Check for a tag type hidden by a non-type decl in a few cases where it
965   // seems likely a type is wanted instead of the non-type that was found.
966   bool NextIsOp = NextToken.is(tok::amp) || NextToken.is(tok::star);
967   if ((NextToken.is(tok::identifier) ||
968        (NextIsOp &&
969         FirstDecl->getUnderlyingDecl()->isFunctionOrFunctionTemplate())) &&
970       isTagTypeWithMissingTag(*this, Result, S, SS, Name, NameLoc)) {
971     TypeDecl *Type = Result.getAsSingle<TypeDecl>();
972     DiagnoseUseOfDecl(Type, NameLoc);
973     QualType T = Context.getTypeDeclType(Type);
974     if (SS.isNotEmpty())
975       return buildNestedType(*this, SS, T, NameLoc);
976     return ParsedType::make(T);
977   }
978 
979   if (FirstDecl->isCXXClassMember())
980     return BuildPossibleImplicitMemberExpr(SS, SourceLocation(), Result,
981                                            nullptr);
982 
983   bool ADL = UseArgumentDependentLookup(SS, Result, NextToken.is(tok::l_paren));
984   return BuildDeclarationNameExpr(SS, Result, ADL);
985 }
986 
987 // Determines the context to return to after temporarily entering a
988 // context.  This depends in an unnecessarily complicated way on the
989 // exact ordering of callbacks from the parser.
990 DeclContext *Sema::getContainingDC(DeclContext *DC) {
991 
992   // Functions defined inline within classes aren't parsed until we've
993   // finished parsing the top-level class, so the top-level class is
994   // the context we'll need to return to.
995   // A Lambda call operator whose parent is a class must not be treated
996   // as an inline member function.  A Lambda can be used legally
997   // either as an in-class member initializer or a default argument.  These
998   // are parsed once the class has been marked complete and so the containing
999   // context would be the nested class (when the lambda is defined in one);
1000   // If the class is not complete, then the lambda is being used in an
1001   // ill-formed fashion (such as to specify the width of a bit-field, or
1002   // in an array-bound) - in which case we still want to return the
1003   // lexically containing DC (which could be a nested class).
1004   if (isa<FunctionDecl>(DC) && !isLambdaCallOperator(DC)) {
1005     DC = DC->getLexicalParent();
1006 
1007     // A function not defined within a class will always return to its
1008     // lexical context.
1009     if (!isa<CXXRecordDecl>(DC))
1010       return DC;
1011 
1012     // A C++ inline method/friend is parsed *after* the topmost class
1013     // it was declared in is fully parsed ("complete");  the topmost
1014     // class is the context we need to return to.
1015     while (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC->getLexicalParent()))
1016       DC = RD;
1017 
1018     // Return the declaration context of the topmost class the inline method is
1019     // declared in.
1020     return DC;
1021   }
1022 
1023   return DC->getLexicalParent();
1024 }
1025 
1026 void Sema::PushDeclContext(Scope *S, DeclContext *DC) {
1027   assert(getContainingDC(DC) == CurContext &&
1028       "The next DeclContext should be lexically contained in the current one.");
1029   CurContext = DC;
1030   S->setEntity(DC);
1031 }
1032 
1033 void Sema::PopDeclContext() {
1034   assert(CurContext && "DeclContext imbalance!");
1035 
1036   CurContext = getContainingDC(CurContext);
1037   assert(CurContext && "Popped translation unit!");
1038 }
1039 
1040 /// EnterDeclaratorContext - Used when we must lookup names in the context
1041 /// of a declarator's nested name specifier.
1042 ///
1043 void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
1044   // C++0x [basic.lookup.unqual]p13:
1045   //   A name used in the definition of a static data member of class
1046   //   X (after the qualified-id of the static member) is looked up as
1047   //   if the name was used in a member function of X.
1048   // C++0x [basic.lookup.unqual]p14:
1049   //   If a variable member of a namespace is defined outside of the
1050   //   scope of its namespace then any name used in the definition of
1051   //   the variable member (after the declarator-id) is looked up as
1052   //   if the definition of the variable member occurred in its
1053   //   namespace.
1054   // Both of these imply that we should push a scope whose context
1055   // is the semantic context of the declaration.  We can't use
1056   // PushDeclContext here because that context is not necessarily
1057   // lexically contained in the current context.  Fortunately,
1058   // the containing scope should have the appropriate information.
1059 
1060   assert(!S->getEntity() && "scope already has entity");
1061 
1062 #ifndef NDEBUG
1063   Scope *Ancestor = S->getParent();
1064   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1065   assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
1066 #endif
1067 
1068   CurContext = DC;
1069   S->setEntity(DC);
1070 }
1071 
1072 void Sema::ExitDeclaratorContext(Scope *S) {
1073   assert(S->getEntity() == CurContext && "Context imbalance!");
1074 
1075   // Switch back to the lexical context.  The safety of this is
1076   // enforced by an assert in EnterDeclaratorContext.
1077   Scope *Ancestor = S->getParent();
1078   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
1079   CurContext = Ancestor->getEntity();
1080 
1081   // We don't need to do anything with the scope, which is going to
1082   // disappear.
1083 }
1084 
1085 
1086 void Sema::ActOnReenterFunctionContext(Scope* S, Decl *D) {
1087   // We assume that the caller has already called
1088   // ActOnReenterTemplateScope so getTemplatedDecl() works.
1089   FunctionDecl *FD = D->getAsFunction();
1090   if (!FD)
1091     return;
1092 
1093   // Same implementation as PushDeclContext, but enters the context
1094   // from the lexical parent, rather than the top-level class.
1095   assert(CurContext == FD->getLexicalParent() &&
1096     "The next DeclContext should be lexically contained in the current one.");
1097   CurContext = FD;
1098   S->setEntity(CurContext);
1099 
1100   for (unsigned P = 0, NumParams = FD->getNumParams(); P < NumParams; ++P) {
1101     ParmVarDecl *Param = FD->getParamDecl(P);
1102     // If the parameter has an identifier, then add it to the scope
1103     if (Param->getIdentifier()) {
1104       S->AddDecl(Param);
1105       IdResolver.AddDecl(Param);
1106     }
1107   }
1108 }
1109 
1110 
1111 void Sema::ActOnExitFunctionContext() {
1112   // Same implementation as PopDeclContext, but returns to the lexical parent,
1113   // rather than the top-level class.
1114   assert(CurContext && "DeclContext imbalance!");
1115   CurContext = CurContext->getLexicalParent();
1116   assert(CurContext && "Popped translation unit!");
1117 }
1118 
1119 
1120 /// \brief Determine whether we allow overloading of the function
1121 /// PrevDecl with another declaration.
1122 ///
1123 /// This routine determines whether overloading is possible, not
1124 /// whether some new function is actually an overload. It will return
1125 /// true in C++ (where we can always provide overloads) or, as an
1126 /// extension, in C when the previous function is already an
1127 /// overloaded function declaration or has the "overloadable"
1128 /// attribute.
1129 static bool AllowOverloadingOfFunction(LookupResult &Previous,
1130                                        ASTContext &Context) {
1131   if (Context.getLangOpts().CPlusPlus)
1132     return true;
1133 
1134   if (Previous.getResultKind() == LookupResult::FoundOverloaded)
1135     return true;
1136 
1137   return (Previous.getResultKind() == LookupResult::Found
1138           && Previous.getFoundDecl()->hasAttr<OverloadableAttr>());
1139 }
1140 
1141 /// Add this decl to the scope shadowed decl chains.
1142 void Sema::PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext) {
1143   // Move up the scope chain until we find the nearest enclosing
1144   // non-transparent context. The declaration will be introduced into this
1145   // scope.
1146   while (S->getEntity() && S->getEntity()->isTransparentContext())
1147     S = S->getParent();
1148 
1149   // Add scoped declarations into their context, so that they can be
1150   // found later. Declarations without a context won't be inserted
1151   // into any context.
1152   if (AddToContext)
1153     CurContext->addDecl(D);
1154 
1155   // Out-of-line definitions shouldn't be pushed into scope in C++, unless they
1156   // are function-local declarations.
1157   if (getLangOpts().CPlusPlus && D->isOutOfLine() &&
1158       !D->getDeclContext()->getRedeclContext()->Equals(
1159         D->getLexicalDeclContext()->getRedeclContext()) &&
1160       !D->getLexicalDeclContext()->isFunctionOrMethod())
1161     return;
1162 
1163   // Template instantiations should also not be pushed into scope.
1164   if (isa<FunctionDecl>(D) &&
1165       cast<FunctionDecl>(D)->isFunctionTemplateSpecialization())
1166     return;
1167 
1168   // If this replaces anything in the current scope,
1169   IdentifierResolver::iterator I = IdResolver.begin(D->getDeclName()),
1170                                IEnd = IdResolver.end();
1171   for (; I != IEnd; ++I) {
1172     if (S->isDeclScope(*I) && D->declarationReplaces(*I)) {
1173       S->RemoveDecl(*I);
1174       IdResolver.RemoveDecl(*I);
1175 
1176       // Should only need to replace one decl.
1177       break;
1178     }
1179   }
1180 
1181   S->AddDecl(D);
1182 
1183   if (isa<LabelDecl>(D) && !cast<LabelDecl>(D)->isGnuLocal()) {
1184     // Implicitly-generated labels may end up getting generated in an order that
1185     // isn't strictly lexical, which breaks name lookup. Be careful to insert
1186     // the label at the appropriate place in the identifier chain.
1187     for (I = IdResolver.begin(D->getDeclName()); I != IEnd; ++I) {
1188       DeclContext *IDC = (*I)->getLexicalDeclContext()->getRedeclContext();
1189       if (IDC == CurContext) {
1190         if (!S->isDeclScope(*I))
1191           continue;
1192       } else if (IDC->Encloses(CurContext))
1193         break;
1194     }
1195 
1196     IdResolver.InsertDeclAfter(I, D);
1197   } else {
1198     IdResolver.AddDecl(D);
1199   }
1200 }
1201 
1202 void Sema::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
1203   if (IdResolver.tryAddTopLevelDecl(D, Name) && TUScope)
1204     TUScope->AddDecl(D);
1205 }
1206 
1207 bool Sema::isDeclInScope(NamedDecl *D, DeclContext *Ctx, Scope *S,
1208                          bool AllowInlineNamespace) {
1209   return IdResolver.isDeclInScope(D, Ctx, S, AllowInlineNamespace);
1210 }
1211 
1212 Scope *Sema::getScopeForDeclContext(Scope *S, DeclContext *DC) {
1213   DeclContext *TargetDC = DC->getPrimaryContext();
1214   do {
1215     if (DeclContext *ScopeDC = S->getEntity())
1216       if (ScopeDC->getPrimaryContext() == TargetDC)
1217         return S;
1218   } while ((S = S->getParent()));
1219 
1220   return nullptr;
1221 }
1222 
1223 static bool isOutOfScopePreviousDeclaration(NamedDecl *,
1224                                             DeclContext*,
1225                                             ASTContext&);
1226 
1227 /// Filters out lookup results that don't fall within the given scope
1228 /// as determined by isDeclInScope.
1229 void Sema::FilterLookupForScope(LookupResult &R, DeclContext *Ctx, Scope *S,
1230                                 bool ConsiderLinkage,
1231                                 bool AllowInlineNamespace) {
1232   LookupResult::Filter F = R.makeFilter();
1233   while (F.hasNext()) {
1234     NamedDecl *D = F.next();
1235 
1236     if (isDeclInScope(D, Ctx, S, AllowInlineNamespace))
1237       continue;
1238 
1239     if (ConsiderLinkage && isOutOfScopePreviousDeclaration(D, Ctx, Context))
1240       continue;
1241 
1242     F.erase();
1243   }
1244 
1245   F.done();
1246 }
1247 
1248 static bool isUsingDecl(NamedDecl *D) {
1249   return isa<UsingShadowDecl>(D) ||
1250          isa<UnresolvedUsingTypenameDecl>(D) ||
1251          isa<UnresolvedUsingValueDecl>(D);
1252 }
1253 
1254 /// Removes using shadow declarations from the lookup results.
1255 static void RemoveUsingDecls(LookupResult &R) {
1256   LookupResult::Filter F = R.makeFilter();
1257   while (F.hasNext())
1258     if (isUsingDecl(F.next()))
1259       F.erase();
1260 
1261   F.done();
1262 }
1263 
1264 /// \brief Check for this common pattern:
1265 /// @code
1266 /// class S {
1267 ///   S(const S&); // DO NOT IMPLEMENT
1268 ///   void operator=(const S&); // DO NOT IMPLEMENT
1269 /// };
1270 /// @endcode
1271 static bool IsDisallowedCopyOrAssign(const CXXMethodDecl *D) {
1272   // FIXME: Should check for private access too but access is set after we get
1273   // the decl here.
1274   if (D->doesThisDeclarationHaveABody())
1275     return false;
1276 
1277   if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D))
1278     return CD->isCopyConstructor();
1279   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D))
1280     return Method->isCopyAssignmentOperator();
1281   return false;
1282 }
1283 
1284 // We need this to handle
1285 //
1286 // typedef struct {
1287 //   void *foo() { return 0; }
1288 // } A;
1289 //
1290 // When we see foo we don't know if after the typedef we will get 'A' or '*A'
1291 // for example. If 'A', foo will have external linkage. If we have '*A',
1292 // foo will have no linkage. Since we can't know until we get to the end
1293 // of the typedef, this function finds out if D might have non-external linkage.
1294 // Callers should verify at the end of the TU if it D has external linkage or
1295 // not.
1296 bool Sema::mightHaveNonExternalLinkage(const DeclaratorDecl *D) {
1297   const DeclContext *DC = D->getDeclContext();
1298   while (!DC->isTranslationUnit()) {
1299     if (const RecordDecl *RD = dyn_cast<RecordDecl>(DC)){
1300       if (!RD->hasNameForLinkage())
1301         return true;
1302     }
1303     DC = DC->getParent();
1304   }
1305 
1306   return !D->isExternallyVisible();
1307 }
1308 
1309 // FIXME: This needs to be refactored; some other isInMainFile users want
1310 // these semantics.
1311 static bool isMainFileLoc(const Sema &S, SourceLocation Loc) {
1312   if (S.TUKind != TU_Complete)
1313     return false;
1314   return S.SourceMgr.isInMainFile(Loc);
1315 }
1316 
1317 bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
1318   assert(D);
1319 
1320   if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
1321     return false;
1322 
1323   // Ignore all entities declared within templates, and out-of-line definitions
1324   // of members of class templates.
1325   if (D->getDeclContext()->isDependentContext() ||
1326       D->getLexicalDeclContext()->isDependentContext())
1327     return false;
1328 
1329   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1330     if (FD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1331       return false;
1332 
1333     if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
1334       if (MD->isVirtual() || IsDisallowedCopyOrAssign(MD))
1335         return false;
1336     } else {
1337       // 'static inline' functions are defined in headers; don't warn.
1338       if (FD->isInlined() && !isMainFileLoc(*this, FD->getLocation()))
1339         return false;
1340     }
1341 
1342     if (FD->doesThisDeclarationHaveABody() &&
1343         Context.DeclMustBeEmitted(FD))
1344       return false;
1345   } else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1346     // Constants and utility variables are defined in headers with internal
1347     // linkage; don't warn.  (Unlike functions, there isn't a convenient marker
1348     // like "inline".)
1349     if (!isMainFileLoc(*this, VD->getLocation()))
1350       return false;
1351 
1352     if (Context.DeclMustBeEmitted(VD))
1353       return false;
1354 
1355     if (VD->isStaticDataMember() &&
1356         VD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
1357       return false;
1358   } else {
1359     return false;
1360   }
1361 
1362   // Only warn for unused decls internal to the translation unit.
1363   // FIXME: This seems like a bogus check; it suppresses -Wunused-function
1364   // for inline functions defined in the main source file, for instance.
1365   return mightHaveNonExternalLinkage(D);
1366 }
1367 
1368 void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
1369   if (!D)
1370     return;
1371 
1372   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1373     const FunctionDecl *First = FD->getFirstDecl();
1374     if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1375       return; // First should already be in the vector.
1376   }
1377 
1378   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1379     const VarDecl *First = VD->getFirstDecl();
1380     if (VD != First && ShouldWarnIfUnusedFileScopedDecl(First))
1381       return; // First should already be in the vector.
1382   }
1383 
1384   if (ShouldWarnIfUnusedFileScopedDecl(D))
1385     UnusedFileScopedDecls.push_back(D);
1386 }
1387 
1388 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
1389   if (D->isInvalidDecl())
1390     return false;
1391 
1392   if (D->isReferenced() || D->isUsed() || D->hasAttr<UnusedAttr>() ||
1393       D->hasAttr<ObjCPreciseLifetimeAttr>())
1394     return false;
1395 
1396   if (isa<LabelDecl>(D))
1397     return true;
1398 
1399   // White-list anything that isn't a local variable.
1400   if (!isa<VarDecl>(D) || isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) ||
1401       !D->getDeclContext()->isFunctionOrMethod())
1402     return false;
1403 
1404   // Types of valid local variables should be complete, so this should succeed.
1405   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
1406 
1407     // White-list anything with an __attribute__((unused)) type.
1408     QualType Ty = VD->getType();
1409 
1410     // Only look at the outermost level of typedef.
1411     if (const TypedefType *TT = Ty->getAs<TypedefType>()) {
1412       if (TT->getDecl()->hasAttr<UnusedAttr>())
1413         return false;
1414     }
1415 
1416     // If we failed to complete the type for some reason, or if the type is
1417     // dependent, don't diagnose the variable.
1418     if (Ty->isIncompleteType() || Ty->isDependentType())
1419       return false;
1420 
1421     if (const TagType *TT = Ty->getAs<TagType>()) {
1422       const TagDecl *Tag = TT->getDecl();
1423       if (Tag->hasAttr<UnusedAttr>())
1424         return false;
1425 
1426       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Tag)) {
1427         if (!RD->hasTrivialDestructor() && !RD->hasAttr<WarnUnusedAttr>())
1428           return false;
1429 
1430         if (const Expr *Init = VD->getInit()) {
1431           if (const ExprWithCleanups *Cleanups =
1432                   dyn_cast<ExprWithCleanups>(Init))
1433             Init = Cleanups->getSubExpr();
1434           const CXXConstructExpr *Construct =
1435             dyn_cast<CXXConstructExpr>(Init);
1436           if (Construct && !Construct->isElidable()) {
1437             CXXConstructorDecl *CD = Construct->getConstructor();
1438             if (!CD->isTrivial() && !RD->hasAttr<WarnUnusedAttr>())
1439               return false;
1440           }
1441         }
1442       }
1443     }
1444 
1445     // TODO: __attribute__((unused)) templates?
1446   }
1447 
1448   return true;
1449 }
1450 
1451 static void GenerateFixForUnusedDecl(const NamedDecl *D, ASTContext &Ctx,
1452                                      FixItHint &Hint) {
1453   if (isa<LabelDecl>(D)) {
1454     SourceLocation AfterColon = Lexer::findLocationAfterToken(D->getLocEnd(),
1455                 tok::colon, Ctx.getSourceManager(), Ctx.getLangOpts(), true);
1456     if (AfterColon.isInvalid())
1457       return;
1458     Hint = FixItHint::CreateRemoval(CharSourceRange::
1459                                     getCharRange(D->getLocStart(), AfterColon));
1460   }
1461   return;
1462 }
1463 
1464 /// DiagnoseUnusedDecl - Emit warnings about declarations that are not used
1465 /// unless they are marked attr(unused).
1466 void Sema::DiagnoseUnusedDecl(const NamedDecl *D) {
1467   if (!ShouldDiagnoseUnusedDecl(D))
1468     return;
1469 
1470   FixItHint Hint;
1471   GenerateFixForUnusedDecl(D, Context, Hint);
1472 
1473   unsigned DiagID;
1474   if (isa<VarDecl>(D) && cast<VarDecl>(D)->isExceptionVariable())
1475     DiagID = diag::warn_unused_exception_param;
1476   else if (isa<LabelDecl>(D))
1477     DiagID = diag::warn_unused_label;
1478   else
1479     DiagID = diag::warn_unused_variable;
1480 
1481   Diag(D->getLocation(), DiagID) << D->getDeclName() << Hint;
1482 }
1483 
1484 static void CheckPoppedLabel(LabelDecl *L, Sema &S) {
1485   // Verify that we have no forward references left.  If so, there was a goto
1486   // or address of a label taken, but no definition of it.  Label fwd
1487   // definitions are indicated with a null substmt.
1488   if (L->getStmt() == nullptr)
1489     S.Diag(L->getLocation(), diag::err_undeclared_label_use) <<L->getDeclName();
1490 }
1491 
1492 void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {
1493   S->mergeNRVOIntoParent();
1494 
1495   if (S->decl_empty()) return;
1496   assert((S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) &&
1497          "Scope shouldn't contain decls!");
1498 
1499   for (auto *TmpD : S->decls()) {
1500     assert(TmpD && "This decl didn't get pushed??");
1501 
1502     assert(isa<NamedDecl>(TmpD) && "Decl isn't NamedDecl?");
1503     NamedDecl *D = cast<NamedDecl>(TmpD);
1504 
1505     if (!D->getDeclName()) continue;
1506 
1507     // Diagnose unused variables in this scope.
1508     if (!S->hasUnrecoverableErrorOccurred())
1509       DiagnoseUnusedDecl(D);
1510 
1511     // If this was a forward reference to a label, verify it was defined.
1512     if (LabelDecl *LD = dyn_cast<LabelDecl>(D))
1513       CheckPoppedLabel(LD, *this);
1514 
1515     // Remove this name from our lexical scope.
1516     IdResolver.RemoveDecl(D);
1517   }
1518 }
1519 
1520 /// \brief Look for an Objective-C class in the translation unit.
1521 ///
1522 /// \param Id The name of the Objective-C class we're looking for. If
1523 /// typo-correction fixes this name, the Id will be updated
1524 /// to the fixed name.
1525 ///
1526 /// \param IdLoc The location of the name in the translation unit.
1527 ///
1528 /// \param DoTypoCorrection If true, this routine will attempt typo correction
1529 /// if there is no class with the given name.
1530 ///
1531 /// \returns The declaration of the named Objective-C class, or NULL if the
1532 /// class could not be found.
1533 ObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id,
1534                                               SourceLocation IdLoc,
1535                                               bool DoTypoCorrection) {
1536   // The third "scope" argument is 0 since we aren't enabling lazy built-in
1537   // creation from this context.
1538   NamedDecl *IDecl = LookupSingleName(TUScope, Id, IdLoc, LookupOrdinaryName);
1539 
1540   if (!IDecl && DoTypoCorrection) {
1541     // Perform typo correction at the given location, but only if we
1542     // find an Objective-C class name.
1543     DeclFilterCCC<ObjCInterfaceDecl> Validator;
1544     if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc),
1545                                        LookupOrdinaryName, TUScope, nullptr,
1546                                        Validator, CTK_ErrorRecovery)) {
1547       diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);
1548       IDecl = C.getCorrectionDeclAs<ObjCInterfaceDecl>();
1549       Id = IDecl->getIdentifier();
1550     }
1551   }
1552   ObjCInterfaceDecl *Def = dyn_cast_or_null<ObjCInterfaceDecl>(IDecl);
1553   // This routine must always return a class definition, if any.
1554   if (Def && Def->getDefinition())
1555       Def = Def->getDefinition();
1556   return Def;
1557 }
1558 
1559 /// getNonFieldDeclScope - Retrieves the innermost scope, starting
1560 /// from S, where a non-field would be declared. This routine copes
1561 /// with the difference between C and C++ scoping rules in structs and
1562 /// unions. For example, the following code is well-formed in C but
1563 /// ill-formed in C++:
1564 /// @code
1565 /// struct S6 {
1566 ///   enum { BAR } e;
1567 /// };
1568 ///
1569 /// void test_S6() {
1570 ///   struct S6 a;
1571 ///   a.e = BAR;
1572 /// }
1573 /// @endcode
1574 /// For the declaration of BAR, this routine will return a different
1575 /// scope. The scope S will be the scope of the unnamed enumeration
1576 /// within S6. In C++, this routine will return the scope associated
1577 /// with S6, because the enumeration's scope is a transparent
1578 /// context but structures can contain non-field names. In C, this
1579 /// routine will return the translation unit scope, since the
1580 /// enumeration's scope is a transparent context and structures cannot
1581 /// contain non-field names.
1582 Scope *Sema::getNonFieldDeclScope(Scope *S) {
1583   while (((S->getFlags() & Scope::DeclScope) == 0) ||
1584          (S->getEntity() && S->getEntity()->isTransparentContext()) ||
1585          (S->isClassScope() && !getLangOpts().CPlusPlus))
1586     S = S->getParent();
1587   return S;
1588 }
1589 
1590 /// \brief Looks up the declaration of "struct objc_super" and
1591 /// saves it for later use in building builtin declaration of
1592 /// objc_msgSendSuper and objc_msgSendSuper_stret. If no such
1593 /// pre-existing declaration exists no action takes place.
1594 static void LookupPredefedObjCSuperType(Sema &ThisSema, Scope *S,
1595                                         IdentifierInfo *II) {
1596   if (!II->isStr("objc_msgSendSuper"))
1597     return;
1598   ASTContext &Context = ThisSema.Context;
1599 
1600   LookupResult Result(ThisSema, &Context.Idents.get("objc_super"),
1601                       SourceLocation(), Sema::LookupTagName);
1602   ThisSema.LookupName(Result, S);
1603   if (Result.getResultKind() == LookupResult::Found)
1604     if (const TagDecl *TD = Result.getAsSingle<TagDecl>())
1605       Context.setObjCSuperType(Context.getTagDeclType(TD));
1606 }
1607 
1608 static StringRef getHeaderName(ASTContext::GetBuiltinTypeError Error) {
1609   switch (Error) {
1610   case ASTContext::GE_None:
1611     return "";
1612   case ASTContext::GE_Missing_stdio:
1613     return "stdio.h";
1614   case ASTContext::GE_Missing_setjmp:
1615     return "setjmp.h";
1616   case ASTContext::GE_Missing_ucontext:
1617     return "ucontext.h";
1618   }
1619   llvm_unreachable("unhandled error kind");
1620 }
1621 
1622 /// LazilyCreateBuiltin - The specified Builtin-ID was first used at
1623 /// file scope.  lazily create a decl for it. ForRedeclaration is true
1624 /// if we're creating this built-in in anticipation of redeclaring the
1625 /// built-in.
1626 NamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned bid,
1627                                      Scope *S, bool ForRedeclaration,
1628                                      SourceLocation Loc) {
1629   LookupPredefedObjCSuperType(*this, S, II);
1630 
1631   Builtin::ID BID = (Builtin::ID)bid;
1632 
1633   ASTContext::GetBuiltinTypeError Error;
1634   QualType R = Context.GetBuiltinType(BID, Error);
1635   if (Error) {
1636     if (ForRedeclaration)
1637       Diag(Loc, diag::warn_implicit_decl_requires_sysheader)
1638           << getHeaderName(Error)
1639           << Context.BuiltinInfo.GetName(BID);
1640     return nullptr;
1641   }
1642 
1643   if (!ForRedeclaration && Context.BuiltinInfo.isPredefinedLibFunction(BID)) {
1644     Diag(Loc, diag::ext_implicit_lib_function_decl)
1645       << Context.BuiltinInfo.GetName(BID)
1646       << R;
1647     if (Context.BuiltinInfo.getHeaderName(BID) &&
1648         !Diags.isIgnored(diag::ext_implicit_lib_function_decl, Loc))
1649       Diag(Loc, diag::note_include_header_or_declare)
1650           << Context.BuiltinInfo.getHeaderName(BID)
1651           << Context.BuiltinInfo.GetName(BID);
1652   }
1653 
1654   DeclContext *Parent = Context.getTranslationUnitDecl();
1655   if (getLangOpts().CPlusPlus) {
1656     LinkageSpecDecl *CLinkageDecl =
1657         LinkageSpecDecl::Create(Context, Parent, Loc, Loc,
1658                                 LinkageSpecDecl::lang_c, false);
1659     CLinkageDecl->setImplicit();
1660     Parent->addDecl(CLinkageDecl);
1661     Parent = CLinkageDecl;
1662   }
1663 
1664   FunctionDecl *New = FunctionDecl::Create(Context,
1665                                            Parent,
1666                                            Loc, Loc, II, R, /*TInfo=*/nullptr,
1667                                            SC_Extern,
1668                                            false,
1669                                            /*hasPrototype=*/true);
1670   New->setImplicit();
1671 
1672   // Create Decl objects for each parameter, adding them to the
1673   // FunctionDecl.
1674   if (const FunctionProtoType *FT = dyn_cast<FunctionProtoType>(R)) {
1675     SmallVector<ParmVarDecl*, 16> Params;
1676     for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i) {
1677       ParmVarDecl *parm =
1678           ParmVarDecl::Create(Context, New, SourceLocation(), SourceLocation(),
1679                               nullptr, FT->getParamType(i), /*TInfo=*/nullptr,
1680                               SC_None, nullptr);
1681       parm->setScopeInfo(0, i);
1682       Params.push_back(parm);
1683     }
1684     New->setParams(Params);
1685   }
1686 
1687   AddKnownFunctionAttributes(New);
1688   RegisterLocallyScopedExternCDecl(New, S);
1689 
1690   // TUScope is the translation-unit scope to insert this function into.
1691   // FIXME: This is hideous. We need to teach PushOnScopeChains to
1692   // relate Scopes to DeclContexts, and probably eliminate CurContext
1693   // entirely, but we're not there yet.
1694   DeclContext *SavedContext = CurContext;
1695   CurContext = Parent;
1696   PushOnScopeChains(New, TUScope);
1697   CurContext = SavedContext;
1698   return New;
1699 }
1700 
1701 /// \brief Filter out any previous declarations that the given declaration
1702 /// should not consider because they are not permitted to conflict, e.g.,
1703 /// because they come from hidden sub-modules and do not refer to the same
1704 /// entity.
1705 static void filterNonConflictingPreviousDecls(ASTContext &context,
1706                                               NamedDecl *decl,
1707                                               LookupResult &previous){
1708   // This is only interesting when modules are enabled.
1709   if (!context.getLangOpts().Modules)
1710     return;
1711 
1712   // Empty sets are uninteresting.
1713   if (previous.empty())
1714     return;
1715 
1716   LookupResult::Filter filter = previous.makeFilter();
1717   while (filter.hasNext()) {
1718     NamedDecl *old = filter.next();
1719 
1720     // Non-hidden declarations are never ignored.
1721     if (!old->isHidden())
1722       continue;
1723 
1724     if (!old->isExternallyVisible())
1725       filter.erase();
1726   }
1727 
1728   filter.done();
1729 }
1730 
1731 /// Typedef declarations don't have linkage, but they still denote the same
1732 /// entity if their types are the same.
1733 /// FIXME: This is notionally doing the same thing as ASTReaderDecl's
1734 /// isSameEntity.
1735 static void filterNonConflictingPreviousTypedefDecls(ASTContext &Context,
1736                                                      TypedefNameDecl *Decl,
1737                                                      LookupResult &Previous) {
1738   // This is only interesting when modules are enabled.
1739   if (!Context.getLangOpts().Modules)
1740     return;
1741 
1742   // Empty sets are uninteresting.
1743   if (Previous.empty())
1744     return;
1745 
1746   LookupResult::Filter Filter = Previous.makeFilter();
1747   while (Filter.hasNext()) {
1748     NamedDecl *Old = Filter.next();
1749 
1750     // Non-hidden declarations are never ignored.
1751     if (!Old->isHidden())
1752       continue;
1753 
1754     // Declarations of the same entity are not ignored, even if they have
1755     // different linkages.
1756     if (auto *OldTD = dyn_cast<TypedefNameDecl>(Old))
1757       if (Context.hasSameType(OldTD->getUnderlyingType(),
1758                               Decl->getUnderlyingType()))
1759         continue;
1760 
1761     if (!Old->isExternallyVisible())
1762       Filter.erase();
1763   }
1764 
1765   Filter.done();
1766 }
1767 
1768 bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {
1769   QualType OldType;
1770   if (TypedefNameDecl *OldTypedef = dyn_cast<TypedefNameDecl>(Old))
1771     OldType = OldTypedef->getUnderlyingType();
1772   else
1773     OldType = Context.getTypeDeclType(Old);
1774   QualType NewType = New->getUnderlyingType();
1775 
1776   if (NewType->isVariablyModifiedType()) {
1777     // Must not redefine a typedef with a variably-modified type.
1778     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1779     Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef)
1780       << Kind << NewType;
1781     if (Old->getLocation().isValid())
1782       Diag(Old->getLocation(), diag::note_previous_definition);
1783     New->setInvalidDecl();
1784     return true;
1785   }
1786 
1787   if (OldType != NewType &&
1788       !OldType->isDependentType() &&
1789       !NewType->isDependentType() &&
1790       !Context.hasSameType(OldType, NewType)) {
1791     int Kind = isa<TypeAliasDecl>(Old) ? 1 : 0;
1792     Diag(New->getLocation(), diag::err_redefinition_different_typedef)
1793       << Kind << NewType << OldType;
1794     if (Old->getLocation().isValid())
1795       Diag(Old->getLocation(), diag::note_previous_definition);
1796     New->setInvalidDecl();
1797     return true;
1798   }
1799   return false;
1800 }
1801 
1802 /// MergeTypedefNameDecl - We just parsed a typedef 'New' which has the
1803 /// same name and scope as a previous declaration 'Old'.  Figure out
1804 /// how to resolve this situation, merging decls or emitting
1805 /// diagnostics as appropriate. If there was an error, set New to be invalid.
1806 ///
1807 void Sema::MergeTypedefNameDecl(TypedefNameDecl *New, LookupResult &OldDecls) {
1808   // If the new decl is known invalid already, don't bother doing any
1809   // merging checks.
1810   if (New->isInvalidDecl()) return;
1811 
1812   // Allow multiple definitions for ObjC built-in typedefs.
1813   // FIXME: Verify the underlying types are equivalent!
1814   if (getLangOpts().ObjC1) {
1815     const IdentifierInfo *TypeID = New->getIdentifier();
1816     switch (TypeID->getLength()) {
1817     default: break;
1818     case 2:
1819       {
1820         if (!TypeID->isStr("id"))
1821           break;
1822         QualType T = New->getUnderlyingType();
1823         if (!T->isPointerType())
1824           break;
1825         if (!T->isVoidPointerType()) {
1826           QualType PT = T->getAs<PointerType>()->getPointeeType();
1827           if (!PT->isStructureType())
1828             break;
1829         }
1830         Context.setObjCIdRedefinitionType(T);
1831         // Install the built-in type for 'id', ignoring the current definition.
1832         New->setTypeForDecl(Context.getObjCIdType().getTypePtr());
1833         return;
1834       }
1835     case 5:
1836       if (!TypeID->isStr("Class"))
1837         break;
1838       Context.setObjCClassRedefinitionType(New->getUnderlyingType());
1839       // Install the built-in type for 'Class', ignoring the current definition.
1840       New->setTypeForDecl(Context.getObjCClassType().getTypePtr());
1841       return;
1842     case 3:
1843       if (!TypeID->isStr("SEL"))
1844         break;
1845       Context.setObjCSelRedefinitionType(New->getUnderlyingType());
1846       // Install the built-in type for 'SEL', ignoring the current definition.
1847       New->setTypeForDecl(Context.getObjCSelType().getTypePtr());
1848       return;
1849     }
1850     // Fall through - the typedef name was not a builtin type.
1851   }
1852 
1853   // Verify the old decl was also a type.
1854   TypeDecl *Old = OldDecls.getAsSingle<TypeDecl>();
1855   if (!Old) {
1856     Diag(New->getLocation(), diag::err_redefinition_different_kind)
1857       << New->getDeclName();
1858 
1859     NamedDecl *OldD = OldDecls.getRepresentativeDecl();
1860     if (OldD->getLocation().isValid())
1861       Diag(OldD->getLocation(), diag::note_previous_definition);
1862 
1863     return New->setInvalidDecl();
1864   }
1865 
1866   // If the old declaration is invalid, just give up here.
1867   if (Old->isInvalidDecl())
1868     return New->setInvalidDecl();
1869 
1870   // If the typedef types are not identical, reject them in all languages and
1871   // with any extensions enabled.
1872   if (isIncompatibleTypedef(Old, New))
1873     return;
1874 
1875   // The types match.  Link up the redeclaration chain and merge attributes if
1876   // the old declaration was a typedef.
1877   if (TypedefNameDecl *Typedef = dyn_cast<TypedefNameDecl>(Old)) {
1878     New->setPreviousDecl(Typedef);
1879     mergeDeclAttributes(New, Old);
1880   }
1881 
1882   if (getLangOpts().MicrosoftExt)
1883     return;
1884 
1885   if (getLangOpts().CPlusPlus) {
1886     // C++ [dcl.typedef]p2:
1887     //   In a given non-class scope, a typedef specifier can be used to
1888     //   redefine the name of any type declared in that scope to refer
1889     //   to the type to which it already refers.
1890     if (!isa<CXXRecordDecl>(CurContext))
1891       return;
1892 
1893     // C++0x [dcl.typedef]p4:
1894     //   In a given class scope, a typedef specifier can be used to redefine
1895     //   any class-name declared in that scope that is not also a typedef-name
1896     //   to refer to the type to which it already refers.
1897     //
1898     // This wording came in via DR424, which was a correction to the
1899     // wording in DR56, which accidentally banned code like:
1900     //
1901     //   struct S {
1902     //     typedef struct A { } A;
1903     //   };
1904     //
1905     // in the C++03 standard. We implement the C++0x semantics, which
1906     // allow the above but disallow
1907     //
1908     //   struct S {
1909     //     typedef int I;
1910     //     typedef int I;
1911     //   };
1912     //
1913     // since that was the intent of DR56.
1914     if (!isa<TypedefNameDecl>(Old))
1915       return;
1916 
1917     Diag(New->getLocation(), diag::err_redefinition)
1918       << New->getDeclName();
1919     Diag(Old->getLocation(), diag::note_previous_definition);
1920     return New->setInvalidDecl();
1921   }
1922 
1923   // Modules always permit redefinition of typedefs, as does C11.
1924   if (getLangOpts().Modules || getLangOpts().C11)
1925     return;
1926 
1927   // If we have a redefinition of a typedef in C, emit a warning.  This warning
1928   // is normally mapped to an error, but can be controlled with
1929   // -Wtypedef-redefinition.  If either the original or the redefinition is
1930   // in a system header, don't emit this for compatibility with GCC.
1931   if (getDiagnostics().getSuppressSystemWarnings() &&
1932       (Context.getSourceManager().isInSystemHeader(Old->getLocation()) ||
1933        Context.getSourceManager().isInSystemHeader(New->getLocation())))
1934     return;
1935 
1936   Diag(New->getLocation(), diag::ext_redefinition_of_typedef)
1937     << New->getDeclName();
1938   Diag(Old->getLocation(), diag::note_previous_definition);
1939   return;
1940 }
1941 
1942 /// DeclhasAttr - returns true if decl Declaration already has the target
1943 /// attribute.
1944 static bool DeclHasAttr(const Decl *D, const Attr *A) {
1945   const OwnershipAttr *OA = dyn_cast<OwnershipAttr>(A);
1946   const AnnotateAttr *Ann = dyn_cast<AnnotateAttr>(A);
1947   for (const auto *i : D->attrs())
1948     if (i->getKind() == A->getKind()) {
1949       if (Ann) {
1950         if (Ann->getAnnotation() == cast<AnnotateAttr>(i)->getAnnotation())
1951           return true;
1952         continue;
1953       }
1954       // FIXME: Don't hardcode this check
1955       if (OA && isa<OwnershipAttr>(i))
1956         return OA->getOwnKind() == cast<OwnershipAttr>(i)->getOwnKind();
1957       return true;
1958     }
1959 
1960   return false;
1961 }
1962 
1963 static bool isAttributeTargetADefinition(Decl *D) {
1964   if (VarDecl *VD = dyn_cast<VarDecl>(D))
1965     return VD->isThisDeclarationADefinition();
1966   if (TagDecl *TD = dyn_cast<TagDecl>(D))
1967     return TD->isCompleteDefinition() || TD->isBeingDefined();
1968   return true;
1969 }
1970 
1971 /// Merge alignment attributes from \p Old to \p New, taking into account the
1972 /// special semantics of C11's _Alignas specifier and C++11's alignas attribute.
1973 ///
1974 /// \return \c true if any attributes were added to \p New.
1975 static bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {
1976   // Look for alignas attributes on Old, and pick out whichever attribute
1977   // specifies the strictest alignment requirement.
1978   AlignedAttr *OldAlignasAttr = nullptr;
1979   AlignedAttr *OldStrictestAlignAttr = nullptr;
1980   unsigned OldAlign = 0;
1981   for (auto *I : Old->specific_attrs<AlignedAttr>()) {
1982     // FIXME: We have no way of representing inherited dependent alignments
1983     // in a case like:
1984     //   template<int A, int B> struct alignas(A) X;
1985     //   template<int A, int B> struct alignas(B) X {};
1986     // For now, we just ignore any alignas attributes which are not on the
1987     // definition in such a case.
1988     if (I->isAlignmentDependent())
1989       return false;
1990 
1991     if (I->isAlignas())
1992       OldAlignasAttr = I;
1993 
1994     unsigned Align = I->getAlignment(S.Context);
1995     if (Align > OldAlign) {
1996       OldAlign = Align;
1997       OldStrictestAlignAttr = I;
1998     }
1999   }
2000 
2001   // Look for alignas attributes on New.
2002   AlignedAttr *NewAlignasAttr = nullptr;
2003   unsigned NewAlign = 0;
2004   for (auto *I : New->specific_attrs<AlignedAttr>()) {
2005     if (I->isAlignmentDependent())
2006       return false;
2007 
2008     if (I->isAlignas())
2009       NewAlignasAttr = I;
2010 
2011     unsigned Align = I->getAlignment(S.Context);
2012     if (Align > NewAlign)
2013       NewAlign = Align;
2014   }
2015 
2016   if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {
2017     // Both declarations have 'alignas' attributes. We require them to match.
2018     // C++11 [dcl.align]p6 and C11 6.7.5/7 both come close to saying this, but
2019     // fall short. (If two declarations both have alignas, they must both match
2020     // every definition, and so must match each other if there is a definition.)
2021 
2022     // If either declaration only contains 'alignas(0)' specifiers, then it
2023     // specifies the natural alignment for the type.
2024     if (OldAlign == 0 || NewAlign == 0) {
2025       QualType Ty;
2026       if (ValueDecl *VD = dyn_cast<ValueDecl>(New))
2027         Ty = VD->getType();
2028       else
2029         Ty = S.Context.getTagDeclType(cast<TagDecl>(New));
2030 
2031       if (OldAlign == 0)
2032         OldAlign = S.Context.getTypeAlign(Ty);
2033       if (NewAlign == 0)
2034         NewAlign = S.Context.getTypeAlign(Ty);
2035     }
2036 
2037     if (OldAlign != NewAlign) {
2038       S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch)
2039         << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity()
2040         << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();
2041       S.Diag(OldAlignasAttr->getLocation(), diag::note_previous_declaration);
2042     }
2043   }
2044 
2045   if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {
2046     // C++11 [dcl.align]p6:
2047     //   if any declaration of an entity has an alignment-specifier,
2048     //   every defining declaration of that entity shall specify an
2049     //   equivalent alignment.
2050     // C11 6.7.5/7:
2051     //   If the definition of an object does not have an alignment
2052     //   specifier, any other declaration of that object shall also
2053     //   have no alignment specifier.
2054     S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition)
2055       << OldAlignasAttr;
2056     S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration)
2057       << OldAlignasAttr;
2058   }
2059 
2060   bool AnyAdded = false;
2061 
2062   // Ensure we have an attribute representing the strictest alignment.
2063   if (OldAlign > NewAlign) {
2064     AlignedAttr *Clone = OldStrictestAlignAttr->clone(S.Context);
2065     Clone->setInherited(true);
2066     New->addAttr(Clone);
2067     AnyAdded = true;
2068   }
2069 
2070   // Ensure we have an alignas attribute if the old declaration had one.
2071   if (OldAlignasAttr && !NewAlignasAttr &&
2072       !(AnyAdded && OldStrictestAlignAttr->isAlignas())) {
2073     AlignedAttr *Clone = OldAlignasAttr->clone(S.Context);
2074     Clone->setInherited(true);
2075     New->addAttr(Clone);
2076     AnyAdded = true;
2077   }
2078 
2079   return AnyAdded;
2080 }
2081 
2082 static bool mergeDeclAttribute(Sema &S, NamedDecl *D,
2083                                const InheritableAttr *Attr, bool Override) {
2084   InheritableAttr *NewAttr = nullptr;
2085   unsigned AttrSpellingListIndex = Attr->getSpellingListIndex();
2086   if (const auto *AA = dyn_cast<AvailabilityAttr>(Attr))
2087     NewAttr = S.mergeAvailabilityAttr(D, AA->getRange(), AA->getPlatform(),
2088                                       AA->getIntroduced(), AA->getDeprecated(),
2089                                       AA->getObsoleted(), AA->getUnavailable(),
2090                                       AA->getMessage(), Override,
2091                                       AttrSpellingListIndex);
2092   else if (const auto *VA = dyn_cast<VisibilityAttr>(Attr))
2093     NewAttr = S.mergeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2094                                     AttrSpellingListIndex);
2095   else if (const auto *VA = dyn_cast<TypeVisibilityAttr>(Attr))
2096     NewAttr = S.mergeTypeVisibilityAttr(D, VA->getRange(), VA->getVisibility(),
2097                                         AttrSpellingListIndex);
2098   else if (const auto *ImportA = dyn_cast<DLLImportAttr>(Attr))
2099     NewAttr = S.mergeDLLImportAttr(D, ImportA->getRange(),
2100                                    AttrSpellingListIndex);
2101   else if (const auto *ExportA = dyn_cast<DLLExportAttr>(Attr))
2102     NewAttr = S.mergeDLLExportAttr(D, ExportA->getRange(),
2103                                    AttrSpellingListIndex);
2104   else if (const auto *FA = dyn_cast<FormatAttr>(Attr))
2105     NewAttr = S.mergeFormatAttr(D, FA->getRange(), FA->getType(),
2106                                 FA->getFormatIdx(), FA->getFirstArg(),
2107                                 AttrSpellingListIndex);
2108   else if (const auto *SA = dyn_cast<SectionAttr>(Attr))
2109     NewAttr = S.mergeSectionAttr(D, SA->getRange(), SA->getName(),
2110                                  AttrSpellingListIndex);
2111   else if (const auto *IA = dyn_cast<MSInheritanceAttr>(Attr))
2112     NewAttr = S.mergeMSInheritanceAttr(D, IA->getRange(), IA->getBestCase(),
2113                                        AttrSpellingListIndex,
2114                                        IA->getSemanticSpelling());
2115   else if (isa<AlignedAttr>(Attr))
2116     // AlignedAttrs are handled separately, because we need to handle all
2117     // such attributes on a declaration at the same time.
2118     NewAttr = nullptr;
2119   else if (isa<DeprecatedAttr>(Attr) && Override)
2120     NewAttr = nullptr;
2121   else if (Attr->duplicatesAllowed() || !DeclHasAttr(D, Attr))
2122     NewAttr = cast<InheritableAttr>(Attr->clone(S.Context));
2123 
2124   if (NewAttr) {
2125     NewAttr->setInherited(true);
2126     D->addAttr(NewAttr);
2127     return true;
2128   }
2129 
2130   return false;
2131 }
2132 
2133 static const Decl *getDefinition(const Decl *D) {
2134   if (const TagDecl *TD = dyn_cast<TagDecl>(D))
2135     return TD->getDefinition();
2136   if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
2137     const VarDecl *Def = VD->getDefinition();
2138     if (Def)
2139       return Def;
2140     return VD->getActingDefinition();
2141   }
2142   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
2143     const FunctionDecl* Def;
2144     if (FD->isDefined(Def))
2145       return Def;
2146   }
2147   return nullptr;
2148 }
2149 
2150 static bool hasAttribute(const Decl *D, attr::Kind Kind) {
2151   for (const auto *Attribute : D->attrs())
2152     if (Attribute->getKind() == Kind)
2153       return true;
2154   return false;
2155 }
2156 
2157 /// checkNewAttributesAfterDef - If we already have a definition, check that
2158 /// there are no new attributes in this declaration.
2159 static void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {
2160   if (!New->hasAttrs())
2161     return;
2162 
2163   const Decl *Def = getDefinition(Old);
2164   if (!Def || Def == New)
2165     return;
2166 
2167   AttrVec &NewAttributes = New->getAttrs();
2168   for (unsigned I = 0, E = NewAttributes.size(); I != E;) {
2169     const Attr *NewAttribute = NewAttributes[I];
2170 
2171     if (isa<AliasAttr>(NewAttribute)) {
2172       if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New))
2173         S.CheckForFunctionRedefinition(FD, cast<FunctionDecl>(Def));
2174       else {
2175         VarDecl *VD = cast<VarDecl>(New);
2176         unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() ==
2177                                 VarDecl::TentativeDefinition
2178                             ? diag::err_alias_after_tentative
2179                             : diag::err_redefinition;
2180         S.Diag(VD->getLocation(), Diag) << VD->getDeclName();
2181         S.Diag(Def->getLocation(), diag::note_previous_definition);
2182         VD->setInvalidDecl();
2183       }
2184       ++I;
2185       continue;
2186     }
2187 
2188     if (const VarDecl *VD = dyn_cast<VarDecl>(Def)) {
2189       // Tentative definitions are only interesting for the alias check above.
2190       if (VD->isThisDeclarationADefinition() != VarDecl::Definition) {
2191         ++I;
2192         continue;
2193       }
2194     }
2195 
2196     if (hasAttribute(Def, NewAttribute->getKind())) {
2197       ++I;
2198       continue; // regular attr merging will take care of validating this.
2199     }
2200 
2201     if (isa<C11NoReturnAttr>(NewAttribute)) {
2202       // C's _Noreturn is allowed to be added to a function after it is defined.
2203       ++I;
2204       continue;
2205     } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {
2206       if (AA->isAlignas()) {
2207         // C++11 [dcl.align]p6:
2208         //   if any declaration of an entity has an alignment-specifier,
2209         //   every defining declaration of that entity shall specify an
2210         //   equivalent alignment.
2211         // C11 6.7.5/7:
2212         //   If the definition of an object does not have an alignment
2213         //   specifier, any other declaration of that object shall also
2214         //   have no alignment specifier.
2215         S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition)
2216           << AA;
2217         S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration)
2218           << AA;
2219         NewAttributes.erase(NewAttributes.begin() + I);
2220         --E;
2221         continue;
2222       }
2223     }
2224 
2225     S.Diag(NewAttribute->getLocation(),
2226            diag::warn_attribute_precede_definition);
2227     S.Diag(Def->getLocation(), diag::note_previous_definition);
2228     NewAttributes.erase(NewAttributes.begin() + I);
2229     --E;
2230   }
2231 }
2232 
2233 /// mergeDeclAttributes - Copy attributes from the Old decl to the New one.
2234 void Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old,
2235                                AvailabilityMergeKind AMK) {
2236   if (UsedAttr *OldAttr = Old->getMostRecentDecl()->getAttr<UsedAttr>()) {
2237     UsedAttr *NewAttr = OldAttr->clone(Context);
2238     NewAttr->setInherited(true);
2239     New->addAttr(NewAttr);
2240   }
2241 
2242   if (!Old->hasAttrs() && !New->hasAttrs())
2243     return;
2244 
2245   // attributes declared post-definition are currently ignored
2246   checkNewAttributesAfterDef(*this, New, Old);
2247 
2248   if (!Old->hasAttrs())
2249     return;
2250 
2251   bool foundAny = New->hasAttrs();
2252 
2253   // Ensure that any moving of objects within the allocated map is done before
2254   // we process them.
2255   if (!foundAny) New->setAttrs(AttrVec());
2256 
2257   for (auto *I : Old->specific_attrs<InheritableAttr>()) {
2258     bool Override = false;
2259     // Ignore deprecated/unavailable/availability attributes if requested.
2260     if (isa<DeprecatedAttr>(I) ||
2261         isa<UnavailableAttr>(I) ||
2262         isa<AvailabilityAttr>(I)) {
2263       switch (AMK) {
2264       case AMK_None:
2265         continue;
2266 
2267       case AMK_Redeclaration:
2268         break;
2269 
2270       case AMK_Override:
2271         Override = true;
2272         break;
2273       }
2274     }
2275 
2276     // Already handled.
2277     if (isa<UsedAttr>(I))
2278       continue;
2279 
2280     if (mergeDeclAttribute(*this, New, I, Override))
2281       foundAny = true;
2282   }
2283 
2284   if (mergeAlignedAttrs(*this, New, Old))
2285     foundAny = true;
2286 
2287   if (!foundAny) New->dropAttrs();
2288 }
2289 
2290 /// mergeParamDeclAttributes - Copy attributes from the old parameter
2291 /// to the new one.
2292 static void mergeParamDeclAttributes(ParmVarDecl *newDecl,
2293                                      const ParmVarDecl *oldDecl,
2294                                      Sema &S) {
2295   // C++11 [dcl.attr.depend]p2:
2296   //   The first declaration of a function shall specify the
2297   //   carries_dependency attribute for its declarator-id if any declaration
2298   //   of the function specifies the carries_dependency attribute.
2299   const CarriesDependencyAttr *CDA = newDecl->getAttr<CarriesDependencyAttr>();
2300   if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {
2301     S.Diag(CDA->getLocation(),
2302            diag::err_carries_dependency_missing_on_first_decl) << 1/*Param*/;
2303     // Find the first declaration of the parameter.
2304     // FIXME: Should we build redeclaration chains for function parameters?
2305     const FunctionDecl *FirstFD =
2306       cast<FunctionDecl>(oldDecl->getDeclContext())->getFirstDecl();
2307     const ParmVarDecl *FirstVD =
2308       FirstFD->getParamDecl(oldDecl->getFunctionScopeIndex());
2309     S.Diag(FirstVD->getLocation(),
2310            diag::note_carries_dependency_missing_first_decl) << 1/*Param*/;
2311   }
2312 
2313   if (!oldDecl->hasAttrs())
2314     return;
2315 
2316   bool foundAny = newDecl->hasAttrs();
2317 
2318   // Ensure that any moving of objects within the allocated map is
2319   // done before we process them.
2320   if (!foundAny) newDecl->setAttrs(AttrVec());
2321 
2322   for (const auto *I : oldDecl->specific_attrs<InheritableParamAttr>()) {
2323     if (!DeclHasAttr(newDecl, I)) {
2324       InheritableAttr *newAttr =
2325         cast<InheritableParamAttr>(I->clone(S.Context));
2326       newAttr->setInherited(true);
2327       newDecl->addAttr(newAttr);
2328       foundAny = true;
2329     }
2330   }
2331 
2332   if (!foundAny) newDecl->dropAttrs();
2333 }
2334 
2335 namespace {
2336 
2337 /// Used in MergeFunctionDecl to keep track of function parameters in
2338 /// C.
2339 struct GNUCompatibleParamWarning {
2340   ParmVarDecl *OldParm;
2341   ParmVarDecl *NewParm;
2342   QualType PromotedType;
2343 };
2344 
2345 }
2346 
2347 /// getSpecialMember - get the special member enum for a method.
2348 Sema::CXXSpecialMember Sema::getSpecialMember(const CXXMethodDecl *MD) {
2349   if (const CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(MD)) {
2350     if (Ctor->isDefaultConstructor())
2351       return Sema::CXXDefaultConstructor;
2352 
2353     if (Ctor->isCopyConstructor())
2354       return Sema::CXXCopyConstructor;
2355 
2356     if (Ctor->isMoveConstructor())
2357       return Sema::CXXMoveConstructor;
2358   } else if (isa<CXXDestructorDecl>(MD)) {
2359     return Sema::CXXDestructor;
2360   } else if (MD->isCopyAssignmentOperator()) {
2361     return Sema::CXXCopyAssignment;
2362   } else if (MD->isMoveAssignmentOperator()) {
2363     return Sema::CXXMoveAssignment;
2364   }
2365 
2366   return Sema::CXXInvalid;
2367 }
2368 
2369 // Determine whether the previous declaration was a definition, implicit
2370 // declaration, or a declaration.
2371 template <typename T>
2372 static std::pair<diag::kind, SourceLocation>
2373 getNoteDiagForInvalidRedeclaration(const T *Old, const T *New) {
2374   diag::kind PrevDiag;
2375   SourceLocation OldLocation = Old->getLocation();
2376   if (Old->isThisDeclarationADefinition())
2377     PrevDiag = diag::note_previous_definition;
2378   else if (Old->isImplicit()) {
2379     PrevDiag = diag::note_previous_implicit_declaration;
2380     if (OldLocation.isInvalid())
2381       OldLocation = New->getLocation();
2382   } else
2383     PrevDiag = diag::note_previous_declaration;
2384   return std::make_pair(PrevDiag, OldLocation);
2385 }
2386 
2387 /// canRedefineFunction - checks if a function can be redefined. Currently,
2388 /// only extern inline functions can be redefined, and even then only in
2389 /// GNU89 mode.
2390 static bool canRedefineFunction(const FunctionDecl *FD,
2391                                 const LangOptions& LangOpts) {
2392   return ((FD->hasAttr<GNUInlineAttr>() || LangOpts.GNUInline) &&
2393           !LangOpts.CPlusPlus &&
2394           FD->isInlineSpecified() &&
2395           FD->getStorageClass() == SC_Extern);
2396 }
2397 
2398 const AttributedType *Sema::getCallingConvAttributedType(QualType T) const {
2399   const AttributedType *AT = T->getAs<AttributedType>();
2400   while (AT && !AT->isCallingConv())
2401     AT = AT->getModifiedType()->getAs<AttributedType>();
2402   return AT;
2403 }
2404 
2405 template <typename T>
2406 static bool haveIncompatibleLanguageLinkages(const T *Old, const T *New) {
2407   const DeclContext *DC = Old->getDeclContext();
2408   if (DC->isRecord())
2409     return false;
2410 
2411   LanguageLinkage OldLinkage = Old->getLanguageLinkage();
2412   if (OldLinkage == CXXLanguageLinkage && New->isInExternCContext())
2413     return true;
2414   if (OldLinkage == CLanguageLinkage && New->isInExternCXXContext())
2415     return true;
2416   return false;
2417 }
2418 
2419 /// MergeFunctionDecl - We just parsed a function 'New' from
2420 /// declarator D which has the same name and scope as a previous
2421 /// declaration 'Old'.  Figure out how to resolve this situation,
2422 /// merging decls or emitting diagnostics as appropriate.
2423 ///
2424 /// In C++, New and Old must be declarations that are not
2425 /// overloaded. Use IsOverload to determine whether New and Old are
2426 /// overloaded, and to select the Old declaration that New should be
2427 /// merged with.
2428 ///
2429 /// Returns true if there was an error, false otherwise.
2430 bool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD,
2431                              Scope *S, bool MergeTypeWithOld) {
2432   // Verify the old decl was also a function.
2433   FunctionDecl *Old = OldD->getAsFunction();
2434   if (!Old) {
2435     if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {
2436       if (New->getFriendObjectKind()) {
2437         Diag(New->getLocation(), diag::err_using_decl_friend);
2438         Diag(Shadow->getTargetDecl()->getLocation(),
2439              diag::note_using_decl_target);
2440         Diag(Shadow->getUsingDecl()->getLocation(),
2441              diag::note_using_decl) << 0;
2442         return true;
2443       }
2444 
2445       // C++11 [namespace.udecl]p14:
2446       //   If a function declaration in namespace scope or block scope has the
2447       //   same name and the same parameter-type-list as a function introduced
2448       //   by a using-declaration, and the declarations do not declare the same
2449       //   function, the program is ill-formed.
2450 
2451       // Check whether the two declarations might declare the same function.
2452       Old = dyn_cast<FunctionDecl>(Shadow->getTargetDecl());
2453       if (Old &&
2454           !Old->getDeclContext()->getRedeclContext()->Equals(
2455               New->getDeclContext()->getRedeclContext()) &&
2456           !(Old->isExternC() && New->isExternC()))
2457         Old = nullptr;
2458 
2459       if (!Old) {
2460         Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);
2461         Diag(Shadow->getTargetDecl()->getLocation(),
2462              diag::note_using_decl_target);
2463         Diag(Shadow->getUsingDecl()->getLocation(), diag::note_using_decl) << 0;
2464         return true;
2465       }
2466       OldD = Old;
2467     } else {
2468       Diag(New->getLocation(), diag::err_redefinition_different_kind)
2469         << New->getDeclName();
2470       Diag(OldD->getLocation(), diag::note_previous_definition);
2471       return true;
2472     }
2473   }
2474 
2475   // If the old declaration is invalid, just give up here.
2476   if (Old->isInvalidDecl())
2477     return true;
2478 
2479   diag::kind PrevDiag;
2480   SourceLocation OldLocation;
2481   std::tie(PrevDiag, OldLocation) =
2482       getNoteDiagForInvalidRedeclaration(Old, New);
2483 
2484   // Don't complain about this if we're in GNU89 mode and the old function
2485   // is an extern inline function.
2486   // Don't complain about specializations. They are not supposed to have
2487   // storage classes.
2488   if (!isa<CXXMethodDecl>(New) && !isa<CXXMethodDecl>(Old) &&
2489       New->getStorageClass() == SC_Static &&
2490       Old->hasExternalFormalLinkage() &&
2491       !New->getTemplateSpecializationInfo() &&
2492       !canRedefineFunction(Old, getLangOpts())) {
2493     if (getLangOpts().MicrosoftExt) {
2494       Diag(New->getLocation(), diag::ext_static_non_static) << New;
2495       Diag(OldLocation, PrevDiag);
2496     } else {
2497       Diag(New->getLocation(), diag::err_static_non_static) << New;
2498       Diag(OldLocation, PrevDiag);
2499       return true;
2500     }
2501   }
2502 
2503 
2504   // If a function is first declared with a calling convention, but is later
2505   // declared or defined without one, all following decls assume the calling
2506   // convention of the first.
2507   //
2508   // It's OK if a function is first declared without a calling convention,
2509   // but is later declared or defined with the default calling convention.
2510   //
2511   // To test if either decl has an explicit calling convention, we look for
2512   // AttributedType sugar nodes on the type as written.  If they are missing or
2513   // were canonicalized away, we assume the calling convention was implicit.
2514   //
2515   // Note also that we DO NOT return at this point, because we still have
2516   // other tests to run.
2517   QualType OldQType = Context.getCanonicalType(Old->getType());
2518   QualType NewQType = Context.getCanonicalType(New->getType());
2519   const FunctionType *OldType = cast<FunctionType>(OldQType);
2520   const FunctionType *NewType = cast<FunctionType>(NewQType);
2521   FunctionType::ExtInfo OldTypeInfo = OldType->getExtInfo();
2522   FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
2523   bool RequiresAdjustment = false;
2524 
2525   if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {
2526     FunctionDecl *First = Old->getFirstDecl();
2527     const FunctionType *FT =
2528         First->getType().getCanonicalType()->castAs<FunctionType>();
2529     FunctionType::ExtInfo FI = FT->getExtInfo();
2530     bool NewCCExplicit = getCallingConvAttributedType(New->getType());
2531     if (!NewCCExplicit) {
2532       // Inherit the CC from the previous declaration if it was specified
2533       // there but not here.
2534       NewTypeInfo = NewTypeInfo.withCallingConv(OldTypeInfo.getCC());
2535       RequiresAdjustment = true;
2536     } else {
2537       // Calling conventions aren't compatible, so complain.
2538       bool FirstCCExplicit = getCallingConvAttributedType(First->getType());
2539       Diag(New->getLocation(), diag::err_cconv_change)
2540         << FunctionType::getNameForCallConv(NewTypeInfo.getCC())
2541         << !FirstCCExplicit
2542         << (!FirstCCExplicit ? "" :
2543             FunctionType::getNameForCallConv(FI.getCC()));
2544 
2545       // Put the note on the first decl, since it is the one that matters.
2546       Diag(First->getLocation(), diag::note_previous_declaration);
2547       return true;
2548     }
2549   }
2550 
2551   // FIXME: diagnose the other way around?
2552   if (OldTypeInfo.getNoReturn() && !NewTypeInfo.getNoReturn()) {
2553     NewTypeInfo = NewTypeInfo.withNoReturn(true);
2554     RequiresAdjustment = true;
2555   }
2556 
2557   // Merge regparm attribute.
2558   if (OldTypeInfo.getHasRegParm() != NewTypeInfo.getHasRegParm() ||
2559       OldTypeInfo.getRegParm() != NewTypeInfo.getRegParm()) {
2560     if (NewTypeInfo.getHasRegParm()) {
2561       Diag(New->getLocation(), diag::err_regparm_mismatch)
2562         << NewType->getRegParmType()
2563         << OldType->getRegParmType();
2564       Diag(OldLocation, diag::note_previous_declaration);
2565       return true;
2566     }
2567 
2568     NewTypeInfo = NewTypeInfo.withRegParm(OldTypeInfo.getRegParm());
2569     RequiresAdjustment = true;
2570   }
2571 
2572   // Merge ns_returns_retained attribute.
2573   if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {
2574     if (NewTypeInfo.getProducesResult()) {
2575       Diag(New->getLocation(), diag::err_returns_retained_mismatch);
2576       Diag(OldLocation, diag::note_previous_declaration);
2577       return true;
2578     }
2579 
2580     NewTypeInfo = NewTypeInfo.withProducesResult(true);
2581     RequiresAdjustment = true;
2582   }
2583 
2584   if (RequiresAdjustment) {
2585     const FunctionType *AdjustedType = New->getType()->getAs<FunctionType>();
2586     AdjustedType = Context.adjustFunctionType(AdjustedType, NewTypeInfo);
2587     New->setType(QualType(AdjustedType, 0));
2588     NewQType = Context.getCanonicalType(New->getType());
2589     NewType = cast<FunctionType>(NewQType);
2590   }
2591 
2592   // If this redeclaration makes the function inline, we may need to add it to
2593   // UndefinedButUsed.
2594   if (!Old->isInlined() && New->isInlined() &&
2595       !New->hasAttr<GNUInlineAttr>() &&
2596       (getLangOpts().CPlusPlus || !getLangOpts().GNUInline) &&
2597       Old->isUsed(false) &&
2598       !Old->isDefined() && !New->isThisDeclarationADefinition())
2599     UndefinedButUsed.insert(std::make_pair(Old->getCanonicalDecl(),
2600                                            SourceLocation()));
2601 
2602   // If this redeclaration makes it newly gnu_inline, we don't want to warn
2603   // about it.
2604   if (New->hasAttr<GNUInlineAttr>() &&
2605       Old->isInlined() && !Old->hasAttr<GNUInlineAttr>()) {
2606     UndefinedButUsed.erase(Old->getCanonicalDecl());
2607   }
2608 
2609   if (getLangOpts().CPlusPlus) {
2610     // (C++98 13.1p2):
2611     //   Certain function declarations cannot be overloaded:
2612     //     -- Function declarations that differ only in the return type
2613     //        cannot be overloaded.
2614 
2615     // Go back to the type source info to compare the declared return types,
2616     // per C++1y [dcl.type.auto]p13:
2617     //   Redeclarations or specializations of a function or function template
2618     //   with a declared return type that uses a placeholder type shall also
2619     //   use that placeholder, not a deduced type.
2620     QualType OldDeclaredReturnType =
2621         (Old->getTypeSourceInfo()
2622              ? Old->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2623              : OldType)->getReturnType();
2624     QualType NewDeclaredReturnType =
2625         (New->getTypeSourceInfo()
2626              ? New->getTypeSourceInfo()->getType()->castAs<FunctionType>()
2627              : NewType)->getReturnType();
2628     QualType ResQT;
2629     if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) &&
2630         !((NewQType->isDependentType() || OldQType->isDependentType()) &&
2631           New->isLocalExternDecl())) {
2632       if (NewDeclaredReturnType->isObjCObjectPointerType() &&
2633           OldDeclaredReturnType->isObjCObjectPointerType())
2634         ResQT = Context.mergeObjCGCQualifiers(NewQType, OldQType);
2635       if (ResQT.isNull()) {
2636         if (New->isCXXClassMember() && New->isOutOfLine())
2637           Diag(New->getLocation(), diag::err_member_def_does_not_match_ret_type)
2638               << New << New->getReturnTypeSourceRange();
2639         else
2640           Diag(New->getLocation(), diag::err_ovl_diff_return_type)
2641               << New->getReturnTypeSourceRange();
2642         Diag(OldLocation, PrevDiag) << Old << Old->getType()
2643                                     << Old->getReturnTypeSourceRange();
2644         return true;
2645       }
2646       else
2647         NewQType = ResQT;
2648     }
2649 
2650     QualType OldReturnType = OldType->getReturnType();
2651     QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
2652     if (OldReturnType != NewReturnType) {
2653       // If this function has a deduced return type and has already been
2654       // defined, copy the deduced value from the old declaration.
2655       AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
2656       if (OldAT && OldAT->isDeduced()) {
2657         New->setType(
2658             SubstAutoType(New->getType(),
2659                           OldAT->isDependentType() ? Context.DependentTy
2660                                                    : OldAT->getDeducedType()));
2661         NewQType = Context.getCanonicalType(
2662             SubstAutoType(NewQType,
2663                           OldAT->isDependentType() ? Context.DependentTy
2664                                                    : OldAT->getDeducedType()));
2665       }
2666     }
2667 
2668     const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
2669     CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
2670     if (OldMethod && NewMethod) {
2671       // Preserve triviality.
2672       NewMethod->setTrivial(OldMethod->isTrivial());
2673 
2674       // MSVC allows explicit template specialization at class scope:
2675       // 2 CXXMethodDecls referring to the same function will be injected.
2676       // We don't want a redeclaration error.
2677       bool IsClassScopeExplicitSpecialization =
2678                               OldMethod->isFunctionTemplateSpecialization() &&
2679                               NewMethod->isFunctionTemplateSpecialization();
2680       bool isFriend = NewMethod->getFriendObjectKind();
2681 
2682       if (!isFriend && NewMethod->getLexicalDeclContext()->isRecord() &&
2683           !IsClassScopeExplicitSpecialization) {
2684         //    -- Member function declarations with the same name and the
2685         //       same parameter types cannot be overloaded if any of them
2686         //       is a static member function declaration.
2687         if (OldMethod->isStatic() != NewMethod->isStatic()) {
2688           Diag(New->getLocation(), diag::err_ovl_static_nonstatic_member);
2689           Diag(OldLocation, PrevDiag) << Old << Old->getType();
2690           return true;
2691         }
2692 
2693         // C++ [class.mem]p1:
2694         //   [...] A member shall not be declared twice in the
2695         //   member-specification, except that a nested class or member
2696         //   class template can be declared and then later defined.
2697         if (ActiveTemplateInstantiations.empty()) {
2698           unsigned NewDiag;
2699           if (isa<CXXConstructorDecl>(OldMethod))
2700             NewDiag = diag::err_constructor_redeclared;
2701           else if (isa<CXXDestructorDecl>(NewMethod))
2702             NewDiag = diag::err_destructor_redeclared;
2703           else if (isa<CXXConversionDecl>(NewMethod))
2704             NewDiag = diag::err_conv_function_redeclared;
2705           else
2706             NewDiag = diag::err_member_redeclared;
2707 
2708           Diag(New->getLocation(), NewDiag);
2709         } else {
2710           Diag(New->getLocation(), diag::err_member_redeclared_in_instantiation)
2711             << New << New->getType();
2712         }
2713         Diag(OldLocation, PrevDiag) << Old << Old->getType();
2714 
2715       // Complain if this is an explicit declaration of a special
2716       // member that was initially declared implicitly.
2717       //
2718       // As an exception, it's okay to befriend such methods in order
2719       // to permit the implicit constructor/destructor/operator calls.
2720       } else if (OldMethod->isImplicit()) {
2721         if (isFriend) {
2722           NewMethod->setImplicit();
2723         } else {
2724           Diag(NewMethod->getLocation(),
2725                diag::err_definition_of_implicitly_declared_member)
2726             << New << getSpecialMember(OldMethod);
2727           return true;
2728         }
2729       } else if (OldMethod->isExplicitlyDefaulted() && !isFriend) {
2730         Diag(NewMethod->getLocation(),
2731              diag::err_definition_of_explicitly_defaulted_member)
2732           << getSpecialMember(OldMethod);
2733         return true;
2734       }
2735     }
2736 
2737     // C++11 [dcl.attr.noreturn]p1:
2738     //   The first declaration of a function shall specify the noreturn
2739     //   attribute if any declaration of that function specifies the noreturn
2740     //   attribute.
2741     const CXX11NoReturnAttr *NRA = New->getAttr<CXX11NoReturnAttr>();
2742     if (NRA && !Old->hasAttr<CXX11NoReturnAttr>()) {
2743       Diag(NRA->getLocation(), diag::err_noreturn_missing_on_first_decl);
2744       Diag(Old->getFirstDecl()->getLocation(),
2745            diag::note_noreturn_missing_first_decl);
2746     }
2747 
2748     // C++11 [dcl.attr.depend]p2:
2749     //   The first declaration of a function shall specify the
2750     //   carries_dependency attribute for its declarator-id if any declaration
2751     //   of the function specifies the carries_dependency attribute.
2752     const CarriesDependencyAttr *CDA = New->getAttr<CarriesDependencyAttr>();
2753     if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {
2754       Diag(CDA->getLocation(),
2755            diag::err_carries_dependency_missing_on_first_decl) << 0/*Function*/;
2756       Diag(Old->getFirstDecl()->getLocation(),
2757            diag::note_carries_dependency_missing_first_decl) << 0/*Function*/;
2758     }
2759 
2760     // (C++98 8.3.5p3):
2761     //   All declarations for a function shall agree exactly in both the
2762     //   return type and the parameter-type-list.
2763     // We also want to respect all the extended bits except noreturn.
2764 
2765     // noreturn should now match unless the old type info didn't have it.
2766     QualType OldQTypeForComparison = OldQType;
2767     if (!OldTypeInfo.getNoReturn() && NewTypeInfo.getNoReturn()) {
2768       assert(OldQType == QualType(OldType, 0));
2769       const FunctionType *OldTypeForComparison
2770         = Context.adjustFunctionType(OldType, OldTypeInfo.withNoReturn(true));
2771       OldQTypeForComparison = QualType(OldTypeForComparison, 0);
2772       assert(OldQTypeForComparison.isCanonical());
2773     }
2774 
2775     if (haveIncompatibleLanguageLinkages(Old, New)) {
2776       // As a special case, retain the language linkage from previous
2777       // declarations of a friend function as an extension.
2778       //
2779       // This liberal interpretation of C++ [class.friend]p3 matches GCC/MSVC
2780       // and is useful because there's otherwise no way to specify language
2781       // linkage within class scope.
2782       //
2783       // Check cautiously as the friend object kind isn't yet complete.
2784       if (New->getFriendObjectKind() != Decl::FOK_None) {
2785         Diag(New->getLocation(), diag::ext_retained_language_linkage) << New;
2786         Diag(OldLocation, PrevDiag);
2787       } else {
2788         Diag(New->getLocation(), diag::err_different_language_linkage) << New;
2789         Diag(OldLocation, PrevDiag);
2790         return true;
2791       }
2792     }
2793 
2794     if (OldQTypeForComparison == NewQType)
2795       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2796 
2797     if ((NewQType->isDependentType() || OldQType->isDependentType()) &&
2798         New->isLocalExternDecl()) {
2799       // It's OK if we couldn't merge types for a local function declaraton
2800       // if either the old or new type is dependent. We'll merge the types
2801       // when we instantiate the function.
2802       return false;
2803     }
2804 
2805     // Fall through for conflicting redeclarations and redefinitions.
2806   }
2807 
2808   // C: Function types need to be compatible, not identical. This handles
2809   // duplicate function decls like "void f(int); void f(enum X);" properly.
2810   if (!getLangOpts().CPlusPlus &&
2811       Context.typesAreCompatible(OldQType, NewQType)) {
2812     const FunctionType *OldFuncType = OldQType->getAs<FunctionType>();
2813     const FunctionType *NewFuncType = NewQType->getAs<FunctionType>();
2814     const FunctionProtoType *OldProto = nullptr;
2815     if (MergeTypeWithOld && isa<FunctionNoProtoType>(NewFuncType) &&
2816         (OldProto = dyn_cast<FunctionProtoType>(OldFuncType))) {
2817       // The old declaration provided a function prototype, but the
2818       // new declaration does not. Merge in the prototype.
2819       assert(!OldProto->hasExceptionSpec() && "Exception spec in C");
2820       SmallVector<QualType, 16> ParamTypes(OldProto->param_types());
2821       NewQType =
2822           Context.getFunctionType(NewFuncType->getReturnType(), ParamTypes,
2823                                   OldProto->getExtProtoInfo());
2824       New->setType(NewQType);
2825       New->setHasInheritedPrototype();
2826 
2827       // Synthesize parameters with the same types.
2828       SmallVector<ParmVarDecl*, 16> Params;
2829       for (const auto &ParamType : OldProto->param_types()) {
2830         ParmVarDecl *Param = ParmVarDecl::Create(Context, New, SourceLocation(),
2831                                                  SourceLocation(), nullptr,
2832                                                  ParamType, /*TInfo=*/nullptr,
2833                                                  SC_None, nullptr);
2834         Param->setScopeInfo(0, Params.size());
2835         Param->setImplicit();
2836         Params.push_back(Param);
2837       }
2838 
2839       New->setParams(Params);
2840     }
2841 
2842     return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2843   }
2844 
2845   // GNU C permits a K&R definition to follow a prototype declaration
2846   // if the declared types of the parameters in the K&R definition
2847   // match the types in the prototype declaration, even when the
2848   // promoted types of the parameters from the K&R definition differ
2849   // from the types in the prototype. GCC then keeps the types from
2850   // the prototype.
2851   //
2852   // If a variadic prototype is followed by a non-variadic K&R definition,
2853   // the K&R definition becomes variadic.  This is sort of an edge case, but
2854   // it's legal per the standard depending on how you read C99 6.7.5.3p15 and
2855   // C99 6.9.1p8.
2856   if (!getLangOpts().CPlusPlus &&
2857       Old->hasPrototype() && !New->hasPrototype() &&
2858       New->getType()->getAs<FunctionProtoType>() &&
2859       Old->getNumParams() == New->getNumParams()) {
2860     SmallVector<QualType, 16> ArgTypes;
2861     SmallVector<GNUCompatibleParamWarning, 16> Warnings;
2862     const FunctionProtoType *OldProto
2863       = Old->getType()->getAs<FunctionProtoType>();
2864     const FunctionProtoType *NewProto
2865       = New->getType()->getAs<FunctionProtoType>();
2866 
2867     // Determine whether this is the GNU C extension.
2868     QualType MergedReturn = Context.mergeTypes(OldProto->getReturnType(),
2869                                                NewProto->getReturnType());
2870     bool LooseCompatible = !MergedReturn.isNull();
2871     for (unsigned Idx = 0, End = Old->getNumParams();
2872          LooseCompatible && Idx != End; ++Idx) {
2873       ParmVarDecl *OldParm = Old->getParamDecl(Idx);
2874       ParmVarDecl *NewParm = New->getParamDecl(Idx);
2875       if (Context.typesAreCompatible(OldParm->getType(),
2876                                      NewProto->getParamType(Idx))) {
2877         ArgTypes.push_back(NewParm->getType());
2878       } else if (Context.typesAreCompatible(OldParm->getType(),
2879                                             NewParm->getType(),
2880                                             /*CompareUnqualified=*/true)) {
2881         GNUCompatibleParamWarning Warn = { OldParm, NewParm,
2882                                            NewProto->getParamType(Idx) };
2883         Warnings.push_back(Warn);
2884         ArgTypes.push_back(NewParm->getType());
2885       } else
2886         LooseCompatible = false;
2887     }
2888 
2889     if (LooseCompatible) {
2890       for (unsigned Warn = 0; Warn < Warnings.size(); ++Warn) {
2891         Diag(Warnings[Warn].NewParm->getLocation(),
2892              diag::ext_param_promoted_not_compatible_with_prototype)
2893           << Warnings[Warn].PromotedType
2894           << Warnings[Warn].OldParm->getType();
2895         if (Warnings[Warn].OldParm->getLocation().isValid())
2896           Diag(Warnings[Warn].OldParm->getLocation(),
2897                diag::note_previous_declaration);
2898       }
2899 
2900       if (MergeTypeWithOld)
2901         New->setType(Context.getFunctionType(MergedReturn, ArgTypes,
2902                                              OldProto->getExtProtoInfo()));
2903       return MergeCompatibleFunctionDecls(New, Old, S, MergeTypeWithOld);
2904     }
2905 
2906     // Fall through to diagnose conflicting types.
2907   }
2908 
2909   // A function that has already been declared has been redeclared or
2910   // defined with a different type; show an appropriate diagnostic.
2911 
2912   // If the previous declaration was an implicitly-generated builtin
2913   // declaration, then at the very least we should use a specialized note.
2914   unsigned BuiltinID;
2915   if (Old->isImplicit() && (BuiltinID = Old->getBuiltinID())) {
2916     // If it's actually a library-defined builtin function like 'malloc'
2917     // or 'printf', just warn about the incompatible redeclaration.
2918     if (Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) {
2919       Diag(New->getLocation(), diag::warn_redecl_library_builtin) << New;
2920       Diag(OldLocation, diag::note_previous_builtin_declaration)
2921         << Old << Old->getType();
2922 
2923       // If this is a global redeclaration, just forget hereafter
2924       // about the "builtin-ness" of the function.
2925       //
2926       // Doing this for local extern declarations is problematic.  If
2927       // the builtin declaration remains visible, a second invalid
2928       // local declaration will produce a hard error; if it doesn't
2929       // remain visible, a single bogus local redeclaration (which is
2930       // actually only a warning) could break all the downstream code.
2931       if (!New->getLexicalDeclContext()->isFunctionOrMethod())
2932         New->getIdentifier()->setBuiltinID(Builtin::NotBuiltin);
2933 
2934       return false;
2935     }
2936 
2937     PrevDiag = diag::note_previous_builtin_declaration;
2938   }
2939 
2940   Diag(New->getLocation(), diag::err_conflicting_types) << New->getDeclName();
2941   Diag(OldLocation, PrevDiag) << Old << Old->getType();
2942   return true;
2943 }
2944 
2945 /// \brief Completes the merge of two function declarations that are
2946 /// known to be compatible.
2947 ///
2948 /// This routine handles the merging of attributes and other
2949 /// properties of function declarations from the old declaration to
2950 /// the new declaration, once we know that New is in fact a
2951 /// redeclaration of Old.
2952 ///
2953 /// \returns false
2954 bool Sema::MergeCompatibleFunctionDecls(FunctionDecl *New, FunctionDecl *Old,
2955                                         Scope *S, bool MergeTypeWithOld) {
2956   // Merge the attributes
2957   mergeDeclAttributes(New, Old);
2958 
2959   // Merge "pure" flag.
2960   if (Old->isPure())
2961     New->setPure();
2962 
2963   // Merge "used" flag.
2964   if (Old->getMostRecentDecl()->isUsed(false))
2965     New->setIsUsed();
2966 
2967   // Merge attributes from the parameters.  These can mismatch with K&R
2968   // declarations.
2969   if (New->getNumParams() == Old->getNumParams())
2970     for (unsigned i = 0, e = New->getNumParams(); i != e; ++i)
2971       mergeParamDeclAttributes(New->getParamDecl(i), Old->getParamDecl(i),
2972                                *this);
2973 
2974   if (getLangOpts().CPlusPlus)
2975     return MergeCXXFunctionDecl(New, Old, S);
2976 
2977   // Merge the function types so the we get the composite types for the return
2978   // and argument types. Per C11 6.2.7/4, only update the type if the old decl
2979   // was visible.
2980   QualType Merged = Context.mergeTypes(Old->getType(), New->getType());
2981   if (!Merged.isNull() && MergeTypeWithOld)
2982     New->setType(Merged);
2983 
2984   return false;
2985 }
2986 
2987 
2988 void Sema::mergeObjCMethodDecls(ObjCMethodDecl *newMethod,
2989                                 ObjCMethodDecl *oldMethod) {
2990 
2991   // Merge the attributes, including deprecated/unavailable
2992   AvailabilityMergeKind MergeKind =
2993     isa<ObjCImplDecl>(newMethod->getDeclContext()) ? AMK_Redeclaration
2994                                                    : AMK_Override;
2995   mergeDeclAttributes(newMethod, oldMethod, MergeKind);
2996 
2997   // Merge attributes from the parameters.
2998   ObjCMethodDecl::param_const_iterator oi = oldMethod->param_begin(),
2999                                        oe = oldMethod->param_end();
3000   for (ObjCMethodDecl::param_iterator
3001          ni = newMethod->param_begin(), ne = newMethod->param_end();
3002        ni != ne && oi != oe; ++ni, ++oi)
3003     mergeParamDeclAttributes(*ni, *oi, *this);
3004 
3005   CheckObjCMethodOverride(newMethod, oldMethod);
3006 }
3007 
3008 /// MergeVarDeclTypes - We parsed a variable 'New' which has the same name and
3009 /// scope as a previous declaration 'Old'.  Figure out how to merge their types,
3010 /// emitting diagnostics as appropriate.
3011 ///
3012 /// Declarations using the auto type specifier (C++ [decl.spec.auto]) call back
3013 /// to here in AddInitializerToDecl. We can't check them before the initializer
3014 /// is attached.
3015 void Sema::MergeVarDeclTypes(VarDecl *New, VarDecl *Old,
3016                              bool MergeTypeWithOld) {
3017   if (New->isInvalidDecl() || Old->isInvalidDecl())
3018     return;
3019 
3020   QualType MergedT;
3021   if (getLangOpts().CPlusPlus) {
3022     if (New->getType()->isUndeducedType()) {
3023       // We don't know what the new type is until the initializer is attached.
3024       return;
3025     } else if (Context.hasSameType(New->getType(), Old->getType())) {
3026       // These could still be something that needs exception specs checked.
3027       return MergeVarDeclExceptionSpecs(New, Old);
3028     }
3029     // C++ [basic.link]p10:
3030     //   [...] the types specified by all declarations referring to a given
3031     //   object or function shall be identical, except that declarations for an
3032     //   array object can specify array types that differ by the presence or
3033     //   absence of a major array bound (8.3.4).
3034     else if (Old->getType()->isIncompleteArrayType() &&
3035              New->getType()->isArrayType()) {
3036       const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3037       const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3038       if (Context.hasSameType(OldArray->getElementType(),
3039                               NewArray->getElementType()))
3040         MergedT = New->getType();
3041     } else if (Old->getType()->isArrayType() &&
3042                New->getType()->isIncompleteArrayType()) {
3043       const ArrayType *OldArray = Context.getAsArrayType(Old->getType());
3044       const ArrayType *NewArray = Context.getAsArrayType(New->getType());
3045       if (Context.hasSameType(OldArray->getElementType(),
3046                               NewArray->getElementType()))
3047         MergedT = Old->getType();
3048     } else if (New->getType()->isObjCObjectPointerType() &&
3049                Old->getType()->isObjCObjectPointerType()) {
3050       MergedT = Context.mergeObjCGCQualifiers(New->getType(),
3051                                               Old->getType());
3052     }
3053   } else {
3054     // C 6.2.7p2:
3055     //   All declarations that refer to the same object or function shall have
3056     //   compatible type.
3057     MergedT = Context.mergeTypes(New->getType(), Old->getType());
3058   }
3059   if (MergedT.isNull()) {
3060     // It's OK if we couldn't merge types if either type is dependent, for a
3061     // block-scope variable. In other cases (static data members of class
3062     // templates, variable templates, ...), we require the types to be
3063     // equivalent.
3064     // FIXME: The C++ standard doesn't say anything about this.
3065     if ((New->getType()->isDependentType() ||
3066          Old->getType()->isDependentType()) && New->isLocalVarDecl()) {
3067       // If the old type was dependent, we can't merge with it, so the new type
3068       // becomes dependent for now. We'll reproduce the original type when we
3069       // instantiate the TypeSourceInfo for the variable.
3070       if (!New->getType()->isDependentType() && MergeTypeWithOld)
3071         New->setType(Context.DependentTy);
3072       return;
3073     }
3074 
3075     // FIXME: Even if this merging succeeds, some other non-visible declaration
3076     // of this variable might have an incompatible type. For instance:
3077     //
3078     //   extern int arr[];
3079     //   void f() { extern int arr[2]; }
3080     //   void g() { extern int arr[3]; }
3081     //
3082     // Neither C nor C++ requires a diagnostic for this, but we should still try
3083     // to diagnose it.
3084     Diag(New->getLocation(), diag::err_redefinition_different_type)
3085       << New->getDeclName() << New->getType() << Old->getType();
3086     Diag(Old->getLocation(), diag::note_previous_definition);
3087     return New->setInvalidDecl();
3088   }
3089 
3090   // Don't actually update the type on the new declaration if the old
3091   // declaration was an extern declaration in a different scope.
3092   if (MergeTypeWithOld)
3093     New->setType(MergedT);
3094 }
3095 
3096 static bool mergeTypeWithPrevious(Sema &S, VarDecl *NewVD, VarDecl *OldVD,
3097                                   LookupResult &Previous) {
3098   // C11 6.2.7p4:
3099   //   For an identifier with internal or external linkage declared
3100   //   in a scope in which a prior declaration of that identifier is
3101   //   visible, if the prior declaration specifies internal or
3102   //   external linkage, the type of the identifier at the later
3103   //   declaration becomes the composite type.
3104   //
3105   // If the variable isn't visible, we do not merge with its type.
3106   if (Previous.isShadowed())
3107     return false;
3108 
3109   if (S.getLangOpts().CPlusPlus) {
3110     // C++11 [dcl.array]p3:
3111     //   If there is a preceding declaration of the entity in the same
3112     //   scope in which the bound was specified, an omitted array bound
3113     //   is taken to be the same as in that earlier declaration.
3114     return NewVD->isPreviousDeclInSameBlockScope() ||
3115            (!OldVD->getLexicalDeclContext()->isFunctionOrMethod() &&
3116             !NewVD->getLexicalDeclContext()->isFunctionOrMethod());
3117   } else {
3118     // If the old declaration was function-local, don't merge with its
3119     // type unless we're in the same function.
3120     return !OldVD->getLexicalDeclContext()->isFunctionOrMethod() ||
3121            OldVD->getLexicalDeclContext() == NewVD->getLexicalDeclContext();
3122   }
3123 }
3124 
3125 /// MergeVarDecl - We just parsed a variable 'New' which has the same name
3126 /// and scope as a previous declaration 'Old'.  Figure out how to resolve this
3127 /// situation, merging decls or emitting diagnostics as appropriate.
3128 ///
3129 /// Tentative definition rules (C99 6.9.2p2) are checked by
3130 /// FinalizeDeclaratorGroup. Unfortunately, we can't analyze tentative
3131 /// definitions here, since the initializer hasn't been attached.
3132 ///
3133 void Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {
3134   // If the new decl is already invalid, don't do any other checking.
3135   if (New->isInvalidDecl())
3136     return;
3137 
3138   VarTemplateDecl *NewTemplate = New->getDescribedVarTemplate();
3139 
3140   // Verify the old decl was also a variable or variable template.
3141   VarDecl *Old = nullptr;
3142   VarTemplateDecl *OldTemplate = nullptr;
3143   if (Previous.isSingleResult()) {
3144     if (NewTemplate) {
3145       OldTemplate = dyn_cast<VarTemplateDecl>(Previous.getFoundDecl());
3146       Old = OldTemplate ? OldTemplate->getTemplatedDecl() : nullptr;
3147     } else
3148       Old = dyn_cast<VarDecl>(Previous.getFoundDecl());
3149   }
3150   if (!Old) {
3151     Diag(New->getLocation(), diag::err_redefinition_different_kind)
3152       << New->getDeclName();
3153     Diag(Previous.getRepresentativeDecl()->getLocation(),
3154          diag::note_previous_definition);
3155     return New->setInvalidDecl();
3156   }
3157 
3158   if (!shouldLinkPossiblyHiddenDecl(Old, New))
3159     return;
3160 
3161   // Ensure the template parameters are compatible.
3162   if (NewTemplate &&
3163       !TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
3164                                       OldTemplate->getTemplateParameters(),
3165                                       /*Complain=*/true, TPL_TemplateMatch))
3166     return;
3167 
3168   // C++ [class.mem]p1:
3169   //   A member shall not be declared twice in the member-specification [...]
3170   //
3171   // Here, we need only consider static data members.
3172   if (Old->isStaticDataMember() && !New->isOutOfLine()) {
3173     Diag(New->getLocation(), diag::err_duplicate_member)
3174       << New->getIdentifier();
3175     Diag(Old->getLocation(), diag::note_previous_declaration);
3176     New->setInvalidDecl();
3177   }
3178 
3179   mergeDeclAttributes(New, Old);
3180   // Warn if an already-declared variable is made a weak_import in a subsequent
3181   // declaration
3182   if (New->hasAttr<WeakImportAttr>() &&
3183       Old->getStorageClass() == SC_None &&
3184       !Old->hasAttr<WeakImportAttr>()) {
3185     Diag(New->getLocation(), diag::warn_weak_import) << New->getDeclName();
3186     Diag(Old->getLocation(), diag::note_previous_definition);
3187     // Remove weak_import attribute on new declaration.
3188     New->dropAttr<WeakImportAttr>();
3189   }
3190 
3191   // Merge the types.
3192   MergeVarDeclTypes(New, Old, mergeTypeWithPrevious(*this, New, Old, Previous));
3193 
3194   if (New->isInvalidDecl())
3195     return;
3196 
3197   diag::kind PrevDiag;
3198   SourceLocation OldLocation;
3199   std::tie(PrevDiag, OldLocation) =
3200       getNoteDiagForInvalidRedeclaration(Old, New);
3201 
3202   // [dcl.stc]p8: Check if we have a non-static decl followed by a static.
3203   if (New->getStorageClass() == SC_Static &&
3204       !New->isStaticDataMember() &&
3205       Old->hasExternalFormalLinkage()) {
3206     if (getLangOpts().MicrosoftExt) {
3207       Diag(New->getLocation(), diag::ext_static_non_static)
3208           << New->getDeclName();
3209       Diag(OldLocation, PrevDiag);
3210     } else {
3211       Diag(New->getLocation(), diag::err_static_non_static)
3212           << New->getDeclName();
3213       Diag(OldLocation, PrevDiag);
3214       return New->setInvalidDecl();
3215     }
3216   }
3217   // C99 6.2.2p4:
3218   //   For an identifier declared with the storage-class specifier
3219   //   extern in a scope in which a prior declaration of that
3220   //   identifier is visible,23) if the prior declaration specifies
3221   //   internal or external linkage, the linkage of the identifier at
3222   //   the later declaration is the same as the linkage specified at
3223   //   the prior declaration. If no prior declaration is visible, or
3224   //   if the prior declaration specifies no linkage, then the
3225   //   identifier has external linkage.
3226   if (New->hasExternalStorage() && Old->hasLinkage())
3227     /* Okay */;
3228   else if (New->getCanonicalDecl()->getStorageClass() != SC_Static &&
3229            !New->isStaticDataMember() &&
3230            Old->getCanonicalDecl()->getStorageClass() == SC_Static) {
3231     Diag(New->getLocation(), diag::err_non_static_static) << New->getDeclName();
3232     Diag(OldLocation, PrevDiag);
3233     return New->setInvalidDecl();
3234   }
3235 
3236   // Check if extern is followed by non-extern and vice-versa.
3237   if (New->hasExternalStorage() &&
3238       !Old->hasLinkage() && Old->isLocalVarDecl()) {
3239     Diag(New->getLocation(), diag::err_extern_non_extern) << New->getDeclName();
3240     Diag(OldLocation, PrevDiag);
3241     return New->setInvalidDecl();
3242   }
3243   if (Old->hasLinkage() && New->isLocalVarDecl() &&
3244       !New->hasExternalStorage()) {
3245     Diag(New->getLocation(), diag::err_non_extern_extern) << New->getDeclName();
3246     Diag(OldLocation, PrevDiag);
3247     return New->setInvalidDecl();
3248   }
3249 
3250   // Variables with external linkage are analyzed in FinalizeDeclaratorGroup.
3251 
3252   // FIXME: The test for external storage here seems wrong? We still
3253   // need to check for mismatches.
3254   if (!New->hasExternalStorage() && !New->isFileVarDecl() &&
3255       // Don't complain about out-of-line definitions of static members.
3256       !(Old->getLexicalDeclContext()->isRecord() &&
3257         !New->getLexicalDeclContext()->isRecord())) {
3258     Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();
3259     Diag(OldLocation, PrevDiag);
3260     return New->setInvalidDecl();
3261   }
3262 
3263   if (New->getTLSKind() != Old->getTLSKind()) {
3264     if (!Old->getTLSKind()) {
3265       Diag(New->getLocation(), diag::err_thread_non_thread) << New->getDeclName();
3266       Diag(OldLocation, PrevDiag);
3267     } else if (!New->getTLSKind()) {
3268       Diag(New->getLocation(), diag::err_non_thread_thread) << New->getDeclName();
3269       Diag(OldLocation, PrevDiag);
3270     } else {
3271       // Do not allow redeclaration to change the variable between requiring
3272       // static and dynamic initialization.
3273       // FIXME: GCC allows this, but uses the TLS keyword on the first
3274       // declaration to determine the kind. Do we need to be compatible here?
3275       Diag(New->getLocation(), diag::err_thread_thread_different_kind)
3276         << New->getDeclName() << (New->getTLSKind() == VarDecl::TLS_Dynamic);
3277       Diag(OldLocation, PrevDiag);
3278     }
3279   }
3280 
3281   // C++ doesn't have tentative definitions, so go right ahead and check here.
3282   const VarDecl *Def;
3283   if (getLangOpts().CPlusPlus &&
3284       New->isThisDeclarationADefinition() == VarDecl::Definition &&
3285       (Def = Old->getDefinition())) {
3286     Diag(New->getLocation(), diag::err_redefinition) << New;
3287     Diag(Def->getLocation(), diag::note_previous_definition);
3288     New->setInvalidDecl();
3289     return;
3290   }
3291 
3292   if (haveIncompatibleLanguageLinkages(Old, New)) {
3293     Diag(New->getLocation(), diag::err_different_language_linkage) << New;
3294     Diag(OldLocation, PrevDiag);
3295     New->setInvalidDecl();
3296     return;
3297   }
3298 
3299   // Merge "used" flag.
3300   if (Old->getMostRecentDecl()->isUsed(false))
3301     New->setIsUsed();
3302 
3303   // Keep a chain of previous declarations.
3304   New->setPreviousDecl(Old);
3305   if (NewTemplate)
3306     NewTemplate->setPreviousDecl(OldTemplate);
3307 
3308   // Inherit access appropriately.
3309   New->setAccess(Old->getAccess());
3310   if (NewTemplate)
3311     NewTemplate->setAccess(New->getAccess());
3312 }
3313 
3314 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3315 /// no declarator (e.g. "struct foo;") is parsed.
3316 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3317                                        DeclSpec &DS) {
3318   return ParsedFreeStandingDeclSpec(S, AS, DS, MultiTemplateParamsArg());
3319 }
3320 
3321 static void HandleTagNumbering(Sema &S, const TagDecl *Tag, Scope *TagScope) {
3322   if (!S.Context.getLangOpts().CPlusPlus)
3323     return;
3324 
3325   if (isa<CXXRecordDecl>(Tag->getParent())) {
3326     // If this tag is the direct child of a class, number it if
3327     // it is anonymous.
3328     if (!Tag->getName().empty() || Tag->getTypedefNameForAnonDecl())
3329       return;
3330     MangleNumberingContext &MCtx =
3331         S.Context.getManglingNumberContext(Tag->getParent());
3332     S.Context.setManglingNumber(
3333         Tag, MCtx.getManglingNumber(Tag, TagScope->getMSLocalManglingNumber()));
3334     return;
3335   }
3336 
3337   // If this tag isn't a direct child of a class, number it if it is local.
3338   Decl *ManglingContextDecl;
3339   if (MangleNumberingContext *MCtx =
3340           S.getCurrentMangleNumberContext(Tag->getDeclContext(),
3341                                           ManglingContextDecl)) {
3342     S.Context.setManglingNumber(
3343         Tag,
3344         MCtx->getManglingNumber(Tag, TagScope->getMSLocalManglingNumber()));
3345   }
3346 }
3347 
3348 /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
3349 /// no declarator (e.g. "struct foo;") is parsed. It also accepts template
3350 /// parameters to cope with template friend declarations.
3351 Decl *Sema::ParsedFreeStandingDeclSpec(Scope *S, AccessSpecifier AS,
3352                                        DeclSpec &DS,
3353                                        MultiTemplateParamsArg TemplateParams,
3354                                        bool IsExplicitInstantiation) {
3355   Decl *TagD = nullptr;
3356   TagDecl *Tag = nullptr;
3357   if (DS.getTypeSpecType() == DeclSpec::TST_class ||
3358       DS.getTypeSpecType() == DeclSpec::TST_struct ||
3359       DS.getTypeSpecType() == DeclSpec::TST_interface ||
3360       DS.getTypeSpecType() == DeclSpec::TST_union ||
3361       DS.getTypeSpecType() == DeclSpec::TST_enum) {
3362     TagD = DS.getRepAsDecl();
3363 
3364     if (!TagD) // We probably had an error
3365       return nullptr;
3366 
3367     // Note that the above type specs guarantee that the
3368     // type rep is a Decl, whereas in many of the others
3369     // it's a Type.
3370     if (isa<TagDecl>(TagD))
3371       Tag = cast<TagDecl>(TagD);
3372     else if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(TagD))
3373       Tag = CTD->getTemplatedDecl();
3374   }
3375 
3376   if (Tag) {
3377     HandleTagNumbering(*this, Tag, S);
3378     Tag->setFreeStanding();
3379     if (Tag->isInvalidDecl())
3380       return Tag;
3381   }
3382 
3383   if (unsigned TypeQuals = DS.getTypeQualifiers()) {
3384     // Enforce C99 6.7.3p2: "Types other than pointer types derived from object
3385     // or incomplete types shall not be restrict-qualified."
3386     if (TypeQuals & DeclSpec::TQ_restrict)
3387       Diag(DS.getRestrictSpecLoc(),
3388            diag::err_typecheck_invalid_restrict_not_pointer_noarg)
3389            << DS.getSourceRange();
3390   }
3391 
3392   if (DS.isConstexprSpecified()) {
3393     // C++0x [dcl.constexpr]p1: constexpr can only be applied to declarations
3394     // and definitions of functions and variables.
3395     if (Tag)
3396       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_tag)
3397         << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
3398             DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
3399             DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
3400             DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4);
3401     else
3402       Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_no_declarators);
3403     // Don't emit warnings after this error.
3404     return TagD;
3405   }
3406 
3407   DiagnoseFunctionSpecifiers(DS);
3408 
3409   if (DS.isFriendSpecified()) {
3410     // If we're dealing with a decl but not a TagDecl, assume that
3411     // whatever routines created it handled the friendship aspect.
3412     if (TagD && !Tag)
3413       return nullptr;
3414     return ActOnFriendTypeDecl(S, DS, TemplateParams);
3415   }
3416 
3417   CXXScopeSpec &SS = DS.getTypeSpecScope();
3418   bool IsExplicitSpecialization =
3419     !TemplateParams.empty() && TemplateParams.back()->size() == 0;
3420   if (Tag && SS.isNotEmpty() && !Tag->isCompleteDefinition() &&
3421       !IsExplicitInstantiation && !IsExplicitSpecialization) {
3422     // Per C++ [dcl.type.elab]p1, a class declaration cannot have a
3423     // nested-name-specifier unless it is an explicit instantiation
3424     // or an explicit specialization.
3425     // Per C++ [dcl.enum]p1, an opaque-enum-declaration can't either.
3426     Diag(SS.getBeginLoc(), diag::err_standalone_class_nested_name_specifier)
3427       << (DS.getTypeSpecType() == DeclSpec::TST_class ? 0 :
3428           DS.getTypeSpecType() == DeclSpec::TST_struct ? 1 :
3429           DS.getTypeSpecType() == DeclSpec::TST_interface ? 2 :
3430           DS.getTypeSpecType() == DeclSpec::TST_union ? 3 : 4)
3431       << SS.getRange();
3432     return nullptr;
3433   }
3434 
3435   // Track whether this decl-specifier declares anything.
3436   bool DeclaresAnything = true;
3437 
3438   // Handle anonymous struct definitions.
3439   if (RecordDecl *Record = dyn_cast_or_null<RecordDecl>(Tag)) {
3440     if (!Record->getDeclName() && Record->isCompleteDefinition() &&
3441         DS.getStorageClassSpec() != DeclSpec::SCS_typedef) {
3442       if (getLangOpts().CPlusPlus ||
3443           Record->getDeclContext()->isRecord())
3444         return BuildAnonymousStructOrUnion(S, DS, AS, Record, Context.getPrintingPolicy());
3445 
3446       DeclaresAnything = false;
3447     }
3448   }
3449 
3450   // C11 6.7.2.1p2:
3451   //   A struct-declaration that does not declare an anonymous structure or
3452   //   anonymous union shall contain a struct-declarator-list.
3453   //
3454   // This rule also existed in C89 and C99; the grammar for struct-declaration
3455   // did not permit a struct-declaration without a struct-declarator-list.
3456   if (!getLangOpts().CPlusPlus && CurContext->isRecord() &&
3457       DS.getStorageClassSpec() == DeclSpec::SCS_unspecified) {
3458     // Check for Microsoft C extension: anonymous struct/union member.
3459     // Handle 2 kinds of anonymous struct/union:
3460     //   struct STRUCT;
3461     //   union UNION;
3462     // and
3463     //   STRUCT_TYPE;  <- where STRUCT_TYPE is a typedef struct.
3464     //   UNION_TYPE;   <- where UNION_TYPE is a typedef union.
3465     if ((Tag && Tag->getDeclName()) ||
3466         DS.getTypeSpecType() == DeclSpec::TST_typename) {
3467       RecordDecl *Record = nullptr;
3468       if (Tag)
3469         Record = dyn_cast<RecordDecl>(Tag);
3470       else if (const RecordType *RT =
3471                    DS.getRepAsType().get()->getAsStructureType())
3472         Record = RT->getDecl();
3473       else if (const RecordType *UT = DS.getRepAsType().get()->getAsUnionType())
3474         Record = UT->getDecl();
3475 
3476       if (Record && getLangOpts().MicrosoftExt) {
3477         Diag(DS.getLocStart(), diag::ext_ms_anonymous_record)
3478           << Record->isUnion() << DS.getSourceRange();
3479         return BuildMicrosoftCAnonymousStruct(S, DS, Record);
3480       }
3481 
3482       DeclaresAnything = false;
3483     }
3484   }
3485 
3486   // Skip all the checks below if we have a type error.
3487   if (DS.getTypeSpecType() == DeclSpec::TST_error ||
3488       (TagD && TagD->isInvalidDecl()))
3489     return TagD;
3490 
3491   if (getLangOpts().CPlusPlus &&
3492       DS.getStorageClassSpec() != DeclSpec::SCS_typedef)
3493     if (EnumDecl *Enum = dyn_cast_or_null<EnumDecl>(Tag))
3494       if (Enum->enumerator_begin() == Enum->enumerator_end() &&
3495           !Enum->getIdentifier() && !Enum->isInvalidDecl())
3496         DeclaresAnything = false;
3497 
3498   if (!DS.isMissingDeclaratorOk()) {
3499     // Customize diagnostic for a typedef missing a name.
3500     if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef)
3501       Diag(DS.getLocStart(), diag::ext_typedef_without_a_name)
3502         << DS.getSourceRange();
3503     else
3504       DeclaresAnything = false;
3505   }
3506 
3507   if (DS.isModulePrivateSpecified() &&
3508       Tag && Tag->getDeclContext()->isFunctionOrMethod())
3509     Diag(DS.getModulePrivateSpecLoc(), diag::err_module_private_local_class)
3510       << Tag->getTagKind()
3511       << FixItHint::CreateRemoval(DS.getModulePrivateSpecLoc());
3512 
3513   ActOnDocumentableDecl(TagD);
3514 
3515   // C 6.7/2:
3516   //   A declaration [...] shall declare at least a declarator [...], a tag,
3517   //   or the members of an enumeration.
3518   // C++ [dcl.dcl]p3:
3519   //   [If there are no declarators], and except for the declaration of an
3520   //   unnamed bit-field, the decl-specifier-seq shall introduce one or more
3521   //   names into the program, or shall redeclare a name introduced by a
3522   //   previous declaration.
3523   if (!DeclaresAnything) {
3524     // In C, we allow this as a (popular) extension / bug. Don't bother
3525     // producing further diagnostics for redundant qualifiers after this.
3526     Diag(DS.getLocStart(), diag::ext_no_declarators) << DS.getSourceRange();
3527     return TagD;
3528   }
3529 
3530   // C++ [dcl.stc]p1:
3531   //   If a storage-class-specifier appears in a decl-specifier-seq, [...] the
3532   //   init-declarator-list of the declaration shall not be empty.
3533   // C++ [dcl.fct.spec]p1:
3534   //   If a cv-qualifier appears in a decl-specifier-seq, the
3535   //   init-declarator-list of the declaration shall not be empty.
3536   //
3537   // Spurious qualifiers here appear to be valid in C.
3538   unsigned DiagID = diag::warn_standalone_specifier;
3539   if (getLangOpts().CPlusPlus)
3540     DiagID = diag::ext_standalone_specifier;
3541 
3542   // Note that a linkage-specification sets a storage class, but
3543   // 'extern "C" struct foo;' is actually valid and not theoretically
3544   // useless.
3545   if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
3546     if (SCS == DeclSpec::SCS_mutable)
3547       // Since mutable is not a viable storage class specifier in C, there is
3548       // no reason to treat it as an extension. Instead, diagnose as an error.
3549       Diag(DS.getStorageClassSpecLoc(), diag::err_mutable_nonmember);
3550     else if (!DS.isExternInLinkageSpec() && SCS != DeclSpec::SCS_typedef)
3551       Diag(DS.getStorageClassSpecLoc(), DiagID)
3552         << DeclSpec::getSpecifierName(SCS);
3553   }
3554 
3555   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
3556     Diag(DS.getThreadStorageClassSpecLoc(), DiagID)
3557       << DeclSpec::getSpecifierName(TSCS);
3558   if (DS.getTypeQualifiers()) {
3559     if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3560       Diag(DS.getConstSpecLoc(), DiagID) << "const";
3561     if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3562       Diag(DS.getConstSpecLoc(), DiagID) << "volatile";
3563     // Restrict is covered above.
3564     if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3565       Diag(DS.getAtomicSpecLoc(), DiagID) << "_Atomic";
3566   }
3567 
3568   // Warn about ignored type attributes, for example:
3569   // __attribute__((aligned)) struct A;
3570   // Attributes should be placed after tag to apply to type declaration.
3571   if (!DS.getAttributes().empty()) {
3572     DeclSpec::TST TypeSpecType = DS.getTypeSpecType();
3573     if (TypeSpecType == DeclSpec::TST_class ||
3574         TypeSpecType == DeclSpec::TST_struct ||
3575         TypeSpecType == DeclSpec::TST_interface ||
3576         TypeSpecType == DeclSpec::TST_union ||
3577         TypeSpecType == DeclSpec::TST_enum) {
3578       AttributeList* attrs = DS.getAttributes().getList();
3579       while (attrs) {
3580         Diag(attrs->getLoc(), diag::warn_declspec_attribute_ignored)
3581         << attrs->getName()
3582         << (TypeSpecType == DeclSpec::TST_class ? 0 :
3583             TypeSpecType == DeclSpec::TST_struct ? 1 :
3584             TypeSpecType == DeclSpec::TST_union ? 2 :
3585             TypeSpecType == DeclSpec::TST_interface ? 3 : 4);
3586         attrs = attrs->getNext();
3587       }
3588     }
3589   }
3590 
3591   return TagD;
3592 }
3593 
3594 /// We are trying to inject an anonymous member into the given scope;
3595 /// check if there's an existing declaration that can't be overloaded.
3596 ///
3597 /// \return true if this is a forbidden redeclaration
3598 static bool CheckAnonMemberRedeclaration(Sema &SemaRef,
3599                                          Scope *S,
3600                                          DeclContext *Owner,
3601                                          DeclarationName Name,
3602                                          SourceLocation NameLoc,
3603                                          unsigned diagnostic) {
3604   LookupResult R(SemaRef, Name, NameLoc, Sema::LookupMemberName,
3605                  Sema::ForRedeclaration);
3606   if (!SemaRef.LookupName(R, S)) return false;
3607 
3608   if (R.getAsSingle<TagDecl>())
3609     return false;
3610 
3611   // Pick a representative declaration.
3612   NamedDecl *PrevDecl = R.getRepresentativeDecl()->getUnderlyingDecl();
3613   assert(PrevDecl && "Expected a non-null Decl");
3614 
3615   if (!SemaRef.isDeclInScope(PrevDecl, Owner, S))
3616     return false;
3617 
3618   SemaRef.Diag(NameLoc, diagnostic) << Name;
3619   SemaRef.Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
3620 
3621   return true;
3622 }
3623 
3624 /// InjectAnonymousStructOrUnionMembers - Inject the members of the
3625 /// anonymous struct or union AnonRecord into the owning context Owner
3626 /// and scope S. This routine will be invoked just after we realize
3627 /// that an unnamed union or struct is actually an anonymous union or
3628 /// struct, e.g.,
3629 ///
3630 /// @code
3631 /// union {
3632 ///   int i;
3633 ///   float f;
3634 /// }; // InjectAnonymousStructOrUnionMembers called here to inject i and
3635 ///    // f into the surrounding scope.x
3636 /// @endcode
3637 ///
3638 /// This routine is recursive, injecting the names of nested anonymous
3639 /// structs/unions into the owning context and scope as well.
3640 static bool InjectAnonymousStructOrUnionMembers(Sema &SemaRef, Scope *S,
3641                                          DeclContext *Owner,
3642                                          RecordDecl *AnonRecord,
3643                                          AccessSpecifier AS,
3644                                          SmallVectorImpl<NamedDecl *> &Chaining,
3645                                          bool MSAnonStruct) {
3646   unsigned diagKind
3647     = AnonRecord->isUnion() ? diag::err_anonymous_union_member_redecl
3648                             : diag::err_anonymous_struct_member_redecl;
3649 
3650   bool Invalid = false;
3651 
3652   // Look every FieldDecl and IndirectFieldDecl with a name.
3653   for (auto *D : AnonRecord->decls()) {
3654     if ((isa<FieldDecl>(D) || isa<IndirectFieldDecl>(D)) &&
3655         cast<NamedDecl>(D)->getDeclName()) {
3656       ValueDecl *VD = cast<ValueDecl>(D);
3657       if (CheckAnonMemberRedeclaration(SemaRef, S, Owner, VD->getDeclName(),
3658                                        VD->getLocation(), diagKind)) {
3659         // C++ [class.union]p2:
3660         //   The names of the members of an anonymous union shall be
3661         //   distinct from the names of any other entity in the
3662         //   scope in which the anonymous union is declared.
3663         Invalid = true;
3664       } else {
3665         // C++ [class.union]p2:
3666         //   For the purpose of name lookup, after the anonymous union
3667         //   definition, the members of the anonymous union are
3668         //   considered to have been defined in the scope in which the
3669         //   anonymous union is declared.
3670         unsigned OldChainingSize = Chaining.size();
3671         if (IndirectFieldDecl *IF = dyn_cast<IndirectFieldDecl>(VD))
3672           for (auto *PI : IF->chain())
3673             Chaining.push_back(PI);
3674         else
3675           Chaining.push_back(VD);
3676 
3677         assert(Chaining.size() >= 2);
3678         NamedDecl **NamedChain =
3679           new (SemaRef.Context)NamedDecl*[Chaining.size()];
3680         for (unsigned i = 0; i < Chaining.size(); i++)
3681           NamedChain[i] = Chaining[i];
3682 
3683         IndirectFieldDecl* IndirectField =
3684           IndirectFieldDecl::Create(SemaRef.Context, Owner, VD->getLocation(),
3685                                     VD->getIdentifier(), VD->getType(),
3686                                     NamedChain, Chaining.size());
3687 
3688         IndirectField->setAccess(AS);
3689         IndirectField->setImplicit();
3690         SemaRef.PushOnScopeChains(IndirectField, S);
3691 
3692         // That includes picking up the appropriate access specifier.
3693         if (AS != AS_none) IndirectField->setAccess(AS);
3694 
3695         Chaining.resize(OldChainingSize);
3696       }
3697     }
3698   }
3699 
3700   return Invalid;
3701 }
3702 
3703 /// StorageClassSpecToVarDeclStorageClass - Maps a DeclSpec::SCS to
3704 /// a VarDecl::StorageClass. Any error reporting is up to the caller:
3705 /// illegal input values are mapped to SC_None.
3706 static StorageClass
3707 StorageClassSpecToVarDeclStorageClass(const DeclSpec &DS) {
3708   DeclSpec::SCS StorageClassSpec = DS.getStorageClassSpec();
3709   assert(StorageClassSpec != DeclSpec::SCS_typedef &&
3710          "Parser allowed 'typedef' as storage class VarDecl.");
3711   switch (StorageClassSpec) {
3712   case DeclSpec::SCS_unspecified:    return SC_None;
3713   case DeclSpec::SCS_extern:
3714     if (DS.isExternInLinkageSpec())
3715       return SC_None;
3716     return SC_Extern;
3717   case DeclSpec::SCS_static:         return SC_Static;
3718   case DeclSpec::SCS_auto:           return SC_Auto;
3719   case DeclSpec::SCS_register:       return SC_Register;
3720   case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
3721     // Illegal SCSs map to None: error reporting is up to the caller.
3722   case DeclSpec::SCS_mutable:        // Fall through.
3723   case DeclSpec::SCS_typedef:        return SC_None;
3724   }
3725   llvm_unreachable("unknown storage class specifier");
3726 }
3727 
3728 static SourceLocation findDefaultInitializer(const CXXRecordDecl *Record) {
3729   assert(Record->hasInClassInitializer());
3730 
3731   for (const auto *I : Record->decls()) {
3732     const auto *FD = dyn_cast<FieldDecl>(I);
3733     if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
3734       FD = IFD->getAnonField();
3735     if (FD && FD->hasInClassInitializer())
3736       return FD->getLocation();
3737   }
3738 
3739   llvm_unreachable("couldn't find in-class initializer");
3740 }
3741 
3742 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3743                                       SourceLocation DefaultInitLoc) {
3744   if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3745     return;
3746 
3747   S.Diag(DefaultInitLoc, diag::err_multiple_mem_union_initialization);
3748   S.Diag(findDefaultInitializer(Parent), diag::note_previous_initializer) << 0;
3749 }
3750 
3751 static void checkDuplicateDefaultInit(Sema &S, CXXRecordDecl *Parent,
3752                                       CXXRecordDecl *AnonUnion) {
3753   if (!Parent->isUnion() || !Parent->hasInClassInitializer())
3754     return;
3755 
3756   checkDuplicateDefaultInit(S, Parent, findDefaultInitializer(AnonUnion));
3757 }
3758 
3759 /// BuildAnonymousStructOrUnion - Handle the declaration of an
3760 /// anonymous structure or union. Anonymous unions are a C++ feature
3761 /// (C++ [class.union]) and a C11 feature; anonymous structures
3762 /// are a C11 feature and GNU C++ extension.
3763 Decl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS,
3764                                         AccessSpecifier AS,
3765                                         RecordDecl *Record,
3766                                         const PrintingPolicy &Policy) {
3767   DeclContext *Owner = Record->getDeclContext();
3768 
3769   // Diagnose whether this anonymous struct/union is an extension.
3770   if (Record->isUnion() && !getLangOpts().CPlusPlus && !getLangOpts().C11)
3771     Diag(Record->getLocation(), diag::ext_anonymous_union);
3772   else if (!Record->isUnion() && getLangOpts().CPlusPlus)
3773     Diag(Record->getLocation(), diag::ext_gnu_anonymous_struct);
3774   else if (!Record->isUnion() && !getLangOpts().C11)
3775     Diag(Record->getLocation(), diag::ext_c11_anonymous_struct);
3776 
3777   // C and C++ require different kinds of checks for anonymous
3778   // structs/unions.
3779   bool Invalid = false;
3780   if (getLangOpts().CPlusPlus) {
3781     const char *PrevSpec = nullptr;
3782     unsigned DiagID;
3783     if (Record->isUnion()) {
3784       // C++ [class.union]p6:
3785       //   Anonymous unions declared in a named namespace or in the
3786       //   global namespace shall be declared static.
3787       if (DS.getStorageClassSpec() != DeclSpec::SCS_static &&
3788           (isa<TranslationUnitDecl>(Owner) ||
3789            (isa<NamespaceDecl>(Owner) &&
3790             cast<NamespaceDecl>(Owner)->getDeclName()))) {
3791         Diag(Record->getLocation(), diag::err_anonymous_union_not_static)
3792           << FixItHint::CreateInsertion(Record->getLocation(), "static ");
3793 
3794         // Recover by adding 'static'.
3795         DS.SetStorageClassSpec(*this, DeclSpec::SCS_static, SourceLocation(),
3796                                PrevSpec, DiagID, Policy);
3797       }
3798       // C++ [class.union]p6:
3799       //   A storage class is not allowed in a declaration of an
3800       //   anonymous union in a class scope.
3801       else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified &&
3802                isa<RecordDecl>(Owner)) {
3803         Diag(DS.getStorageClassSpecLoc(),
3804              diag::err_anonymous_union_with_storage_spec)
3805           << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
3806 
3807         // Recover by removing the storage specifier.
3808         DS.SetStorageClassSpec(*this, DeclSpec::SCS_unspecified,
3809                                SourceLocation(),
3810                                PrevSpec, DiagID, Context.getPrintingPolicy());
3811       }
3812     }
3813 
3814     // Ignore const/volatile/restrict qualifiers.
3815     if (DS.getTypeQualifiers()) {
3816       if (DS.getTypeQualifiers() & DeclSpec::TQ_const)
3817         Diag(DS.getConstSpecLoc(), diag::ext_anonymous_struct_union_qualified)
3818           << Record->isUnion() << "const"
3819           << FixItHint::CreateRemoval(DS.getConstSpecLoc());
3820       if (DS.getTypeQualifiers() & DeclSpec::TQ_volatile)
3821         Diag(DS.getVolatileSpecLoc(),
3822              diag::ext_anonymous_struct_union_qualified)
3823           << Record->isUnion() << "volatile"
3824           << FixItHint::CreateRemoval(DS.getVolatileSpecLoc());
3825       if (DS.getTypeQualifiers() & DeclSpec::TQ_restrict)
3826         Diag(DS.getRestrictSpecLoc(),
3827              diag::ext_anonymous_struct_union_qualified)
3828           << Record->isUnion() << "restrict"
3829           << FixItHint::CreateRemoval(DS.getRestrictSpecLoc());
3830       if (DS.getTypeQualifiers() & DeclSpec::TQ_atomic)
3831         Diag(DS.getAtomicSpecLoc(),
3832              diag::ext_anonymous_struct_union_qualified)
3833           << Record->isUnion() << "_Atomic"
3834           << FixItHint::CreateRemoval(DS.getAtomicSpecLoc());
3835 
3836       DS.ClearTypeQualifiers();
3837     }
3838 
3839     // C++ [class.union]p2:
3840     //   The member-specification of an anonymous union shall only
3841     //   define non-static data members. [Note: nested types and
3842     //   functions cannot be declared within an anonymous union. ]
3843     for (auto *Mem : Record->decls()) {
3844       if (auto *FD = dyn_cast<FieldDecl>(Mem)) {
3845         // C++ [class.union]p3:
3846         //   An anonymous union shall not have private or protected
3847         //   members (clause 11).
3848         assert(FD->getAccess() != AS_none);
3849         if (FD->getAccess() != AS_public) {
3850           Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member)
3851             << (int)Record->isUnion() << (int)(FD->getAccess() == AS_protected);
3852           Invalid = true;
3853         }
3854 
3855         // C++ [class.union]p1
3856         //   An object of a class with a non-trivial constructor, a non-trivial
3857         //   copy constructor, a non-trivial destructor, or a non-trivial copy
3858         //   assignment operator cannot be a member of a union, nor can an
3859         //   array of such objects.
3860         if (CheckNontrivialField(FD))
3861           Invalid = true;
3862       } else if (Mem->isImplicit()) {
3863         // Any implicit members are fine.
3864       } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {
3865         // This is a type that showed up in an
3866         // elaborated-type-specifier inside the anonymous struct or
3867         // union, but which actually declares a type outside of the
3868         // anonymous struct or union. It's okay.
3869       } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {
3870         if (!MemRecord->isAnonymousStructOrUnion() &&
3871             MemRecord->getDeclName()) {
3872           // Visual C++ allows type definition in anonymous struct or union.
3873           if (getLangOpts().MicrosoftExt)
3874             Diag(MemRecord->getLocation(), diag::ext_anonymous_record_with_type)
3875               << (int)Record->isUnion();
3876           else {
3877             // This is a nested type declaration.
3878             Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type)
3879               << (int)Record->isUnion();
3880             Invalid = true;
3881           }
3882         } else {
3883           // This is an anonymous type definition within another anonymous type.
3884           // This is a popular extension, provided by Plan9, MSVC and GCC, but
3885           // not part of standard C++.
3886           Diag(MemRecord->getLocation(),
3887                diag::ext_anonymous_record_with_anonymous_type)
3888             << (int)Record->isUnion();
3889         }
3890       } else if (isa<AccessSpecDecl>(Mem)) {
3891         // Any access specifier is fine.
3892       } else if (isa<StaticAssertDecl>(Mem)) {
3893         // In C++1z, static_assert declarations are also fine.
3894       } else {
3895         // We have something that isn't a non-static data
3896         // member. Complain about it.
3897         unsigned DK = diag::err_anonymous_record_bad_member;
3898         if (isa<TypeDecl>(Mem))
3899           DK = diag::err_anonymous_record_with_type;
3900         else if (isa<FunctionDecl>(Mem))
3901           DK = diag::err_anonymous_record_with_function;
3902         else if (isa<VarDecl>(Mem))
3903           DK = diag::err_anonymous_record_with_static;
3904 
3905         // Visual C++ allows type definition in anonymous struct or union.
3906         if (getLangOpts().MicrosoftExt &&
3907             DK == diag::err_anonymous_record_with_type)
3908           Diag(Mem->getLocation(), diag::ext_anonymous_record_with_type)
3909             << (int)Record->isUnion();
3910         else {
3911           Diag(Mem->getLocation(), DK)
3912               << (int)Record->isUnion();
3913           Invalid = true;
3914         }
3915       }
3916     }
3917 
3918     // C++11 [class.union]p8 (DR1460):
3919     //   At most one variant member of a union may have a
3920     //   brace-or-equal-initializer.
3921     if (cast<CXXRecordDecl>(Record)->hasInClassInitializer() &&
3922         Owner->isRecord())
3923       checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Owner),
3924                                 cast<CXXRecordDecl>(Record));
3925   }
3926 
3927   if (!Record->isUnion() && !Owner->isRecord()) {
3928     Diag(Record->getLocation(), diag::err_anonymous_struct_not_member)
3929       << (int)getLangOpts().CPlusPlus;
3930     Invalid = true;
3931   }
3932 
3933   // Mock up a declarator.
3934   Declarator Dc(DS, Declarator::MemberContext);
3935   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
3936   assert(TInfo && "couldn't build declarator info for anonymous struct/union");
3937 
3938   // Create a declaration for this anonymous struct/union.
3939   NamedDecl *Anon = nullptr;
3940   if (RecordDecl *OwningClass = dyn_cast<RecordDecl>(Owner)) {
3941     Anon = FieldDecl::Create(Context, OwningClass,
3942                              DS.getLocStart(),
3943                              Record->getLocation(),
3944                              /*IdentifierInfo=*/nullptr,
3945                              Context.getTypeDeclType(Record),
3946                              TInfo,
3947                              /*BitWidth=*/nullptr, /*Mutable=*/false,
3948                              /*InitStyle=*/ICIS_NoInit);
3949     Anon->setAccess(AS);
3950     if (getLangOpts().CPlusPlus)
3951       FieldCollector->Add(cast<FieldDecl>(Anon));
3952   } else {
3953     DeclSpec::SCS SCSpec = DS.getStorageClassSpec();
3954     VarDecl::StorageClass SC = StorageClassSpecToVarDeclStorageClass(DS);
3955     if (SCSpec == DeclSpec::SCS_mutable) {
3956       // mutable can only appear on non-static class members, so it's always
3957       // an error here
3958       Diag(Record->getLocation(), diag::err_mutable_nonmember);
3959       Invalid = true;
3960       SC = SC_None;
3961     }
3962 
3963     Anon = VarDecl::Create(Context, Owner,
3964                            DS.getLocStart(),
3965                            Record->getLocation(), /*IdentifierInfo=*/nullptr,
3966                            Context.getTypeDeclType(Record),
3967                            TInfo, SC);
3968 
3969     // Default-initialize the implicit variable. This initialization will be
3970     // trivial in almost all cases, except if a union member has an in-class
3971     // initializer:
3972     //   union { int n = 0; };
3973     ActOnUninitializedDecl(Anon, /*TypeMayContainAuto=*/false);
3974   }
3975   Anon->setImplicit();
3976 
3977   // Mark this as an anonymous struct/union type.
3978   Record->setAnonymousStructOrUnion(true);
3979 
3980   // Add the anonymous struct/union object to the current
3981   // context. We'll be referencing this object when we refer to one of
3982   // its members.
3983   Owner->addDecl(Anon);
3984 
3985   // Inject the members of the anonymous struct/union into the owning
3986   // context and into the identifier resolver chain for name lookup
3987   // purposes.
3988   SmallVector<NamedDecl*, 2> Chain;
3989   Chain.push_back(Anon);
3990 
3991   if (InjectAnonymousStructOrUnionMembers(*this, S, Owner, Record, AS,
3992                                           Chain, false))
3993     Invalid = true;
3994 
3995   if (VarDecl *NewVD = dyn_cast<VarDecl>(Anon)) {
3996     if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
3997       Decl *ManglingContextDecl;
3998       if (MangleNumberingContext *MCtx =
3999               getCurrentMangleNumberContext(NewVD->getDeclContext(),
4000                                             ManglingContextDecl)) {
4001         Context.setManglingNumber(NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber()));
4002         Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
4003       }
4004     }
4005   }
4006 
4007   if (Invalid)
4008     Anon->setInvalidDecl();
4009 
4010   return Anon;
4011 }
4012 
4013 /// BuildMicrosoftCAnonymousStruct - Handle the declaration of an
4014 /// Microsoft C anonymous structure.
4015 /// Ref: http://msdn.microsoft.com/en-us/library/z2cx9y4f.aspx
4016 /// Example:
4017 ///
4018 /// struct A { int a; };
4019 /// struct B { struct A; int b; };
4020 ///
4021 /// void foo() {
4022 ///   B var;
4023 ///   var.a = 3;
4024 /// }
4025 ///
4026 Decl *Sema::BuildMicrosoftCAnonymousStruct(Scope *S, DeclSpec &DS,
4027                                            RecordDecl *Record) {
4028   assert(Record && "expected a record!");
4029 
4030   // Mock up a declarator.
4031   Declarator Dc(DS, Declarator::TypeNameContext);
4032   TypeSourceInfo *TInfo = GetTypeForDeclarator(Dc, S);
4033   assert(TInfo && "couldn't build declarator info for anonymous struct");
4034 
4035   // Create a declaration for this anonymous struct.
4036   NamedDecl *Anon = FieldDecl::Create(Context,
4037                              cast<RecordDecl>(CurContext),
4038                              DS.getLocStart(),
4039                              DS.getLocStart(),
4040                              /*IdentifierInfo=*/nullptr,
4041                              Context.getTypeDeclType(Record),
4042                              TInfo,
4043                              /*BitWidth=*/nullptr, /*Mutable=*/false,
4044                              /*InitStyle=*/ICIS_NoInit);
4045   Anon->setImplicit();
4046 
4047   // Add the anonymous struct object to the current context.
4048   CurContext->addDecl(Anon);
4049 
4050   // Inject the members of the anonymous struct into the current
4051   // context and into the identifier resolver chain for name lookup
4052   // purposes.
4053   SmallVector<NamedDecl*, 2> Chain;
4054   Chain.push_back(Anon);
4055 
4056   RecordDecl *RecordDef = Record->getDefinition();
4057   if (!RecordDef || InjectAnonymousStructOrUnionMembers(*this, S, CurContext,
4058                                                         RecordDef, AS_none,
4059                                                         Chain, true))
4060     Anon->setInvalidDecl();
4061 
4062   return Anon;
4063 }
4064 
4065 /// GetNameForDeclarator - Determine the full declaration name for the
4066 /// given Declarator.
4067 DeclarationNameInfo Sema::GetNameForDeclarator(Declarator &D) {
4068   return GetNameFromUnqualifiedId(D.getName());
4069 }
4070 
4071 /// \brief Retrieves the declaration name from a parsed unqualified-id.
4072 DeclarationNameInfo
4073 Sema::GetNameFromUnqualifiedId(const UnqualifiedId &Name) {
4074   DeclarationNameInfo NameInfo;
4075   NameInfo.setLoc(Name.StartLocation);
4076 
4077   switch (Name.getKind()) {
4078 
4079   case UnqualifiedId::IK_ImplicitSelfParam:
4080   case UnqualifiedId::IK_Identifier:
4081     NameInfo.setName(Name.Identifier);
4082     NameInfo.setLoc(Name.StartLocation);
4083     return NameInfo;
4084 
4085   case UnqualifiedId::IK_OperatorFunctionId:
4086     NameInfo.setName(Context.DeclarationNames.getCXXOperatorName(
4087                                            Name.OperatorFunctionId.Operator));
4088     NameInfo.setLoc(Name.StartLocation);
4089     NameInfo.getInfo().CXXOperatorName.BeginOpNameLoc
4090       = Name.OperatorFunctionId.SymbolLocations[0];
4091     NameInfo.getInfo().CXXOperatorName.EndOpNameLoc
4092       = Name.EndLocation.getRawEncoding();
4093     return NameInfo;
4094 
4095   case UnqualifiedId::IK_LiteralOperatorId:
4096     NameInfo.setName(Context.DeclarationNames.getCXXLiteralOperatorName(
4097                                                            Name.Identifier));
4098     NameInfo.setLoc(Name.StartLocation);
4099     NameInfo.setCXXLiteralOperatorNameLoc(Name.EndLocation);
4100     return NameInfo;
4101 
4102   case UnqualifiedId::IK_ConversionFunctionId: {
4103     TypeSourceInfo *TInfo;
4104     QualType Ty = GetTypeFromParser(Name.ConversionFunctionId, &TInfo);
4105     if (Ty.isNull())
4106       return DeclarationNameInfo();
4107     NameInfo.setName(Context.DeclarationNames.getCXXConversionFunctionName(
4108                                                Context.getCanonicalType(Ty)));
4109     NameInfo.setLoc(Name.StartLocation);
4110     NameInfo.setNamedTypeInfo(TInfo);
4111     return NameInfo;
4112   }
4113 
4114   case UnqualifiedId::IK_ConstructorName: {
4115     TypeSourceInfo *TInfo;
4116     QualType Ty = GetTypeFromParser(Name.ConstructorName, &TInfo);
4117     if (Ty.isNull())
4118       return DeclarationNameInfo();
4119     NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4120                                               Context.getCanonicalType(Ty)));
4121     NameInfo.setLoc(Name.StartLocation);
4122     NameInfo.setNamedTypeInfo(TInfo);
4123     return NameInfo;
4124   }
4125 
4126   case UnqualifiedId::IK_ConstructorTemplateId: {
4127     // In well-formed code, we can only have a constructor
4128     // template-id that refers to the current context, so go there
4129     // to find the actual type being constructed.
4130     CXXRecordDecl *CurClass = dyn_cast<CXXRecordDecl>(CurContext);
4131     if (!CurClass || CurClass->getIdentifier() != Name.TemplateId->Name)
4132       return DeclarationNameInfo();
4133 
4134     // Determine the type of the class being constructed.
4135     QualType CurClassType = Context.getTypeDeclType(CurClass);
4136 
4137     // FIXME: Check two things: that the template-id names the same type as
4138     // CurClassType, and that the template-id does not occur when the name
4139     // was qualified.
4140 
4141     NameInfo.setName(Context.DeclarationNames.getCXXConstructorName(
4142                                     Context.getCanonicalType(CurClassType)));
4143     NameInfo.setLoc(Name.StartLocation);
4144     // FIXME: should we retrieve TypeSourceInfo?
4145     NameInfo.setNamedTypeInfo(nullptr);
4146     return NameInfo;
4147   }
4148 
4149   case UnqualifiedId::IK_DestructorName: {
4150     TypeSourceInfo *TInfo;
4151     QualType Ty = GetTypeFromParser(Name.DestructorName, &TInfo);
4152     if (Ty.isNull())
4153       return DeclarationNameInfo();
4154     NameInfo.setName(Context.DeclarationNames.getCXXDestructorName(
4155                                               Context.getCanonicalType(Ty)));
4156     NameInfo.setLoc(Name.StartLocation);
4157     NameInfo.setNamedTypeInfo(TInfo);
4158     return NameInfo;
4159   }
4160 
4161   case UnqualifiedId::IK_TemplateId: {
4162     TemplateName TName = Name.TemplateId->Template.get();
4163     SourceLocation TNameLoc = Name.TemplateId->TemplateNameLoc;
4164     return Context.getNameForTemplate(TName, TNameLoc);
4165   }
4166 
4167   } // switch (Name.getKind())
4168 
4169   llvm_unreachable("Unknown name kind");
4170 }
4171 
4172 static QualType getCoreType(QualType Ty) {
4173   do {
4174     if (Ty->isPointerType() || Ty->isReferenceType())
4175       Ty = Ty->getPointeeType();
4176     else if (Ty->isArrayType())
4177       Ty = Ty->castAsArrayTypeUnsafe()->getElementType();
4178     else
4179       return Ty.withoutLocalFastQualifiers();
4180   } while (true);
4181 }
4182 
4183 /// hasSimilarParameters - Determine whether the C++ functions Declaration
4184 /// and Definition have "nearly" matching parameters. This heuristic is
4185 /// used to improve diagnostics in the case where an out-of-line function
4186 /// definition doesn't match any declaration within the class or namespace.
4187 /// Also sets Params to the list of indices to the parameters that differ
4188 /// between the declaration and the definition. If hasSimilarParameters
4189 /// returns true and Params is empty, then all of the parameters match.
4190 static bool hasSimilarParameters(ASTContext &Context,
4191                                      FunctionDecl *Declaration,
4192                                      FunctionDecl *Definition,
4193                                      SmallVectorImpl<unsigned> &Params) {
4194   Params.clear();
4195   if (Declaration->param_size() != Definition->param_size())
4196     return false;
4197   for (unsigned Idx = 0; Idx < Declaration->param_size(); ++Idx) {
4198     QualType DeclParamTy = Declaration->getParamDecl(Idx)->getType();
4199     QualType DefParamTy = Definition->getParamDecl(Idx)->getType();
4200 
4201     // The parameter types are identical
4202     if (Context.hasSameType(DefParamTy, DeclParamTy))
4203       continue;
4204 
4205     QualType DeclParamBaseTy = getCoreType(DeclParamTy);
4206     QualType DefParamBaseTy = getCoreType(DefParamTy);
4207     const IdentifierInfo *DeclTyName = DeclParamBaseTy.getBaseTypeIdentifier();
4208     const IdentifierInfo *DefTyName = DefParamBaseTy.getBaseTypeIdentifier();
4209 
4210     if (Context.hasSameUnqualifiedType(DeclParamBaseTy, DefParamBaseTy) ||
4211         (DeclTyName && DeclTyName == DefTyName))
4212       Params.push_back(Idx);
4213     else  // The two parameters aren't even close
4214       return false;
4215   }
4216 
4217   return true;
4218 }
4219 
4220 /// NeedsRebuildingInCurrentInstantiation - Checks whether the given
4221 /// declarator needs to be rebuilt in the current instantiation.
4222 /// Any bits of declarator which appear before the name are valid for
4223 /// consideration here.  That's specifically the type in the decl spec
4224 /// and the base type in any member-pointer chunks.
4225 static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
4226                                                     DeclarationName Name) {
4227   // The types we specifically need to rebuild are:
4228   //   - typenames, typeofs, and decltypes
4229   //   - types which will become injected class names
4230   // Of course, we also need to rebuild any type referencing such a
4231   // type.  It's safest to just say "dependent", but we call out a
4232   // few cases here.
4233 
4234   DeclSpec &DS = D.getMutableDeclSpec();
4235   switch (DS.getTypeSpecType()) {
4236   case DeclSpec::TST_typename:
4237   case DeclSpec::TST_typeofType:
4238   case DeclSpec::TST_underlyingType:
4239   case DeclSpec::TST_atomic: {
4240     // Grab the type from the parser.
4241     TypeSourceInfo *TSI = nullptr;
4242     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
4243     if (T.isNull() || !T->isDependentType()) break;
4244 
4245     // Make sure there's a type source info.  This isn't really much
4246     // of a waste; most dependent types should have type source info
4247     // attached already.
4248     if (!TSI)
4249       TSI = S.Context.getTrivialTypeSourceInfo(T, DS.getTypeSpecTypeLoc());
4250 
4251     // Rebuild the type in the current instantiation.
4252     TSI = S.RebuildTypeInCurrentInstantiation(TSI, D.getIdentifierLoc(), Name);
4253     if (!TSI) return true;
4254 
4255     // Store the new type back in the decl spec.
4256     ParsedType LocType = S.CreateParsedType(TSI->getType(), TSI);
4257     DS.UpdateTypeRep(LocType);
4258     break;
4259   }
4260 
4261   case DeclSpec::TST_decltype:
4262   case DeclSpec::TST_typeofExpr: {
4263     Expr *E = DS.getRepAsExpr();
4264     ExprResult Result = S.RebuildExprInCurrentInstantiation(E);
4265     if (Result.isInvalid()) return true;
4266     DS.UpdateExprRep(Result.get());
4267     break;
4268   }
4269 
4270   default:
4271     // Nothing to do for these decl specs.
4272     break;
4273   }
4274 
4275   // It doesn't matter what order we do this in.
4276   for (unsigned I = 0, E = D.getNumTypeObjects(); I != E; ++I) {
4277     DeclaratorChunk &Chunk = D.getTypeObject(I);
4278 
4279     // The only type information in the declarator which can come
4280     // before the declaration name is the base type of a member
4281     // pointer.
4282     if (Chunk.Kind != DeclaratorChunk::MemberPointer)
4283       continue;
4284 
4285     // Rebuild the scope specifier in-place.
4286     CXXScopeSpec &SS = Chunk.Mem.Scope();
4287     if (S.RebuildNestedNameSpecifierInCurrentInstantiation(SS))
4288       return true;
4289   }
4290 
4291   return false;
4292 }
4293 
4294 Decl *Sema::ActOnDeclarator(Scope *S, Declarator &D) {
4295   D.setFunctionDefinitionKind(FDK_Declaration);
4296   Decl *Dcl = HandleDeclarator(S, D, MultiTemplateParamsArg());
4297 
4298   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer() &&
4299       Dcl && Dcl->getDeclContext()->isFileContext())
4300     Dcl->setTopLevelDeclInObjCContainer();
4301 
4302   return Dcl;
4303 }
4304 
4305 /// DiagnoseClassNameShadow - Implement C++ [class.mem]p13:
4306 ///   If T is the name of a class, then each of the following shall have a
4307 ///   name different from T:
4308 ///     - every static data member of class T;
4309 ///     - every member function of class T
4310 ///     - every member of class T that is itself a type;
4311 /// \returns true if the declaration name violates these rules.
4312 bool Sema::DiagnoseClassNameShadow(DeclContext *DC,
4313                                    DeclarationNameInfo NameInfo) {
4314   DeclarationName Name = NameInfo.getName();
4315 
4316   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(DC))
4317     if (Record->getIdentifier() && Record->getDeclName() == Name) {
4318       Diag(NameInfo.getLoc(), diag::err_member_name_of_class) << Name;
4319       return true;
4320     }
4321 
4322   return false;
4323 }
4324 
4325 /// \brief Diagnose a declaration whose declarator-id has the given
4326 /// nested-name-specifier.
4327 ///
4328 /// \param SS The nested-name-specifier of the declarator-id.
4329 ///
4330 /// \param DC The declaration context to which the nested-name-specifier
4331 /// resolves.
4332 ///
4333 /// \param Name The name of the entity being declared.
4334 ///
4335 /// \param Loc The location of the name of the entity being declared.
4336 ///
4337 /// \returns true if we cannot safely recover from this error, false otherwise.
4338 bool Sema::diagnoseQualifiedDeclaration(CXXScopeSpec &SS, DeclContext *DC,
4339                                         DeclarationName Name,
4340                                         SourceLocation Loc) {
4341   DeclContext *Cur = CurContext;
4342   while (isa<LinkageSpecDecl>(Cur) || isa<CapturedDecl>(Cur))
4343     Cur = Cur->getParent();
4344 
4345   // If the user provided a superfluous scope specifier that refers back to the
4346   // class in which the entity is already declared, diagnose and ignore it.
4347   //
4348   // class X {
4349   //   void X::f();
4350   // };
4351   //
4352   // Note, it was once ill-formed to give redundant qualification in all
4353   // contexts, but that rule was removed by DR482.
4354   if (Cur->Equals(DC)) {
4355     if (Cur->isRecord()) {
4356       Diag(Loc, LangOpts.MicrosoftExt ? diag::warn_member_extra_qualification
4357                                       : diag::err_member_extra_qualification)
4358         << Name << FixItHint::CreateRemoval(SS.getRange());
4359       SS.clear();
4360     } else {
4361       Diag(Loc, diag::warn_namespace_member_extra_qualification) << Name;
4362     }
4363     return false;
4364   }
4365 
4366   // Check whether the qualifying scope encloses the scope of the original
4367   // declaration.
4368   if (!Cur->Encloses(DC)) {
4369     if (Cur->isRecord())
4370       Diag(Loc, diag::err_member_qualification)
4371         << Name << SS.getRange();
4372     else if (isa<TranslationUnitDecl>(DC))
4373       Diag(Loc, diag::err_invalid_declarator_global_scope)
4374         << Name << SS.getRange();
4375     else if (isa<FunctionDecl>(Cur))
4376       Diag(Loc, diag::err_invalid_declarator_in_function)
4377         << Name << SS.getRange();
4378     else if (isa<BlockDecl>(Cur))
4379       Diag(Loc, diag::err_invalid_declarator_in_block)
4380         << Name << SS.getRange();
4381     else
4382       Diag(Loc, diag::err_invalid_declarator_scope)
4383       << Name << cast<NamedDecl>(Cur) << cast<NamedDecl>(DC) << SS.getRange();
4384 
4385     return true;
4386   }
4387 
4388   if (Cur->isRecord()) {
4389     // Cannot qualify members within a class.
4390     Diag(Loc, diag::err_member_qualification)
4391       << Name << SS.getRange();
4392     SS.clear();
4393 
4394     // C++ constructors and destructors with incorrect scopes can break
4395     // our AST invariants by having the wrong underlying types. If
4396     // that's the case, then drop this declaration entirely.
4397     if ((Name.getNameKind() == DeclarationName::CXXConstructorName ||
4398          Name.getNameKind() == DeclarationName::CXXDestructorName) &&
4399         !Context.hasSameType(Name.getCXXNameType(),
4400                              Context.getTypeDeclType(cast<CXXRecordDecl>(Cur))))
4401       return true;
4402 
4403     return false;
4404   }
4405 
4406   // C++11 [dcl.meaning]p1:
4407   //   [...] "The nested-name-specifier of the qualified declarator-id shall
4408   //   not begin with a decltype-specifer"
4409   NestedNameSpecifierLoc SpecLoc(SS.getScopeRep(), SS.location_data());
4410   while (SpecLoc.getPrefix())
4411     SpecLoc = SpecLoc.getPrefix();
4412   if (dyn_cast_or_null<DecltypeType>(
4413         SpecLoc.getNestedNameSpecifier()->getAsType()))
4414     Diag(Loc, diag::err_decltype_in_declarator)
4415       << SpecLoc.getTypeLoc().getSourceRange();
4416 
4417   return false;
4418 }
4419 
4420 NamedDecl *Sema::HandleDeclarator(Scope *S, Declarator &D,
4421                                   MultiTemplateParamsArg TemplateParamLists) {
4422   // TODO: consider using NameInfo for diagnostic.
4423   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
4424   DeclarationName Name = NameInfo.getName();
4425 
4426   // All of these full declarators require an identifier.  If it doesn't have
4427   // one, the ParsedFreeStandingDeclSpec action should be used.
4428   if (!Name) {
4429     if (!D.isInvalidType())  // Reject this if we think it is valid.
4430       Diag(D.getDeclSpec().getLocStart(),
4431            diag::err_declarator_need_ident)
4432         << D.getDeclSpec().getSourceRange() << D.getSourceRange();
4433     return nullptr;
4434   } else if (DiagnoseUnexpandedParameterPack(NameInfo, UPPC_DeclarationType))
4435     return nullptr;
4436 
4437   // The scope passed in may not be a decl scope.  Zip up the scope tree until
4438   // we find one that is.
4439   while ((S->getFlags() & Scope::DeclScope) == 0 ||
4440          (S->getFlags() & Scope::TemplateParamScope) != 0)
4441     S = S->getParent();
4442 
4443   DeclContext *DC = CurContext;
4444   if (D.getCXXScopeSpec().isInvalid())
4445     D.setInvalidType();
4446   else if (D.getCXXScopeSpec().isSet()) {
4447     if (DiagnoseUnexpandedParameterPack(D.getCXXScopeSpec(),
4448                                         UPPC_DeclarationQualifier))
4449       return nullptr;
4450 
4451     bool EnteringContext = !D.getDeclSpec().isFriendSpecified();
4452     DC = computeDeclContext(D.getCXXScopeSpec(), EnteringContext);
4453     if (!DC || isa<EnumDecl>(DC)) {
4454       // If we could not compute the declaration context, it's because the
4455       // declaration context is dependent but does not refer to a class,
4456       // class template, or class template partial specialization. Complain
4457       // and return early, to avoid the coming semantic disaster.
4458       Diag(D.getIdentifierLoc(),
4459            diag::err_template_qualified_declarator_no_match)
4460         << D.getCXXScopeSpec().getScopeRep()
4461         << D.getCXXScopeSpec().getRange();
4462       return nullptr;
4463     }
4464     bool IsDependentContext = DC->isDependentContext();
4465 
4466     if (!IsDependentContext &&
4467         RequireCompleteDeclContext(D.getCXXScopeSpec(), DC))
4468       return nullptr;
4469 
4470     if (isa<CXXRecordDecl>(DC) && !cast<CXXRecordDecl>(DC)->hasDefinition()) {
4471       Diag(D.getIdentifierLoc(),
4472            diag::err_member_def_undefined_record)
4473         << Name << DC << D.getCXXScopeSpec().getRange();
4474       D.setInvalidType();
4475     } else if (!D.getDeclSpec().isFriendSpecified()) {
4476       if (diagnoseQualifiedDeclaration(D.getCXXScopeSpec(), DC,
4477                                       Name, D.getIdentifierLoc())) {
4478         if (DC->isRecord())
4479           return nullptr;
4480 
4481         D.setInvalidType();
4482       }
4483     }
4484 
4485     // Check whether we need to rebuild the type of the given
4486     // declaration in the current instantiation.
4487     if (EnteringContext && IsDependentContext &&
4488         TemplateParamLists.size() != 0) {
4489       ContextRAII SavedContext(*this, DC);
4490       if (RebuildDeclaratorInCurrentInstantiation(*this, D, Name))
4491         D.setInvalidType();
4492     }
4493   }
4494 
4495   if (DiagnoseClassNameShadow(DC, NameInfo))
4496     // If this is a typedef, we'll end up spewing multiple diagnostics.
4497     // Just return early; it's safer.
4498     if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4499       return nullptr;
4500 
4501   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
4502   QualType R = TInfo->getType();
4503 
4504   if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
4505                                       UPPC_DeclarationType))
4506     D.setInvalidType();
4507 
4508   LookupResult Previous(*this, NameInfo, LookupOrdinaryName,
4509                         ForRedeclaration);
4510 
4511   // See if this is a redefinition of a variable in the same scope.
4512   if (!D.getCXXScopeSpec().isSet()) {
4513     bool IsLinkageLookup = false;
4514     bool CreateBuiltins = false;
4515 
4516     // If the declaration we're planning to build will be a function
4517     // or object with linkage, then look for another declaration with
4518     // linkage (C99 6.2.2p4-5 and C++ [basic.link]p6).
4519     //
4520     // If the declaration we're planning to build will be declared with
4521     // external linkage in the translation unit, create any builtin with
4522     // the same name.
4523     if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef)
4524       /* Do nothing*/;
4525     else if (CurContext->isFunctionOrMethod() &&
4526              (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_extern ||
4527               R->isFunctionType())) {
4528       IsLinkageLookup = true;
4529       CreateBuiltins =
4530           CurContext->getEnclosingNamespaceContext()->isTranslationUnit();
4531     } else if (CurContext->getRedeclContext()->isTranslationUnit() &&
4532                D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_static)
4533       CreateBuiltins = true;
4534 
4535     if (IsLinkageLookup)
4536       Previous.clear(LookupRedeclarationWithLinkage);
4537 
4538     LookupName(Previous, S, CreateBuiltins);
4539   } else { // Something like "int foo::x;"
4540     LookupQualifiedName(Previous, DC);
4541 
4542     // C++ [dcl.meaning]p1:
4543     //   When the declarator-id is qualified, the declaration shall refer to a
4544     //  previously declared member of the class or namespace to which the
4545     //  qualifier refers (or, in the case of a namespace, of an element of the
4546     //  inline namespace set of that namespace (7.3.1)) or to a specialization
4547     //  thereof; [...]
4548     //
4549     // Note that we already checked the context above, and that we do not have
4550     // enough information to make sure that Previous contains the declaration
4551     // we want to match. For example, given:
4552     //
4553     //   class X {
4554     //     void f();
4555     //     void f(float);
4556     //   };
4557     //
4558     //   void X::f(int) { } // ill-formed
4559     //
4560     // In this case, Previous will point to the overload set
4561     // containing the two f's declared in X, but neither of them
4562     // matches.
4563 
4564     // C++ [dcl.meaning]p1:
4565     //   [...] the member shall not merely have been introduced by a
4566     //   using-declaration in the scope of the class or namespace nominated by
4567     //   the nested-name-specifier of the declarator-id.
4568     RemoveUsingDecls(Previous);
4569   }
4570 
4571   if (Previous.isSingleResult() &&
4572       Previous.getFoundDecl()->isTemplateParameter()) {
4573     // Maybe we will complain about the shadowed template parameter.
4574     if (!D.isInvalidType())
4575       DiagnoseTemplateParameterShadow(D.getIdentifierLoc(),
4576                                       Previous.getFoundDecl());
4577 
4578     // Just pretend that we didn't see the previous declaration.
4579     Previous.clear();
4580   }
4581 
4582   // In C++, the previous declaration we find might be a tag type
4583   // (class or enum). In this case, the new declaration will hide the
4584   // tag type. Note that this does does not apply if we're declaring a
4585   // typedef (C++ [dcl.typedef]p4).
4586   if (Previous.isSingleTagDecl() &&
4587       D.getDeclSpec().getStorageClassSpec() != DeclSpec::SCS_typedef)
4588     Previous.clear();
4589 
4590   // Check that there are no default arguments other than in the parameters
4591   // of a function declaration (C++ only).
4592   if (getLangOpts().CPlusPlus)
4593     CheckExtraCXXDefaultArguments(D);
4594 
4595   NamedDecl *New;
4596 
4597   bool AddToScope = true;
4598   if (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_typedef) {
4599     if (TemplateParamLists.size()) {
4600       Diag(D.getIdentifierLoc(), diag::err_template_typedef);
4601       return nullptr;
4602     }
4603 
4604     New = ActOnTypedefDeclarator(S, D, DC, TInfo, Previous);
4605   } else if (R->isFunctionType()) {
4606     New = ActOnFunctionDeclarator(S, D, DC, TInfo, Previous,
4607                                   TemplateParamLists,
4608                                   AddToScope);
4609   } else {
4610     New = ActOnVariableDeclarator(S, D, DC, TInfo, Previous, TemplateParamLists,
4611                                   AddToScope);
4612   }
4613 
4614   if (!New)
4615     return nullptr;
4616 
4617   // If this has an identifier and is not an invalid redeclaration or
4618   // function template specialization, add it to the scope stack.
4619   if (New->getDeclName() && AddToScope &&
4620        !(D.isRedeclaration() && New->isInvalidDecl())) {
4621     // Only make a locally-scoped extern declaration visible if it is the first
4622     // declaration of this entity. Qualified lookup for such an entity should
4623     // only find this declaration if there is no visible declaration of it.
4624     bool AddToContext = !D.isRedeclaration() || !New->isLocalExternDecl();
4625     PushOnScopeChains(New, S, AddToContext);
4626     if (!AddToContext)
4627       CurContext->addHiddenDecl(New);
4628   }
4629 
4630   return New;
4631 }
4632 
4633 /// Helper method to turn variable array types into constant array
4634 /// types in certain situations which would otherwise be errors (for
4635 /// GCC compatibility).
4636 static QualType TryToFixInvalidVariablyModifiedType(QualType T,
4637                                                     ASTContext &Context,
4638                                                     bool &SizeIsNegative,
4639                                                     llvm::APSInt &Oversized) {
4640   // This method tries to turn a variable array into a constant
4641   // array even when the size isn't an ICE.  This is necessary
4642   // for compatibility with code that depends on gcc's buggy
4643   // constant expression folding, like struct {char x[(int)(char*)2];}
4644   SizeIsNegative = false;
4645   Oversized = 0;
4646 
4647   if (T->isDependentType())
4648     return QualType();
4649 
4650   QualifierCollector Qs;
4651   const Type *Ty = Qs.strip(T);
4652 
4653   if (const PointerType* PTy = dyn_cast<PointerType>(Ty)) {
4654     QualType Pointee = PTy->getPointeeType();
4655     QualType FixedType =
4656         TryToFixInvalidVariablyModifiedType(Pointee, Context, SizeIsNegative,
4657                                             Oversized);
4658     if (FixedType.isNull()) return FixedType;
4659     FixedType = Context.getPointerType(FixedType);
4660     return Qs.apply(Context, FixedType);
4661   }
4662   if (const ParenType* PTy = dyn_cast<ParenType>(Ty)) {
4663     QualType Inner = PTy->getInnerType();
4664     QualType FixedType =
4665         TryToFixInvalidVariablyModifiedType(Inner, Context, SizeIsNegative,
4666                                             Oversized);
4667     if (FixedType.isNull()) return FixedType;
4668     FixedType = Context.getParenType(FixedType);
4669     return Qs.apply(Context, FixedType);
4670   }
4671 
4672   const VariableArrayType* VLATy = dyn_cast<VariableArrayType>(T);
4673   if (!VLATy)
4674     return QualType();
4675   // FIXME: We should probably handle this case
4676   if (VLATy->getElementType()->isVariablyModifiedType())
4677     return QualType();
4678 
4679   llvm::APSInt Res;
4680   if (!VLATy->getSizeExpr() ||
4681       !VLATy->getSizeExpr()->EvaluateAsInt(Res, Context))
4682     return QualType();
4683 
4684   // Check whether the array size is negative.
4685   if (Res.isSigned() && Res.isNegative()) {
4686     SizeIsNegative = true;
4687     return QualType();
4688   }
4689 
4690   // Check whether the array is too large to be addressed.
4691   unsigned ActiveSizeBits
4692     = ConstantArrayType::getNumAddressingBits(Context, VLATy->getElementType(),
4693                                               Res);
4694   if (ActiveSizeBits > ConstantArrayType::getMaxSizeBits(Context)) {
4695     Oversized = Res;
4696     return QualType();
4697   }
4698 
4699   return Context.getConstantArrayType(VLATy->getElementType(),
4700                                       Res, ArrayType::Normal, 0);
4701 }
4702 
4703 static void
4704 FixInvalidVariablyModifiedTypeLoc(TypeLoc SrcTL, TypeLoc DstTL) {
4705   if (PointerTypeLoc SrcPTL = SrcTL.getAs<PointerTypeLoc>()) {
4706     PointerTypeLoc DstPTL = DstTL.castAs<PointerTypeLoc>();
4707     FixInvalidVariablyModifiedTypeLoc(SrcPTL.getPointeeLoc(),
4708                                       DstPTL.getPointeeLoc());
4709     DstPTL.setStarLoc(SrcPTL.getStarLoc());
4710     return;
4711   }
4712   if (ParenTypeLoc SrcPTL = SrcTL.getAs<ParenTypeLoc>()) {
4713     ParenTypeLoc DstPTL = DstTL.castAs<ParenTypeLoc>();
4714     FixInvalidVariablyModifiedTypeLoc(SrcPTL.getInnerLoc(),
4715                                       DstPTL.getInnerLoc());
4716     DstPTL.setLParenLoc(SrcPTL.getLParenLoc());
4717     DstPTL.setRParenLoc(SrcPTL.getRParenLoc());
4718     return;
4719   }
4720   ArrayTypeLoc SrcATL = SrcTL.castAs<ArrayTypeLoc>();
4721   ArrayTypeLoc DstATL = DstTL.castAs<ArrayTypeLoc>();
4722   TypeLoc SrcElemTL = SrcATL.getElementLoc();
4723   TypeLoc DstElemTL = DstATL.getElementLoc();
4724   DstElemTL.initializeFullCopy(SrcElemTL);
4725   DstATL.setLBracketLoc(SrcATL.getLBracketLoc());
4726   DstATL.setSizeExpr(SrcATL.getSizeExpr());
4727   DstATL.setRBracketLoc(SrcATL.getRBracketLoc());
4728 }
4729 
4730 /// Helper method to turn variable array types into constant array
4731 /// types in certain situations which would otherwise be errors (for
4732 /// GCC compatibility).
4733 static TypeSourceInfo*
4734 TryToFixInvalidVariablyModifiedTypeSourceInfo(TypeSourceInfo *TInfo,
4735                                               ASTContext &Context,
4736                                               bool &SizeIsNegative,
4737                                               llvm::APSInt &Oversized) {
4738   QualType FixedTy
4739     = TryToFixInvalidVariablyModifiedType(TInfo->getType(), Context,
4740                                           SizeIsNegative, Oversized);
4741   if (FixedTy.isNull())
4742     return nullptr;
4743   TypeSourceInfo *FixedTInfo = Context.getTrivialTypeSourceInfo(FixedTy);
4744   FixInvalidVariablyModifiedTypeLoc(TInfo->getTypeLoc(),
4745                                     FixedTInfo->getTypeLoc());
4746   return FixedTInfo;
4747 }
4748 
4749 /// \brief Register the given locally-scoped extern "C" declaration so
4750 /// that it can be found later for redeclarations. We include any extern "C"
4751 /// declaration that is not visible in the translation unit here, not just
4752 /// function-scope declarations.
4753 void
4754 Sema::RegisterLocallyScopedExternCDecl(NamedDecl *ND, Scope *S) {
4755   if (!getLangOpts().CPlusPlus &&
4756       ND->getLexicalDeclContext()->getRedeclContext()->isTranslationUnit())
4757     // Don't need to track declarations in the TU in C.
4758     return;
4759 
4760   // Note that we have a locally-scoped external with this name.
4761   // FIXME: There can be multiple such declarations if they are functions marked
4762   // __attribute__((overloadable)) declared in function scope in C.
4763   LocallyScopedExternCDecls[ND->getDeclName()] = ND;
4764 }
4765 
4766 NamedDecl *Sema::findLocallyScopedExternCDecl(DeclarationName Name) {
4767   if (ExternalSource) {
4768     // Load locally-scoped external decls from the external source.
4769     // FIXME: This is inefficient. Maybe add a DeclContext for extern "C" decls?
4770     SmallVector<NamedDecl *, 4> Decls;
4771     ExternalSource->ReadLocallyScopedExternCDecls(Decls);
4772     for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
4773       llvm::DenseMap<DeclarationName, NamedDecl *>::iterator Pos
4774         = LocallyScopedExternCDecls.find(Decls[I]->getDeclName());
4775       if (Pos == LocallyScopedExternCDecls.end())
4776         LocallyScopedExternCDecls[Decls[I]->getDeclName()] = Decls[I];
4777     }
4778   }
4779 
4780   NamedDecl *D = LocallyScopedExternCDecls.lookup(Name);
4781   return D ? D->getMostRecentDecl() : nullptr;
4782 }
4783 
4784 /// \brief Diagnose function specifiers on a declaration of an identifier that
4785 /// does not identify a function.
4786 void Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {
4787   // FIXME: We should probably indicate the identifier in question to avoid
4788   // confusion for constructs like "inline int a(), b;"
4789   if (DS.isInlineSpecified())
4790     Diag(DS.getInlineSpecLoc(),
4791          diag::err_inline_non_function);
4792 
4793   if (DS.isVirtualSpecified())
4794     Diag(DS.getVirtualSpecLoc(),
4795          diag::err_virtual_non_function);
4796 
4797   if (DS.isExplicitSpecified())
4798     Diag(DS.getExplicitSpecLoc(),
4799          diag::err_explicit_non_function);
4800 
4801   if (DS.isNoreturnSpecified())
4802     Diag(DS.getNoreturnSpecLoc(),
4803          diag::err_noreturn_non_function);
4804 }
4805 
4806 NamedDecl*
4807 Sema::ActOnTypedefDeclarator(Scope* S, Declarator& D, DeclContext* DC,
4808                              TypeSourceInfo *TInfo, LookupResult &Previous) {
4809   // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).
4810   if (D.getCXXScopeSpec().isSet()) {
4811     Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator)
4812       << D.getCXXScopeSpec().getRange();
4813     D.setInvalidType();
4814     // Pretend we didn't see the scope specifier.
4815     DC = CurContext;
4816     Previous.clear();
4817   }
4818 
4819   DiagnoseFunctionSpecifiers(D.getDeclSpec());
4820 
4821   if (D.getDeclSpec().isConstexprSpecified())
4822     Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_invalid_constexpr)
4823       << 1;
4824 
4825   if (D.getName().Kind != UnqualifiedId::IK_Identifier) {
4826     Diag(D.getName().StartLocation, diag::err_typedef_not_identifier)
4827       << D.getName().getSourceRange();
4828     return nullptr;
4829   }
4830 
4831   TypedefDecl *NewTD = ParseTypedefDecl(S, D, TInfo->getType(), TInfo);
4832   if (!NewTD) return nullptr;
4833 
4834   // Handle attributes prior to checking for duplicates in MergeVarDecl
4835   ProcessDeclAttributes(S, NewTD, D);
4836 
4837   CheckTypedefForVariablyModifiedType(S, NewTD);
4838 
4839   bool Redeclaration = D.isRedeclaration();
4840   NamedDecl *ND = ActOnTypedefNameDecl(S, DC, NewTD, Previous, Redeclaration);
4841   D.setRedeclaration(Redeclaration);
4842   return ND;
4843 }
4844 
4845 void
4846 Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {
4847   // C99 6.7.7p2: If a typedef name specifies a variably modified type
4848   // then it shall have block scope.
4849   // Note that variably modified types must be fixed before merging the decl so
4850   // that redeclarations will match.
4851   TypeSourceInfo *TInfo = NewTD->getTypeSourceInfo();
4852   QualType T = TInfo->getType();
4853   if (T->isVariablyModifiedType()) {
4854     getCurFunction()->setHasBranchProtectedScope();
4855 
4856     if (S->getFnParent() == nullptr) {
4857       bool SizeIsNegative;
4858       llvm::APSInt Oversized;
4859       TypeSourceInfo *FixedTInfo =
4860         TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
4861                                                       SizeIsNegative,
4862                                                       Oversized);
4863       if (FixedTInfo) {
4864         Diag(NewTD->getLocation(), diag::warn_illegal_constant_array_size);
4865         NewTD->setTypeSourceInfo(FixedTInfo);
4866       } else {
4867         if (SizeIsNegative)
4868           Diag(NewTD->getLocation(), diag::err_typecheck_negative_array_size);
4869         else if (T->isVariableArrayType())
4870           Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);
4871         else if (Oversized.getBoolValue())
4872           Diag(NewTD->getLocation(), diag::err_array_too_large)
4873             << Oversized.toString(10);
4874         else
4875           Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);
4876         NewTD->setInvalidDecl();
4877       }
4878     }
4879   }
4880 }
4881 
4882 
4883 /// ActOnTypedefNameDecl - Perform semantic checking for a declaration which
4884 /// declares a typedef-name, either using the 'typedef' type specifier or via
4885 /// a C++0x [dcl.typedef]p2 alias-declaration: 'using T = A;'.
4886 NamedDecl*
4887 Sema::ActOnTypedefNameDecl(Scope *S, DeclContext *DC, TypedefNameDecl *NewTD,
4888                            LookupResult &Previous, bool &Redeclaration) {
4889   // Merge the decl with the existing one if appropriate. If the decl is
4890   // in an outer scope, it isn't the same thing.
4891   FilterLookupForScope(Previous, DC, S, /*ConsiderLinkage*/false,
4892                        /*AllowInlineNamespace*/false);
4893   filterNonConflictingPreviousTypedefDecls(Context, NewTD, Previous);
4894   if (!Previous.empty()) {
4895     Redeclaration = true;
4896     MergeTypedefNameDecl(NewTD, Previous);
4897   }
4898 
4899   // If this is the C FILE type, notify the AST context.
4900   if (IdentifierInfo *II = NewTD->getIdentifier())
4901     if (!NewTD->isInvalidDecl() &&
4902         NewTD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
4903       if (II->isStr("FILE"))
4904         Context.setFILEDecl(NewTD);
4905       else if (II->isStr("jmp_buf"))
4906         Context.setjmp_bufDecl(NewTD);
4907       else if (II->isStr("sigjmp_buf"))
4908         Context.setsigjmp_bufDecl(NewTD);
4909       else if (II->isStr("ucontext_t"))
4910         Context.setucontext_tDecl(NewTD);
4911     }
4912 
4913   return NewTD;
4914 }
4915 
4916 /// \brief Determines whether the given declaration is an out-of-scope
4917 /// previous declaration.
4918 ///
4919 /// This routine should be invoked when name lookup has found a
4920 /// previous declaration (PrevDecl) that is not in the scope where a
4921 /// new declaration by the same name is being introduced. If the new
4922 /// declaration occurs in a local scope, previous declarations with
4923 /// linkage may still be considered previous declarations (C99
4924 /// 6.2.2p4-5, C++ [basic.link]p6).
4925 ///
4926 /// \param PrevDecl the previous declaration found by name
4927 /// lookup
4928 ///
4929 /// \param DC the context in which the new declaration is being
4930 /// declared.
4931 ///
4932 /// \returns true if PrevDecl is an out-of-scope previous declaration
4933 /// for a new delcaration with the same name.
4934 static bool
4935 isOutOfScopePreviousDeclaration(NamedDecl *PrevDecl, DeclContext *DC,
4936                                 ASTContext &Context) {
4937   if (!PrevDecl)
4938     return false;
4939 
4940   if (!PrevDecl->hasLinkage())
4941     return false;
4942 
4943   if (Context.getLangOpts().CPlusPlus) {
4944     // C++ [basic.link]p6:
4945     //   If there is a visible declaration of an entity with linkage
4946     //   having the same name and type, ignoring entities declared
4947     //   outside the innermost enclosing namespace scope, the block
4948     //   scope declaration declares that same entity and receives the
4949     //   linkage of the previous declaration.
4950     DeclContext *OuterContext = DC->getRedeclContext();
4951     if (!OuterContext->isFunctionOrMethod())
4952       // This rule only applies to block-scope declarations.
4953       return false;
4954 
4955     DeclContext *PrevOuterContext = PrevDecl->getDeclContext();
4956     if (PrevOuterContext->isRecord())
4957       // We found a member function: ignore it.
4958       return false;
4959 
4960     // Find the innermost enclosing namespace for the new and
4961     // previous declarations.
4962     OuterContext = OuterContext->getEnclosingNamespaceContext();
4963     PrevOuterContext = PrevOuterContext->getEnclosingNamespaceContext();
4964 
4965     // The previous declaration is in a different namespace, so it
4966     // isn't the same function.
4967     if (!OuterContext->Equals(PrevOuterContext))
4968       return false;
4969   }
4970 
4971   return true;
4972 }
4973 
4974 static void SetNestedNameSpecifier(DeclaratorDecl *DD, Declarator &D) {
4975   CXXScopeSpec &SS = D.getCXXScopeSpec();
4976   if (!SS.isSet()) return;
4977   DD->setQualifierInfo(SS.getWithLocInContext(DD->getASTContext()));
4978 }
4979 
4980 bool Sema::inferObjCARCLifetime(ValueDecl *decl) {
4981   QualType type = decl->getType();
4982   Qualifiers::ObjCLifetime lifetime = type.getObjCLifetime();
4983   if (lifetime == Qualifiers::OCL_Autoreleasing) {
4984     // Various kinds of declaration aren't allowed to be __autoreleasing.
4985     unsigned kind = -1U;
4986     if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
4987       if (var->hasAttr<BlocksAttr>())
4988         kind = 0; // __block
4989       else if (!var->hasLocalStorage())
4990         kind = 1; // global
4991     } else if (isa<ObjCIvarDecl>(decl)) {
4992       kind = 3; // ivar
4993     } else if (isa<FieldDecl>(decl)) {
4994       kind = 2; // field
4995     }
4996 
4997     if (kind != -1U) {
4998       Diag(decl->getLocation(), diag::err_arc_autoreleasing_var)
4999         << kind;
5000     }
5001   } else if (lifetime == Qualifiers::OCL_None) {
5002     // Try to infer lifetime.
5003     if (!type->isObjCLifetimeType())
5004       return false;
5005 
5006     lifetime = type->getObjCARCImplicitLifetime();
5007     type = Context.getLifetimeQualifiedType(type, lifetime);
5008     decl->setType(type);
5009   }
5010 
5011   if (VarDecl *var = dyn_cast<VarDecl>(decl)) {
5012     // Thread-local variables cannot have lifetime.
5013     if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone &&
5014         var->getTLSKind()) {
5015       Diag(var->getLocation(), diag::err_arc_thread_ownership)
5016         << var->getType();
5017       return true;
5018     }
5019   }
5020 
5021   return false;
5022 }
5023 
5024 static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {
5025   // Ensure that an auto decl is deduced otherwise the checks below might cache
5026   // the wrong linkage.
5027   assert(S.ParsingInitForAutoVars.count(&ND) == 0);
5028 
5029   // 'weak' only applies to declarations with external linkage.
5030   if (WeakAttr *Attr = ND.getAttr<WeakAttr>()) {
5031     if (!ND.isExternallyVisible()) {
5032       S.Diag(Attr->getLocation(), diag::err_attribute_weak_static);
5033       ND.dropAttr<WeakAttr>();
5034     }
5035   }
5036   if (WeakRefAttr *Attr = ND.getAttr<WeakRefAttr>()) {
5037     if (ND.isExternallyVisible()) {
5038       S.Diag(Attr->getLocation(), diag::err_attribute_weakref_not_static);
5039       ND.dropAttr<WeakRefAttr>();
5040     }
5041   }
5042 
5043   // 'selectany' only applies to externally visible varable declarations.
5044   // It does not apply to functions.
5045   if (SelectAnyAttr *Attr = ND.getAttr<SelectAnyAttr>()) {
5046     if (isa<FunctionDecl>(ND) || !ND.isExternallyVisible()) {
5047       S.Diag(Attr->getLocation(), diag::err_attribute_selectany_non_extern_data);
5048       ND.dropAttr<SelectAnyAttr>();
5049     }
5050   }
5051 
5052   // dll attributes require external linkage.
5053   if (const DLLImportAttr *Attr = ND.getAttr<DLLImportAttr>()) {
5054     if (!ND.isExternallyVisible()) {
5055       S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5056         << &ND << Attr;
5057       ND.setInvalidDecl();
5058     }
5059   }
5060   if (const DLLExportAttr *Attr = ND.getAttr<DLLExportAttr>()) {
5061     if (!ND.isExternallyVisible()) {
5062       S.Diag(ND.getLocation(), diag::err_attribute_dll_not_extern)
5063         << &ND << Attr;
5064       ND.setInvalidDecl();
5065     }
5066   }
5067 }
5068 
5069 static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl,
5070                                            NamedDecl *NewDecl,
5071                                            bool IsSpecialization) {
5072   if (TemplateDecl *OldTD = dyn_cast<TemplateDecl>(OldDecl))
5073     OldDecl = OldTD->getTemplatedDecl();
5074   if (TemplateDecl *NewTD = dyn_cast<TemplateDecl>(NewDecl))
5075     NewDecl = NewTD->getTemplatedDecl();
5076 
5077   if (!OldDecl || !NewDecl)
5078     return;
5079 
5080   const DLLImportAttr *OldImportAttr = OldDecl->getAttr<DLLImportAttr>();
5081   const DLLExportAttr *OldExportAttr = OldDecl->getAttr<DLLExportAttr>();
5082   const DLLImportAttr *NewImportAttr = NewDecl->getAttr<DLLImportAttr>();
5083   const DLLExportAttr *NewExportAttr = NewDecl->getAttr<DLLExportAttr>();
5084 
5085   // dllimport and dllexport are inheritable attributes so we have to exclude
5086   // inherited attribute instances.
5087   bool HasNewAttr = (NewImportAttr && !NewImportAttr->isInherited()) ||
5088                     (NewExportAttr && !NewExportAttr->isInherited());
5089 
5090   // A redeclaration is not allowed to add a dllimport or dllexport attribute,
5091   // the only exception being explicit specializations.
5092   // Implicitly generated declarations are also excluded for now because there
5093   // is no other way to switch these to use dllimport or dllexport.
5094   bool AddsAttr = !(OldImportAttr || OldExportAttr) && HasNewAttr;
5095 
5096   if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {
5097     // If the declaration hasn't been used yet, allow with a warning for
5098     // free functions and global variables.
5099     bool JustWarn = false;
5100     if (!OldDecl->isUsed() && OldDecl->getDeclContext()->isFileContext()) {
5101       auto *VD = dyn_cast<VarDecl>(OldDecl);
5102       if (VD && !VD->getDescribedVarTemplate())
5103         JustWarn = true;
5104       auto *FD = dyn_cast<FunctionDecl>(OldDecl);
5105       if (FD && FD->getTemplatedKind() == FunctionDecl::TK_NonTemplate)
5106         JustWarn = true;
5107     }
5108 
5109     unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration
5110                                : diag::err_attribute_dll_redeclaration;
5111     S.Diag(NewDecl->getLocation(), DiagID)
5112         << NewDecl
5113         << (NewImportAttr ? (const Attr *)NewImportAttr : NewExportAttr);
5114     S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5115     if (!JustWarn) {
5116       NewDecl->setInvalidDecl();
5117       return;
5118     }
5119   }
5120 
5121   // A redeclaration is not allowed to drop a dllimport attribute, the only
5122   // exceptions being inline function definitions, local extern declarations,
5123   // and qualified friend declarations.
5124   // NB: MSVC converts such a declaration to dllexport.
5125   bool IsInline = false, IsStaticDataMember = false, IsQualifiedFriend = false;
5126   if (const auto *VD = dyn_cast<VarDecl>(NewDecl))
5127     // Ignore static data because out-of-line definitions are diagnosed
5128     // separately.
5129     IsStaticDataMember = VD->isStaticDataMember();
5130   else if (const auto *FD = dyn_cast<FunctionDecl>(NewDecl)) {
5131     IsInline = FD->isInlined();
5132     IsQualifiedFriend = FD->getQualifier() &&
5133                         FD->getFriendObjectKind() == Decl::FOK_Declared;
5134   }
5135 
5136   if (OldImportAttr && !HasNewAttr && !IsInline && !IsStaticDataMember &&
5137       !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {
5138     S.Diag(NewDecl->getLocation(),
5139            diag::warn_redeclaration_without_attribute_prev_attribute_ignored)
5140       << NewDecl << OldImportAttr;
5141     S.Diag(OldDecl->getLocation(), diag::note_previous_declaration);
5142     S.Diag(OldImportAttr->getLocation(), diag::note_previous_attribute);
5143     OldDecl->dropAttr<DLLImportAttr>();
5144     NewDecl->dropAttr<DLLImportAttr>();
5145   }
5146 }
5147 
5148 /// Given that we are within the definition of the given function,
5149 /// will that definition behave like C99's 'inline', where the
5150 /// definition is discarded except for optimization purposes?
5151 static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
5152   // Try to avoid calling GetGVALinkageForFunction.
5153 
5154   // All cases of this require the 'inline' keyword.
5155   if (!FD->isInlined()) return false;
5156 
5157   // This is only possible in C++ with the gnu_inline attribute.
5158   if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
5159     return false;
5160 
5161   // Okay, go ahead and call the relatively-more-expensive function.
5162 
5163 #ifndef NDEBUG
5164   // AST quite reasonably asserts that it's working on a function
5165   // definition.  We don't really have a way to tell it that we're
5166   // currently defining the function, so just lie to it in +Asserts
5167   // builds.  This is an awful hack.
5168   FD->setLazyBody(1);
5169 #endif
5170 
5171   bool isC99Inline =
5172       S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
5173 
5174 #ifndef NDEBUG
5175   FD->setLazyBody(0);
5176 #endif
5177 
5178   return isC99Inline;
5179 }
5180 
5181 /// Determine whether a variable is extern "C" prior to attaching
5182 /// an initializer. We can't just call isExternC() here, because that
5183 /// will also compute and cache whether the declaration is externally
5184 /// visible, which might change when we attach the initializer.
5185 ///
5186 /// This can only be used if the declaration is known to not be a
5187 /// redeclaration of an internal linkage declaration.
5188 ///
5189 /// For instance:
5190 ///
5191 ///   auto x = []{};
5192 ///
5193 /// Attaching the initializer here makes this declaration not externally
5194 /// visible, because its type has internal linkage.
5195 ///
5196 /// FIXME: This is a hack.
5197 template<typename T>
5198 static bool isIncompleteDeclExternC(Sema &S, const T *D) {
5199   if (S.getLangOpts().CPlusPlus) {
5200     // In C++, the overloadable attribute negates the effects of extern "C".
5201     if (!D->isInExternCContext() || D->template hasAttr<OverloadableAttr>())
5202       return false;
5203   }
5204   return D->isExternC();
5205 }
5206 
5207 static bool shouldConsiderLinkage(const VarDecl *VD) {
5208   const DeclContext *DC = VD->getDeclContext()->getRedeclContext();
5209   if (DC->isFunctionOrMethod())
5210     return VD->hasExternalStorage();
5211   if (DC->isFileContext())
5212     return true;
5213   if (DC->isRecord())
5214     return false;
5215   llvm_unreachable("Unexpected context");
5216 }
5217 
5218 static bool shouldConsiderLinkage(const FunctionDecl *FD) {
5219   const DeclContext *DC = FD->getDeclContext()->getRedeclContext();
5220   if (DC->isFileContext() || DC->isFunctionOrMethod())
5221     return true;
5222   if (DC->isRecord())
5223     return false;
5224   llvm_unreachable("Unexpected context");
5225 }
5226 
5227 static bool hasParsedAttr(Scope *S, const AttributeList *AttrList,
5228                           AttributeList::Kind Kind) {
5229   for (const AttributeList *L = AttrList; L; L = L->getNext())
5230     if (L->getKind() == Kind)
5231       return true;
5232   return false;
5233 }
5234 
5235 static bool hasParsedAttr(Scope *S, const Declarator &PD,
5236                           AttributeList::Kind Kind) {
5237   // Check decl attributes on the DeclSpec.
5238   if (hasParsedAttr(S, PD.getDeclSpec().getAttributes().getList(), Kind))
5239     return true;
5240 
5241   // Walk the declarator structure, checking decl attributes that were in a type
5242   // position to the decl itself.
5243   for (unsigned I = 0, E = PD.getNumTypeObjects(); I != E; ++I) {
5244     if (hasParsedAttr(S, PD.getTypeObject(I).getAttrs(), Kind))
5245       return true;
5246   }
5247 
5248   // Finally, check attributes on the decl itself.
5249   return hasParsedAttr(S, PD.getAttributes(), Kind);
5250 }
5251 
5252 /// Adjust the \c DeclContext for a function or variable that might be a
5253 /// function-local external declaration.
5254 bool Sema::adjustContextForLocalExternDecl(DeclContext *&DC) {
5255   if (!DC->isFunctionOrMethod())
5256     return false;
5257 
5258   // If this is a local extern function or variable declared within a function
5259   // template, don't add it into the enclosing namespace scope until it is
5260   // instantiated; it might have a dependent type right now.
5261   if (DC->isDependentContext())
5262     return true;
5263 
5264   // C++11 [basic.link]p7:
5265   //   When a block scope declaration of an entity with linkage is not found to
5266   //   refer to some other declaration, then that entity is a member of the
5267   //   innermost enclosing namespace.
5268   //
5269   // Per C++11 [namespace.def]p6, the innermost enclosing namespace is a
5270   // semantically-enclosing namespace, not a lexically-enclosing one.
5271   while (!DC->isFileContext() && !isa<LinkageSpecDecl>(DC))
5272     DC = DC->getParent();
5273   return true;
5274 }
5275 
5276 NamedDecl *
5277 Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC,
5278                               TypeSourceInfo *TInfo, LookupResult &Previous,
5279                               MultiTemplateParamsArg TemplateParamLists,
5280                               bool &AddToScope) {
5281   QualType R = TInfo->getType();
5282   DeclarationName Name = GetNameForDeclarator(D).getName();
5283 
5284   DeclSpec::SCS SCSpec = D.getDeclSpec().getStorageClassSpec();
5285   VarDecl::StorageClass SC =
5286     StorageClassSpecToVarDeclStorageClass(D.getDeclSpec());
5287 
5288   // dllimport globals without explicit storage class are treated as extern. We
5289   // have to change the storage class this early to get the right DeclContext.
5290   if (SC == SC_None && !DC->isRecord() &&
5291       hasParsedAttr(S, D, AttributeList::AT_DLLImport) &&
5292       !hasParsedAttr(S, D, AttributeList::AT_DLLExport))
5293     SC = SC_Extern;
5294 
5295   DeclContext *OriginalDC = DC;
5296   bool IsLocalExternDecl = SC == SC_Extern &&
5297                            adjustContextForLocalExternDecl(DC);
5298 
5299   if (getLangOpts().OpenCL) {
5300     // OpenCL v1.0 s6.8.a.3: Pointers to functions are not allowed.
5301     QualType NR = R;
5302     while (NR->isPointerType()) {
5303       if (NR->isFunctionPointerType()) {
5304         Diag(D.getIdentifierLoc(), diag::err_opencl_function_pointer_variable);
5305         D.setInvalidType();
5306         break;
5307       }
5308       NR = NR->getPointeeType();
5309     }
5310 
5311     if (!getOpenCLOptions().cl_khr_fp16) {
5312       // OpenCL v1.2 s6.1.1.1: reject declaring variables of the half and
5313       // half array type (unless the cl_khr_fp16 extension is enabled).
5314       if (Context.getBaseElementType(R)->isHalfType()) {
5315         Diag(D.getIdentifierLoc(), diag::err_opencl_half_declaration) << R;
5316         D.setInvalidType();
5317       }
5318     }
5319   }
5320 
5321   if (SCSpec == DeclSpec::SCS_mutable) {
5322     // mutable can only appear on non-static class members, so it's always
5323     // an error here
5324     Diag(D.getIdentifierLoc(), diag::err_mutable_nonmember);
5325     D.setInvalidType();
5326     SC = SC_None;
5327   }
5328 
5329   if (getLangOpts().CPlusPlus11 && SCSpec == DeclSpec::SCS_register &&
5330       !D.getAsmLabel() && !getSourceManager().isInSystemMacro(
5331                               D.getDeclSpec().getStorageClassSpecLoc())) {
5332     // In C++11, the 'register' storage class specifier is deprecated.
5333     // Suppress the warning in system macros, it's used in macros in some
5334     // popular C system headers, such as in glibc's htonl() macro.
5335     Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5336          diag::warn_deprecated_register)
5337       << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5338   }
5339 
5340   IdentifierInfo *II = Name.getAsIdentifierInfo();
5341   if (!II) {
5342     Diag(D.getIdentifierLoc(), diag::err_bad_variable_name)
5343       << Name;
5344     return nullptr;
5345   }
5346 
5347   DiagnoseFunctionSpecifiers(D.getDeclSpec());
5348 
5349   if (!DC->isRecord() && S->getFnParent() == nullptr) {
5350     // C99 6.9p2: The storage-class specifiers auto and register shall not
5351     // appear in the declaration specifiers in an external declaration.
5352     // Global Register+Asm is a GNU extension we support.
5353     if (SC == SC_Auto || (SC == SC_Register && !D.getAsmLabel())) {
5354       Diag(D.getIdentifierLoc(), diag::err_typecheck_sclass_fscope);
5355       D.setInvalidType();
5356     }
5357   }
5358 
5359   if (getLangOpts().OpenCL) {
5360     // Set up the special work-group-local storage class for variables in the
5361     // OpenCL __local address space.
5362     if (R.getAddressSpace() == LangAS::opencl_local) {
5363       SC = SC_OpenCLWorkGroupLocal;
5364     }
5365 
5366     // OpenCL v1.2 s6.9.b p4:
5367     // The sampler type cannot be used with the __local and __global address
5368     // space qualifiers.
5369     if (R->isSamplerT() && (R.getAddressSpace() == LangAS::opencl_local ||
5370       R.getAddressSpace() == LangAS::opencl_global)) {
5371       Diag(D.getIdentifierLoc(), diag::err_wrong_sampler_addressspace);
5372     }
5373 
5374     // OpenCL 1.2 spec, p6.9 r:
5375     // The event type cannot be used to declare a program scope variable.
5376     // The event type cannot be used with the __local, __constant and __global
5377     // address space qualifiers.
5378     if (R->isEventT()) {
5379       if (S->getParent() == nullptr) {
5380         Diag(D.getLocStart(), diag::err_event_t_global_var);
5381         D.setInvalidType();
5382       }
5383 
5384       if (R.getAddressSpace()) {
5385         Diag(D.getLocStart(), diag::err_event_t_addr_space_qual);
5386         D.setInvalidType();
5387       }
5388     }
5389   }
5390 
5391   bool IsExplicitSpecialization = false;
5392   bool IsVariableTemplateSpecialization = false;
5393   bool IsPartialSpecialization = false;
5394   bool IsVariableTemplate = false;
5395   VarDecl *NewVD = nullptr;
5396   VarTemplateDecl *NewTemplate = nullptr;
5397   TemplateParameterList *TemplateParams = nullptr;
5398   if (!getLangOpts().CPlusPlus) {
5399     NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5400                             D.getIdentifierLoc(), II,
5401                             R, TInfo, SC);
5402 
5403     if (D.isInvalidType())
5404       NewVD->setInvalidDecl();
5405   } else {
5406     bool Invalid = false;
5407 
5408     if (DC->isRecord() && !CurContext->isRecord()) {
5409       // This is an out-of-line definition of a static data member.
5410       switch (SC) {
5411       case SC_None:
5412         break;
5413       case SC_Static:
5414         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5415              diag::err_static_out_of_line)
5416           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5417         break;
5418       case SC_Auto:
5419       case SC_Register:
5420       case SC_Extern:
5421         // [dcl.stc] p2: The auto or register specifiers shall be applied only
5422         // to names of variables declared in a block or to function parameters.
5423         // [dcl.stc] p6: The extern specifier cannot be used in the declaration
5424         // of class members
5425 
5426         Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5427              diag::err_storage_class_for_static_member)
5428           << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
5429         break;
5430       case SC_PrivateExtern:
5431         llvm_unreachable("C storage class in c++!");
5432       case SC_OpenCLWorkGroupLocal:
5433         llvm_unreachable("OpenCL storage class in c++!");
5434       }
5435     }
5436 
5437     if (SC == SC_Static && CurContext->isRecord()) {
5438       if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
5439         if (RD->isLocalClass())
5440           Diag(D.getIdentifierLoc(),
5441                diag::err_static_data_member_not_allowed_in_local_class)
5442             << Name << RD->getDeclName();
5443 
5444         // C++98 [class.union]p1: If a union contains a static data member,
5445         // the program is ill-formed. C++11 drops this restriction.
5446         if (RD->isUnion())
5447           Diag(D.getIdentifierLoc(),
5448                getLangOpts().CPlusPlus11
5449                  ? diag::warn_cxx98_compat_static_data_member_in_union
5450                  : diag::ext_static_data_member_in_union) << Name;
5451         // We conservatively disallow static data members in anonymous structs.
5452         else if (!RD->getDeclName())
5453           Diag(D.getIdentifierLoc(),
5454                diag::err_static_data_member_not_allowed_in_anon_struct)
5455             << Name << RD->isUnion();
5456       }
5457     }
5458 
5459     // Match up the template parameter lists with the scope specifier, then
5460     // determine whether we have a template or a template specialization.
5461     TemplateParams = MatchTemplateParametersToScopeSpecifier(
5462         D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
5463         D.getCXXScopeSpec(),
5464         D.getName().getKind() == UnqualifiedId::IK_TemplateId
5465             ? D.getName().TemplateId
5466             : nullptr,
5467         TemplateParamLists,
5468         /*never a friend*/ false, IsExplicitSpecialization, Invalid);
5469 
5470     if (TemplateParams) {
5471       if (!TemplateParams->size() &&
5472           D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
5473         // There is an extraneous 'template<>' for this variable. Complain
5474         // about it, but allow the declaration of the variable.
5475         Diag(TemplateParams->getTemplateLoc(),
5476              diag::err_template_variable_noparams)
5477           << II
5478           << SourceRange(TemplateParams->getTemplateLoc(),
5479                          TemplateParams->getRAngleLoc());
5480         TemplateParams = nullptr;
5481       } else {
5482         if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
5483           // This is an explicit specialization or a partial specialization.
5484           // FIXME: Check that we can declare a specialization here.
5485           IsVariableTemplateSpecialization = true;
5486           IsPartialSpecialization = TemplateParams->size() > 0;
5487         } else { // if (TemplateParams->size() > 0)
5488           // This is a template declaration.
5489           IsVariableTemplate = true;
5490 
5491           // Check that we can declare a template here.
5492           if (CheckTemplateDeclScope(S, TemplateParams))
5493             return nullptr;
5494 
5495           // Only C++1y supports variable templates (N3651).
5496           Diag(D.getIdentifierLoc(),
5497                getLangOpts().CPlusPlus14
5498                    ? diag::warn_cxx11_compat_variable_template
5499                    : diag::ext_variable_template);
5500         }
5501       }
5502     } else {
5503       assert(D.getName().getKind() != UnqualifiedId::IK_TemplateId &&
5504              "should have a 'template<>' for this decl");
5505     }
5506 
5507     if (IsVariableTemplateSpecialization) {
5508       SourceLocation TemplateKWLoc =
5509           TemplateParamLists.size() > 0
5510               ? TemplateParamLists[0]->getTemplateLoc()
5511               : SourceLocation();
5512       DeclResult Res = ActOnVarTemplateSpecialization(
5513           S, D, TInfo, TemplateKWLoc, TemplateParams, SC,
5514           IsPartialSpecialization);
5515       if (Res.isInvalid())
5516         return nullptr;
5517       NewVD = cast<VarDecl>(Res.get());
5518       AddToScope = false;
5519     } else
5520       NewVD = VarDecl::Create(Context, DC, D.getLocStart(),
5521                               D.getIdentifierLoc(), II, R, TInfo, SC);
5522 
5523     // If this is supposed to be a variable template, create it as such.
5524     if (IsVariableTemplate) {
5525       NewTemplate =
5526           VarTemplateDecl::Create(Context, DC, D.getIdentifierLoc(), Name,
5527                                   TemplateParams, NewVD);
5528       NewVD->setDescribedVarTemplate(NewTemplate);
5529     }
5530 
5531     // If this decl has an auto type in need of deduction, make a note of the
5532     // Decl so we can diagnose uses of it in its own initializer.
5533     if (D.getDeclSpec().containsPlaceholderType() && R->getContainedAutoType())
5534       ParsingInitForAutoVars.insert(NewVD);
5535 
5536     if (D.isInvalidType() || Invalid) {
5537       NewVD->setInvalidDecl();
5538       if (NewTemplate)
5539         NewTemplate->setInvalidDecl();
5540     }
5541 
5542     SetNestedNameSpecifier(NewVD, D);
5543 
5544     // If we have any template parameter lists that don't directly belong to
5545     // the variable (matching the scope specifier), store them.
5546     unsigned VDTemplateParamLists = TemplateParams ? 1 : 0;
5547     if (TemplateParamLists.size() > VDTemplateParamLists)
5548       NewVD->setTemplateParameterListsInfo(
5549           Context, TemplateParamLists.size() - VDTemplateParamLists,
5550           TemplateParamLists.data());
5551 
5552     if (D.getDeclSpec().isConstexprSpecified())
5553       NewVD->setConstexpr(true);
5554   }
5555 
5556   // Set the lexical context. If the declarator has a C++ scope specifier, the
5557   // lexical context will be different from the semantic context.
5558   NewVD->setLexicalDeclContext(CurContext);
5559   if (NewTemplate)
5560     NewTemplate->setLexicalDeclContext(CurContext);
5561 
5562   if (IsLocalExternDecl)
5563     NewVD->setLocalExternDecl();
5564 
5565   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec()) {
5566     if (NewVD->hasLocalStorage()) {
5567       // C++11 [dcl.stc]p4:
5568       //   When thread_local is applied to a variable of block scope the
5569       //   storage-class-specifier static is implied if it does not appear
5570       //   explicitly.
5571       // Core issue: 'static' is not implied if the variable is declared
5572       //   'extern'.
5573       if (SCSpec == DeclSpec::SCS_unspecified &&
5574           TSCS == DeclSpec::TSCS_thread_local &&
5575           DC->isFunctionOrMethod())
5576         NewVD->setTSCSpec(TSCS);
5577       else
5578         Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5579              diag::err_thread_non_global)
5580           << DeclSpec::getSpecifierName(TSCS);
5581     } else if (!Context.getTargetInfo().isTLSSupported())
5582       Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
5583            diag::err_thread_unsupported);
5584     else
5585       NewVD->setTSCSpec(TSCS);
5586   }
5587 
5588   // C99 6.7.4p3
5589   //   An inline definition of a function with external linkage shall
5590   //   not contain a definition of a modifiable object with static or
5591   //   thread storage duration...
5592   // We only apply this when the function is required to be defined
5593   // elsewhere, i.e. when the function is not 'extern inline'.  Note
5594   // that a local variable with thread storage duration still has to
5595   // be marked 'static'.  Also note that it's possible to get these
5596   // semantics in C++ using __attribute__((gnu_inline)).
5597   if (SC == SC_Static && S->getFnParent() != nullptr &&
5598       !NewVD->getType().isConstQualified()) {
5599     FunctionDecl *CurFD = getCurFunctionDecl();
5600     if (CurFD && isFunctionDefinitionDiscarded(*this, CurFD)) {
5601       Diag(D.getDeclSpec().getStorageClassSpecLoc(),
5602            diag::warn_static_local_in_extern_inline);
5603       MaybeSuggestAddingStaticToDecl(CurFD);
5604     }
5605   }
5606 
5607   if (D.getDeclSpec().isModulePrivateSpecified()) {
5608     if (IsVariableTemplateSpecialization)
5609       Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5610           << (IsPartialSpecialization ? 1 : 0)
5611           << FixItHint::CreateRemoval(
5612                  D.getDeclSpec().getModulePrivateSpecLoc());
5613     else if (IsExplicitSpecialization)
5614       Diag(NewVD->getLocation(), diag::err_module_private_specialization)
5615         << 2
5616         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
5617     else if (NewVD->hasLocalStorage())
5618       Diag(NewVD->getLocation(), diag::err_module_private_local)
5619         << 0 << NewVD->getDeclName()
5620         << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
5621         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
5622     else {
5623       NewVD->setModulePrivate();
5624       if (NewTemplate)
5625         NewTemplate->setModulePrivate();
5626     }
5627   }
5628 
5629   // Handle attributes prior to checking for duplicates in MergeVarDecl
5630   ProcessDeclAttributes(S, NewVD, D);
5631 
5632   if (getLangOpts().CUDA) {
5633     // CUDA B.2.5: "__shared__ and __constant__ variables have implied static
5634     // storage [duration]."
5635     if (SC == SC_None && S->getFnParent() != nullptr &&
5636         (NewVD->hasAttr<CUDASharedAttr>() ||
5637          NewVD->hasAttr<CUDAConstantAttr>())) {
5638       NewVD->setStorageClass(SC_Static);
5639     }
5640   }
5641 
5642   // Ensure that dllimport globals without explicit storage class are treated as
5643   // extern. The storage class is set above using parsed attributes. Now we can
5644   // check the VarDecl itself.
5645   assert(!NewVD->hasAttr<DLLImportAttr>() ||
5646          NewVD->getAttr<DLLImportAttr>()->isInherited() ||
5647          NewVD->isStaticDataMember() || NewVD->getStorageClass() != SC_None);
5648 
5649   // In auto-retain/release, infer strong retension for variables of
5650   // retainable type.
5651   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewVD))
5652     NewVD->setInvalidDecl();
5653 
5654   // Handle GNU asm-label extension (encoded as an attribute).
5655   if (Expr *E = (Expr*)D.getAsmLabel()) {
5656     // The parser guarantees this is a string.
5657     StringLiteral *SE = cast<StringLiteral>(E);
5658     StringRef Label = SE->getString();
5659     if (S->getFnParent() != nullptr) {
5660       switch (SC) {
5661       case SC_None:
5662       case SC_Auto:
5663         Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;
5664         break;
5665       case SC_Register:
5666         // Local Named register
5667         if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5668           Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5669         break;
5670       case SC_Static:
5671       case SC_Extern:
5672       case SC_PrivateExtern:
5673       case SC_OpenCLWorkGroupLocal:
5674         break;
5675       }
5676     } else if (SC == SC_Register) {
5677       // Global Named register
5678       if (!Context.getTargetInfo().isValidGCCRegisterName(Label))
5679         Diag(E->getExprLoc(), diag::err_asm_unknown_register_name) << Label;
5680       if (!R->isIntegralType(Context) && !R->isPointerType()) {
5681         Diag(D.getLocStart(), diag::err_asm_bad_register_type);
5682         NewVD->setInvalidDecl(true);
5683       }
5684     }
5685 
5686     NewVD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0),
5687                                                 Context, Label, 0));
5688   } else if (!ExtnameUndeclaredIdentifiers.empty()) {
5689     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
5690       ExtnameUndeclaredIdentifiers.find(NewVD->getIdentifier());
5691     if (I != ExtnameUndeclaredIdentifiers.end()) {
5692       NewVD->addAttr(I->second);
5693       ExtnameUndeclaredIdentifiers.erase(I);
5694     }
5695   }
5696 
5697   // Diagnose shadowed variables before filtering for scope.
5698   if (D.getCXXScopeSpec().isEmpty())
5699     CheckShadow(S, NewVD, Previous);
5700 
5701   // Don't consider existing declarations that are in a different
5702   // scope and are out-of-semantic-context declarations (if the new
5703   // declaration has linkage).
5704   FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewVD),
5705                        D.getCXXScopeSpec().isNotEmpty() ||
5706                        IsExplicitSpecialization ||
5707                        IsVariableTemplateSpecialization);
5708 
5709   // Check whether the previous declaration is in the same block scope. This
5710   // affects whether we merge types with it, per C++11 [dcl.array]p3.
5711   if (getLangOpts().CPlusPlus &&
5712       NewVD->isLocalVarDecl() && NewVD->hasExternalStorage())
5713     NewVD->setPreviousDeclInSameBlockScope(
5714         Previous.isSingleResult() && !Previous.isShadowed() &&
5715         isDeclInScope(Previous.getFoundDecl(), OriginalDC, S, false));
5716 
5717   if (!getLangOpts().CPlusPlus) {
5718     D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
5719   } else {
5720     // If this is an explicit specialization of a static data member, check it.
5721     if (IsExplicitSpecialization && !NewVD->isInvalidDecl() &&
5722         CheckMemberSpecialization(NewVD, Previous))
5723       NewVD->setInvalidDecl();
5724 
5725     // Merge the decl with the existing one if appropriate.
5726     if (!Previous.empty()) {
5727       if (Previous.isSingleResult() &&
5728           isa<FieldDecl>(Previous.getFoundDecl()) &&
5729           D.getCXXScopeSpec().isSet()) {
5730         // The user tried to define a non-static data member
5731         // out-of-line (C++ [dcl.meaning]p1).
5732         Diag(NewVD->getLocation(), diag::err_nonstatic_member_out_of_line)
5733           << D.getCXXScopeSpec().getRange();
5734         Previous.clear();
5735         NewVD->setInvalidDecl();
5736       }
5737     } else if (D.getCXXScopeSpec().isSet()) {
5738       // No previous declaration in the qualifying scope.
5739       Diag(D.getIdentifierLoc(), diag::err_no_member)
5740         << Name << computeDeclContext(D.getCXXScopeSpec(), true)
5741         << D.getCXXScopeSpec().getRange();
5742       NewVD->setInvalidDecl();
5743     }
5744 
5745     if (!IsVariableTemplateSpecialization)
5746       D.setRedeclaration(CheckVariableDeclaration(NewVD, Previous));
5747 
5748     if (NewTemplate) {
5749       VarTemplateDecl *PrevVarTemplate =
5750           NewVD->getPreviousDecl()
5751               ? NewVD->getPreviousDecl()->getDescribedVarTemplate()
5752               : nullptr;
5753 
5754       // Check the template parameter list of this declaration, possibly
5755       // merging in the template parameter list from the previous variable
5756       // template declaration.
5757       if (CheckTemplateParameterList(
5758               TemplateParams,
5759               PrevVarTemplate ? PrevVarTemplate->getTemplateParameters()
5760                               : nullptr,
5761               (D.getCXXScopeSpec().isSet() && DC && DC->isRecord() &&
5762                DC->isDependentContext())
5763                   ? TPC_ClassTemplateMember
5764                   : TPC_VarTemplate))
5765         NewVD->setInvalidDecl();
5766 
5767       // If we are providing an explicit specialization of a static variable
5768       // template, make a note of that.
5769       if (PrevVarTemplate &&
5770           PrevVarTemplate->getInstantiatedFromMemberTemplate())
5771         PrevVarTemplate->setMemberSpecialization();
5772     }
5773   }
5774 
5775   ProcessPragmaWeak(S, NewVD);
5776 
5777   // If this is the first declaration of an extern C variable, update
5778   // the map of such variables.
5779   if (NewVD->isFirstDecl() && !NewVD->isInvalidDecl() &&
5780       isIncompleteDeclExternC(*this, NewVD))
5781     RegisterLocallyScopedExternCDecl(NewVD, S);
5782 
5783   if (getLangOpts().CPlusPlus && NewVD->isStaticLocal()) {
5784     Decl *ManglingContextDecl;
5785     if (MangleNumberingContext *MCtx =
5786             getCurrentMangleNumberContext(NewVD->getDeclContext(),
5787                                           ManglingContextDecl)) {
5788       Context.setManglingNumber(
5789           NewVD, MCtx->getManglingNumber(NewVD, S->getMSLocalManglingNumber()));
5790       Context.setStaticLocalNumber(NewVD, MCtx->getStaticLocalNumber(NewVD));
5791     }
5792   }
5793 
5794   if (D.isRedeclaration() && !Previous.empty()) {
5795     checkDLLAttributeRedeclaration(
5796         *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewVD,
5797         IsExplicitSpecialization);
5798   }
5799 
5800   if (NewTemplate) {
5801     if (NewVD->isInvalidDecl())
5802       NewTemplate->setInvalidDecl();
5803     ActOnDocumentableDecl(NewTemplate);
5804     return NewTemplate;
5805   }
5806 
5807   return NewVD;
5808 }
5809 
5810 /// \brief Diagnose variable or built-in function shadowing.  Implements
5811 /// -Wshadow.
5812 ///
5813 /// This method is called whenever a VarDecl is added to a "useful"
5814 /// scope.
5815 ///
5816 /// \param S the scope in which the shadowing name is being declared
5817 /// \param R the lookup of the name
5818 ///
5819 void Sema::CheckShadow(Scope *S, VarDecl *D, const LookupResult& R) {
5820   // Return if warning is ignored.
5821   if (Diags.isIgnored(diag::warn_decl_shadow, R.getNameLoc()))
5822     return;
5823 
5824   // Don't diagnose declarations at file scope.
5825   if (D->hasGlobalStorage())
5826     return;
5827 
5828   DeclContext *NewDC = D->getDeclContext();
5829 
5830   // Only diagnose if we're shadowing an unambiguous field or variable.
5831   if (R.getResultKind() != LookupResult::Found)
5832     return;
5833 
5834   NamedDecl* ShadowedDecl = R.getFoundDecl();
5835   if (!isa<VarDecl>(ShadowedDecl) && !isa<FieldDecl>(ShadowedDecl))
5836     return;
5837 
5838   // Fields are not shadowed by variables in C++ static methods.
5839   if (isa<FieldDecl>(ShadowedDecl))
5840     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewDC))
5841       if (MD->isStatic())
5842         return;
5843 
5844   if (VarDecl *shadowedVar = dyn_cast<VarDecl>(ShadowedDecl))
5845     if (shadowedVar->isExternC()) {
5846       // For shadowing external vars, make sure that we point to the global
5847       // declaration, not a locally scoped extern declaration.
5848       for (auto I : shadowedVar->redecls())
5849         if (I->isFileVarDecl()) {
5850           ShadowedDecl = I;
5851           break;
5852         }
5853     }
5854 
5855   DeclContext *OldDC = ShadowedDecl->getDeclContext();
5856 
5857   // Only warn about certain kinds of shadowing for class members.
5858   if (NewDC && NewDC->isRecord()) {
5859     // In particular, don't warn about shadowing non-class members.
5860     if (!OldDC->isRecord())
5861       return;
5862 
5863     // TODO: should we warn about static data members shadowing
5864     // static data members from base classes?
5865 
5866     // TODO: don't diagnose for inaccessible shadowed members.
5867     // This is hard to do perfectly because we might friend the
5868     // shadowing context, but that's just a false negative.
5869   }
5870 
5871   // Determine what kind of declaration we're shadowing.
5872   unsigned Kind;
5873   if (isa<RecordDecl>(OldDC)) {
5874     if (isa<FieldDecl>(ShadowedDecl))
5875       Kind = 3; // field
5876     else
5877       Kind = 2; // static data member
5878   } else if (OldDC->isFileContext())
5879     Kind = 1; // global
5880   else
5881     Kind = 0; // local
5882 
5883   DeclarationName Name = R.getLookupName();
5884 
5885   // Emit warning and note.
5886   if (getSourceManager().isInSystemMacro(R.getNameLoc()))
5887     return;
5888   Diag(R.getNameLoc(), diag::warn_decl_shadow) << Name << Kind << OldDC;
5889   Diag(ShadowedDecl->getLocation(), diag::note_previous_declaration);
5890 }
5891 
5892 /// \brief Check -Wshadow without the advantage of a previous lookup.
5893 void Sema::CheckShadow(Scope *S, VarDecl *D) {
5894   if (Diags.isIgnored(diag::warn_decl_shadow, D->getLocation()))
5895     return;
5896 
5897   LookupResult R(*this, D->getDeclName(), D->getLocation(),
5898                  Sema::LookupOrdinaryName, Sema::ForRedeclaration);
5899   LookupName(R, S);
5900   CheckShadow(S, D, R);
5901 }
5902 
5903 /// Check for conflict between this global or extern "C" declaration and
5904 /// previous global or extern "C" declarations. This is only used in C++.
5905 template<typename T>
5906 static bool checkGlobalOrExternCConflict(
5907     Sema &S, const T *ND, bool IsGlobal, LookupResult &Previous) {
5908   assert(S.getLangOpts().CPlusPlus && "only C++ has extern \"C\"");
5909   NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName());
5910 
5911   if (!Prev && IsGlobal && !isIncompleteDeclExternC(S, ND)) {
5912     // The common case: this global doesn't conflict with any extern "C"
5913     // declaration.
5914     return false;
5915   }
5916 
5917   if (Prev) {
5918     if (!IsGlobal || isIncompleteDeclExternC(S, ND)) {
5919       // Both the old and new declarations have C language linkage. This is a
5920       // redeclaration.
5921       Previous.clear();
5922       Previous.addDecl(Prev);
5923       return true;
5924     }
5925 
5926     // This is a global, non-extern "C" declaration, and there is a previous
5927     // non-global extern "C" declaration. Diagnose if this is a variable
5928     // declaration.
5929     if (!isa<VarDecl>(ND))
5930       return false;
5931   } else {
5932     // The declaration is extern "C". Check for any declaration in the
5933     // translation unit which might conflict.
5934     if (IsGlobal) {
5935       // We have already performed the lookup into the translation unit.
5936       IsGlobal = false;
5937       for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
5938            I != E; ++I) {
5939         if (isa<VarDecl>(*I)) {
5940           Prev = *I;
5941           break;
5942         }
5943       }
5944     } else {
5945       DeclContext::lookup_result R =
5946           S.Context.getTranslationUnitDecl()->lookup(ND->getDeclName());
5947       for (DeclContext::lookup_result::iterator I = R.begin(), E = R.end();
5948            I != E; ++I) {
5949         if (isa<VarDecl>(*I)) {
5950           Prev = *I;
5951           break;
5952         }
5953         // FIXME: If we have any other entity with this name in global scope,
5954         // the declaration is ill-formed, but that is a defect: it breaks the
5955         // 'stat' hack, for instance. Only variables can have mangled name
5956         // clashes with extern "C" declarations, so only they deserve a
5957         // diagnostic.
5958       }
5959     }
5960 
5961     if (!Prev)
5962       return false;
5963   }
5964 
5965   // Use the first declaration's location to ensure we point at something which
5966   // is lexically inside an extern "C" linkage-spec.
5967   assert(Prev && "should have found a previous declaration to diagnose");
5968   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(Prev))
5969     Prev = FD->getFirstDecl();
5970   else
5971     Prev = cast<VarDecl>(Prev)->getFirstDecl();
5972 
5973   S.Diag(ND->getLocation(), diag::err_extern_c_global_conflict)
5974     << IsGlobal << ND;
5975   S.Diag(Prev->getLocation(), diag::note_extern_c_global_conflict)
5976     << IsGlobal;
5977   return false;
5978 }
5979 
5980 /// Apply special rules for handling extern "C" declarations. Returns \c true
5981 /// if we have found that this is a redeclaration of some prior entity.
5982 ///
5983 /// Per C++ [dcl.link]p6:
5984 ///   Two declarations [for a function or variable] with C language linkage
5985 ///   with the same name that appear in different scopes refer to the same
5986 ///   [entity]. An entity with C language linkage shall not be declared with
5987 ///   the same name as an entity in global scope.
5988 template<typename T>
5989 static bool checkForConflictWithNonVisibleExternC(Sema &S, const T *ND,
5990                                                   LookupResult &Previous) {
5991   if (!S.getLangOpts().CPlusPlus) {
5992     // In C, when declaring a global variable, look for a corresponding 'extern'
5993     // variable declared in function scope. We don't need this in C++, because
5994     // we find local extern decls in the surrounding file-scope DeclContext.
5995     if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
5996       if (NamedDecl *Prev = S.findLocallyScopedExternCDecl(ND->getDeclName())) {
5997         Previous.clear();
5998         Previous.addDecl(Prev);
5999         return true;
6000       }
6001     }
6002     return false;
6003   }
6004 
6005   // A declaration in the translation unit can conflict with an extern "C"
6006   // declaration.
6007   if (ND->getDeclContext()->getRedeclContext()->isTranslationUnit())
6008     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/true, Previous);
6009 
6010   // An extern "C" declaration can conflict with a declaration in the
6011   // translation unit or can be a redeclaration of an extern "C" declaration
6012   // in another scope.
6013   if (isIncompleteDeclExternC(S,ND))
6014     return checkGlobalOrExternCConflict(S, ND, /*IsGlobal*/false, Previous);
6015 
6016   // Neither global nor extern "C": nothing to do.
6017   return false;
6018 }
6019 
6020 void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {
6021   // If the decl is already known invalid, don't check it.
6022   if (NewVD->isInvalidDecl())
6023     return;
6024 
6025   TypeSourceInfo *TInfo = NewVD->getTypeSourceInfo();
6026   QualType T = TInfo->getType();
6027 
6028   // Defer checking an 'auto' type until its initializer is attached.
6029   if (T->isUndeducedType())
6030     return;
6031 
6032   if (NewVD->hasAttrs())
6033     CheckAlignasUnderalignment(NewVD);
6034 
6035   if (T->isObjCObjectType()) {
6036     Diag(NewVD->getLocation(), diag::err_statically_allocated_object)
6037       << FixItHint::CreateInsertion(NewVD->getLocation(), "*");
6038     T = Context.getObjCObjectPointerType(T);
6039     NewVD->setType(T);
6040   }
6041 
6042   // Emit an error if an address space was applied to decl with local storage.
6043   // This includes arrays of objects with address space qualifiers, but not
6044   // automatic variables that point to other address spaces.
6045   // ISO/IEC TR 18037 S5.1.2
6046   if (NewVD->hasLocalStorage() && T.getAddressSpace() != 0) {
6047     Diag(NewVD->getLocation(), diag::err_as_qualified_auto_decl);
6048     NewVD->setInvalidDecl();
6049     return;
6050   }
6051 
6052   // OpenCL v1.2 s6.5 - All program scope variables must be declared in the
6053   // __constant address space.
6054   if (getLangOpts().OpenCL && NewVD->isFileVarDecl()
6055       && T.getAddressSpace() != LangAS::opencl_constant
6056       && !T->isSamplerT()){
6057     Diag(NewVD->getLocation(), diag::err_opencl_global_invalid_addr_space);
6058     NewVD->setInvalidDecl();
6059     return;
6060   }
6061 
6062   // OpenCL v1.2 s6.8 -- The static qualifier is valid only in program
6063   // scope.
6064   if ((getLangOpts().OpenCLVersion >= 120)
6065       && NewVD->isStaticLocal()) {
6066     Diag(NewVD->getLocation(), diag::err_static_function_scope);
6067     NewVD->setInvalidDecl();
6068     return;
6069   }
6070 
6071   if (NewVD->hasLocalStorage() && T.isObjCGCWeak()
6072       && !NewVD->hasAttr<BlocksAttr>()) {
6073     if (getLangOpts().getGC() != LangOptions::NonGC)
6074       Diag(NewVD->getLocation(), diag::warn_gc_attribute_weak_on_local);
6075     else {
6076       assert(!getLangOpts().ObjCAutoRefCount);
6077       Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);
6078     }
6079   }
6080 
6081   bool isVM = T->isVariablyModifiedType();
6082   if (isVM || NewVD->hasAttr<CleanupAttr>() ||
6083       NewVD->hasAttr<BlocksAttr>())
6084     getCurFunction()->setHasBranchProtectedScope();
6085 
6086   if ((isVM && NewVD->hasLinkage()) ||
6087       (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {
6088     bool SizeIsNegative;
6089     llvm::APSInt Oversized;
6090     TypeSourceInfo *FixedTInfo =
6091       TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
6092                                                     SizeIsNegative, Oversized);
6093     if (!FixedTInfo && T->isVariableArrayType()) {
6094       const VariableArrayType *VAT = Context.getAsVariableArrayType(T);
6095       // FIXME: This won't give the correct result for
6096       // int a[10][n];
6097       SourceRange SizeRange = VAT->getSizeExpr()->getSourceRange();
6098 
6099       if (NewVD->isFileVarDecl())
6100         Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope)
6101         << SizeRange;
6102       else if (NewVD->isStaticLocal())
6103         Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage)
6104         << SizeRange;
6105       else
6106         Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage)
6107         << SizeRange;
6108       NewVD->setInvalidDecl();
6109       return;
6110     }
6111 
6112     if (!FixedTInfo) {
6113       if (NewVD->isFileVarDecl())
6114         Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);
6115       else
6116         Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);
6117       NewVD->setInvalidDecl();
6118       return;
6119     }
6120 
6121     Diag(NewVD->getLocation(), diag::warn_illegal_constant_array_size);
6122     NewVD->setType(FixedTInfo->getType());
6123     NewVD->setTypeSourceInfo(FixedTInfo);
6124   }
6125 
6126   if (T->isVoidType()) {
6127     // C++98 [dcl.stc]p5: The extern specifier can be applied only to the names
6128     //                    of objects and functions.
6129     if (NewVD->isThisDeclarationADefinition() || getLangOpts().CPlusPlus) {
6130       Diag(NewVD->getLocation(), diag::err_typecheck_decl_incomplete_type)
6131         << T;
6132       NewVD->setInvalidDecl();
6133       return;
6134     }
6135   }
6136 
6137   if (!NewVD->hasLocalStorage() && NewVD->hasAttr<BlocksAttr>()) {
6138     Diag(NewVD->getLocation(), diag::err_block_on_nonlocal);
6139     NewVD->setInvalidDecl();
6140     return;
6141   }
6142 
6143   if (isVM && NewVD->hasAttr<BlocksAttr>()) {
6144     Diag(NewVD->getLocation(), diag::err_block_on_vm);
6145     NewVD->setInvalidDecl();
6146     return;
6147   }
6148 
6149   if (NewVD->isConstexpr() && !T->isDependentType() &&
6150       RequireLiteralType(NewVD->getLocation(), T,
6151                          diag::err_constexpr_var_non_literal)) {
6152     NewVD->setInvalidDecl();
6153     return;
6154   }
6155 }
6156 
6157 /// \brief Perform semantic checking on a newly-created variable
6158 /// declaration.
6159 ///
6160 /// This routine performs all of the type-checking required for a
6161 /// variable declaration once it has been built. It is used both to
6162 /// check variables after they have been parsed and their declarators
6163 /// have been translated into a declaration, and to check variables
6164 /// that have been instantiated from a template.
6165 ///
6166 /// Sets NewVD->isInvalidDecl() if an error was encountered.
6167 ///
6168 /// Returns true if the variable declaration is a redeclaration.
6169 bool Sema::CheckVariableDeclaration(VarDecl *NewVD, LookupResult &Previous) {
6170   CheckVariableDeclarationType(NewVD);
6171 
6172   // If the decl is already known invalid, don't check it.
6173   if (NewVD->isInvalidDecl())
6174     return false;
6175 
6176   // If we did not find anything by this name, look for a non-visible
6177   // extern "C" declaration with the same name.
6178   if (Previous.empty() &&
6179       checkForConflictWithNonVisibleExternC(*this, NewVD, Previous))
6180     Previous.setShadowed();
6181 
6182   // Filter out any non-conflicting previous declarations.
6183   filterNonConflictingPreviousDecls(Context, NewVD, Previous);
6184 
6185   if (!Previous.empty()) {
6186     MergeVarDecl(NewVD, Previous);
6187     return true;
6188   }
6189   return false;
6190 }
6191 
6192 /// \brief Data used with FindOverriddenMethod
6193 struct FindOverriddenMethodData {
6194   Sema *S;
6195   CXXMethodDecl *Method;
6196 };
6197 
6198 /// \brief Member lookup function that determines whether a given C++
6199 /// method overrides a method in a base class, to be used with
6200 /// CXXRecordDecl::lookupInBases().
6201 static bool FindOverriddenMethod(const CXXBaseSpecifier *Specifier,
6202                                  CXXBasePath &Path,
6203                                  void *UserData) {
6204   RecordDecl *BaseRecord = Specifier->getType()->getAs<RecordType>()->getDecl();
6205 
6206   FindOverriddenMethodData *Data
6207     = reinterpret_cast<FindOverriddenMethodData*>(UserData);
6208 
6209   DeclarationName Name = Data->Method->getDeclName();
6210 
6211   // FIXME: Do we care about other names here too?
6212   if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6213     // We really want to find the base class destructor here.
6214     QualType T = Data->S->Context.getTypeDeclType(BaseRecord);
6215     CanQualType CT = Data->S->Context.getCanonicalType(T);
6216 
6217     Name = Data->S->Context.DeclarationNames.getCXXDestructorName(CT);
6218   }
6219 
6220   for (Path.Decls = BaseRecord->lookup(Name);
6221        !Path.Decls.empty();
6222        Path.Decls = Path.Decls.slice(1)) {
6223     NamedDecl *D = Path.Decls.front();
6224     if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) {
6225       if (MD->isVirtual() && !Data->S->IsOverload(Data->Method, MD, false))
6226         return true;
6227     }
6228   }
6229 
6230   return false;
6231 }
6232 
6233 namespace {
6234   enum OverrideErrorKind { OEK_All, OEK_NonDeleted, OEK_Deleted };
6235 }
6236 /// \brief Report an error regarding overriding, along with any relevant
6237 /// overriden methods.
6238 ///
6239 /// \param DiagID the primary error to report.
6240 /// \param MD the overriding method.
6241 /// \param OEK which overrides to include as notes.
6242 static void ReportOverrides(Sema& S, unsigned DiagID, const CXXMethodDecl *MD,
6243                             OverrideErrorKind OEK = OEK_All) {
6244   S.Diag(MD->getLocation(), DiagID) << MD->getDeclName();
6245   for (CXXMethodDecl::method_iterator I = MD->begin_overridden_methods(),
6246                                       E = MD->end_overridden_methods();
6247        I != E; ++I) {
6248     // This check (& the OEK parameter) could be replaced by a predicate, but
6249     // without lambdas that would be overkill. This is still nicer than writing
6250     // out the diag loop 3 times.
6251     if ((OEK == OEK_All) ||
6252         (OEK == OEK_NonDeleted && !(*I)->isDeleted()) ||
6253         (OEK == OEK_Deleted && (*I)->isDeleted()))
6254       S.Diag((*I)->getLocation(), diag::note_overridden_virtual_function);
6255   }
6256 }
6257 
6258 /// AddOverriddenMethods - See if a method overrides any in the base classes,
6259 /// and if so, check that it's a valid override and remember it.
6260 bool Sema::AddOverriddenMethods(CXXRecordDecl *DC, CXXMethodDecl *MD) {
6261   // Look for virtual methods in base classes that this method might override.
6262   CXXBasePaths Paths;
6263   FindOverriddenMethodData Data;
6264   Data.Method = MD;
6265   Data.S = this;
6266   bool hasDeletedOverridenMethods = false;
6267   bool hasNonDeletedOverridenMethods = false;
6268   bool AddedAny = false;
6269   if (DC->lookupInBases(&FindOverriddenMethod, &Data, Paths)) {
6270     for (auto *I : Paths.found_decls()) {
6271       if (CXXMethodDecl *OldMD = dyn_cast<CXXMethodDecl>(I)) {
6272         MD->addOverriddenMethod(OldMD->getCanonicalDecl());
6273         if (!CheckOverridingFunctionReturnType(MD, OldMD) &&
6274             !CheckOverridingFunctionAttributes(MD, OldMD) &&
6275             !CheckOverridingFunctionExceptionSpec(MD, OldMD) &&
6276             !CheckIfOverriddenFunctionIsMarkedFinal(MD, OldMD)) {
6277           hasDeletedOverridenMethods |= OldMD->isDeleted();
6278           hasNonDeletedOverridenMethods |= !OldMD->isDeleted();
6279           AddedAny = true;
6280         }
6281       }
6282     }
6283   }
6284 
6285   if (hasDeletedOverridenMethods && !MD->isDeleted()) {
6286     ReportOverrides(*this, diag::err_non_deleted_override, MD, OEK_Deleted);
6287   }
6288   if (hasNonDeletedOverridenMethods && MD->isDeleted()) {
6289     ReportOverrides(*this, diag::err_deleted_override, MD, OEK_NonDeleted);
6290   }
6291 
6292   return AddedAny;
6293 }
6294 
6295 namespace {
6296   // Struct for holding all of the extra arguments needed by
6297   // DiagnoseInvalidRedeclaration to call Sema::ActOnFunctionDeclarator.
6298   struct ActOnFDArgs {
6299     Scope *S;
6300     Declarator &D;
6301     MultiTemplateParamsArg TemplateParamLists;
6302     bool AddToScope;
6303   };
6304 }
6305 
6306 namespace {
6307 
6308 // Callback to only accept typo corrections that have a non-zero edit distance.
6309 // Also only accept corrections that have the same parent decl.
6310 class DifferentNameValidatorCCC : public CorrectionCandidateCallback {
6311  public:
6312   DifferentNameValidatorCCC(ASTContext &Context, FunctionDecl *TypoFD,
6313                             CXXRecordDecl *Parent)
6314       : Context(Context), OriginalFD(TypoFD),
6315         ExpectedParent(Parent ? Parent->getCanonicalDecl() : nullptr) {}
6316 
6317   bool ValidateCandidate(const TypoCorrection &candidate) override {
6318     if (candidate.getEditDistance() == 0)
6319       return false;
6320 
6321     SmallVector<unsigned, 1> MismatchedParams;
6322     for (TypoCorrection::const_decl_iterator CDecl = candidate.begin(),
6323                                           CDeclEnd = candidate.end();
6324          CDecl != CDeclEnd; ++CDecl) {
6325       FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6326 
6327       if (FD && !FD->hasBody() &&
6328           hasSimilarParameters(Context, FD, OriginalFD, MismatchedParams)) {
6329         if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) {
6330           CXXRecordDecl *Parent = MD->getParent();
6331           if (Parent && Parent->getCanonicalDecl() == ExpectedParent)
6332             return true;
6333         } else if (!ExpectedParent) {
6334           return true;
6335         }
6336       }
6337     }
6338 
6339     return false;
6340   }
6341 
6342  private:
6343   ASTContext &Context;
6344   FunctionDecl *OriginalFD;
6345   CXXRecordDecl *ExpectedParent;
6346 };
6347 
6348 }
6349 
6350 /// \brief Generate diagnostics for an invalid function redeclaration.
6351 ///
6352 /// This routine handles generating the diagnostic messages for an invalid
6353 /// function redeclaration, including finding possible similar declarations
6354 /// or performing typo correction if there are no previous declarations with
6355 /// the same name.
6356 ///
6357 /// Returns a NamedDecl iff typo correction was performed and substituting in
6358 /// the new declaration name does not cause new errors.
6359 static NamedDecl *DiagnoseInvalidRedeclaration(
6360     Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD,
6361     ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {
6362   DeclarationName Name = NewFD->getDeclName();
6363   DeclContext *NewDC = NewFD->getDeclContext();
6364   SmallVector<unsigned, 1> MismatchedParams;
6365   SmallVector<std::pair<FunctionDecl *, unsigned>, 1> NearMatches;
6366   TypoCorrection Correction;
6367   bool IsDefinition = ExtraArgs.D.isFunctionDefinition();
6368   unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend
6369                                    : diag::err_member_decl_does_not_match;
6370   LookupResult Prev(SemaRef, Name, NewFD->getLocation(),
6371                     IsLocalFriend ? Sema::LookupLocalFriendName
6372                                   : Sema::LookupOrdinaryName,
6373                     Sema::ForRedeclaration);
6374 
6375   NewFD->setInvalidDecl();
6376   if (IsLocalFriend)
6377     SemaRef.LookupName(Prev, S);
6378   else
6379     SemaRef.LookupQualifiedName(Prev, NewDC);
6380   assert(!Prev.isAmbiguous() &&
6381          "Cannot have an ambiguity in previous-declaration lookup");
6382   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
6383   DifferentNameValidatorCCC Validator(SemaRef.Context, NewFD,
6384                                       MD ? MD->getParent() : nullptr);
6385   if (!Prev.empty()) {
6386     for (LookupResult::iterator Func = Prev.begin(), FuncEnd = Prev.end();
6387          Func != FuncEnd; ++Func) {
6388       FunctionDecl *FD = dyn_cast<FunctionDecl>(*Func);
6389       if (FD &&
6390           hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6391         // Add 1 to the index so that 0 can mean the mismatch didn't
6392         // involve a parameter
6393         unsigned ParamNum =
6394             MismatchedParams.empty() ? 0 : MismatchedParams.front() + 1;
6395         NearMatches.push_back(std::make_pair(FD, ParamNum));
6396       }
6397     }
6398   // If the qualified name lookup yielded nothing, try typo correction
6399   } else if ((Correction = SemaRef.CorrectTypo(
6400                  Prev.getLookupNameInfo(), Prev.getLookupKind(), S,
6401                  &ExtraArgs.D.getCXXScopeSpec(), Validator,
6402                  Sema::CTK_ErrorRecovery, IsLocalFriend ? nullptr : NewDC))) {
6403     // Set up everything for the call to ActOnFunctionDeclarator
6404     ExtraArgs.D.SetIdentifier(Correction.getCorrectionAsIdentifierInfo(),
6405                               ExtraArgs.D.getIdentifierLoc());
6406     Previous.clear();
6407     Previous.setLookupName(Correction.getCorrection());
6408     for (TypoCorrection::decl_iterator CDecl = Correction.begin(),
6409                                     CDeclEnd = Correction.end();
6410          CDecl != CDeclEnd; ++CDecl) {
6411       FunctionDecl *FD = dyn_cast<FunctionDecl>(*CDecl);
6412       if (FD && !FD->hasBody() &&
6413           hasSimilarParameters(SemaRef.Context, FD, NewFD, MismatchedParams)) {
6414         Previous.addDecl(FD);
6415       }
6416     }
6417     bool wasRedeclaration = ExtraArgs.D.isRedeclaration();
6418 
6419     NamedDecl *Result;
6420     // Retry building the function declaration with the new previous
6421     // declarations, and with errors suppressed.
6422     {
6423       // Trap errors.
6424       Sema::SFINAETrap Trap(SemaRef);
6425 
6426       // TODO: Refactor ActOnFunctionDeclarator so that we can call only the
6427       // pieces need to verify the typo-corrected C++ declaration and hopefully
6428       // eliminate the need for the parameter pack ExtraArgs.
6429       Result = SemaRef.ActOnFunctionDeclarator(
6430           ExtraArgs.S, ExtraArgs.D,
6431           Correction.getCorrectionDecl()->getDeclContext(),
6432           NewFD->getTypeSourceInfo(), Previous, ExtraArgs.TemplateParamLists,
6433           ExtraArgs.AddToScope);
6434 
6435       if (Trap.hasErrorOccurred())
6436         Result = nullptr;
6437     }
6438 
6439     if (Result) {
6440       // Determine which correction we picked.
6441       Decl *Canonical = Result->getCanonicalDecl();
6442       for (LookupResult::iterator I = Previous.begin(), E = Previous.end();
6443            I != E; ++I)
6444         if ((*I)->getCanonicalDecl() == Canonical)
6445           Correction.setCorrectionDecl(*I);
6446 
6447       SemaRef.diagnoseTypo(
6448           Correction,
6449           SemaRef.PDiag(IsLocalFriend
6450                           ? diag::err_no_matching_local_friend_suggest
6451                           : diag::err_member_decl_does_not_match_suggest)
6452             << Name << NewDC << IsDefinition);
6453       return Result;
6454     }
6455 
6456     // Pretend the typo correction never occurred
6457     ExtraArgs.D.SetIdentifier(Name.getAsIdentifierInfo(),
6458                               ExtraArgs.D.getIdentifierLoc());
6459     ExtraArgs.D.setRedeclaration(wasRedeclaration);
6460     Previous.clear();
6461     Previous.setLookupName(Name);
6462   }
6463 
6464   SemaRef.Diag(NewFD->getLocation(), DiagMsg)
6465       << Name << NewDC << IsDefinition << NewFD->getLocation();
6466 
6467   bool NewFDisConst = false;
6468   if (CXXMethodDecl *NewMD = dyn_cast<CXXMethodDecl>(NewFD))
6469     NewFDisConst = NewMD->isConst();
6470 
6471   for (SmallVectorImpl<std::pair<FunctionDecl *, unsigned> >::iterator
6472        NearMatch = NearMatches.begin(), NearMatchEnd = NearMatches.end();
6473        NearMatch != NearMatchEnd; ++NearMatch) {
6474     FunctionDecl *FD = NearMatch->first;
6475     CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD);
6476     bool FDisConst = MD && MD->isConst();
6477     bool IsMember = MD || !IsLocalFriend;
6478 
6479     // FIXME: These notes are poorly worded for the local friend case.
6480     if (unsigned Idx = NearMatch->second) {
6481       ParmVarDecl *FDParam = FD->getParamDecl(Idx-1);
6482       SourceLocation Loc = FDParam->getTypeSpecStartLoc();
6483       if (Loc.isInvalid()) Loc = FD->getLocation();
6484       SemaRef.Diag(Loc, IsMember ? diag::note_member_def_close_param_match
6485                                  : diag::note_local_decl_close_param_match)
6486         << Idx << FDParam->getType()
6487         << NewFD->getParamDecl(Idx - 1)->getType();
6488     } else if (FDisConst != NewFDisConst) {
6489       SemaRef.Diag(FD->getLocation(), diag::note_member_def_close_const_match)
6490           << NewFDisConst << FD->getSourceRange().getEnd();
6491     } else
6492       SemaRef.Diag(FD->getLocation(),
6493                    IsMember ? diag::note_member_def_close_match
6494                             : diag::note_local_decl_close_match);
6495   }
6496   return nullptr;
6497 }
6498 
6499 static FunctionDecl::StorageClass getFunctionStorageClass(Sema &SemaRef,
6500                                                           Declarator &D) {
6501   switch (D.getDeclSpec().getStorageClassSpec()) {
6502   default: llvm_unreachable("Unknown storage class!");
6503   case DeclSpec::SCS_auto:
6504   case DeclSpec::SCS_register:
6505   case DeclSpec::SCS_mutable:
6506     SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6507                  diag::err_typecheck_sclass_func);
6508     D.setInvalidType();
6509     break;
6510   case DeclSpec::SCS_unspecified: break;
6511   case DeclSpec::SCS_extern:
6512     if (D.getDeclSpec().isExternInLinkageSpec())
6513       return SC_None;
6514     return SC_Extern;
6515   case DeclSpec::SCS_static: {
6516     if (SemaRef.CurContext->getRedeclContext()->isFunctionOrMethod()) {
6517       // C99 6.7.1p5:
6518       //   The declaration of an identifier for a function that has
6519       //   block scope shall have no explicit storage-class specifier
6520       //   other than extern
6521       // See also (C++ [dcl.stc]p4).
6522       SemaRef.Diag(D.getDeclSpec().getStorageClassSpecLoc(),
6523                    diag::err_static_block_func);
6524       break;
6525     } else
6526       return SC_Static;
6527   }
6528   case DeclSpec::SCS_private_extern: return SC_PrivateExtern;
6529   }
6530 
6531   // No explicit storage class has already been returned
6532   return SC_None;
6533 }
6534 
6535 static FunctionDecl* CreateNewFunctionDecl(Sema &SemaRef, Declarator &D,
6536                                            DeclContext *DC, QualType &R,
6537                                            TypeSourceInfo *TInfo,
6538                                            FunctionDecl::StorageClass SC,
6539                                            bool &IsVirtualOkay) {
6540   DeclarationNameInfo NameInfo = SemaRef.GetNameForDeclarator(D);
6541   DeclarationName Name = NameInfo.getName();
6542 
6543   FunctionDecl *NewFD = nullptr;
6544   bool isInline = D.getDeclSpec().isInlineSpecified();
6545 
6546   if (!SemaRef.getLangOpts().CPlusPlus) {
6547     // Determine whether the function was written with a
6548     // prototype. This true when:
6549     //   - there is a prototype in the declarator, or
6550     //   - the type R of the function is some kind of typedef or other reference
6551     //     to a type name (which eventually refers to a function type).
6552     bool HasPrototype =
6553       (D.isFunctionDeclarator() && D.getFunctionTypeInfo().hasPrototype) ||
6554       (!isa<FunctionType>(R.getTypePtr()) && R->isFunctionProtoType());
6555 
6556     NewFD = FunctionDecl::Create(SemaRef.Context, DC,
6557                                  D.getLocStart(), NameInfo, R,
6558                                  TInfo, SC, isInline,
6559                                  HasPrototype, false);
6560     if (D.isInvalidType())
6561       NewFD->setInvalidDecl();
6562 
6563     // Set the lexical context.
6564     NewFD->setLexicalDeclContext(SemaRef.CurContext);
6565 
6566     return NewFD;
6567   }
6568 
6569   bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6570   bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6571 
6572   // Check that the return type is not an abstract class type.
6573   // For record types, this is done by the AbstractClassUsageDiagnoser once
6574   // the class has been completely parsed.
6575   if (!DC->isRecord() &&
6576       SemaRef.RequireNonAbstractType(
6577           D.getIdentifierLoc(), R->getAs<FunctionType>()->getReturnType(),
6578           diag::err_abstract_type_in_decl, SemaRef.AbstractReturnType))
6579     D.setInvalidType();
6580 
6581   if (Name.getNameKind() == DeclarationName::CXXConstructorName) {
6582     // This is a C++ constructor declaration.
6583     assert(DC->isRecord() &&
6584            "Constructors can only be declared in a member context");
6585 
6586     R = SemaRef.CheckConstructorDeclarator(D, R, SC);
6587     return CXXConstructorDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
6588                                       D.getLocStart(), NameInfo,
6589                                       R, TInfo, isExplicit, isInline,
6590                                       /*isImplicitlyDeclared=*/false,
6591                                       isConstexpr);
6592 
6593   } else if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6594     // This is a C++ destructor declaration.
6595     if (DC->isRecord()) {
6596       R = SemaRef.CheckDestructorDeclarator(D, R, SC);
6597       CXXRecordDecl *Record = cast<CXXRecordDecl>(DC);
6598       CXXDestructorDecl *NewDD = CXXDestructorDecl::Create(
6599                                         SemaRef.Context, Record,
6600                                         D.getLocStart(),
6601                                         NameInfo, R, TInfo, isInline,
6602                                         /*isImplicitlyDeclared=*/false);
6603 
6604       // If the class is complete, then we now create the implicit exception
6605       // specification. If the class is incomplete or dependent, we can't do
6606       // it yet.
6607       if (SemaRef.getLangOpts().CPlusPlus11 && !Record->isDependentType() &&
6608           Record->getDefinition() && !Record->isBeingDefined() &&
6609           R->getAs<FunctionProtoType>()->getExceptionSpecType() == EST_None) {
6610         SemaRef.AdjustDestructorExceptionSpec(Record, NewDD);
6611       }
6612 
6613       IsVirtualOkay = true;
6614       return NewDD;
6615 
6616     } else {
6617       SemaRef.Diag(D.getIdentifierLoc(), diag::err_destructor_not_member);
6618       D.setInvalidType();
6619 
6620       // Create a FunctionDecl to satisfy the function definition parsing
6621       // code path.
6622       return FunctionDecl::Create(SemaRef.Context, DC,
6623                                   D.getLocStart(),
6624                                   D.getIdentifierLoc(), Name, R, TInfo,
6625                                   SC, isInline,
6626                                   /*hasPrototype=*/true, isConstexpr);
6627     }
6628 
6629   } else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {
6630     if (!DC->isRecord()) {
6631       SemaRef.Diag(D.getIdentifierLoc(),
6632            diag::err_conv_function_not_member);
6633       return nullptr;
6634     }
6635 
6636     SemaRef.CheckConversionDeclarator(D, R, SC);
6637     IsVirtualOkay = true;
6638     return CXXConversionDecl::Create(SemaRef.Context, cast<CXXRecordDecl>(DC),
6639                                      D.getLocStart(), NameInfo,
6640                                      R, TInfo, isInline, isExplicit,
6641                                      isConstexpr, SourceLocation());
6642 
6643   } else if (DC->isRecord()) {
6644     // If the name of the function is the same as the name of the record,
6645     // then this must be an invalid constructor that has a return type.
6646     // (The parser checks for a return type and makes the declarator a
6647     // constructor if it has no return type).
6648     if (Name.getAsIdentifierInfo() &&
6649         Name.getAsIdentifierInfo() == cast<CXXRecordDecl>(DC)->getIdentifier()){
6650       SemaRef.Diag(D.getIdentifierLoc(), diag::err_constructor_return_type)
6651         << SourceRange(D.getDeclSpec().getTypeSpecTypeLoc())
6652         << SourceRange(D.getIdentifierLoc());
6653       return nullptr;
6654     }
6655 
6656     // This is a C++ method declaration.
6657     CXXMethodDecl *Ret = CXXMethodDecl::Create(SemaRef.Context,
6658                                                cast<CXXRecordDecl>(DC),
6659                                                D.getLocStart(), NameInfo, R,
6660                                                TInfo, SC, isInline,
6661                                                isConstexpr, SourceLocation());
6662     IsVirtualOkay = !Ret->isStatic();
6663     return Ret;
6664   } else {
6665     // Determine whether the function was written with a
6666     // prototype. This true when:
6667     //   - we're in C++ (where every function has a prototype),
6668     return FunctionDecl::Create(SemaRef.Context, DC,
6669                                 D.getLocStart(),
6670                                 NameInfo, R, TInfo, SC, isInline,
6671                                 true/*HasPrototype*/, isConstexpr);
6672   }
6673 }
6674 
6675 enum OpenCLParamType {
6676   ValidKernelParam,
6677   PtrPtrKernelParam,
6678   PtrKernelParam,
6679   PrivatePtrKernelParam,
6680   InvalidKernelParam,
6681   RecordKernelParam
6682 };
6683 
6684 static OpenCLParamType getOpenCLKernelParameterType(QualType PT) {
6685   if (PT->isPointerType()) {
6686     QualType PointeeType = PT->getPointeeType();
6687     if (PointeeType->isPointerType())
6688       return PtrPtrKernelParam;
6689     return PointeeType.getAddressSpace() == 0 ? PrivatePtrKernelParam
6690                                               : PtrKernelParam;
6691   }
6692 
6693   // TODO: Forbid the other integer types (size_t, ptrdiff_t...) when they can
6694   // be used as builtin types.
6695 
6696   if (PT->isImageType())
6697     return PtrKernelParam;
6698 
6699   if (PT->isBooleanType())
6700     return InvalidKernelParam;
6701 
6702   if (PT->isEventT())
6703     return InvalidKernelParam;
6704 
6705   if (PT->isHalfType())
6706     return InvalidKernelParam;
6707 
6708   if (PT->isRecordType())
6709     return RecordKernelParam;
6710 
6711   return ValidKernelParam;
6712 }
6713 
6714 static void checkIsValidOpenCLKernelParameter(
6715   Sema &S,
6716   Declarator &D,
6717   ParmVarDecl *Param,
6718   llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {
6719   QualType PT = Param->getType();
6720 
6721   // Cache the valid types we encounter to avoid rechecking structs that are
6722   // used again
6723   if (ValidTypes.count(PT.getTypePtr()))
6724     return;
6725 
6726   switch (getOpenCLKernelParameterType(PT)) {
6727   case PtrPtrKernelParam:
6728     // OpenCL v1.2 s6.9.a:
6729     // A kernel function argument cannot be declared as a
6730     // pointer to a pointer type.
6731     S.Diag(Param->getLocation(), diag::err_opencl_ptrptr_kernel_param);
6732     D.setInvalidType();
6733     return;
6734 
6735   case PrivatePtrKernelParam:
6736     // OpenCL v1.2 s6.9.a:
6737     // A kernel function argument cannot be declared as a
6738     // pointer to the private address space.
6739     S.Diag(Param->getLocation(), diag::err_opencl_private_ptr_kernel_param);
6740     D.setInvalidType();
6741     return;
6742 
6743     // OpenCL v1.2 s6.9.k:
6744     // Arguments to kernel functions in a program cannot be declared with the
6745     // built-in scalar types bool, half, size_t, ptrdiff_t, intptr_t, and
6746     // uintptr_t or a struct and/or union that contain fields declared to be
6747     // one of these built-in scalar types.
6748 
6749   case InvalidKernelParam:
6750     // OpenCL v1.2 s6.8 n:
6751     // A kernel function argument cannot be declared
6752     // of event_t type.
6753     S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
6754     D.setInvalidType();
6755     return;
6756 
6757   case PtrKernelParam:
6758   case ValidKernelParam:
6759     ValidTypes.insert(PT.getTypePtr());
6760     return;
6761 
6762   case RecordKernelParam:
6763     break;
6764   }
6765 
6766   // Track nested structs we will inspect
6767   SmallVector<const Decl *, 4> VisitStack;
6768 
6769   // Track where we are in the nested structs. Items will migrate from
6770   // VisitStack to HistoryStack as we do the DFS for bad field.
6771   SmallVector<const FieldDecl *, 4> HistoryStack;
6772   HistoryStack.push_back(nullptr);
6773 
6774   const RecordDecl *PD = PT->castAs<RecordType>()->getDecl();
6775   VisitStack.push_back(PD);
6776 
6777   assert(VisitStack.back() && "First decl null?");
6778 
6779   do {
6780     const Decl *Next = VisitStack.pop_back_val();
6781     if (!Next) {
6782       assert(!HistoryStack.empty());
6783       // Found a marker, we have gone up a level
6784       if (const FieldDecl *Hist = HistoryStack.pop_back_val())
6785         ValidTypes.insert(Hist->getType().getTypePtr());
6786 
6787       continue;
6788     }
6789 
6790     // Adds everything except the original parameter declaration (which is not a
6791     // field itself) to the history stack.
6792     const RecordDecl *RD;
6793     if (const FieldDecl *Field = dyn_cast<FieldDecl>(Next)) {
6794       HistoryStack.push_back(Field);
6795       RD = Field->getType()->castAs<RecordType>()->getDecl();
6796     } else {
6797       RD = cast<RecordDecl>(Next);
6798     }
6799 
6800     // Add a null marker so we know when we've gone back up a level
6801     VisitStack.push_back(nullptr);
6802 
6803     for (const auto *FD : RD->fields()) {
6804       QualType QT = FD->getType();
6805 
6806       if (ValidTypes.count(QT.getTypePtr()))
6807         continue;
6808 
6809       OpenCLParamType ParamType = getOpenCLKernelParameterType(QT);
6810       if (ParamType == ValidKernelParam)
6811         continue;
6812 
6813       if (ParamType == RecordKernelParam) {
6814         VisitStack.push_back(FD);
6815         continue;
6816       }
6817 
6818       // OpenCL v1.2 s6.9.p:
6819       // Arguments to kernel functions that are declared to be a struct or union
6820       // do not allow OpenCL objects to be passed as elements of the struct or
6821       // union.
6822       if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam ||
6823           ParamType == PrivatePtrKernelParam) {
6824         S.Diag(Param->getLocation(),
6825                diag::err_record_with_pointers_kernel_param)
6826           << PT->isUnionType()
6827           << PT;
6828       } else {
6829         S.Diag(Param->getLocation(), diag::err_bad_kernel_param_type) << PT;
6830       }
6831 
6832       S.Diag(PD->getLocation(), diag::note_within_field_of_type)
6833         << PD->getDeclName();
6834 
6835       // We have an error, now let's go back up through history and show where
6836       // the offending field came from
6837       for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1,
6838              E = HistoryStack.end(); I != E; ++I) {
6839         const FieldDecl *OuterField = *I;
6840         S.Diag(OuterField->getLocation(), diag::note_within_field_of_type)
6841           << OuterField->getType();
6842       }
6843 
6844       S.Diag(FD->getLocation(), diag::note_illegal_field_declared_here)
6845         << QT->isPointerType()
6846         << QT;
6847       D.setInvalidType();
6848       return;
6849     }
6850   } while (!VisitStack.empty());
6851 }
6852 
6853 NamedDecl*
6854 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,
6855                               TypeSourceInfo *TInfo, LookupResult &Previous,
6856                               MultiTemplateParamsArg TemplateParamLists,
6857                               bool &AddToScope) {
6858   QualType R = TInfo->getType();
6859 
6860   assert(R.getTypePtr()->isFunctionType());
6861 
6862   // TODO: consider using NameInfo for diagnostic.
6863   DeclarationNameInfo NameInfo = GetNameForDeclarator(D);
6864   DeclarationName Name = NameInfo.getName();
6865   FunctionDecl::StorageClass SC = getFunctionStorageClass(*this, D);
6866 
6867   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
6868     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
6869          diag::err_invalid_thread)
6870       << DeclSpec::getSpecifierName(TSCS);
6871 
6872   if (D.isFirstDeclarationOfMember())
6873     adjustMemberFunctionCC(R, D.isStaticMember());
6874 
6875   bool isFriend = false;
6876   FunctionTemplateDecl *FunctionTemplate = nullptr;
6877   bool isExplicitSpecialization = false;
6878   bool isFunctionTemplateSpecialization = false;
6879 
6880   bool isDependentClassScopeExplicitSpecialization = false;
6881   bool HasExplicitTemplateArgs = false;
6882   TemplateArgumentListInfo TemplateArgs;
6883 
6884   bool isVirtualOkay = false;
6885 
6886   DeclContext *OriginalDC = DC;
6887   bool IsLocalExternDecl = adjustContextForLocalExternDecl(DC);
6888 
6889   FunctionDecl *NewFD = CreateNewFunctionDecl(*this, D, DC, R, TInfo, SC,
6890                                               isVirtualOkay);
6891   if (!NewFD) return nullptr;
6892 
6893   if (OriginalLexicalContext && OriginalLexicalContext->isObjCContainer())
6894     NewFD->setTopLevelDeclInObjCContainer();
6895 
6896   // Set the lexical context. If this is a function-scope declaration, or has a
6897   // C++ scope specifier, or is the object of a friend declaration, the lexical
6898   // context will be different from the semantic context.
6899   NewFD->setLexicalDeclContext(CurContext);
6900 
6901   if (IsLocalExternDecl)
6902     NewFD->setLocalExternDecl();
6903 
6904   if (getLangOpts().CPlusPlus) {
6905     bool isInline = D.getDeclSpec().isInlineSpecified();
6906     bool isVirtual = D.getDeclSpec().isVirtualSpecified();
6907     bool isExplicit = D.getDeclSpec().isExplicitSpecified();
6908     bool isConstexpr = D.getDeclSpec().isConstexprSpecified();
6909     isFriend = D.getDeclSpec().isFriendSpecified();
6910     if (isFriend && !isInline && D.isFunctionDefinition()) {
6911       // C++ [class.friend]p5
6912       //   A function can be defined in a friend declaration of a
6913       //   class . . . . Such a function is implicitly inline.
6914       NewFD->setImplicitlyInline();
6915     }
6916 
6917     // If this is a method defined in an __interface, and is not a constructor
6918     // or an overloaded operator, then set the pure flag (isVirtual will already
6919     // return true).
6920     if (const CXXRecordDecl *Parent =
6921           dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {
6922       if (Parent->isInterface() && cast<CXXMethodDecl>(NewFD)->isUserProvided())
6923         NewFD->setPure(true);
6924     }
6925 
6926     SetNestedNameSpecifier(NewFD, D);
6927     isExplicitSpecialization = false;
6928     isFunctionTemplateSpecialization = false;
6929     if (D.isInvalidType())
6930       NewFD->setInvalidDecl();
6931 
6932     // Match up the template parameter lists with the scope specifier, then
6933     // determine whether we have a template or a template specialization.
6934     bool Invalid = false;
6935     if (TemplateParameterList *TemplateParams =
6936             MatchTemplateParametersToScopeSpecifier(
6937                 D.getDeclSpec().getLocStart(), D.getIdentifierLoc(),
6938                 D.getCXXScopeSpec(),
6939                 D.getName().getKind() == UnqualifiedId::IK_TemplateId
6940                     ? D.getName().TemplateId
6941                     : nullptr,
6942                 TemplateParamLists, isFriend, isExplicitSpecialization,
6943                 Invalid)) {
6944       if (TemplateParams->size() > 0) {
6945         // This is a function template
6946 
6947         // Check that we can declare a template here.
6948         if (CheckTemplateDeclScope(S, TemplateParams))
6949           return nullptr;
6950 
6951         // A destructor cannot be a template.
6952         if (Name.getNameKind() == DeclarationName::CXXDestructorName) {
6953           Diag(NewFD->getLocation(), diag::err_destructor_template);
6954           return nullptr;
6955         }
6956 
6957         // If we're adding a template to a dependent context, we may need to
6958         // rebuilding some of the types used within the template parameter list,
6959         // now that we know what the current instantiation is.
6960         if (DC->isDependentContext()) {
6961           ContextRAII SavedContext(*this, DC);
6962           if (RebuildTemplateParamsInCurrentInstantiation(TemplateParams))
6963             Invalid = true;
6964         }
6965 
6966 
6967         FunctionTemplate = FunctionTemplateDecl::Create(Context, DC,
6968                                                         NewFD->getLocation(),
6969                                                         Name, TemplateParams,
6970                                                         NewFD);
6971         FunctionTemplate->setLexicalDeclContext(CurContext);
6972         NewFD->setDescribedFunctionTemplate(FunctionTemplate);
6973 
6974         // For source fidelity, store the other template param lists.
6975         if (TemplateParamLists.size() > 1) {
6976           NewFD->setTemplateParameterListsInfo(Context,
6977                                                TemplateParamLists.size() - 1,
6978                                                TemplateParamLists.data());
6979         }
6980       } else {
6981         // This is a function template specialization.
6982         isFunctionTemplateSpecialization = true;
6983         // For source fidelity, store all the template param lists.
6984         if (TemplateParamLists.size() > 0)
6985           NewFD->setTemplateParameterListsInfo(Context,
6986                                                TemplateParamLists.size(),
6987                                                TemplateParamLists.data());
6988 
6989         // C++0x [temp.expl.spec]p20 forbids "template<> friend void foo(int);".
6990         if (isFriend) {
6991           // We want to remove the "template<>", found here.
6992           SourceRange RemoveRange = TemplateParams->getSourceRange();
6993 
6994           // If we remove the template<> and the name is not a
6995           // template-id, we're actually silently creating a problem:
6996           // the friend declaration will refer to an untemplated decl,
6997           // and clearly the user wants a template specialization.  So
6998           // we need to insert '<>' after the name.
6999           SourceLocation InsertLoc;
7000           if (D.getName().getKind() != UnqualifiedId::IK_TemplateId) {
7001             InsertLoc = D.getName().getSourceRange().getEnd();
7002             InsertLoc = getLocForEndOfToken(InsertLoc);
7003           }
7004 
7005           Diag(D.getIdentifierLoc(), diag::err_template_spec_decl_friend)
7006             << Name << RemoveRange
7007             << FixItHint::CreateRemoval(RemoveRange)
7008             << FixItHint::CreateInsertion(InsertLoc, "<>");
7009         }
7010       }
7011     }
7012     else {
7013       // All template param lists were matched against the scope specifier:
7014       // this is NOT (an explicit specialization of) a template.
7015       if (TemplateParamLists.size() > 0)
7016         // For source fidelity, store all the template param lists.
7017         NewFD->setTemplateParameterListsInfo(Context,
7018                                              TemplateParamLists.size(),
7019                                              TemplateParamLists.data());
7020     }
7021 
7022     if (Invalid) {
7023       NewFD->setInvalidDecl();
7024       if (FunctionTemplate)
7025         FunctionTemplate->setInvalidDecl();
7026     }
7027 
7028     // C++ [dcl.fct.spec]p5:
7029     //   The virtual specifier shall only be used in declarations of
7030     //   nonstatic class member functions that appear within a
7031     //   member-specification of a class declaration; see 10.3.
7032     //
7033     if (isVirtual && !NewFD->isInvalidDecl()) {
7034       if (!isVirtualOkay) {
7035         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7036              diag::err_virtual_non_function);
7037       } else if (!CurContext->isRecord()) {
7038         // 'virtual' was specified outside of the class.
7039         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7040              diag::err_virtual_out_of_class)
7041           << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7042       } else if (NewFD->getDescribedFunctionTemplate()) {
7043         // C++ [temp.mem]p3:
7044         //  A member function template shall not be virtual.
7045         Diag(D.getDeclSpec().getVirtualSpecLoc(),
7046              diag::err_virtual_member_function_template)
7047           << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());
7048       } else {
7049         // Okay: Add virtual to the method.
7050         NewFD->setVirtualAsWritten(true);
7051       }
7052 
7053       if (getLangOpts().CPlusPlus14 &&
7054           NewFD->getReturnType()->isUndeducedType())
7055         Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_auto_fn_virtual);
7056     }
7057 
7058     if (getLangOpts().CPlusPlus14 &&
7059         (NewFD->isDependentContext() ||
7060          (isFriend && CurContext->isDependentContext())) &&
7061         NewFD->getReturnType()->isUndeducedType()) {
7062       // If the function template is referenced directly (for instance, as a
7063       // member of the current instantiation), pretend it has a dependent type.
7064       // This is not really justified by the standard, but is the only sane
7065       // thing to do.
7066       // FIXME: For a friend function, we have not marked the function as being
7067       // a friend yet, so 'isDependentContext' on the FD doesn't work.
7068       const FunctionProtoType *FPT =
7069           NewFD->getType()->castAs<FunctionProtoType>();
7070       QualType Result =
7071           SubstAutoType(FPT->getReturnType(), Context.DependentTy);
7072       NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
7073                                              FPT->getExtProtoInfo()));
7074     }
7075 
7076     // C++ [dcl.fct.spec]p3:
7077     //  The inline specifier shall not appear on a block scope function
7078     //  declaration.
7079     if (isInline && !NewFD->isInvalidDecl()) {
7080       if (CurContext->isFunctionOrMethod()) {
7081         // 'inline' is not allowed on block scope function declaration.
7082         Diag(D.getDeclSpec().getInlineSpecLoc(),
7083              diag::err_inline_declaration_block_scope) << Name
7084           << FixItHint::CreateRemoval(D.getDeclSpec().getInlineSpecLoc());
7085       }
7086     }
7087 
7088     // C++ [dcl.fct.spec]p6:
7089     //  The explicit specifier shall be used only in the declaration of a
7090     //  constructor or conversion function within its class definition;
7091     //  see 12.3.1 and 12.3.2.
7092     if (isExplicit && !NewFD->isInvalidDecl()) {
7093       if (!CurContext->isRecord()) {
7094         // 'explicit' was specified outside of the class.
7095         Diag(D.getDeclSpec().getExplicitSpecLoc(),
7096              diag::err_explicit_out_of_class)
7097           << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7098       } else if (!isa<CXXConstructorDecl>(NewFD) &&
7099                  !isa<CXXConversionDecl>(NewFD)) {
7100         // 'explicit' was specified on a function that wasn't a constructor
7101         // or conversion function.
7102         Diag(D.getDeclSpec().getExplicitSpecLoc(),
7103              diag::err_explicit_non_ctor_or_conv_function)
7104           << FixItHint::CreateRemoval(D.getDeclSpec().getExplicitSpecLoc());
7105       }
7106     }
7107 
7108     if (isConstexpr) {
7109       // C++11 [dcl.constexpr]p2: constexpr functions and constexpr constructors
7110       // are implicitly inline.
7111       NewFD->setImplicitlyInline();
7112 
7113       // C++11 [dcl.constexpr]p3: functions declared constexpr are required to
7114       // be either constructors or to return a literal type. Therefore,
7115       // destructors cannot be declared constexpr.
7116       if (isa<CXXDestructorDecl>(NewFD))
7117         Diag(D.getDeclSpec().getConstexprSpecLoc(), diag::err_constexpr_dtor);
7118     }
7119 
7120     // If __module_private__ was specified, mark the function accordingly.
7121     if (D.getDeclSpec().isModulePrivateSpecified()) {
7122       if (isFunctionTemplateSpecialization) {
7123         SourceLocation ModulePrivateLoc
7124           = D.getDeclSpec().getModulePrivateSpecLoc();
7125         Diag(ModulePrivateLoc, diag::err_module_private_specialization)
7126           << 0
7127           << FixItHint::CreateRemoval(ModulePrivateLoc);
7128       } else {
7129         NewFD->setModulePrivate();
7130         if (FunctionTemplate)
7131           FunctionTemplate->setModulePrivate();
7132       }
7133     }
7134 
7135     if (isFriend) {
7136       if (FunctionTemplate) {
7137         FunctionTemplate->setObjectOfFriendDecl();
7138         FunctionTemplate->setAccess(AS_public);
7139       }
7140       NewFD->setObjectOfFriendDecl();
7141       NewFD->setAccess(AS_public);
7142     }
7143 
7144     // If a function is defined as defaulted or deleted, mark it as such now.
7145     // FIXME: Does this ever happen? ActOnStartOfFunctionDef forces the function
7146     // definition kind to FDK_Definition.
7147     switch (D.getFunctionDefinitionKind()) {
7148       case FDK_Declaration:
7149       case FDK_Definition:
7150         break;
7151 
7152       case FDK_Defaulted:
7153         NewFD->setDefaulted();
7154         break;
7155 
7156       case FDK_Deleted:
7157         NewFD->setDeletedAsWritten();
7158         break;
7159     }
7160 
7161     if (isa<CXXMethodDecl>(NewFD) && DC == CurContext &&
7162         D.isFunctionDefinition()) {
7163       // C++ [class.mfct]p2:
7164       //   A member function may be defined (8.4) in its class definition, in
7165       //   which case it is an inline member function (7.1.2)
7166       NewFD->setImplicitlyInline();
7167     }
7168 
7169     if (SC == SC_Static && isa<CXXMethodDecl>(NewFD) &&
7170         !CurContext->isRecord()) {
7171       // C++ [class.static]p1:
7172       //   A data or function member of a class may be declared static
7173       //   in a class definition, in which case it is a static member of
7174       //   the class.
7175 
7176       // Complain about the 'static' specifier if it's on an out-of-line
7177       // member function definition.
7178       Diag(D.getDeclSpec().getStorageClassSpecLoc(),
7179            diag::err_static_out_of_line)
7180         << FixItHint::CreateRemoval(D.getDeclSpec().getStorageClassSpecLoc());
7181     }
7182 
7183     // C++11 [except.spec]p15:
7184     //   A deallocation function with no exception-specification is treated
7185     //   as if it were specified with noexcept(true).
7186     const FunctionProtoType *FPT = R->getAs<FunctionProtoType>();
7187     if ((Name.getCXXOverloadedOperator() == OO_Delete ||
7188          Name.getCXXOverloadedOperator() == OO_Array_Delete) &&
7189         getLangOpts().CPlusPlus11 && FPT && !FPT->hasExceptionSpec())
7190       NewFD->setType(Context.getFunctionType(
7191           FPT->getReturnType(), FPT->getParamTypes(),
7192           FPT->getExtProtoInfo().withExceptionSpec(EST_BasicNoexcept)));
7193   }
7194 
7195   // Filter out previous declarations that don't match the scope.
7196   FilterLookupForScope(Previous, OriginalDC, S, shouldConsiderLinkage(NewFD),
7197                        D.getCXXScopeSpec().isNotEmpty() ||
7198                        isExplicitSpecialization ||
7199                        isFunctionTemplateSpecialization);
7200 
7201   // Handle GNU asm-label extension (encoded as an attribute).
7202   if (Expr *E = (Expr*) D.getAsmLabel()) {
7203     // The parser guarantees this is a string.
7204     StringLiteral *SE = cast<StringLiteral>(E);
7205     NewFD->addAttr(::new (Context) AsmLabelAttr(SE->getStrTokenLoc(0), Context,
7206                                                 SE->getString(), 0));
7207   } else if (!ExtnameUndeclaredIdentifiers.empty()) {
7208     llvm::DenseMap<IdentifierInfo*,AsmLabelAttr*>::iterator I =
7209       ExtnameUndeclaredIdentifiers.find(NewFD->getIdentifier());
7210     if (I != ExtnameUndeclaredIdentifiers.end()) {
7211       NewFD->addAttr(I->second);
7212       ExtnameUndeclaredIdentifiers.erase(I);
7213     }
7214   }
7215 
7216   // Copy the parameter declarations from the declarator D to the function
7217   // declaration NewFD, if they are available.  First scavenge them into Params.
7218   SmallVector<ParmVarDecl*, 16> Params;
7219   if (D.isFunctionDeclarator()) {
7220     DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
7221 
7222     // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs
7223     // function that takes no arguments, not a function that takes a
7224     // single void argument.
7225     // We let through "const void" here because Sema::GetTypeForDeclarator
7226     // already checks for that case.
7227     if (FTIHasNonVoidParameters(FTI) && FTI.Params[0].Param) {
7228       for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {
7229         ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
7230         assert(Param->getDeclContext() != NewFD && "Was set before ?");
7231         Param->setDeclContext(NewFD);
7232         Params.push_back(Param);
7233 
7234         if (Param->isInvalidDecl())
7235           NewFD->setInvalidDecl();
7236       }
7237     }
7238 
7239   } else if (const FunctionProtoType *FT = R->getAs<FunctionProtoType>()) {
7240     // When we're declaring a function with a typedef, typeof, etc as in the
7241     // following example, we'll need to synthesize (unnamed)
7242     // parameters for use in the declaration.
7243     //
7244     // @code
7245     // typedef void fn(int);
7246     // fn f;
7247     // @endcode
7248 
7249     // Synthesize a parameter for each argument type.
7250     for (const auto &AI : FT->param_types()) {
7251       ParmVarDecl *Param =
7252           BuildParmVarDeclForTypedef(NewFD, D.getIdentifierLoc(), AI);
7253       Param->setScopeInfo(0, Params.size());
7254       Params.push_back(Param);
7255     }
7256   } else {
7257     assert(R->isFunctionNoProtoType() && NewFD->getNumParams() == 0 &&
7258            "Should not need args for typedef of non-prototype fn");
7259   }
7260 
7261   // Finally, we know we have the right number of parameters, install them.
7262   NewFD->setParams(Params);
7263 
7264   // Find all anonymous symbols defined during the declaration of this function
7265   // and add to NewFD. This lets us track decls such 'enum Y' in:
7266   //
7267   //   void f(enum Y {AA} x) {}
7268   //
7269   // which would otherwise incorrectly end up in the translation unit scope.
7270   NewFD->setDeclsInPrototypeScope(DeclsInPrototypeScope);
7271   DeclsInPrototypeScope.clear();
7272 
7273   if (D.getDeclSpec().isNoreturnSpecified())
7274     NewFD->addAttr(
7275         ::new(Context) C11NoReturnAttr(D.getDeclSpec().getNoreturnSpecLoc(),
7276                                        Context, 0));
7277 
7278   // Functions returning a variably modified type violate C99 6.7.5.2p2
7279   // because all functions have linkage.
7280   if (!NewFD->isInvalidDecl() &&
7281       NewFD->getReturnType()->isVariablyModifiedType()) {
7282     Diag(NewFD->getLocation(), diag::err_vm_func_decl);
7283     NewFD->setInvalidDecl();
7284   }
7285 
7286   if (D.isFunctionDefinition() && CodeSegStack.CurrentValue &&
7287       !NewFD->hasAttr<SectionAttr>()) {
7288     NewFD->addAttr(
7289         SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
7290                                     CodeSegStack.CurrentValue->getString(),
7291                                     CodeSegStack.CurrentPragmaLocation));
7292     if (UnifySection(CodeSegStack.CurrentValue->getString(),
7293                      PSF_Implicit | PSF_Execute | PSF_Read, NewFD))
7294       NewFD->dropAttr<SectionAttr>();
7295   }
7296 
7297   // Handle attributes.
7298   ProcessDeclAttributes(S, NewFD, D);
7299 
7300   QualType RetType = NewFD->getReturnType();
7301   const CXXRecordDecl *Ret = RetType->isRecordType() ?
7302       RetType->getAsCXXRecordDecl() : RetType->getPointeeCXXRecordDecl();
7303   if (!NewFD->isInvalidDecl() && !NewFD->hasAttr<WarnUnusedResultAttr>() &&
7304       Ret && Ret->hasAttr<WarnUnusedResultAttr>()) {
7305     const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7306     // Attach WarnUnusedResult to functions returning types with that attribute.
7307     // Don't apply the attribute to that type's own non-static member functions
7308     // (to avoid warning on things like assignment operators)
7309     if (!MD || MD->getParent() != Ret)
7310       NewFD->addAttr(WarnUnusedResultAttr::CreateImplicit(Context));
7311   }
7312 
7313   if (getLangOpts().OpenCL) {
7314     // OpenCL v1.1 s6.5: Using an address space qualifier in a function return
7315     // type declaration will generate a compilation error.
7316     unsigned AddressSpace = RetType.getAddressSpace();
7317     if (AddressSpace == LangAS::opencl_local ||
7318         AddressSpace == LangAS::opencl_global ||
7319         AddressSpace == LangAS::opencl_constant) {
7320       Diag(NewFD->getLocation(),
7321            diag::err_opencl_return_value_with_address_space);
7322       NewFD->setInvalidDecl();
7323     }
7324   }
7325 
7326   if (!getLangOpts().CPlusPlus) {
7327     // Perform semantic checking on the function declaration.
7328     bool isExplicitSpecialization=false;
7329     if (!NewFD->isInvalidDecl() && NewFD->isMain())
7330       CheckMain(NewFD, D.getDeclSpec());
7331 
7332     if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7333       CheckMSVCRTEntryPoint(NewFD);
7334 
7335     if (!NewFD->isInvalidDecl())
7336       D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7337                                                   isExplicitSpecialization));
7338     else if (!Previous.empty())
7339       // Make graceful recovery from an invalid redeclaration.
7340       D.setRedeclaration(true);
7341     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7342             Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7343            "previous declaration set still overloaded");
7344   } else {
7345     // C++11 [replacement.functions]p3:
7346     //  The program's definitions shall not be specified as inline.
7347     //
7348     // N.B. We diagnose declarations instead of definitions per LWG issue 2340.
7349     //
7350     // Suppress the diagnostic if the function is __attribute__((used)), since
7351     // that forces an external definition to be emitted.
7352     if (D.getDeclSpec().isInlineSpecified() &&
7353         NewFD->isReplaceableGlobalAllocationFunction() &&
7354         !NewFD->hasAttr<UsedAttr>())
7355       Diag(D.getDeclSpec().getInlineSpecLoc(),
7356            diag::ext_operator_new_delete_declared_inline)
7357         << NewFD->getDeclName();
7358 
7359     // If the declarator is a template-id, translate the parser's template
7360     // argument list into our AST format.
7361     if (D.getName().getKind() == UnqualifiedId::IK_TemplateId) {
7362       TemplateIdAnnotation *TemplateId = D.getName().TemplateId;
7363       TemplateArgs.setLAngleLoc(TemplateId->LAngleLoc);
7364       TemplateArgs.setRAngleLoc(TemplateId->RAngleLoc);
7365       ASTTemplateArgsPtr TemplateArgsPtr(TemplateId->getTemplateArgs(),
7366                                          TemplateId->NumArgs);
7367       translateTemplateArguments(TemplateArgsPtr,
7368                                  TemplateArgs);
7369 
7370       HasExplicitTemplateArgs = true;
7371 
7372       if (NewFD->isInvalidDecl()) {
7373         HasExplicitTemplateArgs = false;
7374       } else if (FunctionTemplate) {
7375         // Function template with explicit template arguments.
7376         Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec)
7377           << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);
7378 
7379         HasExplicitTemplateArgs = false;
7380       } else {
7381         assert((isFunctionTemplateSpecialization ||
7382                 D.getDeclSpec().isFriendSpecified()) &&
7383                "should have a 'template<>' for this decl");
7384         // "friend void foo<>(int);" is an implicit specialization decl.
7385         isFunctionTemplateSpecialization = true;
7386       }
7387     } else if (isFriend && isFunctionTemplateSpecialization) {
7388       // This combination is only possible in a recovery case;  the user
7389       // wrote something like:
7390       //   template <> friend void foo(int);
7391       // which we're recovering from as if the user had written:
7392       //   friend void foo<>(int);
7393       // Go ahead and fake up a template id.
7394       HasExplicitTemplateArgs = true;
7395       TemplateArgs.setLAngleLoc(D.getIdentifierLoc());
7396       TemplateArgs.setRAngleLoc(D.getIdentifierLoc());
7397     }
7398 
7399     // If it's a friend (and only if it's a friend), it's possible
7400     // that either the specialized function type or the specialized
7401     // template is dependent, and therefore matching will fail.  In
7402     // this case, don't check the specialization yet.
7403     bool InstantiationDependent = false;
7404     if (isFunctionTemplateSpecialization && isFriend &&
7405         (NewFD->getType()->isDependentType() || DC->isDependentContext() ||
7406          TemplateSpecializationType::anyDependentTemplateArguments(
7407             TemplateArgs.getArgumentArray(), TemplateArgs.size(),
7408             InstantiationDependent))) {
7409       assert(HasExplicitTemplateArgs &&
7410              "friend function specialization without template args");
7411       if (CheckDependentFunctionTemplateSpecialization(NewFD, TemplateArgs,
7412                                                        Previous))
7413         NewFD->setInvalidDecl();
7414     } else if (isFunctionTemplateSpecialization) {
7415       if (CurContext->isDependentContext() && CurContext->isRecord()
7416           && !isFriend) {
7417         isDependentClassScopeExplicitSpecialization = true;
7418         Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
7419           diag::ext_function_specialization_in_class :
7420           diag::err_function_specialization_in_class)
7421           << NewFD->getDeclName();
7422       } else if (CheckFunctionTemplateSpecialization(NewFD,
7423                                   (HasExplicitTemplateArgs ? &TemplateArgs
7424                                                            : nullptr),
7425                                                      Previous))
7426         NewFD->setInvalidDecl();
7427 
7428       // C++ [dcl.stc]p1:
7429       //   A storage-class-specifier shall not be specified in an explicit
7430       //   specialization (14.7.3)
7431       FunctionTemplateSpecializationInfo *Info =
7432           NewFD->getTemplateSpecializationInfo();
7433       if (Info && SC != SC_None) {
7434         if (SC != Info->getTemplate()->getTemplatedDecl()->getStorageClass())
7435           Diag(NewFD->getLocation(),
7436                diag::err_explicit_specialization_inconsistent_storage_class)
7437             << SC
7438             << FixItHint::CreateRemoval(
7439                                       D.getDeclSpec().getStorageClassSpecLoc());
7440 
7441         else
7442           Diag(NewFD->getLocation(),
7443                diag::ext_explicit_specialization_storage_class)
7444             << FixItHint::CreateRemoval(
7445                                       D.getDeclSpec().getStorageClassSpecLoc());
7446       }
7447 
7448     } else if (isExplicitSpecialization && isa<CXXMethodDecl>(NewFD)) {
7449       if (CheckMemberSpecialization(NewFD, Previous))
7450           NewFD->setInvalidDecl();
7451     }
7452 
7453     // Perform semantic checking on the function declaration.
7454     if (!isDependentClassScopeExplicitSpecialization) {
7455       if (!NewFD->isInvalidDecl() && NewFD->isMain())
7456         CheckMain(NewFD, D.getDeclSpec());
7457 
7458       if (!NewFD->isInvalidDecl() && NewFD->isMSVCRTEntryPoint())
7459         CheckMSVCRTEntryPoint(NewFD);
7460 
7461       if (!NewFD->isInvalidDecl())
7462         D.setRedeclaration(CheckFunctionDeclaration(S, NewFD, Previous,
7463                                                     isExplicitSpecialization));
7464     }
7465 
7466     assert((NewFD->isInvalidDecl() || !D.isRedeclaration() ||
7467             Previous.getResultKind() != LookupResult::FoundOverloaded) &&
7468            "previous declaration set still overloaded");
7469 
7470     NamedDecl *PrincipalDecl = (FunctionTemplate
7471                                 ? cast<NamedDecl>(FunctionTemplate)
7472                                 : NewFD);
7473 
7474     if (isFriend && D.isRedeclaration()) {
7475       AccessSpecifier Access = AS_public;
7476       if (!NewFD->isInvalidDecl())
7477         Access = NewFD->getPreviousDecl()->getAccess();
7478 
7479       NewFD->setAccess(Access);
7480       if (FunctionTemplate) FunctionTemplate->setAccess(Access);
7481     }
7482 
7483     if (NewFD->isOverloadedOperator() && !DC->isRecord() &&
7484         PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
7485       PrincipalDecl->setNonMemberOperator();
7486 
7487     // If we have a function template, check the template parameter
7488     // list. This will check and merge default template arguments.
7489     if (FunctionTemplate) {
7490       FunctionTemplateDecl *PrevTemplate =
7491                                      FunctionTemplate->getPreviousDecl();
7492       CheckTemplateParameterList(FunctionTemplate->getTemplateParameters(),
7493                        PrevTemplate ? PrevTemplate->getTemplateParameters()
7494                                     : nullptr,
7495                             D.getDeclSpec().isFriendSpecified()
7496                               ? (D.isFunctionDefinition()
7497                                    ? TPC_FriendFunctionTemplateDefinition
7498                                    : TPC_FriendFunctionTemplate)
7499                               : (D.getCXXScopeSpec().isSet() &&
7500                                  DC && DC->isRecord() &&
7501                                  DC->isDependentContext())
7502                                   ? TPC_ClassTemplateMember
7503                                   : TPC_FunctionTemplate);
7504     }
7505 
7506     if (NewFD->isInvalidDecl()) {
7507       // Ignore all the rest of this.
7508     } else if (!D.isRedeclaration()) {
7509       struct ActOnFDArgs ExtraArgs = { S, D, TemplateParamLists,
7510                                        AddToScope };
7511       // Fake up an access specifier if it's supposed to be a class member.
7512       if (isa<CXXRecordDecl>(NewFD->getDeclContext()))
7513         NewFD->setAccess(AS_public);
7514 
7515       // Qualified decls generally require a previous declaration.
7516       if (D.getCXXScopeSpec().isSet()) {
7517         // ...with the major exception of templated-scope or
7518         // dependent-scope friend declarations.
7519 
7520         // TODO: we currently also suppress this check in dependent
7521         // contexts because (1) the parameter depth will be off when
7522         // matching friend templates and (2) we might actually be
7523         // selecting a friend based on a dependent factor.  But there
7524         // are situations where these conditions don't apply and we
7525         // can actually do this check immediately.
7526         if (isFriend &&
7527             (TemplateParamLists.size() ||
7528              D.getCXXScopeSpec().getScopeRep()->isDependent() ||
7529              CurContext->isDependentContext())) {
7530           // ignore these
7531         } else {
7532           // The user tried to provide an out-of-line definition for a
7533           // function that is a member of a class or namespace, but there
7534           // was no such member function declared (C++ [class.mfct]p2,
7535           // C++ [namespace.memdef]p2). For example:
7536           //
7537           // class X {
7538           //   void f() const;
7539           // };
7540           //
7541           // void X::f() { } // ill-formed
7542           //
7543           // Complain about this problem, and attempt to suggest close
7544           // matches (e.g., those that differ only in cv-qualifiers and
7545           // whether the parameter types are references).
7546 
7547           if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7548                   *this, Previous, NewFD, ExtraArgs, false, nullptr)) {
7549             AddToScope = ExtraArgs.AddToScope;
7550             return Result;
7551           }
7552         }
7553 
7554         // Unqualified local friend declarations are required to resolve
7555         // to something.
7556       } else if (isFriend && cast<CXXRecordDecl>(CurContext)->isLocalClass()) {
7557         if (NamedDecl *Result = DiagnoseInvalidRedeclaration(
7558                 *this, Previous, NewFD, ExtraArgs, true, S)) {
7559           AddToScope = ExtraArgs.AddToScope;
7560           return Result;
7561         }
7562       }
7563 
7564     } else if (!D.isFunctionDefinition() &&
7565                isa<CXXMethodDecl>(NewFD) && NewFD->isOutOfLine() &&
7566                !isFriend && !isFunctionTemplateSpecialization &&
7567                !isExplicitSpecialization) {
7568       // An out-of-line member function declaration must also be a
7569       // definition (C++ [class.mfct]p2).
7570       // Note that this is not the case for explicit specializations of
7571       // function templates or member functions of class templates, per
7572       // C++ [temp.expl.spec]p2. We also allow these declarations as an
7573       // extension for compatibility with old SWIG code which likes to
7574       // generate them.
7575       Diag(NewFD->getLocation(), diag::ext_out_of_line_declaration)
7576         << D.getCXXScopeSpec().getRange();
7577     }
7578   }
7579 
7580   ProcessPragmaWeak(S, NewFD);
7581   checkAttributesAfterMerging(*this, *NewFD);
7582 
7583   AddKnownFunctionAttributes(NewFD);
7584 
7585   if (NewFD->hasAttr<OverloadableAttr>() &&
7586       !NewFD->getType()->getAs<FunctionProtoType>()) {
7587     Diag(NewFD->getLocation(),
7588          diag::err_attribute_overloadable_no_prototype)
7589       << NewFD;
7590 
7591     // Turn this into a variadic function with no parameters.
7592     const FunctionType *FT = NewFD->getType()->getAs<FunctionType>();
7593     FunctionProtoType::ExtProtoInfo EPI(
7594         Context.getDefaultCallingConvention(true, false));
7595     EPI.Variadic = true;
7596     EPI.ExtInfo = FT->getExtInfo();
7597 
7598     QualType R = Context.getFunctionType(FT->getReturnType(), None, EPI);
7599     NewFD->setType(R);
7600   }
7601 
7602   // If there's a #pragma GCC visibility in scope, and this isn't a class
7603   // member, set the visibility of this function.
7604   if (!DC->isRecord() && NewFD->isExternallyVisible())
7605     AddPushedVisibilityAttribute(NewFD);
7606 
7607   // If there's a #pragma clang arc_cf_code_audited in scope, consider
7608   // marking the function.
7609   AddCFAuditedAttribute(NewFD);
7610 
7611   // If this is a function definition, check if we have to apply optnone due to
7612   // a pragma.
7613   if(D.isFunctionDefinition())
7614     AddRangeBasedOptnone(NewFD);
7615 
7616   // If this is the first declaration of an extern C variable, update
7617   // the map of such variables.
7618   if (NewFD->isFirstDecl() && !NewFD->isInvalidDecl() &&
7619       isIncompleteDeclExternC(*this, NewFD))
7620     RegisterLocallyScopedExternCDecl(NewFD, S);
7621 
7622   // Set this FunctionDecl's range up to the right paren.
7623   NewFD->setRangeEnd(D.getSourceRange().getEnd());
7624 
7625   if (D.isRedeclaration() && !Previous.empty()) {
7626     checkDLLAttributeRedeclaration(
7627         *this, dyn_cast<NamedDecl>(Previous.getRepresentativeDecl()), NewFD,
7628         isExplicitSpecialization || isFunctionTemplateSpecialization);
7629   }
7630 
7631   if (getLangOpts().CPlusPlus) {
7632     if (FunctionTemplate) {
7633       if (NewFD->isInvalidDecl())
7634         FunctionTemplate->setInvalidDecl();
7635       return FunctionTemplate;
7636     }
7637   }
7638 
7639   if (NewFD->hasAttr<OpenCLKernelAttr>()) {
7640     // OpenCL v1.2 s6.8 static is invalid for kernel functions.
7641     if ((getLangOpts().OpenCLVersion >= 120)
7642         && (SC == SC_Static)) {
7643       Diag(D.getIdentifierLoc(), diag::err_static_kernel);
7644       D.setInvalidType();
7645     }
7646 
7647     // OpenCL v1.2, s6.9 -- Kernels can only have return type void.
7648     if (!NewFD->getReturnType()->isVoidType()) {
7649       SourceRange RTRange = NewFD->getReturnTypeSourceRange();
7650       Diag(D.getIdentifierLoc(), diag::err_expected_kernel_void_return_type)
7651           << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "void")
7652                                 : FixItHint());
7653       D.setInvalidType();
7654     }
7655 
7656     llvm::SmallPtrSet<const Type *, 16> ValidTypes;
7657     for (auto Param : NewFD->params())
7658       checkIsValidOpenCLKernelParameter(*this, D, Param, ValidTypes);
7659   }
7660 
7661   MarkUnusedFileScopedDecl(NewFD);
7662 
7663   if (getLangOpts().CUDA)
7664     if (IdentifierInfo *II = NewFD->getIdentifier())
7665       if (!NewFD->isInvalidDecl() &&
7666           NewFD->getDeclContext()->getRedeclContext()->isTranslationUnit()) {
7667         if (II->isStr("cudaConfigureCall")) {
7668           if (!R->getAs<FunctionType>()->getReturnType()->isScalarType())
7669             Diag(NewFD->getLocation(), diag::err_config_scalar_return);
7670 
7671           Context.setcudaConfigureCallDecl(NewFD);
7672         }
7673       }
7674 
7675   // Here we have an function template explicit specialization at class scope.
7676   // The actually specialization will be postponed to template instatiation
7677   // time via the ClassScopeFunctionSpecializationDecl node.
7678   if (isDependentClassScopeExplicitSpecialization) {
7679     ClassScopeFunctionSpecializationDecl *NewSpec =
7680                          ClassScopeFunctionSpecializationDecl::Create(
7681                                 Context, CurContext, SourceLocation(),
7682                                 cast<CXXMethodDecl>(NewFD),
7683                                 HasExplicitTemplateArgs, TemplateArgs);
7684     CurContext->addDecl(NewSpec);
7685     AddToScope = false;
7686   }
7687 
7688   return NewFD;
7689 }
7690 
7691 /// \brief Perform semantic checking of a new function declaration.
7692 ///
7693 /// Performs semantic analysis of the new function declaration
7694 /// NewFD. This routine performs all semantic checking that does not
7695 /// require the actual declarator involved in the declaration, and is
7696 /// used both for the declaration of functions as they are parsed
7697 /// (called via ActOnDeclarator) and for the declaration of functions
7698 /// that have been instantiated via C++ template instantiation (called
7699 /// via InstantiateDecl).
7700 ///
7701 /// \param IsExplicitSpecialization whether this new function declaration is
7702 /// an explicit specialization of the previous declaration.
7703 ///
7704 /// This sets NewFD->isInvalidDecl() to true if there was an error.
7705 ///
7706 /// \returns true if the function declaration is a redeclaration.
7707 bool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD,
7708                                     LookupResult &Previous,
7709                                     bool IsExplicitSpecialization) {
7710   assert(!NewFD->getReturnType()->isVariablyModifiedType() &&
7711          "Variably modified return types are not handled here");
7712 
7713   // Determine whether the type of this function should be merged with
7714   // a previous visible declaration. This never happens for functions in C++,
7715   // and always happens in C if the previous declaration was visible.
7716   bool MergeTypeWithPrevious = !getLangOpts().CPlusPlus &&
7717                                !Previous.isShadowed();
7718 
7719   // Filter out any non-conflicting previous declarations.
7720   filterNonConflictingPreviousDecls(Context, NewFD, Previous);
7721 
7722   bool Redeclaration = false;
7723   NamedDecl *OldDecl = nullptr;
7724 
7725   // Merge or overload the declaration with an existing declaration of
7726   // the same name, if appropriate.
7727   if (!Previous.empty()) {
7728     // Determine whether NewFD is an overload of PrevDecl or
7729     // a declaration that requires merging. If it's an overload,
7730     // there's no more work to do here; we'll just add the new
7731     // function to the scope.
7732     if (!AllowOverloadingOfFunction(Previous, Context)) {
7733       NamedDecl *Candidate = Previous.getFoundDecl();
7734       if (shouldLinkPossiblyHiddenDecl(Candidate, NewFD)) {
7735         Redeclaration = true;
7736         OldDecl = Candidate;
7737       }
7738     } else {
7739       switch (CheckOverload(S, NewFD, Previous, OldDecl,
7740                             /*NewIsUsingDecl*/ false)) {
7741       case Ovl_Match:
7742         Redeclaration = true;
7743         break;
7744 
7745       case Ovl_NonFunction:
7746         Redeclaration = true;
7747         break;
7748 
7749       case Ovl_Overload:
7750         Redeclaration = false;
7751         break;
7752       }
7753 
7754       if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
7755         // If a function name is overloadable in C, then every function
7756         // with that name must be marked "overloadable".
7757         Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
7758           << Redeclaration << NewFD;
7759         NamedDecl *OverloadedDecl = nullptr;
7760         if (Redeclaration)
7761           OverloadedDecl = OldDecl;
7762         else if (!Previous.empty())
7763           OverloadedDecl = Previous.getRepresentativeDecl();
7764         if (OverloadedDecl)
7765           Diag(OverloadedDecl->getLocation(),
7766                diag::note_attribute_overloadable_prev_overload);
7767         NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
7768       }
7769     }
7770   }
7771 
7772   // Check for a previous extern "C" declaration with this name.
7773   if (!Redeclaration &&
7774       checkForConflictWithNonVisibleExternC(*this, NewFD, Previous)) {
7775     filterNonConflictingPreviousDecls(Context, NewFD, Previous);
7776     if (!Previous.empty()) {
7777       // This is an extern "C" declaration with the same name as a previous
7778       // declaration, and thus redeclares that entity...
7779       Redeclaration = true;
7780       OldDecl = Previous.getFoundDecl();
7781       MergeTypeWithPrevious = false;
7782 
7783       // ... except in the presence of __attribute__((overloadable)).
7784       if (OldDecl->hasAttr<OverloadableAttr>()) {
7785         if (!getLangOpts().CPlusPlus && !NewFD->hasAttr<OverloadableAttr>()) {
7786           Diag(NewFD->getLocation(), diag::err_attribute_overloadable_missing)
7787             << Redeclaration << NewFD;
7788           Diag(Previous.getFoundDecl()->getLocation(),
7789                diag::note_attribute_overloadable_prev_overload);
7790           NewFD->addAttr(OverloadableAttr::CreateImplicit(Context));
7791         }
7792         if (IsOverload(NewFD, cast<FunctionDecl>(OldDecl), false)) {
7793           Redeclaration = false;
7794           OldDecl = nullptr;
7795         }
7796       }
7797     }
7798   }
7799 
7800   // C++11 [dcl.constexpr]p8:
7801   //   A constexpr specifier for a non-static member function that is not
7802   //   a constructor declares that member function to be const.
7803   //
7804   // This needs to be delayed until we know whether this is an out-of-line
7805   // definition of a static member function.
7806   //
7807   // This rule is not present in C++1y, so we produce a backwards
7808   // compatibility warning whenever it happens in C++11.
7809   CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(NewFD);
7810   if (!getLangOpts().CPlusPlus14 && MD && MD->isConstexpr() &&
7811       !MD->isStatic() && !isa<CXXConstructorDecl>(MD) &&
7812       (MD->getTypeQualifiers() & Qualifiers::Const) == 0) {
7813     CXXMethodDecl *OldMD = nullptr;
7814     if (OldDecl)
7815       OldMD = dyn_cast<CXXMethodDecl>(OldDecl->getAsFunction());
7816     if (!OldMD || !OldMD->isStatic()) {
7817       const FunctionProtoType *FPT =
7818         MD->getType()->castAs<FunctionProtoType>();
7819       FunctionProtoType::ExtProtoInfo EPI = FPT->getExtProtoInfo();
7820       EPI.TypeQuals |= Qualifiers::Const;
7821       MD->setType(Context.getFunctionType(FPT->getReturnType(),
7822                                           FPT->getParamTypes(), EPI));
7823 
7824       // Warn that we did this, if we're not performing template instantiation.
7825       // In that case, we'll have warned already when the template was defined.
7826       if (ActiveTemplateInstantiations.empty()) {
7827         SourceLocation AddConstLoc;
7828         if (FunctionTypeLoc FTL = MD->getTypeSourceInfo()->getTypeLoc()
7829                 .IgnoreParens().getAs<FunctionTypeLoc>())
7830           AddConstLoc = getLocForEndOfToken(FTL.getRParenLoc());
7831 
7832         Diag(MD->getLocation(), diag::warn_cxx14_compat_constexpr_not_const)
7833           << FixItHint::CreateInsertion(AddConstLoc, " const");
7834       }
7835     }
7836   }
7837 
7838   if (Redeclaration) {
7839     // NewFD and OldDecl represent declarations that need to be
7840     // merged.
7841     if (MergeFunctionDecl(NewFD, OldDecl, S, MergeTypeWithPrevious)) {
7842       NewFD->setInvalidDecl();
7843       return Redeclaration;
7844     }
7845 
7846     Previous.clear();
7847     Previous.addDecl(OldDecl);
7848 
7849     if (FunctionTemplateDecl *OldTemplateDecl
7850                                   = dyn_cast<FunctionTemplateDecl>(OldDecl)) {
7851       NewFD->setPreviousDeclaration(OldTemplateDecl->getTemplatedDecl());
7852       FunctionTemplateDecl *NewTemplateDecl
7853         = NewFD->getDescribedFunctionTemplate();
7854       assert(NewTemplateDecl && "Template/non-template mismatch");
7855       if (CXXMethodDecl *Method
7856             = dyn_cast<CXXMethodDecl>(NewTemplateDecl->getTemplatedDecl())) {
7857         Method->setAccess(OldTemplateDecl->getAccess());
7858         NewTemplateDecl->setAccess(OldTemplateDecl->getAccess());
7859       }
7860 
7861       // If this is an explicit specialization of a member that is a function
7862       // template, mark it as a member specialization.
7863       if (IsExplicitSpecialization &&
7864           NewTemplateDecl->getInstantiatedFromMemberTemplate()) {
7865         NewTemplateDecl->setMemberSpecialization();
7866         assert(OldTemplateDecl->isMemberSpecialization());
7867       }
7868 
7869     } else {
7870       // This needs to happen first so that 'inline' propagates.
7871       NewFD->setPreviousDeclaration(cast<FunctionDecl>(OldDecl));
7872 
7873       if (isa<CXXMethodDecl>(NewFD)) {
7874         // A valid redeclaration of a C++ method must be out-of-line,
7875         // but (unfortunately) it's not necessarily a definition
7876         // because of templates, which means that the previous
7877         // declaration is not necessarily from the class definition.
7878 
7879         // For just setting the access, that doesn't matter.
7880         CXXMethodDecl *oldMethod = cast<CXXMethodDecl>(OldDecl);
7881         NewFD->setAccess(oldMethod->getAccess());
7882 
7883         // Update the key-function state if necessary for this ABI.
7884         if (NewFD->isInlined() &&
7885             !Context.getTargetInfo().getCXXABI().canKeyFunctionBeInline()) {
7886           // setNonKeyFunction needs to work with the original
7887           // declaration from the class definition, and isVirtual() is
7888           // just faster in that case, so map back to that now.
7889           oldMethod = cast<CXXMethodDecl>(oldMethod->getFirstDecl());
7890           if (oldMethod->isVirtual()) {
7891             Context.setNonKeyFunction(oldMethod);
7892           }
7893         }
7894       }
7895     }
7896   }
7897 
7898   // Semantic checking for this function declaration (in isolation).
7899 
7900   // Diagnose the use of X86 fastcall on unprototyped functions.
7901   QualType NewQType = Context.getCanonicalType(NewFD->getType());
7902   const FunctionType *NewType = cast<FunctionType>(NewQType);
7903   if (isa<FunctionNoProtoType>(NewType)) {
7904     FunctionType::ExtInfo NewTypeInfo = NewType->getExtInfo();
7905     if (NewTypeInfo.getCC() == CC_X86FastCall)
7906       Diag(NewFD->getLocation(), diag::err_cconv_knr)
7907           << FunctionType::getNameForCallConv(CC_X86FastCall);
7908     // TODO: Also diagnose unprototyped stdcall functions?
7909   }
7910 
7911   if (getLangOpts().CPlusPlus) {
7912     // C++-specific checks.
7913     if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(NewFD)) {
7914       CheckConstructor(Constructor);
7915     } else if (CXXDestructorDecl *Destructor =
7916                 dyn_cast<CXXDestructorDecl>(NewFD)) {
7917       CXXRecordDecl *Record = Destructor->getParent();
7918       QualType ClassType = Context.getTypeDeclType(Record);
7919 
7920       // FIXME: Shouldn't we be able to perform this check even when the class
7921       // type is dependent? Both gcc and edg can handle that.
7922       if (!ClassType->isDependentType()) {
7923         DeclarationName Name
7924           = Context.DeclarationNames.getCXXDestructorName(
7925                                         Context.getCanonicalType(ClassType));
7926         if (NewFD->getDeclName() != Name) {
7927           Diag(NewFD->getLocation(), diag::err_destructor_name);
7928           NewFD->setInvalidDecl();
7929           return Redeclaration;
7930         }
7931       }
7932     } else if (CXXConversionDecl *Conversion
7933                = dyn_cast<CXXConversionDecl>(NewFD)) {
7934       ActOnConversionDeclarator(Conversion);
7935     }
7936 
7937     // Find any virtual functions that this function overrides.
7938     if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(NewFD)) {
7939       if (!Method->isFunctionTemplateSpecialization() &&
7940           !Method->getDescribedFunctionTemplate() &&
7941           Method->isCanonicalDecl()) {
7942         if (AddOverriddenMethods(Method->getParent(), Method)) {
7943           // If the function was marked as "static", we have a problem.
7944           if (NewFD->getStorageClass() == SC_Static) {
7945             ReportOverrides(*this, diag::err_static_overrides_virtual, Method);
7946           }
7947         }
7948       }
7949 
7950       if (Method->isStatic())
7951         checkThisInStaticMemberFunctionType(Method);
7952     }
7953 
7954     // Extra checking for C++ overloaded operators (C++ [over.oper]).
7955     if (NewFD->isOverloadedOperator() &&
7956         CheckOverloadedOperatorDeclaration(NewFD)) {
7957       NewFD->setInvalidDecl();
7958       return Redeclaration;
7959     }
7960 
7961     // Extra checking for C++0x literal operators (C++0x [over.literal]).
7962     if (NewFD->getLiteralIdentifier() &&
7963         CheckLiteralOperatorDeclaration(NewFD)) {
7964       NewFD->setInvalidDecl();
7965       return Redeclaration;
7966     }
7967 
7968     // In C++, check default arguments now that we have merged decls. Unless
7969     // the lexical context is the class, because in this case this is done
7970     // during delayed parsing anyway.
7971     if (!CurContext->isRecord())
7972       CheckCXXDefaultArguments(NewFD);
7973 
7974     // If this function declares a builtin function, check the type of this
7975     // declaration against the expected type for the builtin.
7976     if (unsigned BuiltinID = NewFD->getBuiltinID()) {
7977       ASTContext::GetBuiltinTypeError Error;
7978       LookupPredefedObjCSuperType(*this, S, NewFD->getIdentifier());
7979       QualType T = Context.GetBuiltinType(BuiltinID, Error);
7980       if (!T.isNull() && !Context.hasSameType(T, NewFD->getType())) {
7981         // The type of this function differs from the type of the builtin,
7982         // so forget about the builtin entirely.
7983         Context.BuiltinInfo.ForgetBuiltin(BuiltinID, Context.Idents);
7984       }
7985     }
7986 
7987     // If this function is declared as being extern "C", then check to see if
7988     // the function returns a UDT (class, struct, or union type) that is not C
7989     // compatible, and if it does, warn the user.
7990     // But, issue any diagnostic on the first declaration only.
7991     if (NewFD->isExternC() && Previous.empty()) {
7992       QualType R = NewFD->getReturnType();
7993       if (R->isIncompleteType() && !R->isVoidType())
7994         Diag(NewFD->getLocation(), diag::warn_return_value_udt_incomplete)
7995             << NewFD << R;
7996       else if (!R.isPODType(Context) && !R->isVoidType() &&
7997                !R->isObjCObjectPointerType())
7998         Diag(NewFD->getLocation(), diag::warn_return_value_udt) << NewFD << R;
7999     }
8000   }
8001   return Redeclaration;
8002 }
8003 
8004 void Sema::CheckMain(FunctionDecl* FD, const DeclSpec& DS) {
8005   // C++11 [basic.start.main]p3:
8006   //   A program that [...] declares main to be inline, static or
8007   //   constexpr is ill-formed.
8008   // C11 6.7.4p4:  In a hosted environment, no function specifier(s) shall
8009   //   appear in a declaration of main.
8010   // static main is not an error under C99, but we should warn about it.
8011   // We accept _Noreturn main as an extension.
8012   if (FD->getStorageClass() == SC_Static)
8013     Diag(DS.getStorageClassSpecLoc(), getLangOpts().CPlusPlus
8014          ? diag::err_static_main : diag::warn_static_main)
8015       << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());
8016   if (FD->isInlineSpecified())
8017     Diag(DS.getInlineSpecLoc(), diag::err_inline_main)
8018       << FixItHint::CreateRemoval(DS.getInlineSpecLoc());
8019   if (DS.isNoreturnSpecified()) {
8020     SourceLocation NoreturnLoc = DS.getNoreturnSpecLoc();
8021     SourceRange NoreturnRange(NoreturnLoc, getLocForEndOfToken(NoreturnLoc));
8022     Diag(NoreturnLoc, diag::ext_noreturn_main);
8023     Diag(NoreturnLoc, diag::note_main_remove_noreturn)
8024       << FixItHint::CreateRemoval(NoreturnRange);
8025   }
8026   if (FD->isConstexpr()) {
8027     Diag(DS.getConstexprSpecLoc(), diag::err_constexpr_main)
8028       << FixItHint::CreateRemoval(DS.getConstexprSpecLoc());
8029     FD->setConstexpr(false);
8030   }
8031 
8032   if (getLangOpts().OpenCL) {
8033     Diag(FD->getLocation(), diag::err_opencl_no_main)
8034         << FD->hasAttr<OpenCLKernelAttr>();
8035     FD->setInvalidDecl();
8036     return;
8037   }
8038 
8039   QualType T = FD->getType();
8040   assert(T->isFunctionType() && "function decl is not of function type");
8041   const FunctionType* FT = T->castAs<FunctionType>();
8042 
8043   if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {
8044     // In C with GNU extensions we allow main() to have non-integer return
8045     // type, but we should warn about the extension, and we disable the
8046     // implicit-return-zero rule.
8047 
8048     // GCC in C mode accepts qualified 'int'.
8049     if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))
8050       FD->setHasImplicitReturnZero(true);
8051     else {
8052       Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);
8053       SourceRange RTRange = FD->getReturnTypeSourceRange();
8054       if (RTRange.isValid())
8055         Diag(RTRange.getBegin(), diag::note_main_change_return_type)
8056             << FixItHint::CreateReplacement(RTRange, "int");
8057     }
8058   } else {
8059     // In C and C++, main magically returns 0 if you fall off the end;
8060     // set the flag which tells us that.
8061     // This is C++ [basic.start.main]p5 and C99 5.1.2.2.3.
8062 
8063     // All the standards say that main() should return 'int'.
8064     if (Context.hasSameType(FT->getReturnType(), Context.IntTy))
8065       FD->setHasImplicitReturnZero(true);
8066     else {
8067       // Otherwise, this is just a flat-out error.
8068       SourceRange RTRange = FD->getReturnTypeSourceRange();
8069       Diag(FD->getTypeSpecStartLoc(), diag::err_main_returns_nonint)
8070           << (RTRange.isValid() ? FixItHint::CreateReplacement(RTRange, "int")
8071                                 : FixItHint());
8072       FD->setInvalidDecl(true);
8073     }
8074   }
8075 
8076   // Treat protoless main() as nullary.
8077   if (isa<FunctionNoProtoType>(FT)) return;
8078 
8079   const FunctionProtoType* FTP = cast<const FunctionProtoType>(FT);
8080   unsigned nparams = FTP->getNumParams();
8081   assert(FD->getNumParams() == nparams);
8082 
8083   bool HasExtraParameters = (nparams > 3);
8084 
8085   // Darwin passes an undocumented fourth argument of type char**.  If
8086   // other platforms start sprouting these, the logic below will start
8087   // getting shifty.
8088   if (nparams == 4 && Context.getTargetInfo().getTriple().isOSDarwin())
8089     HasExtraParameters = false;
8090 
8091   if (HasExtraParameters) {
8092     Diag(FD->getLocation(), diag::err_main_surplus_args) << nparams;
8093     FD->setInvalidDecl(true);
8094     nparams = 3;
8095   }
8096 
8097   // FIXME: a lot of the following diagnostics would be improved
8098   // if we had some location information about types.
8099 
8100   QualType CharPP =
8101     Context.getPointerType(Context.getPointerType(Context.CharTy));
8102   QualType Expected[] = { Context.IntTy, CharPP, CharPP, CharPP };
8103 
8104   for (unsigned i = 0; i < nparams; ++i) {
8105     QualType AT = FTP->getParamType(i);
8106 
8107     bool mismatch = true;
8108 
8109     if (Context.hasSameUnqualifiedType(AT, Expected[i]))
8110       mismatch = false;
8111     else if (Expected[i] == CharPP) {
8112       // As an extension, the following forms are okay:
8113       //   char const **
8114       //   char const * const *
8115       //   char * const *
8116 
8117       QualifierCollector qs;
8118       const PointerType* PT;
8119       if ((PT = qs.strip(AT)->getAs<PointerType>()) &&
8120           (PT = qs.strip(PT->getPointeeType())->getAs<PointerType>()) &&
8121           Context.hasSameType(QualType(qs.strip(PT->getPointeeType()), 0),
8122                               Context.CharTy)) {
8123         qs.removeConst();
8124         mismatch = !qs.empty();
8125       }
8126     }
8127 
8128     if (mismatch) {
8129       Diag(FD->getLocation(), diag::err_main_arg_wrong) << i << Expected[i];
8130       // TODO: suggest replacing given type with expected type
8131       FD->setInvalidDecl(true);
8132     }
8133   }
8134 
8135   if (nparams == 1 && !FD->isInvalidDecl()) {
8136     Diag(FD->getLocation(), diag::warn_main_one_arg);
8137   }
8138 
8139   if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8140     Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8141     FD->setInvalidDecl();
8142   }
8143 }
8144 
8145 void Sema::CheckMSVCRTEntryPoint(FunctionDecl *FD) {
8146   QualType T = FD->getType();
8147   assert(T->isFunctionType() && "function decl is not of function type");
8148   const FunctionType *FT = T->castAs<FunctionType>();
8149 
8150   // Set an implicit return of 'zero' if the function can return some integral,
8151   // enumeration, pointer or nullptr type.
8152   if (FT->getReturnType()->isIntegralOrEnumerationType() ||
8153       FT->getReturnType()->isAnyPointerType() ||
8154       FT->getReturnType()->isNullPtrType())
8155     // DllMain is exempt because a return value of zero means it failed.
8156     if (FD->getName() != "DllMain")
8157       FD->setHasImplicitReturnZero(true);
8158 
8159   if (!FD->isInvalidDecl() && FD->getDescribedFunctionTemplate()) {
8160     Diag(FD->getLocation(), diag::err_mainlike_template_decl) << FD;
8161     FD->setInvalidDecl();
8162   }
8163 }
8164 
8165 bool Sema::CheckForConstantInitializer(Expr *Init, QualType DclT) {
8166   // FIXME: Need strict checking.  In C89, we need to check for
8167   // any assignment, increment, decrement, function-calls, or
8168   // commas outside of a sizeof.  In C99, it's the same list,
8169   // except that the aforementioned are allowed in unevaluated
8170   // expressions.  Everything else falls under the
8171   // "may accept other forms of constant expressions" exception.
8172   // (We never end up here for C++, so the constant expression
8173   // rules there don't matter.)
8174   const Expr *Culprit;
8175   if (Init->isConstantInitializer(Context, false, &Culprit))
8176     return false;
8177   Diag(Culprit->getExprLoc(), diag::err_init_element_not_constant)
8178     << Culprit->getSourceRange();
8179   return true;
8180 }
8181 
8182 namespace {
8183   // Visits an initialization expression to see if OrigDecl is evaluated in
8184   // its own initialization and throws a warning if it does.
8185   class SelfReferenceChecker
8186       : public EvaluatedExprVisitor<SelfReferenceChecker> {
8187     Sema &S;
8188     Decl *OrigDecl;
8189     bool isRecordType;
8190     bool isPODType;
8191     bool isReferenceType;
8192 
8193   public:
8194     typedef EvaluatedExprVisitor<SelfReferenceChecker> Inherited;
8195 
8196     SelfReferenceChecker(Sema &S, Decl *OrigDecl) : Inherited(S.Context),
8197                                                     S(S), OrigDecl(OrigDecl) {
8198       isPODType = false;
8199       isRecordType = false;
8200       isReferenceType = false;
8201       if (ValueDecl *VD = dyn_cast<ValueDecl>(OrigDecl)) {
8202         isPODType = VD->getType().isPODType(S.Context);
8203         isRecordType = VD->getType()->isRecordType();
8204         isReferenceType = VD->getType()->isReferenceType();
8205       }
8206     }
8207 
8208     // For most expressions, the cast is directly above the DeclRefExpr.
8209     // For conditional operators, the cast can be outside the conditional
8210     // operator if both expressions are DeclRefExpr's.
8211     void HandleValue(Expr *E) {
8212       if (isReferenceType)
8213         return;
8214       E = E->IgnoreParens();
8215       if (DeclRefExpr* DRE = dyn_cast<DeclRefExpr>(E)) {
8216         HandleDeclRefExpr(DRE);
8217         return;
8218       }
8219 
8220       if (ConditionalOperator *CO = dyn_cast<ConditionalOperator>(E)) {
8221         HandleValue(CO->getTrueExpr());
8222         HandleValue(CO->getFalseExpr());
8223         return;
8224       }
8225 
8226       if (BinaryConditionalOperator *BCO =
8227               dyn_cast<BinaryConditionalOperator>(E)) {
8228         HandleValue(BCO->getFalseExpr());
8229         return;
8230       }
8231 
8232       if (OpaqueValueExpr *OVE = dyn_cast<OpaqueValueExpr>(E)) {
8233         HandleValue(OVE->getSourceExpr());
8234         return;
8235       }
8236 
8237       if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) {
8238         if (BO->getOpcode() == BO_Comma)
8239           HandleValue(BO->getRHS());
8240         return;
8241       }
8242 
8243       if (isa<MemberExpr>(E)) {
8244         Expr *Base = E->IgnoreParenImpCasts();
8245         while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8246           // Check for static member variables and don't warn on them.
8247           if (!isa<FieldDecl>(ME->getMemberDecl()))
8248             return;
8249           Base = ME->getBase()->IgnoreParenImpCasts();
8250         }
8251         if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base))
8252           HandleDeclRefExpr(DRE);
8253         return;
8254       }
8255     }
8256 
8257     // Reference types are handled here since all uses of references are
8258     // bad, not just r-value uses.
8259     void VisitDeclRefExpr(DeclRefExpr *E) {
8260       if (isReferenceType)
8261         HandleDeclRefExpr(E);
8262     }
8263 
8264     void VisitImplicitCastExpr(ImplicitCastExpr *E) {
8265       if (E->getCastKind() == CK_LValueToRValue ||
8266           (isRecordType && E->getCastKind() == CK_NoOp))
8267         HandleValue(E->getSubExpr());
8268 
8269       Inherited::VisitImplicitCastExpr(E);
8270     }
8271 
8272     void VisitMemberExpr(MemberExpr *E) {
8273       // Don't warn on arrays since they can be treated as pointers.
8274       if (E->getType()->canDecayToPointerType()) return;
8275 
8276       // Warn when a non-static method call is followed by non-static member
8277       // field accesses, which is followed by a DeclRefExpr.
8278       CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(E->getMemberDecl());
8279       bool Warn = (MD && !MD->isStatic());
8280       Expr *Base = E->getBase()->IgnoreParenImpCasts();
8281       while (MemberExpr *ME = dyn_cast<MemberExpr>(Base)) {
8282         if (!isa<FieldDecl>(ME->getMemberDecl()))
8283           Warn = false;
8284         Base = ME->getBase()->IgnoreParenImpCasts();
8285       }
8286 
8287       if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Base)) {
8288         if (Warn)
8289           HandleDeclRefExpr(DRE);
8290         return;
8291       }
8292 
8293       // The base of a MemberExpr is not a MemberExpr or a DeclRefExpr.
8294       // Visit that expression.
8295       Visit(Base);
8296     }
8297 
8298     void VisitCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
8299       if (E->getNumArgs() > 0)
8300         if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0)))
8301           HandleDeclRefExpr(DRE);
8302 
8303       Inherited::VisitCXXOperatorCallExpr(E);
8304     }
8305 
8306     void VisitUnaryOperator(UnaryOperator *E) {
8307       // For POD record types, addresses of its own members are well-defined.
8308       if (E->getOpcode() == UO_AddrOf && isRecordType &&
8309           isa<MemberExpr>(E->getSubExpr()->IgnoreParens())) {
8310         if (!isPODType)
8311           HandleValue(E->getSubExpr());
8312         return;
8313       }
8314       Inherited::VisitUnaryOperator(E);
8315     }
8316 
8317     void VisitObjCMessageExpr(ObjCMessageExpr *E) { return; }
8318 
8319     void VisitCXXConstructExpr(CXXConstructExpr *E) {
8320       if (E->getConstructor()->isCopyConstructor()) {
8321         if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->getArg(0))) {
8322           HandleDeclRefExpr(DRE);
8323         }
8324       }
8325       Inherited::VisitCXXConstructExpr(E);
8326     }
8327 
8328     void VisitCallExpr(CallExpr *E) {
8329       // Treat std::move as a use.
8330       if (E->getNumArgs() == 1) {
8331         if (FunctionDecl *FD = E->getDirectCallee()) {
8332           if (FD->getIdentifier() && FD->getIdentifier()->isStr("move")) {
8333             HandleValue(E->getArg(0));
8334           }
8335         }
8336       }
8337 
8338       Inherited::VisitCallExpr(E);
8339     }
8340 
8341     void HandleDeclRefExpr(DeclRefExpr *DRE) {
8342       Decl* ReferenceDecl = DRE->getDecl();
8343       if (OrigDecl != ReferenceDecl) return;
8344       unsigned diag;
8345       if (isReferenceType) {
8346         diag = diag::warn_uninit_self_reference_in_reference_init;
8347       } else if (cast<VarDecl>(OrigDecl)->isStaticLocal()) {
8348         diag = diag::warn_static_self_reference_in_init;
8349       } else {
8350         diag = diag::warn_uninit_self_reference_in_init;
8351       }
8352 
8353       S.DiagRuntimeBehavior(DRE->getLocStart(), DRE,
8354                             S.PDiag(diag)
8355                               << DRE->getNameInfo().getName()
8356                               << OrigDecl->getLocation()
8357                               << DRE->getSourceRange());
8358     }
8359   };
8360 
8361   /// CheckSelfReference - Warns if OrigDecl is used in expression E.
8362   static void CheckSelfReference(Sema &S, Decl* OrigDecl, Expr *E,
8363                                  bool DirectInit) {
8364     // Parameters arguments are occassionially constructed with itself,
8365     // for instance, in recursive functions.  Skip them.
8366     if (isa<ParmVarDecl>(OrigDecl))
8367       return;
8368 
8369     E = E->IgnoreParens();
8370 
8371     // Skip checking T a = a where T is not a record or reference type.
8372     // Doing so is a way to silence uninitialized warnings.
8373     if (!DirectInit && !cast<VarDecl>(OrigDecl)->getType()->isRecordType())
8374       if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
8375         if (ICE->getCastKind() == CK_LValueToRValue)
8376           if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr()))
8377             if (DRE->getDecl() == OrigDecl)
8378               return;
8379 
8380     SelfReferenceChecker(S, OrigDecl).Visit(E);
8381   }
8382 }
8383 
8384 /// AddInitializerToDecl - Adds the initializer Init to the
8385 /// declaration dcl. If DirectInit is true, this is C++ direct
8386 /// initialization rather than copy initialization.
8387 void Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init,
8388                                 bool DirectInit, bool TypeMayContainAuto) {
8389   // If there is no declaration, there was an error parsing it.  Just ignore
8390   // the initializer.
8391   if (!RealDecl || RealDecl->isInvalidDecl())
8392     return;
8393 
8394   if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(RealDecl)) {
8395     // With declarators parsed the way they are, the parser cannot
8396     // distinguish between a normal initializer and a pure-specifier.
8397     // Thus this grotesque test.
8398     IntegerLiteral *IL;
8399     if ((IL = dyn_cast<IntegerLiteral>(Init)) && IL->getValue() == 0 &&
8400         Context.getCanonicalType(IL->getType()) == Context.IntTy)
8401       CheckPureMethod(Method, Init->getSourceRange());
8402     else {
8403       Diag(Method->getLocation(), diag::err_member_function_initialization)
8404         << Method->getDeclName() << Init->getSourceRange();
8405       Method->setInvalidDecl();
8406     }
8407     return;
8408   }
8409 
8410   VarDecl *VDecl = dyn_cast<VarDecl>(RealDecl);
8411   if (!VDecl) {
8412     assert(!isa<FieldDecl>(RealDecl) && "field init shouldn't get here");
8413     Diag(RealDecl->getLocation(), diag::err_illegal_initializer);
8414     RealDecl->setInvalidDecl();
8415     return;
8416   }
8417   ParenListExpr *CXXDirectInit = dyn_cast<ParenListExpr>(Init);
8418 
8419   // C++11 [decl.spec.auto]p6. Deduce the type which 'auto' stands in for.
8420   if (TypeMayContainAuto && VDecl->getType()->isUndeducedType()) {
8421     Expr *DeduceInit = Init;
8422     // Initializer could be a C++ direct-initializer. Deduction only works if it
8423     // contains exactly one expression.
8424     if (CXXDirectInit) {
8425       if (CXXDirectInit->getNumExprs() == 0) {
8426         // It isn't possible to write this directly, but it is possible to
8427         // end up in this situation with "auto x(some_pack...);"
8428         Diag(CXXDirectInit->getLocStart(),
8429              VDecl->isInitCapture() ? diag::err_init_capture_no_expression
8430                                     : diag::err_auto_var_init_no_expression)
8431           << VDecl->getDeclName() << VDecl->getType()
8432           << VDecl->getSourceRange();
8433         RealDecl->setInvalidDecl();
8434         return;
8435       } else if (CXXDirectInit->getNumExprs() > 1) {
8436         Diag(CXXDirectInit->getExpr(1)->getLocStart(),
8437              VDecl->isInitCapture()
8438                  ? diag::err_init_capture_multiple_expressions
8439                  : diag::err_auto_var_init_multiple_expressions)
8440           << VDecl->getDeclName() << VDecl->getType()
8441           << VDecl->getSourceRange();
8442         RealDecl->setInvalidDecl();
8443         return;
8444       } else {
8445         DeduceInit = CXXDirectInit->getExpr(0);
8446         if (isa<InitListExpr>(DeduceInit))
8447           Diag(CXXDirectInit->getLocStart(),
8448                diag::err_auto_var_init_paren_braces)
8449             << VDecl->getDeclName() << VDecl->getType()
8450             << VDecl->getSourceRange();
8451       }
8452     }
8453 
8454     // Expressions default to 'id' when we're in a debugger.
8455     bool DefaultedToAuto = false;
8456     if (getLangOpts().DebuggerCastResultToId &&
8457         Init->getType() == Context.UnknownAnyTy) {
8458       ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8459       if (Result.isInvalid()) {
8460         VDecl->setInvalidDecl();
8461         return;
8462       }
8463       Init = Result.get();
8464       DefaultedToAuto = true;
8465     }
8466 
8467     QualType DeducedType;
8468     if (DeduceAutoType(VDecl->getTypeSourceInfo(), DeduceInit, DeducedType) ==
8469             DAR_Failed)
8470       DiagnoseAutoDeductionFailure(VDecl, DeduceInit);
8471     if (DeducedType.isNull()) {
8472       RealDecl->setInvalidDecl();
8473       return;
8474     }
8475     VDecl->setType(DeducedType);
8476     assert(VDecl->isLinkageValid());
8477 
8478     // In ARC, infer lifetime.
8479     if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(VDecl))
8480       VDecl->setInvalidDecl();
8481 
8482     // Warn if we deduced 'id'. 'auto' usually implies type-safety, but using
8483     // 'id' instead of a specific object type prevents most of our usual checks.
8484     // We only want to warn outside of template instantiations, though:
8485     // inside a template, the 'id' could have come from a parameter.
8486     if (ActiveTemplateInstantiations.empty() && !DefaultedToAuto &&
8487         DeducedType->isObjCIdType()) {
8488       SourceLocation Loc =
8489           VDecl->getTypeSourceInfo()->getTypeLoc().getBeginLoc();
8490       Diag(Loc, diag::warn_auto_var_is_id)
8491         << VDecl->getDeclName() << DeduceInit->getSourceRange();
8492     }
8493 
8494     // If this is a redeclaration, check that the type we just deduced matches
8495     // the previously declared type.
8496     if (VarDecl *Old = VDecl->getPreviousDecl()) {
8497       // We never need to merge the type, because we cannot form an incomplete
8498       // array of auto, nor deduce such a type.
8499       MergeVarDeclTypes(VDecl, Old, /*MergeTypeWithPrevious*/false);
8500     }
8501 
8502     // Check the deduced type is valid for a variable declaration.
8503     CheckVariableDeclarationType(VDecl);
8504     if (VDecl->isInvalidDecl())
8505       return;
8506   }
8507 
8508   // dllimport cannot be used on variable definitions.
8509   if (VDecl->hasAttr<DLLImportAttr>() && !VDecl->isStaticDataMember()) {
8510     Diag(VDecl->getLocation(), diag::err_attribute_dllimport_data_definition);
8511     VDecl->setInvalidDecl();
8512     return;
8513   }
8514 
8515   if (VDecl->isLocalVarDecl() && VDecl->hasExternalStorage()) {
8516     // C99 6.7.8p5. C++ has no such restriction, but that is a defect.
8517     Diag(VDecl->getLocation(), diag::err_block_extern_cant_init);
8518     VDecl->setInvalidDecl();
8519     return;
8520   }
8521 
8522   if (!VDecl->getType()->isDependentType()) {
8523     // A definition must end up with a complete type, which means it must be
8524     // complete with the restriction that an array type might be completed by
8525     // the initializer; note that later code assumes this restriction.
8526     QualType BaseDeclType = VDecl->getType();
8527     if (const ArrayType *Array = Context.getAsIncompleteArrayType(BaseDeclType))
8528       BaseDeclType = Array->getElementType();
8529     if (RequireCompleteType(VDecl->getLocation(), BaseDeclType,
8530                             diag::err_typecheck_decl_incomplete_type)) {
8531       RealDecl->setInvalidDecl();
8532       return;
8533     }
8534 
8535     // The variable can not have an abstract class type.
8536     if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(),
8537                                diag::err_abstract_type_in_decl,
8538                                AbstractVariableType))
8539       VDecl->setInvalidDecl();
8540   }
8541 
8542   const VarDecl *Def;
8543   if ((Def = VDecl->getDefinition()) && Def != VDecl) {
8544     Diag(VDecl->getLocation(), diag::err_redefinition)
8545       << VDecl->getDeclName();
8546     Diag(Def->getLocation(), diag::note_previous_definition);
8547     VDecl->setInvalidDecl();
8548     return;
8549   }
8550 
8551   const VarDecl *PrevInit = nullptr;
8552   if (getLangOpts().CPlusPlus) {
8553     // C++ [class.static.data]p4
8554     //   If a static data member is of const integral or const
8555     //   enumeration type, its declaration in the class definition can
8556     //   specify a constant-initializer which shall be an integral
8557     //   constant expression (5.19). In that case, the member can appear
8558     //   in integral constant expressions. The member shall still be
8559     //   defined in a namespace scope if it is used in the program and the
8560     //   namespace scope definition shall not contain an initializer.
8561     //
8562     // We already performed a redefinition check above, but for static
8563     // data members we also need to check whether there was an in-class
8564     // declaration with an initializer.
8565     if (VDecl->isStaticDataMember() && VDecl->getAnyInitializer(PrevInit)) {
8566       Diag(Init->getExprLoc(), diag::err_static_data_member_reinitialization)
8567           << VDecl->getDeclName();
8568       Diag(PrevInit->getInit()->getExprLoc(), diag::note_previous_initializer) << 0;
8569       return;
8570     }
8571 
8572     if (VDecl->hasLocalStorage())
8573       getCurFunction()->setHasBranchProtectedScope();
8574 
8575     if (DiagnoseUnexpandedParameterPack(Init, UPPC_Initializer)) {
8576       VDecl->setInvalidDecl();
8577       return;
8578     }
8579   }
8580 
8581   // OpenCL 1.1 6.5.2: "Variables allocated in the __local address space inside
8582   // a kernel function cannot be initialized."
8583   if (VDecl->getStorageClass() == SC_OpenCLWorkGroupLocal) {
8584     Diag(VDecl->getLocation(), diag::err_local_cant_init);
8585     VDecl->setInvalidDecl();
8586     return;
8587   }
8588 
8589   // Get the decls type and save a reference for later, since
8590   // CheckInitializerTypes may change it.
8591   QualType DclT = VDecl->getType(), SavT = DclT;
8592 
8593   // Expressions default to 'id' when we're in a debugger
8594   // and we are assigning it to a variable of Objective-C pointer type.
8595   if (getLangOpts().DebuggerCastResultToId && DclT->isObjCObjectPointerType() &&
8596       Init->getType() == Context.UnknownAnyTy) {
8597     ExprResult Result = forceUnknownAnyToType(Init, Context.getObjCIdType());
8598     if (Result.isInvalid()) {
8599       VDecl->setInvalidDecl();
8600       return;
8601     }
8602     Init = Result.get();
8603   }
8604 
8605   // Perform the initialization.
8606   if (!VDecl->isInvalidDecl()) {
8607     InitializedEntity Entity = InitializedEntity::InitializeVariable(VDecl);
8608     InitializationKind Kind
8609       = DirectInit ?
8610           CXXDirectInit ? InitializationKind::CreateDirect(VDecl->getLocation(),
8611                                                            Init->getLocStart(),
8612                                                            Init->getLocEnd())
8613                         : InitializationKind::CreateDirectList(
8614                                                           VDecl->getLocation())
8615                    : InitializationKind::CreateCopy(VDecl->getLocation(),
8616                                                     Init->getLocStart());
8617 
8618     MultiExprArg Args = Init;
8619     if (CXXDirectInit)
8620       Args = MultiExprArg(CXXDirectInit->getExprs(),
8621                           CXXDirectInit->getNumExprs());
8622 
8623     InitializationSequence InitSeq(*this, Entity, Kind, Args);
8624     ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
8625     if (Result.isInvalid()) {
8626       VDecl->setInvalidDecl();
8627       return;
8628     }
8629 
8630     Init = Result.getAs<Expr>();
8631   }
8632 
8633   // Check for self-references within variable initializers.
8634   // Variables declared within a function/method body (except for references)
8635   // are handled by a dataflow analysis.
8636   if (!VDecl->hasLocalStorage() || VDecl->getType()->isRecordType() ||
8637       VDecl->getType()->isReferenceType()) {
8638     CheckSelfReference(*this, RealDecl, Init, DirectInit);
8639   }
8640 
8641   // If the type changed, it means we had an incomplete type that was
8642   // completed by the initializer. For example:
8643   //   int ary[] = { 1, 3, 5 };
8644   // "ary" transitions from an IncompleteArrayType to a ConstantArrayType.
8645   if (!VDecl->isInvalidDecl() && (DclT != SavT))
8646     VDecl->setType(DclT);
8647 
8648   if (!VDecl->isInvalidDecl()) {
8649     checkUnsafeAssigns(VDecl->getLocation(), VDecl->getType(), Init);
8650 
8651     if (VDecl->hasAttr<BlocksAttr>())
8652       checkRetainCycles(VDecl, Init);
8653 
8654     // It is safe to assign a weak reference into a strong variable.
8655     // Although this code can still have problems:
8656     //   id x = self.weakProp;
8657     //   id y = self.weakProp;
8658     // we do not warn to warn spuriously when 'x' and 'y' are on separate
8659     // paths through the function. This should be revisited if
8660     // -Wrepeated-use-of-weak is made flow-sensitive.
8661     if (VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong &&
8662         !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak,
8663                          Init->getLocStart()))
8664         getCurFunction()->markSafeWeakUse(Init);
8665   }
8666 
8667   // The initialization is usually a full-expression.
8668   //
8669   // FIXME: If this is a braced initialization of an aggregate, it is not
8670   // an expression, and each individual field initializer is a separate
8671   // full-expression. For instance, in:
8672   //
8673   //   struct Temp { ~Temp(); };
8674   //   struct S { S(Temp); };
8675   //   struct T { S a, b; } t = { Temp(), Temp() }
8676   //
8677   // we should destroy the first Temp before constructing the second.
8678   ExprResult Result = ActOnFinishFullExpr(Init, VDecl->getLocation(),
8679                                           false,
8680                                           VDecl->isConstexpr());
8681   if (Result.isInvalid()) {
8682     VDecl->setInvalidDecl();
8683     return;
8684   }
8685   Init = Result.get();
8686 
8687   // Attach the initializer to the decl.
8688   VDecl->setInit(Init);
8689 
8690   if (VDecl->isLocalVarDecl()) {
8691     // C99 6.7.8p4: All the expressions in an initializer for an object that has
8692     // static storage duration shall be constant expressions or string literals.
8693     // C++ does not have this restriction.
8694     if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl()) {
8695       const Expr *Culprit;
8696       if (VDecl->getStorageClass() == SC_Static)
8697         CheckForConstantInitializer(Init, DclT);
8698       // C89 is stricter than C99 for non-static aggregate types.
8699       // C89 6.5.7p3: All the expressions [...] in an initializer list
8700       // for an object that has aggregate or union type shall be
8701       // constant expressions.
8702       else if (!getLangOpts().C99 && VDecl->getType()->isAggregateType() &&
8703                isa<InitListExpr>(Init) &&
8704                !Init->isConstantInitializer(Context, false, &Culprit))
8705         Diag(Culprit->getExprLoc(),
8706              diag::ext_aggregate_init_not_constant)
8707           << Culprit->getSourceRange();
8708     }
8709   } else if (VDecl->isStaticDataMember() &&
8710              VDecl->getLexicalDeclContext()->isRecord()) {
8711     // This is an in-class initialization for a static data member, e.g.,
8712     //
8713     // struct S {
8714     //   static const int value = 17;
8715     // };
8716 
8717     // C++ [class.mem]p4:
8718     //   A member-declarator can contain a constant-initializer only
8719     //   if it declares a static member (9.4) of const integral or
8720     //   const enumeration type, see 9.4.2.
8721     //
8722     // C++11 [class.static.data]p3:
8723     //   If a non-volatile const static data member is of integral or
8724     //   enumeration type, its declaration in the class definition can
8725     //   specify a brace-or-equal-initializer in which every initalizer-clause
8726     //   that is an assignment-expression is a constant expression. A static
8727     //   data member of literal type can be declared in the class definition
8728     //   with the constexpr specifier; if so, its declaration shall specify a
8729     //   brace-or-equal-initializer in which every initializer-clause that is
8730     //   an assignment-expression is a constant expression.
8731 
8732     // Do nothing on dependent types.
8733     if (DclT->isDependentType()) {
8734 
8735     // Allow any 'static constexpr' members, whether or not they are of literal
8736     // type. We separately check that every constexpr variable is of literal
8737     // type.
8738     } else if (VDecl->isConstexpr()) {
8739 
8740     // Require constness.
8741     } else if (!DclT.isConstQualified()) {
8742       Diag(VDecl->getLocation(), diag::err_in_class_initializer_non_const)
8743         << Init->getSourceRange();
8744       VDecl->setInvalidDecl();
8745 
8746     // We allow integer constant expressions in all cases.
8747     } else if (DclT->isIntegralOrEnumerationType()) {
8748       // Check whether the expression is a constant expression.
8749       SourceLocation Loc;
8750       if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())
8751         // In C++11, a non-constexpr const static data member with an
8752         // in-class initializer cannot be volatile.
8753         Diag(VDecl->getLocation(), diag::err_in_class_initializer_volatile);
8754       else if (Init->isValueDependent())
8755         ; // Nothing to check.
8756       else if (Init->isIntegerConstantExpr(Context, &Loc))
8757         ; // Ok, it's an ICE!
8758       else if (Init->isEvaluatable(Context)) {
8759         // If we can constant fold the initializer through heroics, accept it,
8760         // but report this as a use of an extension for -pedantic.
8761         Diag(Loc, diag::ext_in_class_initializer_non_constant)
8762           << Init->getSourceRange();
8763       } else {
8764         // Otherwise, this is some crazy unknown case.  Report the issue at the
8765         // location provided by the isIntegerConstantExpr failed check.
8766         Diag(Loc, diag::err_in_class_initializer_non_constant)
8767           << Init->getSourceRange();
8768         VDecl->setInvalidDecl();
8769       }
8770 
8771     // We allow foldable floating-point constants as an extension.
8772     } else if (DclT->isFloatingType()) { // also permits complex, which is ok
8773       // In C++98, this is a GNU extension. In C++11, it is not, but we support
8774       // it anyway and provide a fixit to add the 'constexpr'.
8775       if (getLangOpts().CPlusPlus11) {
8776         Diag(VDecl->getLocation(),
8777              diag::ext_in_class_initializer_float_type_cxx11)
8778             << DclT << Init->getSourceRange();
8779         Diag(VDecl->getLocStart(),
8780              diag::note_in_class_initializer_float_type_cxx11)
8781             << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
8782       } else {
8783         Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type)
8784           << DclT << Init->getSourceRange();
8785 
8786         if (!Init->isValueDependent() && !Init->isEvaluatable(Context)) {
8787           Diag(Init->getExprLoc(), diag::err_in_class_initializer_non_constant)
8788             << Init->getSourceRange();
8789           VDecl->setInvalidDecl();
8790         }
8791       }
8792 
8793     // Suggest adding 'constexpr' in C++11 for literal types.
8794     } else if (getLangOpts().CPlusPlus11 && DclT->isLiteralType(Context)) {
8795       Diag(VDecl->getLocation(), diag::err_in_class_initializer_literal_type)
8796         << DclT << Init->getSourceRange()
8797         << FixItHint::CreateInsertion(VDecl->getLocStart(), "constexpr ");
8798       VDecl->setConstexpr(true);
8799 
8800     } else {
8801       Diag(VDecl->getLocation(), diag::err_in_class_initializer_bad_type)
8802         << DclT << Init->getSourceRange();
8803       VDecl->setInvalidDecl();
8804     }
8805   } else if (VDecl->isFileVarDecl()) {
8806     if (VDecl->getStorageClass() == SC_Extern &&
8807         (!getLangOpts().CPlusPlus ||
8808          !(Context.getBaseElementType(VDecl->getType()).isConstQualified() ||
8809            VDecl->isExternC())) &&
8810         !isTemplateInstantiation(VDecl->getTemplateSpecializationKind()))
8811       Diag(VDecl->getLocation(), diag::warn_extern_init);
8812 
8813     // C99 6.7.8p4. All file scoped initializers need to be constant.
8814     if (!getLangOpts().CPlusPlus && !VDecl->isInvalidDecl())
8815       CheckForConstantInitializer(Init, DclT);
8816   }
8817 
8818   // We will represent direct-initialization similarly to copy-initialization:
8819   //    int x(1);  -as-> int x = 1;
8820   //    ClassType x(a,b,c); -as-> ClassType x = ClassType(a,b,c);
8821   //
8822   // Clients that want to distinguish between the two forms, can check for
8823   // direct initializer using VarDecl::getInitStyle().
8824   // A major benefit is that clients that don't particularly care about which
8825   // exactly form was it (like the CodeGen) can handle both cases without
8826   // special case code.
8827 
8828   // C++ 8.5p11:
8829   // The form of initialization (using parentheses or '=') is generally
8830   // insignificant, but does matter when the entity being initialized has a
8831   // class type.
8832   if (CXXDirectInit) {
8833     assert(DirectInit && "Call-style initializer must be direct init.");
8834     VDecl->setInitStyle(VarDecl::CallInit);
8835   } else if (DirectInit) {
8836     // This must be list-initialization. No other way is direct-initialization.
8837     VDecl->setInitStyle(VarDecl::ListInit);
8838   }
8839 
8840   CheckCompleteVariableDeclaration(VDecl);
8841 }
8842 
8843 /// ActOnInitializerError - Given that there was an error parsing an
8844 /// initializer for the given declaration, try to return to some form
8845 /// of sanity.
8846 void Sema::ActOnInitializerError(Decl *D) {
8847   // Our main concern here is re-establishing invariants like "a
8848   // variable's type is either dependent or complete".
8849   if (!D || D->isInvalidDecl()) return;
8850 
8851   VarDecl *VD = dyn_cast<VarDecl>(D);
8852   if (!VD) return;
8853 
8854   // Auto types are meaningless if we can't make sense of the initializer.
8855   if (ParsingInitForAutoVars.count(D)) {
8856     D->setInvalidDecl();
8857     return;
8858   }
8859 
8860   QualType Ty = VD->getType();
8861   if (Ty->isDependentType()) return;
8862 
8863   // Require a complete type.
8864   if (RequireCompleteType(VD->getLocation(),
8865                           Context.getBaseElementType(Ty),
8866                           diag::err_typecheck_decl_incomplete_type)) {
8867     VD->setInvalidDecl();
8868     return;
8869   }
8870 
8871   // Require a non-abstract type.
8872   if (RequireNonAbstractType(VD->getLocation(), Ty,
8873                              diag::err_abstract_type_in_decl,
8874                              AbstractVariableType)) {
8875     VD->setInvalidDecl();
8876     return;
8877   }
8878 
8879   // Don't bother complaining about constructors or destructors,
8880   // though.
8881 }
8882 
8883 void Sema::ActOnUninitializedDecl(Decl *RealDecl,
8884                                   bool TypeMayContainAuto) {
8885   // If there is no declaration, there was an error parsing it. Just ignore it.
8886   if (!RealDecl)
8887     return;
8888 
8889   if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {
8890     QualType Type = Var->getType();
8891 
8892     // C++11 [dcl.spec.auto]p3
8893     if (TypeMayContainAuto && Type->getContainedAutoType()) {
8894       Diag(Var->getLocation(), diag::err_auto_var_requires_init)
8895         << Var->getDeclName() << Type;
8896       Var->setInvalidDecl();
8897       return;
8898     }
8899 
8900     // C++11 [class.static.data]p3: A static data member can be declared with
8901     // the constexpr specifier; if so, its declaration shall specify
8902     // a brace-or-equal-initializer.
8903     // C++11 [dcl.constexpr]p1: The constexpr specifier shall be applied only to
8904     // the definition of a variable [...] or the declaration of a static data
8905     // member.
8906     if (Var->isConstexpr() && !Var->isThisDeclarationADefinition()) {
8907       if (Var->isStaticDataMember())
8908         Diag(Var->getLocation(),
8909              diag::err_constexpr_static_mem_var_requires_init)
8910           << Var->getDeclName();
8911       else
8912         Diag(Var->getLocation(), diag::err_invalid_constexpr_var_decl);
8913       Var->setInvalidDecl();
8914       return;
8915     }
8916 
8917     // OpenCL v1.1 s6.5.3: variables declared in the constant address space must
8918     // be initialized.
8919     if (!Var->isInvalidDecl() &&
8920         Var->getType().getAddressSpace() == LangAS::opencl_constant &&
8921         Var->getStorageClass() != SC_Extern && !Var->getInit()) {
8922       Diag(Var->getLocation(), diag::err_opencl_constant_no_init);
8923       Var->setInvalidDecl();
8924       return;
8925     }
8926 
8927     switch (Var->isThisDeclarationADefinition()) {
8928     case VarDecl::Definition:
8929       if (!Var->isStaticDataMember() || !Var->getAnyInitializer())
8930         break;
8931 
8932       // We have an out-of-line definition of a static data member
8933       // that has an in-class initializer, so we type-check this like
8934       // a declaration.
8935       //
8936       // Fall through
8937 
8938     case VarDecl::DeclarationOnly:
8939       // It's only a declaration.
8940 
8941       // Block scope. C99 6.7p7: If an identifier for an object is
8942       // declared with no linkage (C99 6.2.2p6), the type for the
8943       // object shall be complete.
8944       if (!Type->isDependentType() && Var->isLocalVarDecl() &&
8945           !Var->hasLinkage() && !Var->isInvalidDecl() &&
8946           RequireCompleteType(Var->getLocation(), Type,
8947                               diag::err_typecheck_decl_incomplete_type))
8948         Var->setInvalidDecl();
8949 
8950       // Make sure that the type is not abstract.
8951       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
8952           RequireNonAbstractType(Var->getLocation(), Type,
8953                                  diag::err_abstract_type_in_decl,
8954                                  AbstractVariableType))
8955         Var->setInvalidDecl();
8956       if (!Type->isDependentType() && !Var->isInvalidDecl() &&
8957           Var->getStorageClass() == SC_PrivateExtern) {
8958         Diag(Var->getLocation(), diag::warn_private_extern);
8959         Diag(Var->getLocation(), diag::note_private_extern);
8960       }
8961 
8962       return;
8963 
8964     case VarDecl::TentativeDefinition:
8965       // File scope. C99 6.9.2p2: A declaration of an identifier for an
8966       // object that has file scope without an initializer, and without a
8967       // storage-class specifier or with the storage-class specifier "static",
8968       // constitutes a tentative definition. Note: A tentative definition with
8969       // external linkage is valid (C99 6.2.2p5).
8970       if (!Var->isInvalidDecl()) {
8971         if (const IncompleteArrayType *ArrayT
8972                                     = Context.getAsIncompleteArrayType(Type)) {
8973           if (RequireCompleteType(Var->getLocation(),
8974                                   ArrayT->getElementType(),
8975                                   diag::err_illegal_decl_array_incomplete_type))
8976             Var->setInvalidDecl();
8977         } else if (Var->getStorageClass() == SC_Static) {
8978           // C99 6.9.2p3: If the declaration of an identifier for an object is
8979           // a tentative definition and has internal linkage (C99 6.2.2p3), the
8980           // declared type shall not be an incomplete type.
8981           // NOTE: code such as the following
8982           //     static struct s;
8983           //     struct s { int a; };
8984           // is accepted by gcc. Hence here we issue a warning instead of
8985           // an error and we do not invalidate the static declaration.
8986           // NOTE: to avoid multiple warnings, only check the first declaration.
8987           if (Var->isFirstDecl())
8988             RequireCompleteType(Var->getLocation(), Type,
8989                                 diag::ext_typecheck_decl_incomplete_type);
8990         }
8991       }
8992 
8993       // Record the tentative definition; we're done.
8994       if (!Var->isInvalidDecl())
8995         TentativeDefinitions.push_back(Var);
8996       return;
8997     }
8998 
8999     // Provide a specific diagnostic for uninitialized variable
9000     // definitions with incomplete array type.
9001     if (Type->isIncompleteArrayType()) {
9002       Diag(Var->getLocation(),
9003            diag::err_typecheck_incomplete_array_needs_initializer);
9004       Var->setInvalidDecl();
9005       return;
9006     }
9007 
9008     // Provide a specific diagnostic for uninitialized variable
9009     // definitions with reference type.
9010     if (Type->isReferenceType()) {
9011       Diag(Var->getLocation(), diag::err_reference_var_requires_init)
9012         << Var->getDeclName()
9013         << SourceRange(Var->getLocation(), Var->getLocation());
9014       Var->setInvalidDecl();
9015       return;
9016     }
9017 
9018     // Do not attempt to type-check the default initializer for a
9019     // variable with dependent type.
9020     if (Type->isDependentType())
9021       return;
9022 
9023     if (Var->isInvalidDecl())
9024       return;
9025 
9026     if (!Var->hasAttr<AliasAttr>()) {
9027       if (RequireCompleteType(Var->getLocation(),
9028                               Context.getBaseElementType(Type),
9029                               diag::err_typecheck_decl_incomplete_type)) {
9030         Var->setInvalidDecl();
9031         return;
9032       }
9033     }
9034 
9035     // The variable can not have an abstract class type.
9036     if (RequireNonAbstractType(Var->getLocation(), Type,
9037                                diag::err_abstract_type_in_decl,
9038                                AbstractVariableType)) {
9039       Var->setInvalidDecl();
9040       return;
9041     }
9042 
9043     // Check for jumps past the implicit initializer.  C++0x
9044     // clarifies that this applies to a "variable with automatic
9045     // storage duration", not a "local variable".
9046     // C++11 [stmt.dcl]p3
9047     //   A program that jumps from a point where a variable with automatic
9048     //   storage duration is not in scope to a point where it is in scope is
9049     //   ill-formed unless the variable has scalar type, class type with a
9050     //   trivial default constructor and a trivial destructor, a cv-qualified
9051     //   version of one of these types, or an array of one of the preceding
9052     //   types and is declared without an initializer.
9053     if (getLangOpts().CPlusPlus && Var->hasLocalStorage()) {
9054       if (const RecordType *Record
9055             = Context.getBaseElementType(Type)->getAs<RecordType>()) {
9056         CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record->getDecl());
9057         // Mark the function for further checking even if the looser rules of
9058         // C++11 do not require such checks, so that we can diagnose
9059         // incompatibilities with C++98.
9060         if (!CXXRecord->isPOD())
9061           getCurFunction()->setHasBranchProtectedScope();
9062       }
9063     }
9064 
9065     // C++03 [dcl.init]p9:
9066     //   If no initializer is specified for an object, and the
9067     //   object is of (possibly cv-qualified) non-POD class type (or
9068     //   array thereof), the object shall be default-initialized; if
9069     //   the object is of const-qualified type, the underlying class
9070     //   type shall have a user-declared default
9071     //   constructor. Otherwise, if no initializer is specified for
9072     //   a non- static object, the object and its subobjects, if
9073     //   any, have an indeterminate initial value); if the object
9074     //   or any of its subobjects are of const-qualified type, the
9075     //   program is ill-formed.
9076     // C++0x [dcl.init]p11:
9077     //   If no initializer is specified for an object, the object is
9078     //   default-initialized; [...].
9079     InitializedEntity Entity = InitializedEntity::InitializeVariable(Var);
9080     InitializationKind Kind
9081       = InitializationKind::CreateDefault(Var->getLocation());
9082 
9083     InitializationSequence InitSeq(*this, Entity, Kind, None);
9084     ExprResult Init = InitSeq.Perform(*this, Entity, Kind, None);
9085     if (Init.isInvalid())
9086       Var->setInvalidDecl();
9087     else if (Init.get()) {
9088       Var->setInit(MaybeCreateExprWithCleanups(Init.get()));
9089       // This is important for template substitution.
9090       Var->setInitStyle(VarDecl::CallInit);
9091     }
9092 
9093     CheckCompleteVariableDeclaration(Var);
9094   }
9095 }
9096 
9097 void Sema::ActOnCXXForRangeDecl(Decl *D) {
9098   VarDecl *VD = dyn_cast<VarDecl>(D);
9099   if (!VD) {
9100     Diag(D->getLocation(), diag::err_for_range_decl_must_be_var);
9101     D->setInvalidDecl();
9102     return;
9103   }
9104 
9105   VD->setCXXForRangeDecl(true);
9106 
9107   // for-range-declaration cannot be given a storage class specifier.
9108   int Error = -1;
9109   switch (VD->getStorageClass()) {
9110   case SC_None:
9111     break;
9112   case SC_Extern:
9113     Error = 0;
9114     break;
9115   case SC_Static:
9116     Error = 1;
9117     break;
9118   case SC_PrivateExtern:
9119     Error = 2;
9120     break;
9121   case SC_Auto:
9122     Error = 3;
9123     break;
9124   case SC_Register:
9125     Error = 4;
9126     break;
9127   case SC_OpenCLWorkGroupLocal:
9128     llvm_unreachable("Unexpected storage class");
9129   }
9130   if (VD->isConstexpr())
9131     Error = 5;
9132   if (Error != -1) {
9133     Diag(VD->getOuterLocStart(), diag::err_for_range_storage_class)
9134       << VD->getDeclName() << Error;
9135     D->setInvalidDecl();
9136   }
9137 }
9138 
9139 StmtResult
9140 Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc,
9141                                  IdentifierInfo *Ident,
9142                                  ParsedAttributes &Attrs,
9143                                  SourceLocation AttrEnd) {
9144   // C++1y [stmt.iter]p1:
9145   //   A range-based for statement of the form
9146   //      for ( for-range-identifier : for-range-initializer ) statement
9147   //   is equivalent to
9148   //      for ( auto&& for-range-identifier : for-range-initializer ) statement
9149   DeclSpec DS(Attrs.getPool().getFactory());
9150 
9151   const char *PrevSpec;
9152   unsigned DiagID;
9153   DS.SetTypeSpecType(DeclSpec::TST_auto, IdentLoc, PrevSpec, DiagID,
9154                      getPrintingPolicy());
9155 
9156   Declarator D(DS, Declarator::ForContext);
9157   D.SetIdentifier(Ident, IdentLoc);
9158   D.takeAttributes(Attrs, AttrEnd);
9159 
9160   ParsedAttributes EmptyAttrs(Attrs.getPool().getFactory());
9161   D.AddTypeInfo(DeclaratorChunk::getReference(0, IdentLoc, /*lvalue*/false),
9162                 EmptyAttrs, IdentLoc);
9163   Decl *Var = ActOnDeclarator(S, D);
9164   cast<VarDecl>(Var)->setCXXForRangeDecl(true);
9165   FinalizeDeclaration(Var);
9166   return ActOnDeclStmt(FinalizeDeclaratorGroup(S, DS, Var), IdentLoc,
9167                        AttrEnd.isValid() ? AttrEnd : IdentLoc);
9168 }
9169 
9170 void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {
9171   if (var->isInvalidDecl()) return;
9172 
9173   // In ARC, don't allow jumps past the implicit initialization of a
9174   // local retaining variable.
9175   if (getLangOpts().ObjCAutoRefCount &&
9176       var->hasLocalStorage()) {
9177     switch (var->getType().getObjCLifetime()) {
9178     case Qualifiers::OCL_None:
9179     case Qualifiers::OCL_ExplicitNone:
9180     case Qualifiers::OCL_Autoreleasing:
9181       break;
9182 
9183     case Qualifiers::OCL_Weak:
9184     case Qualifiers::OCL_Strong:
9185       getCurFunction()->setHasBranchProtectedScope();
9186       break;
9187     }
9188   }
9189 
9190   // Warn about externally-visible variables being defined without a
9191   // prior declaration.  We only want to do this for global
9192   // declarations, but we also specifically need to avoid doing it for
9193   // class members because the linkage of an anonymous class can
9194   // change if it's later given a typedef name.
9195   if (var->isThisDeclarationADefinition() &&
9196       var->getDeclContext()->getRedeclContext()->isFileContext() &&
9197       var->isExternallyVisible() && var->hasLinkage() &&
9198       !getDiagnostics().isIgnored(diag::warn_missing_variable_declarations,
9199                                   var->getLocation())) {
9200     // Find a previous declaration that's not a definition.
9201     VarDecl *prev = var->getPreviousDecl();
9202     while (prev && prev->isThisDeclarationADefinition())
9203       prev = prev->getPreviousDecl();
9204 
9205     if (!prev)
9206       Diag(var->getLocation(), diag::warn_missing_variable_declarations) << var;
9207   }
9208 
9209   if (var->getTLSKind() == VarDecl::TLS_Static) {
9210     const Expr *Culprit;
9211     if (var->getType().isDestructedType()) {
9212       // GNU C++98 edits for __thread, [basic.start.term]p3:
9213       //   The type of an object with thread storage duration shall not
9214       //   have a non-trivial destructor.
9215       Diag(var->getLocation(), diag::err_thread_nontrivial_dtor);
9216       if (getLangOpts().CPlusPlus11)
9217         Diag(var->getLocation(), diag::note_use_thread_local);
9218     } else if (getLangOpts().CPlusPlus && var->hasInit() &&
9219                !var->getInit()->isConstantInitializer(
9220                    Context, var->getType()->isReferenceType(), &Culprit)) {
9221       // GNU C++98 edits for __thread, [basic.start.init]p4:
9222       //   An object of thread storage duration shall not require dynamic
9223       //   initialization.
9224       // FIXME: Need strict checking here.
9225       Diag(Culprit->getExprLoc(), diag::err_thread_dynamic_init)
9226         << Culprit->getSourceRange();
9227       if (getLangOpts().CPlusPlus11)
9228         Diag(var->getLocation(), diag::note_use_thread_local);
9229     }
9230 
9231   }
9232 
9233   if (var->isThisDeclarationADefinition() &&
9234       ActiveTemplateInstantiations.empty()) {
9235     PragmaStack<StringLiteral *> *Stack = nullptr;
9236     int SectionFlags = PSF_Implicit | PSF_Read;
9237     if (var->getType().isConstQualified())
9238       Stack = &ConstSegStack;
9239     else if (!var->getInit()) {
9240       Stack = &BSSSegStack;
9241       SectionFlags |= PSF_Write;
9242     } else {
9243       Stack = &DataSegStack;
9244       SectionFlags |= PSF_Write;
9245     }
9246     if (!var->hasAttr<SectionAttr>() && Stack->CurrentValue)
9247       var->addAttr(
9248           SectionAttr::CreateImplicit(Context, SectionAttr::Declspec_allocate,
9249                                       Stack->CurrentValue->getString(),
9250                                       Stack->CurrentPragmaLocation));
9251     if (const SectionAttr *SA = var->getAttr<SectionAttr>())
9252       if (UnifySection(SA->getName(), SectionFlags, var))
9253         var->dropAttr<SectionAttr>();
9254 
9255     // Apply the init_seg attribute if this has an initializer.  If the
9256     // initializer turns out to not be dynamic, we'll end up ignoring this
9257     // attribute.
9258     if (CurInitSeg && var->getInit())
9259       var->addAttr(InitSegAttr::CreateImplicit(Context, CurInitSeg->getString(),
9260                                                CurInitSegLoc));
9261   }
9262 
9263   // All the following checks are C++ only.
9264   if (!getLangOpts().CPlusPlus) return;
9265 
9266   QualType type = var->getType();
9267   if (type->isDependentType()) return;
9268 
9269   // __block variables might require us to capture a copy-initializer.
9270   if (var->hasAttr<BlocksAttr>()) {
9271     // It's currently invalid to ever have a __block variable with an
9272     // array type; should we diagnose that here?
9273 
9274     // Regardless, we don't want to ignore array nesting when
9275     // constructing this copy.
9276     if (type->isStructureOrClassType()) {
9277       EnterExpressionEvaluationContext scope(*this, PotentiallyEvaluated);
9278       SourceLocation poi = var->getLocation();
9279       Expr *varRef =new (Context) DeclRefExpr(var, false, type, VK_LValue, poi);
9280       ExprResult result
9281         = PerformMoveOrCopyInitialization(
9282             InitializedEntity::InitializeBlock(poi, type, false),
9283             var, var->getType(), varRef, /*AllowNRVO=*/true);
9284       if (!result.isInvalid()) {
9285         result = MaybeCreateExprWithCleanups(result);
9286         Expr *init = result.getAs<Expr>();
9287         Context.setBlockVarCopyInits(var, init);
9288       }
9289     }
9290   }
9291 
9292   Expr *Init = var->getInit();
9293   bool IsGlobal = var->hasGlobalStorage() && !var->isStaticLocal();
9294   QualType baseType = Context.getBaseElementType(type);
9295 
9296   if (!var->getDeclContext()->isDependentContext() &&
9297       Init && !Init->isValueDependent()) {
9298     if (IsGlobal && !var->isConstexpr() &&
9299         !getDiagnostics().isIgnored(diag::warn_global_constructor,
9300                                     var->getLocation())) {
9301       // Warn about globals which don't have a constant initializer.  Don't
9302       // warn about globals with a non-trivial destructor because we already
9303       // warned about them.
9304       CXXRecordDecl *RD = baseType->getAsCXXRecordDecl();
9305       if (!(RD && !RD->hasTrivialDestructor()) &&
9306           !Init->isConstantInitializer(Context, baseType->isReferenceType()))
9307         Diag(var->getLocation(), diag::warn_global_constructor)
9308           << Init->getSourceRange();
9309     }
9310 
9311     if (var->isConstexpr()) {
9312       SmallVector<PartialDiagnosticAt, 8> Notes;
9313       if (!var->evaluateValue(Notes) || !var->isInitICE()) {
9314         SourceLocation DiagLoc = var->getLocation();
9315         // If the note doesn't add any useful information other than a source
9316         // location, fold it into the primary diagnostic.
9317         if (Notes.size() == 1 && Notes[0].second.getDiagID() ==
9318               diag::note_invalid_subexpr_in_const_expr) {
9319           DiagLoc = Notes[0].first;
9320           Notes.clear();
9321         }
9322         Diag(DiagLoc, diag::err_constexpr_var_requires_const_init)
9323           << var << Init->getSourceRange();
9324         for (unsigned I = 0, N = Notes.size(); I != N; ++I)
9325           Diag(Notes[I].first, Notes[I].second);
9326       }
9327     } else if (var->isUsableInConstantExpressions(Context)) {
9328       // Check whether the initializer of a const variable of integral or
9329       // enumeration type is an ICE now, since we can't tell whether it was
9330       // initialized by a constant expression if we check later.
9331       var->checkInitIsICE();
9332     }
9333   }
9334 
9335   // Require the destructor.
9336   if (const RecordType *recordType = baseType->getAs<RecordType>())
9337     FinalizeVarWithDestructor(var, recordType);
9338 }
9339 
9340 /// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform
9341 /// any semantic actions necessary after any initializer has been attached.
9342 void
9343 Sema::FinalizeDeclaration(Decl *ThisDecl) {
9344   // Note that we are no longer parsing the initializer for this declaration.
9345   ParsingInitForAutoVars.erase(ThisDecl);
9346 
9347   VarDecl *VD = dyn_cast_or_null<VarDecl>(ThisDecl);
9348   if (!VD)
9349     return;
9350 
9351   checkAttributesAfterMerging(*this, *VD);
9352 
9353   // Static locals inherit dll attributes from their function.
9354   if (VD->isStaticLocal()) {
9355     if (FunctionDecl *FD =
9356             dyn_cast_or_null<FunctionDecl>(VD->getParentFunctionOrMethod())) {
9357       if (Attr *A = getDLLAttr(FD)) {
9358         auto *NewAttr = cast<InheritableAttr>(A->clone(getASTContext()));
9359         NewAttr->setInherited(true);
9360         VD->addAttr(NewAttr);
9361       }
9362     }
9363   }
9364 
9365   // Imported static data members cannot be defined out-of-line.
9366   if (const DLLImportAttr *IA = VD->getAttr<DLLImportAttr>()) {
9367     if (VD->isStaticDataMember() && VD->isOutOfLine() &&
9368         VD->isThisDeclarationADefinition()) {
9369       // We allow definitions of dllimport class template static data members
9370       // with a warning.
9371       CXXRecordDecl *Context =
9372         cast<CXXRecordDecl>(VD->getFirstDecl()->getDeclContext());
9373       bool IsClassTemplateMember =
9374           isa<ClassTemplatePartialSpecializationDecl>(Context) ||
9375           Context->getDescribedClassTemplate();
9376 
9377       Diag(VD->getLocation(),
9378            IsClassTemplateMember
9379                ? diag::warn_attribute_dllimport_static_field_definition
9380                : diag::err_attribute_dllimport_static_field_definition);
9381       Diag(IA->getLocation(), diag::note_attribute);
9382       if (!IsClassTemplateMember)
9383         VD->setInvalidDecl();
9384     }
9385   }
9386 
9387   if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {
9388     if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {
9389       Diag(Attr->getLocation(), diag::warn_attribute_ignored) << Attr;
9390       VD->dropAttr<UsedAttr>();
9391     }
9392   }
9393 
9394   if (!VD->isInvalidDecl() &&
9395       VD->isThisDeclarationADefinition() == VarDecl::TentativeDefinition) {
9396     if (const VarDecl *Def = VD->getDefinition()) {
9397       if (Def->hasAttr<AliasAttr>()) {
9398         Diag(VD->getLocation(), diag::err_tentative_after_alias)
9399             << VD->getDeclName();
9400         Diag(Def->getLocation(), diag::note_previous_definition);
9401         VD->setInvalidDecl();
9402       }
9403     }
9404   }
9405 
9406   const DeclContext *DC = VD->getDeclContext();
9407   // If there's a #pragma GCC visibility in scope, and this isn't a class
9408   // member, set the visibility of this variable.
9409   if (DC->getRedeclContext()->isFileContext() && VD->isExternallyVisible())
9410     AddPushedVisibilityAttribute(VD);
9411 
9412   // FIXME: Warn on unused templates.
9413   if (VD->isFileVarDecl() && !VD->getDescribedVarTemplate() &&
9414       !isa<VarTemplatePartialSpecializationDecl>(VD))
9415     MarkUnusedFileScopedDecl(VD);
9416 
9417   // Now we have parsed the initializer and can update the table of magic
9418   // tag values.
9419   if (!VD->hasAttr<TypeTagForDatatypeAttr>() ||
9420       !VD->getType()->isIntegralOrEnumerationType())
9421     return;
9422 
9423   for (const auto *I : ThisDecl->specific_attrs<TypeTagForDatatypeAttr>()) {
9424     const Expr *MagicValueExpr = VD->getInit();
9425     if (!MagicValueExpr) {
9426       continue;
9427     }
9428     llvm::APSInt MagicValueInt;
9429     if (!MagicValueExpr->isIntegerConstantExpr(MagicValueInt, Context)) {
9430       Diag(I->getRange().getBegin(),
9431            diag::err_type_tag_for_datatype_not_ice)
9432         << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9433       continue;
9434     }
9435     if (MagicValueInt.getActiveBits() > 64) {
9436       Diag(I->getRange().getBegin(),
9437            diag::err_type_tag_for_datatype_too_large)
9438         << LangOpts.CPlusPlus << MagicValueExpr->getSourceRange();
9439       continue;
9440     }
9441     uint64_t MagicValue = MagicValueInt.getZExtValue();
9442     RegisterTypeTagForDatatype(I->getArgumentKind(),
9443                                MagicValue,
9444                                I->getMatchingCType(),
9445                                I->getLayoutCompatible(),
9446                                I->getMustBeNull());
9447   }
9448 }
9449 
9450 Sema::DeclGroupPtrTy Sema::FinalizeDeclaratorGroup(Scope *S, const DeclSpec &DS,
9451                                                    ArrayRef<Decl *> Group) {
9452   SmallVector<Decl*, 8> Decls;
9453 
9454   if (DS.isTypeSpecOwned())
9455     Decls.push_back(DS.getRepAsDecl());
9456 
9457   DeclaratorDecl *FirstDeclaratorInGroup = nullptr;
9458   for (unsigned i = 0, e = Group.size(); i != e; ++i)
9459     if (Decl *D = Group[i]) {
9460       if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D))
9461         if (!FirstDeclaratorInGroup)
9462           FirstDeclaratorInGroup = DD;
9463       Decls.push_back(D);
9464     }
9465 
9466   if (DeclSpec::isDeclRep(DS.getTypeSpecType())) {
9467     if (TagDecl *Tag = dyn_cast_or_null<TagDecl>(DS.getRepAsDecl())) {
9468       HandleTagNumbering(*this, Tag, S);
9469       if (!Tag->hasNameForLinkage() && !Tag->hasDeclaratorForAnonDecl())
9470         Tag->setDeclaratorForAnonDecl(FirstDeclaratorInGroup);
9471     }
9472   }
9473 
9474   return BuildDeclaratorGroup(Decls, DS.containsPlaceholderType());
9475 }
9476 
9477 /// BuildDeclaratorGroup - convert a list of declarations into a declaration
9478 /// group, performing any necessary semantic checking.
9479 Sema::DeclGroupPtrTy
9480 Sema::BuildDeclaratorGroup(MutableArrayRef<Decl *> Group,
9481                            bool TypeMayContainAuto) {
9482   // C++0x [dcl.spec.auto]p7:
9483   //   If the type deduced for the template parameter U is not the same in each
9484   //   deduction, the program is ill-formed.
9485   // FIXME: When initializer-list support is added, a distinction is needed
9486   // between the deduced type U and the deduced type which 'auto' stands for.
9487   //   auto a = 0, b = { 1, 2, 3 };
9488   // is legal because the deduced type U is 'int' in both cases.
9489   if (TypeMayContainAuto && Group.size() > 1) {
9490     QualType Deduced;
9491     CanQualType DeducedCanon;
9492     VarDecl *DeducedDecl = nullptr;
9493     for (unsigned i = 0, e = Group.size(); i != e; ++i) {
9494       if (VarDecl *D = dyn_cast<VarDecl>(Group[i])) {
9495         AutoType *AT = D->getType()->getContainedAutoType();
9496         // Don't reissue diagnostics when instantiating a template.
9497         if (AT && D->isInvalidDecl())
9498           break;
9499         QualType U = AT ? AT->getDeducedType() : QualType();
9500         if (!U.isNull()) {
9501           CanQualType UCanon = Context.getCanonicalType(U);
9502           if (Deduced.isNull()) {
9503             Deduced = U;
9504             DeducedCanon = UCanon;
9505             DeducedDecl = D;
9506           } else if (DeducedCanon != UCanon) {
9507             Diag(D->getTypeSourceInfo()->getTypeLoc().getBeginLoc(),
9508                  diag::err_auto_different_deductions)
9509               << (AT->isDecltypeAuto() ? 1 : 0)
9510               << Deduced << DeducedDecl->getDeclName()
9511               << U << D->getDeclName()
9512               << DeducedDecl->getInit()->getSourceRange()
9513               << D->getInit()->getSourceRange();
9514             D->setInvalidDecl();
9515             break;
9516           }
9517         }
9518       }
9519     }
9520   }
9521 
9522   ActOnDocumentableDecls(Group);
9523 
9524   return DeclGroupPtrTy::make(
9525       DeclGroupRef::Create(Context, Group.data(), Group.size()));
9526 }
9527 
9528 void Sema::ActOnDocumentableDecl(Decl *D) {
9529   ActOnDocumentableDecls(D);
9530 }
9531 
9532 void Sema::ActOnDocumentableDecls(ArrayRef<Decl *> Group) {
9533   // Don't parse the comment if Doxygen diagnostics are ignored.
9534   if (Group.empty() || !Group[0])
9535    return;
9536 
9537   if (Diags.isIgnored(diag::warn_doc_param_not_found, Group[0]->getLocation()))
9538     return;
9539 
9540   if (Group.size() >= 2) {
9541     // This is a decl group.  Normally it will contain only declarations
9542     // produced from declarator list.  But in case we have any definitions or
9543     // additional declaration references:
9544     //   'typedef struct S {} S;'
9545     //   'typedef struct S *S;'
9546     //   'struct S *pS;'
9547     // FinalizeDeclaratorGroup adds these as separate declarations.
9548     Decl *MaybeTagDecl = Group[0];
9549     if (MaybeTagDecl && isa<TagDecl>(MaybeTagDecl)) {
9550       Group = Group.slice(1);
9551     }
9552   }
9553 
9554   // See if there are any new comments that are not attached to a decl.
9555   ArrayRef<RawComment *> Comments = Context.getRawCommentList().getComments();
9556   if (!Comments.empty() &&
9557       !Comments.back()->isAttached()) {
9558     // There is at least one comment that not attached to a decl.
9559     // Maybe it should be attached to one of these decls?
9560     //
9561     // Note that this way we pick up not only comments that precede the
9562     // declaration, but also comments that *follow* the declaration -- thanks to
9563     // the lookahead in the lexer: we've consumed the semicolon and looked
9564     // ahead through comments.
9565     for (unsigned i = 0, e = Group.size(); i != e; ++i)
9566       Context.getCommentForDecl(Group[i], &PP);
9567   }
9568 }
9569 
9570 /// ActOnParamDeclarator - Called from Parser::ParseFunctionDeclarator()
9571 /// to introduce parameters into function prototype scope.
9572 Decl *Sema::ActOnParamDeclarator(Scope *S, Declarator &D) {
9573   const DeclSpec &DS = D.getDeclSpec();
9574 
9575   // Verify C99 6.7.5.3p2: The only SCS allowed is 'register'.
9576 
9577   // C++03 [dcl.stc]p2 also permits 'auto'.
9578   VarDecl::StorageClass StorageClass = SC_None;
9579   if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
9580     StorageClass = SC_Register;
9581   } else if (getLangOpts().CPlusPlus &&
9582              DS.getStorageClassSpec() == DeclSpec::SCS_auto) {
9583     StorageClass = SC_Auto;
9584   } else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified) {
9585     Diag(DS.getStorageClassSpecLoc(),
9586          diag::err_invalid_storage_class_in_func_decl);
9587     D.getMutableDeclSpec().ClearStorageClassSpecs();
9588   }
9589 
9590   if (DeclSpec::TSCS TSCS = DS.getThreadStorageClassSpec())
9591     Diag(DS.getThreadStorageClassSpecLoc(), diag::err_invalid_thread)
9592       << DeclSpec::getSpecifierName(TSCS);
9593   if (DS.isConstexprSpecified())
9594     Diag(DS.getConstexprSpecLoc(), diag::err_invalid_constexpr)
9595       << 0;
9596 
9597   DiagnoseFunctionSpecifiers(DS);
9598 
9599   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
9600   QualType parmDeclType = TInfo->getType();
9601 
9602   if (getLangOpts().CPlusPlus) {
9603     // Check that there are no default arguments inside the type of this
9604     // parameter.
9605     CheckExtraCXXDefaultArguments(D);
9606 
9607     // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
9608     if (D.getCXXScopeSpec().isSet()) {
9609       Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator)
9610         << D.getCXXScopeSpec().getRange();
9611       D.getCXXScopeSpec().clear();
9612     }
9613   }
9614 
9615   // Ensure we have a valid name
9616   IdentifierInfo *II = nullptr;
9617   if (D.hasName()) {
9618     II = D.getIdentifier();
9619     if (!II) {
9620       Diag(D.getIdentifierLoc(), diag::err_bad_parameter_name)
9621         << GetNameForDeclarator(D).getName();
9622       D.setInvalidType(true);
9623     }
9624   }
9625 
9626   // Check for redeclaration of parameters, e.g. int foo(int x, int x);
9627   if (II) {
9628     LookupResult R(*this, II, D.getIdentifierLoc(), LookupOrdinaryName,
9629                    ForRedeclaration);
9630     LookupName(R, S);
9631     if (R.isSingleResult()) {
9632       NamedDecl *PrevDecl = R.getFoundDecl();
9633       if (PrevDecl->isTemplateParameter()) {
9634         // Maybe we will complain about the shadowed template parameter.
9635         DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
9636         // Just pretend that we didn't see the previous declaration.
9637         PrevDecl = nullptr;
9638       } else if (S->isDeclScope(PrevDecl)) {
9639         Diag(D.getIdentifierLoc(), diag::err_param_redefinition) << II;
9640         Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
9641 
9642         // Recover by removing the name
9643         II = nullptr;
9644         D.SetIdentifier(nullptr, D.getIdentifierLoc());
9645         D.setInvalidType(true);
9646       }
9647     }
9648   }
9649 
9650   // Temporarily put parameter variables in the translation unit, not
9651   // the enclosing context.  This prevents them from accidentally
9652   // looking like class members in C++.
9653   ParmVarDecl *New = CheckParameter(Context.getTranslationUnitDecl(),
9654                                     D.getLocStart(),
9655                                     D.getIdentifierLoc(), II,
9656                                     parmDeclType, TInfo,
9657                                     StorageClass);
9658 
9659   if (D.isInvalidType())
9660     New->setInvalidDecl();
9661 
9662   assert(S->isFunctionPrototypeScope());
9663   assert(S->getFunctionPrototypeDepth() >= 1);
9664   New->setScopeInfo(S->getFunctionPrototypeDepth() - 1,
9665                     S->getNextFunctionPrototypeIndex());
9666 
9667   // Add the parameter declaration into this scope.
9668   S->AddDecl(New);
9669   if (II)
9670     IdResolver.AddDecl(New);
9671 
9672   ProcessDeclAttributes(S, New, D);
9673 
9674   if (D.getDeclSpec().isModulePrivateSpecified())
9675     Diag(New->getLocation(), diag::err_module_private_local)
9676       << 1 << New->getDeclName()
9677       << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
9678       << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
9679 
9680   if (New->hasAttr<BlocksAttr>()) {
9681     Diag(New->getLocation(), diag::err_block_on_nonlocal);
9682   }
9683   return New;
9684 }
9685 
9686 /// \brief Synthesizes a variable for a parameter arising from a
9687 /// typedef.
9688 ParmVarDecl *Sema::BuildParmVarDeclForTypedef(DeclContext *DC,
9689                                               SourceLocation Loc,
9690                                               QualType T) {
9691   /* FIXME: setting StartLoc == Loc.
9692      Would it be worth to modify callers so as to provide proper source
9693      location for the unnamed parameters, embedding the parameter's type? */
9694   ParmVarDecl *Param = ParmVarDecl::Create(Context, DC, Loc, Loc, nullptr,
9695                                 T, Context.getTrivialTypeSourceInfo(T, Loc),
9696                                            SC_None, nullptr);
9697   Param->setImplicit();
9698   return Param;
9699 }
9700 
9701 void Sema::DiagnoseUnusedParameters(ParmVarDecl * const *Param,
9702                                     ParmVarDecl * const *ParamEnd) {
9703   // Don't diagnose unused-parameter errors in template instantiations; we
9704   // will already have done so in the template itself.
9705   if (!ActiveTemplateInstantiations.empty())
9706     return;
9707 
9708   for (; Param != ParamEnd; ++Param) {
9709     if (!(*Param)->isReferenced() && (*Param)->getDeclName() &&
9710         !(*Param)->hasAttr<UnusedAttr>()) {
9711       Diag((*Param)->getLocation(), diag::warn_unused_parameter)
9712         << (*Param)->getDeclName();
9713     }
9714   }
9715 }
9716 
9717 void Sema::DiagnoseSizeOfParametersAndReturnValue(ParmVarDecl * const *Param,
9718                                                   ParmVarDecl * const *ParamEnd,
9719                                                   QualType ReturnTy,
9720                                                   NamedDecl *D) {
9721   if (LangOpts.NumLargeByValueCopy == 0) // No check.
9722     return;
9723 
9724   // Warn if the return value is pass-by-value and larger than the specified
9725   // threshold.
9726   if (!ReturnTy->isDependentType() && ReturnTy.isPODType(Context)) {
9727     unsigned Size = Context.getTypeSizeInChars(ReturnTy).getQuantity();
9728     if (Size > LangOpts.NumLargeByValueCopy)
9729       Diag(D->getLocation(), diag::warn_return_value_size)
9730           << D->getDeclName() << Size;
9731   }
9732 
9733   // Warn if any parameter is pass-by-value and larger than the specified
9734   // threshold.
9735   for (; Param != ParamEnd; ++Param) {
9736     QualType T = (*Param)->getType();
9737     if (T->isDependentType() || !T.isPODType(Context))
9738       continue;
9739     unsigned Size = Context.getTypeSizeInChars(T).getQuantity();
9740     if (Size > LangOpts.NumLargeByValueCopy)
9741       Diag((*Param)->getLocation(), diag::warn_parameter_size)
9742           << (*Param)->getDeclName() << Size;
9743   }
9744 }
9745 
9746 ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc,
9747                                   SourceLocation NameLoc, IdentifierInfo *Name,
9748                                   QualType T, TypeSourceInfo *TSInfo,
9749                                   VarDecl::StorageClass StorageClass) {
9750   // In ARC, infer a lifetime qualifier for appropriate parameter types.
9751   if (getLangOpts().ObjCAutoRefCount &&
9752       T.getObjCLifetime() == Qualifiers::OCL_None &&
9753       T->isObjCLifetimeType()) {
9754 
9755     Qualifiers::ObjCLifetime lifetime;
9756 
9757     // Special cases for arrays:
9758     //   - if it's const, use __unsafe_unretained
9759     //   - otherwise, it's an error
9760     if (T->isArrayType()) {
9761       if (!T.isConstQualified()) {
9762         DelayedDiagnostics.add(
9763             sema::DelayedDiagnostic::makeForbiddenType(
9764             NameLoc, diag::err_arc_array_param_no_ownership, T, false));
9765       }
9766       lifetime = Qualifiers::OCL_ExplicitNone;
9767     } else {
9768       lifetime = T->getObjCARCImplicitLifetime();
9769     }
9770     T = Context.getLifetimeQualifiedType(T, lifetime);
9771   }
9772 
9773   ParmVarDecl *New = ParmVarDecl::Create(Context, DC, StartLoc, NameLoc, Name,
9774                                          Context.getAdjustedParameterType(T),
9775                                          TSInfo,
9776                                          StorageClass, nullptr);
9777 
9778   // Parameters can not be abstract class types.
9779   // For record types, this is done by the AbstractClassUsageDiagnoser once
9780   // the class has been completely parsed.
9781   if (!CurContext->isRecord() &&
9782       RequireNonAbstractType(NameLoc, T, diag::err_abstract_type_in_decl,
9783                              AbstractParamType))
9784     New->setInvalidDecl();
9785 
9786   // Parameter declarators cannot be interface types. All ObjC objects are
9787   // passed by reference.
9788   if (T->isObjCObjectType()) {
9789     SourceLocation TypeEndLoc = TSInfo->getTypeLoc().getLocEnd();
9790     Diag(NameLoc,
9791          diag::err_object_cannot_be_passed_returned_by_value) << 1 << T
9792       << FixItHint::CreateInsertion(TypeEndLoc, "*");
9793     T = Context.getObjCObjectPointerType(T);
9794     New->setType(T);
9795   }
9796 
9797   // ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage
9798   // duration shall not be qualified by an address-space qualifier."
9799   // Since all parameters have automatic store duration, they can not have
9800   // an address space.
9801   if (T.getAddressSpace() != 0) {
9802     // OpenCL allows function arguments declared to be an array of a type
9803     // to be qualified with an address space.
9804     if (!(getLangOpts().OpenCL && T->isArrayType())) {
9805       Diag(NameLoc, diag::err_arg_with_address_space);
9806       New->setInvalidDecl();
9807     }
9808   }
9809 
9810   return New;
9811 }
9812 
9813 void Sema::ActOnFinishKNRParamDeclarations(Scope *S, Declarator &D,
9814                                            SourceLocation LocAfterDecls) {
9815   DeclaratorChunk::FunctionTypeInfo &FTI = D.getFunctionTypeInfo();
9816 
9817   // Verify 6.9.1p6: 'every identifier in the identifier list shall be declared'
9818   // for a K&R function.
9819   if (!FTI.hasPrototype) {
9820     for (int i = FTI.NumParams; i != 0; /* decrement in loop */) {
9821       --i;
9822       if (FTI.Params[i].Param == nullptr) {
9823         SmallString<256> Code;
9824         llvm::raw_svector_ostream(Code)
9825             << "  int " << FTI.Params[i].Ident->getName() << ";\n";
9826         Diag(FTI.Params[i].IdentLoc, diag::ext_param_not_declared)
9827             << FTI.Params[i].Ident
9828             << FixItHint::CreateInsertion(LocAfterDecls, Code.str());
9829 
9830         // Implicitly declare the argument as type 'int' for lack of a better
9831         // type.
9832         AttributeFactory attrs;
9833         DeclSpec DS(attrs);
9834         const char* PrevSpec; // unused
9835         unsigned DiagID; // unused
9836         DS.SetTypeSpecType(DeclSpec::TST_int, FTI.Params[i].IdentLoc, PrevSpec,
9837                            DiagID, Context.getPrintingPolicy());
9838         // Use the identifier location for the type source range.
9839         DS.SetRangeStart(FTI.Params[i].IdentLoc);
9840         DS.SetRangeEnd(FTI.Params[i].IdentLoc);
9841         Declarator ParamD(DS, Declarator::KNRTypeListContext);
9842         ParamD.SetIdentifier(FTI.Params[i].Ident, FTI.Params[i].IdentLoc);
9843         FTI.Params[i].Param = ActOnParamDeclarator(S, ParamD);
9844       }
9845     }
9846   }
9847 }
9848 
9849 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Declarator &D) {
9850   assert(getCurFunctionDecl() == nullptr && "Function parsing confused");
9851   assert(D.isFunctionDeclarator() && "Not a function declarator!");
9852   Scope *ParentScope = FnBodyScope->getParent();
9853 
9854   D.setFunctionDefinitionKind(FDK_Definition);
9855   Decl *DP = HandleDeclarator(ParentScope, D, MultiTemplateParamsArg());
9856   return ActOnStartOfFunctionDef(FnBodyScope, DP);
9857 }
9858 
9859 void Sema::ActOnFinishInlineMethodDef(CXXMethodDecl *D) {
9860   Consumer.HandleInlineMethodDefinition(D);
9861 }
9862 
9863 static bool ShouldWarnAboutMissingPrototype(const FunctionDecl *FD,
9864                              const FunctionDecl*& PossibleZeroParamPrototype) {
9865   // Don't warn about invalid declarations.
9866   if (FD->isInvalidDecl())
9867     return false;
9868 
9869   // Or declarations that aren't global.
9870   if (!FD->isGlobal())
9871     return false;
9872 
9873   // Don't warn about C++ member functions.
9874   if (isa<CXXMethodDecl>(FD))
9875     return false;
9876 
9877   // Don't warn about 'main'.
9878   if (FD->isMain())
9879     return false;
9880 
9881   // Don't warn about inline functions.
9882   if (FD->isInlined())
9883     return false;
9884 
9885   // Don't warn about function templates.
9886   if (FD->getDescribedFunctionTemplate())
9887     return false;
9888 
9889   // Don't warn about function template specializations.
9890   if (FD->isFunctionTemplateSpecialization())
9891     return false;
9892 
9893   // Don't warn for OpenCL kernels.
9894   if (FD->hasAttr<OpenCLKernelAttr>())
9895     return false;
9896 
9897   bool MissingPrototype = true;
9898   for (const FunctionDecl *Prev = FD->getPreviousDecl();
9899        Prev; Prev = Prev->getPreviousDecl()) {
9900     // Ignore any declarations that occur in function or method
9901     // scope, because they aren't visible from the header.
9902     if (Prev->getLexicalDeclContext()->isFunctionOrMethod())
9903       continue;
9904 
9905     MissingPrototype = !Prev->getType()->isFunctionProtoType();
9906     if (FD->getNumParams() == 0)
9907       PossibleZeroParamPrototype = Prev;
9908     break;
9909   }
9910 
9911   return MissingPrototype;
9912 }
9913 
9914 void
9915 Sema::CheckForFunctionRedefinition(FunctionDecl *FD,
9916                                    const FunctionDecl *EffectiveDefinition) {
9917   // Don't complain if we're in GNU89 mode and the previous definition
9918   // was an extern inline function.
9919   const FunctionDecl *Definition = EffectiveDefinition;
9920   if (!Definition)
9921     if (!FD->isDefined(Definition))
9922       return;
9923 
9924   if (canRedefineFunction(Definition, getLangOpts()))
9925     return;
9926 
9927   if (getLangOpts().GNUMode && Definition->isInlineSpecified() &&
9928       Definition->getStorageClass() == SC_Extern)
9929     Diag(FD->getLocation(), diag::err_redefinition_extern_inline)
9930         << FD->getDeclName() << getLangOpts().CPlusPlus;
9931   else
9932     Diag(FD->getLocation(), diag::err_redefinition) << FD->getDeclName();
9933 
9934   Diag(Definition->getLocation(), diag::note_previous_definition);
9935   FD->setInvalidDecl();
9936 }
9937 
9938 
9939 static void RebuildLambdaScopeInfo(CXXMethodDecl *CallOperator,
9940                                    Sema &S) {
9941   CXXRecordDecl *const LambdaClass = CallOperator->getParent();
9942 
9943   LambdaScopeInfo *LSI = S.PushLambdaScope();
9944   LSI->CallOperator = CallOperator;
9945   LSI->Lambda = LambdaClass;
9946   LSI->ReturnType = CallOperator->getReturnType();
9947   const LambdaCaptureDefault LCD = LambdaClass->getLambdaCaptureDefault();
9948 
9949   if (LCD == LCD_None)
9950     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_None;
9951   else if (LCD == LCD_ByCopy)
9952     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByval;
9953   else if (LCD == LCD_ByRef)
9954     LSI->ImpCaptureStyle = CapturingScopeInfo::ImpCap_LambdaByref;
9955   DeclarationNameInfo DNI = CallOperator->getNameInfo();
9956 
9957   LSI->IntroducerRange = DNI.getCXXOperatorNameRange();
9958   LSI->Mutable = !CallOperator->isConst();
9959 
9960   // Add the captures to the LSI so they can be noted as already
9961   // captured within tryCaptureVar.
9962   auto I = LambdaClass->field_begin();
9963   for (const auto &C : LambdaClass->captures()) {
9964     if (C.capturesVariable()) {
9965       VarDecl *VD = C.getCapturedVar();
9966       if (VD->isInitCapture())
9967         S.CurrentInstantiationScope->InstantiatedLocal(VD, VD);
9968       QualType CaptureType = VD->getType();
9969       const bool ByRef = C.getCaptureKind() == LCK_ByRef;
9970       LSI->addCapture(VD, /*IsBlock*/false, ByRef,
9971           /*RefersToEnclosingLocal*/true, C.getLocation(),
9972           /*EllipsisLoc*/C.isPackExpansion()
9973                          ? C.getEllipsisLoc() : SourceLocation(),
9974           CaptureType, /*Expr*/ nullptr);
9975 
9976     } else if (C.capturesThis()) {
9977       LSI->addThisCapture(/*Nested*/ false, C.getLocation(),
9978                               S.getCurrentThisType(), /*Expr*/ nullptr);
9979     } else {
9980       LSI->addVLATypeCapture(C.getLocation(), I->getType());
9981     }
9982     ++I;
9983   }
9984 }
9985 
9986 Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D) {
9987   // Clear the last template instantiation error context.
9988   LastTemplateInstantiationErrorContext = ActiveTemplateInstantiation();
9989 
9990   if (!D)
9991     return D;
9992   FunctionDecl *FD = nullptr;
9993 
9994   if (FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D))
9995     FD = FunTmpl->getTemplatedDecl();
9996   else
9997     FD = cast<FunctionDecl>(D);
9998   // If we are instantiating a generic lambda call operator, push
9999   // a LambdaScopeInfo onto the function stack.  But use the information
10000   // that's already been calculated (ActOnLambdaExpr) to prime the current
10001   // LambdaScopeInfo.
10002   // When the template operator is being specialized, the LambdaScopeInfo,
10003   // has to be properly restored so that tryCaptureVariable doesn't try
10004   // and capture any new variables. In addition when calculating potential
10005   // captures during transformation of nested lambdas, it is necessary to
10006   // have the LSI properly restored.
10007   if (isGenericLambdaCallOperatorSpecialization(FD)) {
10008     assert(ActiveTemplateInstantiations.size() &&
10009       "There should be an active template instantiation on the stack "
10010       "when instantiating a generic lambda!");
10011     RebuildLambdaScopeInfo(cast<CXXMethodDecl>(D), *this);
10012   }
10013   else
10014     // Enter a new function scope
10015     PushFunctionScope();
10016 
10017   // See if this is a redefinition.
10018   if (!FD->isLateTemplateParsed())
10019     CheckForFunctionRedefinition(FD);
10020 
10021   // Builtin functions cannot be defined.
10022   if (unsigned BuiltinID = FD->getBuiltinID()) {
10023     if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID) &&
10024         !Context.BuiltinInfo.isPredefinedRuntimeFunction(BuiltinID)) {
10025       Diag(FD->getLocation(), diag::err_builtin_definition) << FD;
10026       FD->setInvalidDecl();
10027     }
10028   }
10029 
10030   // The return type of a function definition must be complete
10031   // (C99 6.9.1p3, C++ [dcl.fct]p6).
10032   QualType ResultType = FD->getReturnType();
10033   if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
10034       !FD->isInvalidDecl() &&
10035       RequireCompleteType(FD->getLocation(), ResultType,
10036                           diag::err_func_def_incomplete_result))
10037     FD->setInvalidDecl();
10038 
10039   // GNU warning -Wmissing-prototypes:
10040   //   Warn if a global function is defined without a previous
10041   //   prototype declaration. This warning is issued even if the
10042   //   definition itself provides a prototype. The aim is to detect
10043   //   global functions that fail to be declared in header files.
10044   const FunctionDecl *PossibleZeroParamPrototype = nullptr;
10045   if (ShouldWarnAboutMissingPrototype(FD, PossibleZeroParamPrototype)) {
10046     Diag(FD->getLocation(), diag::warn_missing_prototype) << FD;
10047 
10048     if (PossibleZeroParamPrototype) {
10049       // We found a declaration that is not a prototype,
10050       // but that could be a zero-parameter prototype
10051       if (TypeSourceInfo *TI =
10052               PossibleZeroParamPrototype->getTypeSourceInfo()) {
10053         TypeLoc TL = TI->getTypeLoc();
10054         if (FunctionNoProtoTypeLoc FTL = TL.getAs<FunctionNoProtoTypeLoc>())
10055           Diag(PossibleZeroParamPrototype->getLocation(),
10056                diag::note_declaration_not_a_prototype)
10057             << PossibleZeroParamPrototype
10058             << FixItHint::CreateInsertion(FTL.getRParenLoc(), "void");
10059       }
10060     }
10061   }
10062 
10063   if (FnBodyScope)
10064     PushDeclContext(FnBodyScope, FD);
10065 
10066   // Check the validity of our function parameters
10067   CheckParmsForFunctionDef(FD->param_begin(), FD->param_end(),
10068                            /*CheckParameterNames=*/true);
10069 
10070   // Introduce our parameters into the function scope
10071   for (auto Param : FD->params()) {
10072     Param->setOwningFunction(FD);
10073 
10074     // If this has an identifier, add it to the scope stack.
10075     if (Param->getIdentifier() && FnBodyScope) {
10076       CheckShadow(FnBodyScope, Param);
10077 
10078       PushOnScopeChains(Param, FnBodyScope);
10079     }
10080   }
10081 
10082   // If we had any tags defined in the function prototype,
10083   // introduce them into the function scope.
10084   if (FnBodyScope) {
10085     for (ArrayRef<NamedDecl *>::iterator
10086              I = FD->getDeclsInPrototypeScope().begin(),
10087              E = FD->getDeclsInPrototypeScope().end();
10088          I != E; ++I) {
10089       NamedDecl *D = *I;
10090 
10091       // Some of these decls (like enums) may have been pinned to the translation unit
10092       // for lack of a real context earlier. If so, remove from the translation unit
10093       // and reattach to the current context.
10094       if (D->getLexicalDeclContext() == Context.getTranslationUnitDecl()) {
10095         // Is the decl actually in the context?
10096         for (const auto *DI : Context.getTranslationUnitDecl()->decls()) {
10097           if (DI == D) {
10098             Context.getTranslationUnitDecl()->removeDecl(D);
10099             break;
10100           }
10101         }
10102         // Either way, reassign the lexical decl context to our FunctionDecl.
10103         D->setLexicalDeclContext(CurContext);
10104       }
10105 
10106       // If the decl has a non-null name, make accessible in the current scope.
10107       if (!D->getName().empty())
10108         PushOnScopeChains(D, FnBodyScope, /*AddToContext=*/false);
10109 
10110       // Similarly, dive into enums and fish their constants out, making them
10111       // accessible in this scope.
10112       if (auto *ED = dyn_cast<EnumDecl>(D)) {
10113         for (auto *EI : ED->enumerators())
10114           PushOnScopeChains(EI, FnBodyScope, /*AddToContext=*/false);
10115       }
10116     }
10117   }
10118 
10119   // Ensure that the function's exception specification is instantiated.
10120   if (const FunctionProtoType *FPT = FD->getType()->getAs<FunctionProtoType>())
10121     ResolveExceptionSpec(D->getLocation(), FPT);
10122 
10123   // dllimport cannot be applied to non-inline function definitions.
10124   if (FD->hasAttr<DLLImportAttr>() && !FD->isInlined() &&
10125       !FD->isTemplateInstantiation()) {
10126     assert(!FD->hasAttr<DLLExportAttr>());
10127     Diag(FD->getLocation(), diag::err_attribute_dllimport_function_definition);
10128     FD->setInvalidDecl();
10129     return D;
10130   }
10131   // We want to attach documentation to original Decl (which might be
10132   // a function template).
10133   ActOnDocumentableDecl(D);
10134   if (getCurLexicalContext()->isObjCContainer() &&
10135       getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl &&
10136       getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation)
10137     Diag(FD->getLocation(), diag::warn_function_def_in_objc_container);
10138 
10139   return D;
10140 }
10141 
10142 /// \brief Given the set of return statements within a function body,
10143 /// compute the variables that are subject to the named return value
10144 /// optimization.
10145 ///
10146 /// Each of the variables that is subject to the named return value
10147 /// optimization will be marked as NRVO variables in the AST, and any
10148 /// return statement that has a marked NRVO variable as its NRVO candidate can
10149 /// use the named return value optimization.
10150 ///
10151 /// This function applies a very simplistic algorithm for NRVO: if every return
10152 /// statement in the scope of a variable has the same NRVO candidate, that
10153 /// candidate is an NRVO variable.
10154 void Sema::computeNRVO(Stmt *Body, FunctionScopeInfo *Scope) {
10155   ReturnStmt **Returns = Scope->Returns.data();
10156 
10157   for (unsigned I = 0, E = Scope->Returns.size(); I != E; ++I) {
10158     if (const VarDecl *NRVOCandidate = Returns[I]->getNRVOCandidate()) {
10159       if (!NRVOCandidate->isNRVOVariable())
10160         Returns[I]->setNRVOCandidate(nullptr);
10161     }
10162   }
10163 }
10164 
10165 bool Sema::canDelayFunctionBody(const Declarator &D) {
10166   // We can't delay parsing the body of a constexpr function template (yet).
10167   if (D.getDeclSpec().isConstexprSpecified())
10168     return false;
10169 
10170   // We can't delay parsing the body of a function template with a deduced
10171   // return type (yet).
10172   if (D.getDeclSpec().containsPlaceholderType()) {
10173     // If the placeholder introduces a non-deduced trailing return type,
10174     // we can still delay parsing it.
10175     if (D.getNumTypeObjects()) {
10176       const auto &Outer = D.getTypeObject(D.getNumTypeObjects() - 1);
10177       if (Outer.Kind == DeclaratorChunk::Function &&
10178           Outer.Fun.hasTrailingReturnType()) {
10179         QualType Ty = GetTypeFromParser(Outer.Fun.getTrailingReturnType());
10180         return Ty.isNull() || !Ty->isUndeducedType();
10181       }
10182     }
10183     return false;
10184   }
10185 
10186   return true;
10187 }
10188 
10189 bool Sema::canSkipFunctionBody(Decl *D) {
10190   // We cannot skip the body of a function (or function template) which is
10191   // constexpr, since we may need to evaluate its body in order to parse the
10192   // rest of the file.
10193   // We cannot skip the body of a function with an undeduced return type,
10194   // because any callers of that function need to know the type.
10195   if (const FunctionDecl *FD = D->getAsFunction())
10196     if (FD->isConstexpr() || FD->getReturnType()->isUndeducedType())
10197       return false;
10198   return Consumer.shouldSkipFunctionBody(D);
10199 }
10200 
10201 Decl *Sema::ActOnSkippedFunctionBody(Decl *Decl) {
10202   if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(Decl))
10203     FD->setHasSkippedBody();
10204   else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(Decl))
10205     MD->setHasSkippedBody();
10206   return ActOnFinishFunctionBody(Decl, nullptr);
10207 }
10208 
10209 Decl *Sema::ActOnFinishFunctionBody(Decl *D, Stmt *BodyArg) {
10210   return ActOnFinishFunctionBody(D, BodyArg, false);
10211 }
10212 
10213 Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body,
10214                                     bool IsInstantiation) {
10215   FunctionDecl *FD = dcl ? dcl->getAsFunction() : nullptr;
10216 
10217   sema::AnalysisBasedWarnings::Policy WP = AnalysisWarnings.getDefaultPolicy();
10218   sema::AnalysisBasedWarnings::Policy *ActivePolicy = nullptr;
10219 
10220   if (FD) {
10221     FD->setBody(Body);
10222 
10223     if (getLangOpts().CPlusPlus14 && !FD->isInvalidDecl() && Body &&
10224         !FD->isDependentContext() && FD->getReturnType()->isUndeducedType()) {
10225       // If the function has a deduced result type but contains no 'return'
10226       // statements, the result type as written must be exactly 'auto', and
10227       // the deduced result type is 'void'.
10228       if (!FD->getReturnType()->getAs<AutoType>()) {
10229         Diag(dcl->getLocation(), diag::err_auto_fn_no_return_but_not_auto)
10230             << FD->getReturnType();
10231         FD->setInvalidDecl();
10232       } else {
10233         // Substitute 'void' for the 'auto' in the type.
10234         TypeLoc ResultType = FD->getTypeSourceInfo()->getTypeLoc().
10235             IgnoreParens().castAs<FunctionProtoTypeLoc>().getReturnLoc();
10236         Context.adjustDeducedFunctionResultType(
10237             FD, SubstAutoType(ResultType.getType(), Context.VoidTy));
10238       }
10239     }
10240 
10241     // The only way to be included in UndefinedButUsed is if there is an
10242     // ODR use before the definition. Avoid the expensive map lookup if this
10243     // is the first declaration.
10244     if (!FD->isFirstDecl() && FD->getPreviousDecl()->isUsed()) {
10245       if (!FD->isExternallyVisible())
10246         UndefinedButUsed.erase(FD);
10247       else if (FD->isInlined() &&
10248                (LangOpts.CPlusPlus || !LangOpts.GNUInline) &&
10249                (!FD->getPreviousDecl()->hasAttr<GNUInlineAttr>()))
10250         UndefinedButUsed.erase(FD);
10251     }
10252 
10253     // If the function implicitly returns zero (like 'main') or is naked,
10254     // don't complain about missing return statements.
10255     if (FD->hasImplicitReturnZero() || FD->hasAttr<NakedAttr>())
10256       WP.disableCheckFallThrough();
10257 
10258     // MSVC permits the use of pure specifier (=0) on function definition,
10259     // defined at class scope, warn about this non-standard construct.
10260     if (getLangOpts().MicrosoftExt && FD->isPure() && FD->isCanonicalDecl())
10261       Diag(FD->getLocation(), diag::ext_pure_function_definition);
10262 
10263     if (!FD->isInvalidDecl()) {
10264       // Don't diagnose unused parameters of defaulted or deleted functions.
10265       if (Body)
10266         DiagnoseUnusedParameters(FD->param_begin(), FD->param_end());
10267       DiagnoseSizeOfParametersAndReturnValue(FD->param_begin(), FD->param_end(),
10268                                              FD->getReturnType(), FD);
10269 
10270       // If this is a constructor, we need a vtable.
10271       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(FD))
10272         MarkVTableUsed(FD->getLocation(), Constructor->getParent());
10273 
10274       // Try to apply the named return value optimization. We have to check
10275       // if we can do this here because lambdas keep return statements around
10276       // to deduce an implicit return type.
10277       if (getLangOpts().CPlusPlus && FD->getReturnType()->isRecordType() &&
10278           !FD->isDependentContext())
10279         computeNRVO(Body, getCurFunction());
10280     }
10281 
10282     assert((FD == getCurFunctionDecl() || getCurLambda()->CallOperator == FD) &&
10283            "Function parsing confused");
10284   } else if (ObjCMethodDecl *MD = dyn_cast_or_null<ObjCMethodDecl>(dcl)) {
10285     assert(MD == getCurMethodDecl() && "Method parsing confused");
10286     MD->setBody(Body);
10287     if (!MD->isInvalidDecl()) {
10288       DiagnoseUnusedParameters(MD->param_begin(), MD->param_end());
10289       DiagnoseSizeOfParametersAndReturnValue(MD->param_begin(), MD->param_end(),
10290                                              MD->getReturnType(), MD);
10291 
10292       if (Body)
10293         computeNRVO(Body, getCurFunction());
10294     }
10295     if (getCurFunction()->ObjCShouldCallSuper) {
10296       Diag(MD->getLocEnd(), diag::warn_objc_missing_super_call)
10297         << MD->getSelector().getAsString();
10298       getCurFunction()->ObjCShouldCallSuper = false;
10299     }
10300     if (getCurFunction()->ObjCWarnForNoDesignatedInitChain) {
10301       const ObjCMethodDecl *InitMethod = nullptr;
10302       bool isDesignated =
10303           MD->isDesignatedInitializerForTheInterface(&InitMethod);
10304       assert(isDesignated && InitMethod);
10305       (void)isDesignated;
10306 
10307       auto superIsNSObject = [&](const ObjCMethodDecl *MD) {
10308         auto IFace = MD->getClassInterface();
10309         if (!IFace)
10310           return false;
10311         auto SuperD = IFace->getSuperClass();
10312         if (!SuperD)
10313           return false;
10314         return SuperD->getIdentifier() ==
10315             NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject);
10316       };
10317       // Don't issue this warning for unavailable inits or direct subclasses
10318       // of NSObject.
10319       if (!MD->isUnavailable() && !superIsNSObject(MD)) {
10320         Diag(MD->getLocation(),
10321              diag::warn_objc_designated_init_missing_super_call);
10322         Diag(InitMethod->getLocation(),
10323              diag::note_objc_designated_init_marked_here);
10324       }
10325       getCurFunction()->ObjCWarnForNoDesignatedInitChain = false;
10326     }
10327     if (getCurFunction()->ObjCWarnForNoInitDelegation) {
10328       // Don't issue this warning for unavaialable inits.
10329       if (!MD->isUnavailable())
10330         Diag(MD->getLocation(), diag::warn_objc_secondary_init_missing_init_call);
10331       getCurFunction()->ObjCWarnForNoInitDelegation = false;
10332     }
10333   } else {
10334     return nullptr;
10335   }
10336 
10337   assert(!getCurFunction()->ObjCShouldCallSuper &&
10338          "This should only be set for ObjC methods, which should have been "
10339          "handled in the block above.");
10340 
10341   // Verify and clean out per-function state.
10342   if (Body) {
10343     // C++ constructors that have function-try-blocks can't have return
10344     // statements in the handlers of that block. (C++ [except.handle]p14)
10345     // Verify this.
10346     if (FD && isa<CXXConstructorDecl>(FD) && isa<CXXTryStmt>(Body))
10347       DiagnoseReturnInConstructorExceptionHandler(cast<CXXTryStmt>(Body));
10348 
10349     // Verify that gotos and switch cases don't jump into scopes illegally.
10350     if (getCurFunction()->NeedsScopeChecking() &&
10351         !PP.isCodeCompletionEnabled())
10352       DiagnoseInvalidJumps(Body);
10353 
10354     if (CXXDestructorDecl *Destructor = dyn_cast<CXXDestructorDecl>(dcl)) {
10355       if (!Destructor->getParent()->isDependentType())
10356         CheckDestructor(Destructor);
10357 
10358       MarkBaseAndMemberDestructorsReferenced(Destructor->getLocation(),
10359                                              Destructor->getParent());
10360     }
10361 
10362     // If any errors have occurred, clear out any temporaries that may have
10363     // been leftover. This ensures that these temporaries won't be picked up for
10364     // deletion in some later function.
10365     if (getDiagnostics().hasErrorOccurred() ||
10366         getDiagnostics().getSuppressAllDiagnostics()) {
10367       DiscardCleanupsInEvaluationContext();
10368     }
10369     if (!getDiagnostics().hasUncompilableErrorOccurred() &&
10370         !isa<FunctionTemplateDecl>(dcl)) {
10371       // Since the body is valid, issue any analysis-based warnings that are
10372       // enabled.
10373       ActivePolicy = &WP;
10374     }
10375 
10376     if (!IsInstantiation && FD && FD->isConstexpr() && !FD->isInvalidDecl() &&
10377         (!CheckConstexprFunctionDecl(FD) ||
10378          !CheckConstexprFunctionBody(FD, Body)))
10379       FD->setInvalidDecl();
10380 
10381     assert(ExprCleanupObjects.empty() && "Leftover temporaries in function");
10382     assert(!ExprNeedsCleanups && "Unaccounted cleanups in function");
10383     assert(MaybeODRUseExprs.empty() &&
10384            "Leftover expressions for odr-use checking");
10385   }
10386 
10387   if (!IsInstantiation)
10388     PopDeclContext();
10389 
10390   PopFunctionScopeInfo(ActivePolicy, dcl);
10391   // If any errors have occurred, clear out any temporaries that may have
10392   // been leftover. This ensures that these temporaries won't be picked up for
10393   // deletion in some later function.
10394   if (getDiagnostics().hasErrorOccurred()) {
10395     DiscardCleanupsInEvaluationContext();
10396   }
10397 
10398   return dcl;
10399 }
10400 
10401 
10402 /// When we finish delayed parsing of an attribute, we must attach it to the
10403 /// relevant Decl.
10404 void Sema::ActOnFinishDelayedAttribute(Scope *S, Decl *D,
10405                                        ParsedAttributes &Attrs) {
10406   // Always attach attributes to the underlying decl.
10407   if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
10408     D = TD->getTemplatedDecl();
10409   ProcessDeclAttributeList(S, D, Attrs.getList());
10410 
10411   if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(D))
10412     if (Method->isStatic())
10413       checkThisInStaticMemberFunctionAttributes(Method);
10414 }
10415 
10416 
10417 /// ImplicitlyDefineFunction - An undeclared identifier was used in a function
10418 /// call, forming a call to an implicitly defined function (per C99 6.5.1p2).
10419 NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
10420                                           IdentifierInfo &II, Scope *S) {
10421   // Before we produce a declaration for an implicitly defined
10422   // function, see whether there was a locally-scoped declaration of
10423   // this name as a function or variable. If so, use that
10424   // (non-visible) declaration, and complain about it.
10425   if (NamedDecl *ExternCPrev = findLocallyScopedExternCDecl(&II)) {
10426     Diag(Loc, diag::warn_use_out_of_scope_declaration) << ExternCPrev;
10427     Diag(ExternCPrev->getLocation(), diag::note_previous_declaration);
10428     return ExternCPrev;
10429   }
10430 
10431   // Extension in C99.  Legal in C90, but warn about it.
10432   unsigned diag_id;
10433   if (II.getName().startswith("__builtin_"))
10434     diag_id = diag::warn_builtin_unknown;
10435   else if (getLangOpts().C99)
10436     diag_id = diag::ext_implicit_function_decl;
10437   else
10438     diag_id = diag::warn_implicit_function_decl;
10439   Diag(Loc, diag_id) << &II;
10440 
10441   // Because typo correction is expensive, only do it if the implicit
10442   // function declaration is going to be treated as an error.
10443   if (Diags.getDiagnosticLevel(diag_id, Loc) >= DiagnosticsEngine::Error) {
10444     TypoCorrection Corrected;
10445     DeclFilterCCC<FunctionDecl> Validator;
10446     if (S && (Corrected = CorrectTypo(DeclarationNameInfo(&II, Loc),
10447                                       LookupOrdinaryName, S, nullptr, Validator,
10448                                       CTK_NonError)))
10449       diagnoseTypo(Corrected, PDiag(diag::note_function_suggestion),
10450                    /*ErrorRecovery*/false);
10451   }
10452 
10453   // Set a Declarator for the implicit definition: int foo();
10454   const char *Dummy;
10455   AttributeFactory attrFactory;
10456   DeclSpec DS(attrFactory);
10457   unsigned DiagID;
10458   bool Error = DS.SetTypeSpecType(DeclSpec::TST_int, Loc, Dummy, DiagID,
10459                                   Context.getPrintingPolicy());
10460   (void)Error; // Silence warning.
10461   assert(!Error && "Error setting up implicit decl!");
10462   SourceLocation NoLoc;
10463   Declarator D(DS, Declarator::BlockContext);
10464   D.AddTypeInfo(DeclaratorChunk::getFunction(/*HasProto=*/false,
10465                                              /*IsAmbiguous=*/false,
10466                                              /*LParenLoc=*/NoLoc,
10467                                              /*Params=*/nullptr,
10468                                              /*NumParams=*/0,
10469                                              /*EllipsisLoc=*/NoLoc,
10470                                              /*RParenLoc=*/NoLoc,
10471                                              /*TypeQuals=*/0,
10472                                              /*RefQualifierIsLvalueRef=*/true,
10473                                              /*RefQualifierLoc=*/NoLoc,
10474                                              /*ConstQualifierLoc=*/NoLoc,
10475                                              /*VolatileQualifierLoc=*/NoLoc,
10476                                              /*MutableLoc=*/NoLoc,
10477                                              EST_None,
10478                                              /*ESpecLoc=*/NoLoc,
10479                                              /*Exceptions=*/nullptr,
10480                                              /*ExceptionRanges=*/nullptr,
10481                                              /*NumExceptions=*/0,
10482                                              /*NoexceptExpr=*/nullptr,
10483                                              Loc, Loc, D),
10484                 DS.getAttributes(),
10485                 SourceLocation());
10486   D.SetIdentifier(&II, Loc);
10487 
10488   // Insert this function into translation-unit scope.
10489 
10490   DeclContext *PrevDC = CurContext;
10491   CurContext = Context.getTranslationUnitDecl();
10492 
10493   FunctionDecl *FD = cast<FunctionDecl>(ActOnDeclarator(TUScope, D));
10494   FD->setImplicit();
10495 
10496   CurContext = PrevDC;
10497 
10498   AddKnownFunctionAttributes(FD);
10499 
10500   return FD;
10501 }
10502 
10503 /// \brief Adds any function attributes that we know a priori based on
10504 /// the declaration of this function.
10505 ///
10506 /// These attributes can apply both to implicitly-declared builtins
10507 /// (like __builtin___printf_chk) or to library-declared functions
10508 /// like NSLog or printf.
10509 ///
10510 /// We need to check for duplicate attributes both here and where user-written
10511 /// attributes are applied to declarations.
10512 void Sema::AddKnownFunctionAttributes(FunctionDecl *FD) {
10513   if (FD->isInvalidDecl())
10514     return;
10515 
10516   // If this is a built-in function, map its builtin attributes to
10517   // actual attributes.
10518   if (unsigned BuiltinID = FD->getBuiltinID()) {
10519     // Handle printf-formatting attributes.
10520     unsigned FormatIdx;
10521     bool HasVAListArg;
10522     if (Context.BuiltinInfo.isPrintfLike(BuiltinID, FormatIdx, HasVAListArg)) {
10523       if (!FD->hasAttr<FormatAttr>()) {
10524         const char *fmt = "printf";
10525         unsigned int NumParams = FD->getNumParams();
10526         if (FormatIdx < NumParams && // NumParams may be 0 (e.g. vfprintf)
10527             FD->getParamDecl(FormatIdx)->getType()->isObjCObjectPointerType())
10528           fmt = "NSString";
10529         FD->addAttr(FormatAttr::CreateImplicit(Context,
10530                                                &Context.Idents.get(fmt),
10531                                                FormatIdx+1,
10532                                                HasVAListArg ? 0 : FormatIdx+2,
10533                                                FD->getLocation()));
10534       }
10535     }
10536     if (Context.BuiltinInfo.isScanfLike(BuiltinID, FormatIdx,
10537                                              HasVAListArg)) {
10538      if (!FD->hasAttr<FormatAttr>())
10539        FD->addAttr(FormatAttr::CreateImplicit(Context,
10540                                               &Context.Idents.get("scanf"),
10541                                               FormatIdx+1,
10542                                               HasVAListArg ? 0 : FormatIdx+2,
10543                                               FD->getLocation()));
10544     }
10545 
10546     // Mark const if we don't care about errno and that is the only
10547     // thing preventing the function from being const. This allows
10548     // IRgen to use LLVM intrinsics for such functions.
10549     if (!getLangOpts().MathErrno &&
10550         Context.BuiltinInfo.isConstWithoutErrno(BuiltinID)) {
10551       if (!FD->hasAttr<ConstAttr>())
10552         FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
10553     }
10554 
10555     if (Context.BuiltinInfo.isReturnsTwice(BuiltinID) &&
10556         !FD->hasAttr<ReturnsTwiceAttr>())
10557       FD->addAttr(ReturnsTwiceAttr::CreateImplicit(Context,
10558                                          FD->getLocation()));
10559     if (Context.BuiltinInfo.isNoThrow(BuiltinID) && !FD->hasAttr<NoThrowAttr>())
10560       FD->addAttr(NoThrowAttr::CreateImplicit(Context, FD->getLocation()));
10561     if (Context.BuiltinInfo.isConst(BuiltinID) && !FD->hasAttr<ConstAttr>())
10562       FD->addAttr(ConstAttr::CreateImplicit(Context, FD->getLocation()));
10563   }
10564 
10565   IdentifierInfo *Name = FD->getIdentifier();
10566   if (!Name)
10567     return;
10568   if ((!getLangOpts().CPlusPlus &&
10569        FD->getDeclContext()->isTranslationUnit()) ||
10570       (isa<LinkageSpecDecl>(FD->getDeclContext()) &&
10571        cast<LinkageSpecDecl>(FD->getDeclContext())->getLanguage() ==
10572        LinkageSpecDecl::lang_c)) {
10573     // Okay: this could be a libc/libm/Objective-C function we know
10574     // about.
10575   } else
10576     return;
10577 
10578   if (Name->isStr("asprintf") || Name->isStr("vasprintf")) {
10579     // FIXME: asprintf and vasprintf aren't C99 functions. Should they be
10580     // target-specific builtins, perhaps?
10581     if (!FD->hasAttr<FormatAttr>())
10582       FD->addAttr(FormatAttr::CreateImplicit(Context,
10583                                              &Context.Idents.get("printf"), 2,
10584                                              Name->isStr("vasprintf") ? 0 : 3,
10585                                              FD->getLocation()));
10586   }
10587 
10588   if (Name->isStr("__CFStringMakeConstantString")) {
10589     // We already have a __builtin___CFStringMakeConstantString,
10590     // but builds that use -fno-constant-cfstrings don't go through that.
10591     if (!FD->hasAttr<FormatArgAttr>())
10592       FD->addAttr(FormatArgAttr::CreateImplicit(Context, 1,
10593                                                 FD->getLocation()));
10594   }
10595 }
10596 
10597 TypedefDecl *Sema::ParseTypedefDecl(Scope *S, Declarator &D, QualType T,
10598                                     TypeSourceInfo *TInfo) {
10599   assert(D.getIdentifier() && "Wrong callback for declspec without declarator");
10600   assert(!T.isNull() && "GetTypeForDeclarator() returned null type");
10601 
10602   if (!TInfo) {
10603     assert(D.isInvalidType() && "no declarator info for valid type");
10604     TInfo = Context.getTrivialTypeSourceInfo(T);
10605   }
10606 
10607   // Scope manipulation handled by caller.
10608   TypedefDecl *NewTD = TypedefDecl::Create(Context, CurContext,
10609                                            D.getLocStart(),
10610                                            D.getIdentifierLoc(),
10611                                            D.getIdentifier(),
10612                                            TInfo);
10613 
10614   // Bail out immediately if we have an invalid declaration.
10615   if (D.isInvalidType()) {
10616     NewTD->setInvalidDecl();
10617     return NewTD;
10618   }
10619 
10620   if (D.getDeclSpec().isModulePrivateSpecified()) {
10621     if (CurContext->isFunctionOrMethod())
10622       Diag(NewTD->getLocation(), diag::err_module_private_local)
10623         << 2 << NewTD->getDeclName()
10624         << SourceRange(D.getDeclSpec().getModulePrivateSpecLoc())
10625         << FixItHint::CreateRemoval(D.getDeclSpec().getModulePrivateSpecLoc());
10626     else
10627       NewTD->setModulePrivate();
10628   }
10629 
10630   // C++ [dcl.typedef]p8:
10631   //   If the typedef declaration defines an unnamed class (or
10632   //   enum), the first typedef-name declared by the declaration
10633   //   to be that class type (or enum type) is used to denote the
10634   //   class type (or enum type) for linkage purposes only.
10635   // We need to check whether the type was declared in the declaration.
10636   switch (D.getDeclSpec().getTypeSpecType()) {
10637   case TST_enum:
10638   case TST_struct:
10639   case TST_interface:
10640   case TST_union:
10641   case TST_class: {
10642     TagDecl *tagFromDeclSpec = cast<TagDecl>(D.getDeclSpec().getRepAsDecl());
10643 
10644     // Do nothing if the tag is not anonymous or already has an
10645     // associated typedef (from an earlier typedef in this decl group).
10646     if (tagFromDeclSpec->getIdentifier()) break;
10647     if (tagFromDeclSpec->getTypedefNameForAnonDecl()) break;
10648 
10649     // A well-formed anonymous tag must always be a TUK_Definition.
10650     assert(tagFromDeclSpec->isThisDeclarationADefinition());
10651 
10652     // The type must match the tag exactly;  no qualifiers allowed.
10653     if (!Context.hasSameType(T, Context.getTagDeclType(tagFromDeclSpec)))
10654       break;
10655 
10656     // If we've already computed linkage for the anonymous tag, then
10657     // adding a typedef name for the anonymous decl can change that
10658     // linkage, which might be a serious problem.  Diagnose this as
10659     // unsupported and ignore the typedef name.  TODO: we should
10660     // pursue this as a language defect and establish a formal rule
10661     // for how to handle it.
10662     if (tagFromDeclSpec->hasLinkageBeenComputed()) {
10663       Diag(D.getIdentifierLoc(), diag::err_typedef_changes_linkage);
10664 
10665       SourceLocation tagLoc = D.getDeclSpec().getTypeSpecTypeLoc();
10666       tagLoc = getLocForEndOfToken(tagLoc);
10667 
10668       llvm::SmallString<40> textToInsert;
10669       textToInsert += ' ';
10670       textToInsert += D.getIdentifier()->getName();
10671       Diag(tagLoc, diag::note_typedef_changes_linkage)
10672         << FixItHint::CreateInsertion(tagLoc, textToInsert);
10673       break;
10674     }
10675 
10676     // Otherwise, set this is the anon-decl typedef for the tag.
10677     tagFromDeclSpec->setTypedefNameForAnonDecl(NewTD);
10678     break;
10679   }
10680 
10681   default:
10682     break;
10683   }
10684 
10685   return NewTD;
10686 }
10687 
10688 
10689 /// \brief Check that this is a valid underlying type for an enum declaration.
10690 bool Sema::CheckEnumUnderlyingType(TypeSourceInfo *TI) {
10691   SourceLocation UnderlyingLoc = TI->getTypeLoc().getBeginLoc();
10692   QualType T = TI->getType();
10693 
10694   if (T->isDependentType())
10695     return false;
10696 
10697   if (const BuiltinType *BT = T->getAs<BuiltinType>())
10698     if (BT->isInteger())
10699       return false;
10700 
10701   Diag(UnderlyingLoc, diag::err_enum_invalid_underlying) << T;
10702   return true;
10703 }
10704 
10705 /// Check whether this is a valid redeclaration of a previous enumeration.
10706 /// \return true if the redeclaration was invalid.
10707 bool Sema::CheckEnumRedeclaration(SourceLocation EnumLoc, bool IsScoped,
10708                                   QualType EnumUnderlyingTy,
10709                                   const EnumDecl *Prev) {
10710   bool IsFixed = !EnumUnderlyingTy.isNull();
10711 
10712   if (IsScoped != Prev->isScoped()) {
10713     Diag(EnumLoc, diag::err_enum_redeclare_scoped_mismatch)
10714       << Prev->isScoped();
10715     Diag(Prev->getLocation(), diag::note_previous_declaration);
10716     return true;
10717   }
10718 
10719   if (IsFixed && Prev->isFixed()) {
10720     if (!EnumUnderlyingTy->isDependentType() &&
10721         !Prev->getIntegerType()->isDependentType() &&
10722         !Context.hasSameUnqualifiedType(EnumUnderlyingTy,
10723                                         Prev->getIntegerType())) {
10724       // TODO: Highlight the underlying type of the redeclaration.
10725       Diag(EnumLoc, diag::err_enum_redeclare_type_mismatch)
10726         << EnumUnderlyingTy << Prev->getIntegerType();
10727       Diag(Prev->getLocation(), diag::note_previous_declaration)
10728           << Prev->getIntegerTypeRange();
10729       return true;
10730     }
10731   } else if (IsFixed != Prev->isFixed()) {
10732     Diag(EnumLoc, diag::err_enum_redeclare_fixed_mismatch)
10733       << Prev->isFixed();
10734     Diag(Prev->getLocation(), diag::note_previous_declaration);
10735     return true;
10736   }
10737 
10738   return false;
10739 }
10740 
10741 /// \brief Get diagnostic %select index for tag kind for
10742 /// redeclaration diagnostic message.
10743 /// WARNING: Indexes apply to particular diagnostics only!
10744 ///
10745 /// \returns diagnostic %select index.
10746 static unsigned getRedeclDiagFromTagKind(TagTypeKind Tag) {
10747   switch (Tag) {
10748   case TTK_Struct: return 0;
10749   case TTK_Interface: return 1;
10750   case TTK_Class:  return 2;
10751   default: llvm_unreachable("Invalid tag kind for redecl diagnostic!");
10752   }
10753 }
10754 
10755 /// \brief Determine if tag kind is a class-key compatible with
10756 /// class for redeclaration (class, struct, or __interface).
10757 ///
10758 /// \returns true iff the tag kind is compatible.
10759 static bool isClassCompatTagKind(TagTypeKind Tag)
10760 {
10761   return Tag == TTK_Struct || Tag == TTK_Class || Tag == TTK_Interface;
10762 }
10763 
10764 /// \brief Determine whether a tag with a given kind is acceptable
10765 /// as a redeclaration of the given tag declaration.
10766 ///
10767 /// \returns true if the new tag kind is acceptable, false otherwise.
10768 bool Sema::isAcceptableTagRedeclaration(const TagDecl *Previous,
10769                                         TagTypeKind NewTag, bool isDefinition,
10770                                         SourceLocation NewTagLoc,
10771                                         const IdentifierInfo &Name) {
10772   // C++ [dcl.type.elab]p3:
10773   //   The class-key or enum keyword present in the
10774   //   elaborated-type-specifier shall agree in kind with the
10775   //   declaration to which the name in the elaborated-type-specifier
10776   //   refers. This rule also applies to the form of
10777   //   elaborated-type-specifier that declares a class-name or
10778   //   friend class since it can be construed as referring to the
10779   //   definition of the class. Thus, in any
10780   //   elaborated-type-specifier, the enum keyword shall be used to
10781   //   refer to an enumeration (7.2), the union class-key shall be
10782   //   used to refer to a union (clause 9), and either the class or
10783   //   struct class-key shall be used to refer to a class (clause 9)
10784   //   declared using the class or struct class-key.
10785   TagTypeKind OldTag = Previous->getTagKind();
10786   if (!isDefinition || !isClassCompatTagKind(NewTag))
10787     if (OldTag == NewTag)
10788       return true;
10789 
10790   if (isClassCompatTagKind(OldTag) && isClassCompatTagKind(NewTag)) {
10791     // Warn about the struct/class tag mismatch.
10792     bool isTemplate = false;
10793     if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Previous))
10794       isTemplate = Record->getDescribedClassTemplate();
10795 
10796     if (!ActiveTemplateInstantiations.empty()) {
10797       // In a template instantiation, do not offer fix-its for tag mismatches
10798       // since they usually mess up the template instead of fixing the problem.
10799       Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
10800         << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
10801         << getRedeclDiagFromTagKind(OldTag);
10802       return true;
10803     }
10804 
10805     if (isDefinition) {
10806       // On definitions, check previous tags and issue a fix-it for each
10807       // one that doesn't match the current tag.
10808       if (Previous->getDefinition()) {
10809         // Don't suggest fix-its for redefinitions.
10810         return true;
10811       }
10812 
10813       bool previousMismatch = false;
10814       for (auto I : Previous->redecls()) {
10815         if (I->getTagKind() != NewTag) {
10816           if (!previousMismatch) {
10817             previousMismatch = true;
10818             Diag(NewTagLoc, diag::warn_struct_class_previous_tag_mismatch)
10819               << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
10820               << getRedeclDiagFromTagKind(I->getTagKind());
10821           }
10822           Diag(I->getInnerLocStart(), diag::note_struct_class_suggestion)
10823             << getRedeclDiagFromTagKind(NewTag)
10824             << FixItHint::CreateReplacement(I->getInnerLocStart(),
10825                  TypeWithKeyword::getTagTypeKindName(NewTag));
10826         }
10827       }
10828       return true;
10829     }
10830 
10831     // Check for a previous definition.  If current tag and definition
10832     // are same type, do nothing.  If no definition, but disagree with
10833     // with previous tag type, give a warning, but no fix-it.
10834     const TagDecl *Redecl = Previous->getDefinition() ?
10835                             Previous->getDefinition() : Previous;
10836     if (Redecl->getTagKind() == NewTag) {
10837       return true;
10838     }
10839 
10840     Diag(NewTagLoc, diag::warn_struct_class_tag_mismatch)
10841       << getRedeclDiagFromTagKind(NewTag) << isTemplate << &Name
10842       << getRedeclDiagFromTagKind(OldTag);
10843     Diag(Redecl->getLocation(), diag::note_previous_use);
10844 
10845     // If there is a previous definition, suggest a fix-it.
10846     if (Previous->getDefinition()) {
10847         Diag(NewTagLoc, diag::note_struct_class_suggestion)
10848           << getRedeclDiagFromTagKind(Redecl->getTagKind())
10849           << FixItHint::CreateReplacement(SourceRange(NewTagLoc),
10850                TypeWithKeyword::getTagTypeKindName(Redecl->getTagKind()));
10851     }
10852 
10853     return true;
10854   }
10855   return false;
10856 }
10857 
10858 /// Add a minimal nested name specifier fixit hint to allow lookup of a tag name
10859 /// from an outer enclosing namespace or file scope inside a friend declaration.
10860 /// This should provide the commented out code in the following snippet:
10861 ///   namespace N {
10862 ///     struct X;
10863 ///     namespace M {
10864 ///       struct Y { friend struct /*N::*/ X; };
10865 ///     }
10866 ///   }
10867 static FixItHint createFriendTagNNSFixIt(Sema &SemaRef, NamedDecl *ND, Scope *S,
10868                                          SourceLocation NameLoc) {
10869   // While the decl is in a namespace, do repeated lookup of that name and see
10870   // if we get the same namespace back.  If we do not, continue until
10871   // translation unit scope, at which point we have a fully qualified NNS.
10872   SmallVector<IdentifierInfo *, 4> Namespaces;
10873   DeclContext *DC = ND->getDeclContext()->getRedeclContext();
10874   for (; !DC->isTranslationUnit(); DC = DC->getParent()) {
10875     // This tag should be declared in a namespace, which can only be enclosed by
10876     // other namespaces.  Bail if there's an anonymous namespace in the chain.
10877     NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(DC);
10878     if (!Namespace || Namespace->isAnonymousNamespace())
10879       return FixItHint();
10880     IdentifierInfo *II = Namespace->getIdentifier();
10881     Namespaces.push_back(II);
10882     NamedDecl *Lookup = SemaRef.LookupSingleName(
10883         S, II, NameLoc, Sema::LookupNestedNameSpecifierName);
10884     if (Lookup == Namespace)
10885       break;
10886   }
10887 
10888   // Once we have all the namespaces, reverse them to go outermost first, and
10889   // build an NNS.
10890   SmallString<64> Insertion;
10891   llvm::raw_svector_ostream OS(Insertion);
10892   if (DC->isTranslationUnit())
10893     OS << "::";
10894   std::reverse(Namespaces.begin(), Namespaces.end());
10895   for (auto *II : Namespaces)
10896     OS << II->getName() << "::";
10897   OS.flush();
10898   return FixItHint::CreateInsertion(NameLoc, Insertion);
10899 }
10900 
10901 /// ActOnTag - This is invoked when we see 'struct foo' or 'struct {'.  In the
10902 /// former case, Name will be non-null.  In the later case, Name will be null.
10903 /// TagSpec indicates what kind of tag this is. TUK indicates whether this is a
10904 /// reference/declaration/definition of a tag.
10905 ///
10906 /// IsTypeSpecifier is true if this is a type-specifier (or
10907 /// trailing-type-specifier) other than one in an alias-declaration.
10908 Decl *Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK,
10909                      SourceLocation KWLoc, CXXScopeSpec &SS,
10910                      IdentifierInfo *Name, SourceLocation NameLoc,
10911                      AttributeList *Attr, AccessSpecifier AS,
10912                      SourceLocation ModulePrivateLoc,
10913                      MultiTemplateParamsArg TemplateParameterLists,
10914                      bool &OwnedDecl, bool &IsDependent,
10915                      SourceLocation ScopedEnumKWLoc,
10916                      bool ScopedEnumUsesClassTag,
10917                      TypeResult UnderlyingType,
10918                      bool IsTypeSpecifier) {
10919   // If this is not a definition, it must have a name.
10920   IdentifierInfo *OrigName = Name;
10921   assert((Name != nullptr || TUK == TUK_Definition) &&
10922          "Nameless record must be a definition!");
10923   assert(TemplateParameterLists.size() == 0 || TUK != TUK_Reference);
10924 
10925   OwnedDecl = false;
10926   TagTypeKind Kind = TypeWithKeyword::getTagTypeKindForTypeSpec(TagSpec);
10927   bool ScopedEnum = ScopedEnumKWLoc.isValid();
10928 
10929   // FIXME: Check explicit specializations more carefully.
10930   bool isExplicitSpecialization = false;
10931   bool Invalid = false;
10932 
10933   // We only need to do this matching if we have template parameters
10934   // or a scope specifier, which also conveniently avoids this work
10935   // for non-C++ cases.
10936   if (TemplateParameterLists.size() > 0 ||
10937       (SS.isNotEmpty() && TUK != TUK_Reference)) {
10938     if (TemplateParameterList *TemplateParams =
10939             MatchTemplateParametersToScopeSpecifier(
10940                 KWLoc, NameLoc, SS, nullptr, TemplateParameterLists,
10941                 TUK == TUK_Friend, isExplicitSpecialization, Invalid)) {
10942       if (Kind == TTK_Enum) {
10943         Diag(KWLoc, diag::err_enum_template);
10944         return nullptr;
10945       }
10946 
10947       if (TemplateParams->size() > 0) {
10948         // This is a declaration or definition of a class template (which may
10949         // be a member of another template).
10950 
10951         if (Invalid)
10952           return nullptr;
10953 
10954         OwnedDecl = false;
10955         DeclResult Result = CheckClassTemplate(S, TagSpec, TUK, KWLoc,
10956                                                SS, Name, NameLoc, Attr,
10957                                                TemplateParams, AS,
10958                                                ModulePrivateLoc,
10959                                                /*FriendLoc*/SourceLocation(),
10960                                                TemplateParameterLists.size()-1,
10961                                                TemplateParameterLists.data());
10962         return Result.get();
10963       } else {
10964         // The "template<>" header is extraneous.
10965         Diag(TemplateParams->getTemplateLoc(), diag::err_template_tag_noparams)
10966           << TypeWithKeyword::getTagTypeKindName(Kind) << Name;
10967         isExplicitSpecialization = true;
10968       }
10969     }
10970   }
10971 
10972   // Figure out the underlying type if this a enum declaration. We need to do
10973   // this early, because it's needed to detect if this is an incompatible
10974   // redeclaration.
10975   llvm::PointerUnion<const Type*, TypeSourceInfo*> EnumUnderlying;
10976 
10977   if (Kind == TTK_Enum) {
10978     if (UnderlyingType.isInvalid() || (!UnderlyingType.get() && ScopedEnum))
10979       // No underlying type explicitly specified, or we failed to parse the
10980       // type, default to int.
10981       EnumUnderlying = Context.IntTy.getTypePtr();
10982     else if (UnderlyingType.get()) {
10983       // C++0x 7.2p2: The type-specifier-seq of an enum-base shall name an
10984       // integral type; any cv-qualification is ignored.
10985       TypeSourceInfo *TI = nullptr;
10986       GetTypeFromParser(UnderlyingType.get(), &TI);
10987       EnumUnderlying = TI;
10988 
10989       if (CheckEnumUnderlyingType(TI))
10990         // Recover by falling back to int.
10991         EnumUnderlying = Context.IntTy.getTypePtr();
10992 
10993       if (DiagnoseUnexpandedParameterPack(TI->getTypeLoc().getBeginLoc(), TI,
10994                                           UPPC_FixedUnderlyingType))
10995         EnumUnderlying = Context.IntTy.getTypePtr();
10996 
10997     } else if (getLangOpts().MSVCCompat)
10998       // Microsoft enums are always of int type.
10999       EnumUnderlying = Context.IntTy.getTypePtr();
11000   }
11001 
11002   DeclContext *SearchDC = CurContext;
11003   DeclContext *DC = CurContext;
11004   bool isStdBadAlloc = false;
11005 
11006   RedeclarationKind Redecl = ForRedeclaration;
11007   if (TUK == TUK_Friend || TUK == TUK_Reference)
11008     Redecl = NotForRedeclaration;
11009 
11010   LookupResult Previous(*this, Name, NameLoc, LookupTagName, Redecl);
11011   if (Name && SS.isNotEmpty()) {
11012     // We have a nested-name tag ('struct foo::bar').
11013 
11014     // Check for invalid 'foo::'.
11015     if (SS.isInvalid()) {
11016       Name = nullptr;
11017       goto CreateNewDecl;
11018     }
11019 
11020     // If this is a friend or a reference to a class in a dependent
11021     // context, don't try to make a decl for it.
11022     if (TUK == TUK_Friend || TUK == TUK_Reference) {
11023       DC = computeDeclContext(SS, false);
11024       if (!DC) {
11025         IsDependent = true;
11026         return nullptr;
11027       }
11028     } else {
11029       DC = computeDeclContext(SS, true);
11030       if (!DC) {
11031         Diag(SS.getRange().getBegin(), diag::err_dependent_nested_name_spec)
11032           << SS.getRange();
11033         return nullptr;
11034       }
11035     }
11036 
11037     if (RequireCompleteDeclContext(SS, DC))
11038       return nullptr;
11039 
11040     SearchDC = DC;
11041     // Look-up name inside 'foo::'.
11042     LookupQualifiedName(Previous, DC);
11043 
11044     if (Previous.isAmbiguous())
11045       return nullptr;
11046 
11047     if (Previous.empty()) {
11048       // Name lookup did not find anything. However, if the
11049       // nested-name-specifier refers to the current instantiation,
11050       // and that current instantiation has any dependent base
11051       // classes, we might find something at instantiation time: treat
11052       // this as a dependent elaborated-type-specifier.
11053       // But this only makes any sense for reference-like lookups.
11054       if (Previous.wasNotFoundInCurrentInstantiation() &&
11055           (TUK == TUK_Reference || TUK == TUK_Friend)) {
11056         IsDependent = true;
11057         return nullptr;
11058       }
11059 
11060       // A tag 'foo::bar' must already exist.
11061       Diag(NameLoc, diag::err_not_tag_in_scope)
11062         << Kind << Name << DC << SS.getRange();
11063       Name = nullptr;
11064       Invalid = true;
11065       goto CreateNewDecl;
11066     }
11067   } else if (Name) {
11068     // If this is a named struct, check to see if there was a previous forward
11069     // declaration or definition.
11070     // FIXME: We're looking into outer scopes here, even when we
11071     // shouldn't be. Doing so can result in ambiguities that we
11072     // shouldn't be diagnosing.
11073     LookupName(Previous, S);
11074 
11075     // When declaring or defining a tag, ignore ambiguities introduced
11076     // by types using'ed into this scope.
11077     if (Previous.isAmbiguous() &&
11078         (TUK == TUK_Definition || TUK == TUK_Declaration)) {
11079       LookupResult::Filter F = Previous.makeFilter();
11080       while (F.hasNext()) {
11081         NamedDecl *ND = F.next();
11082         if (ND->getDeclContext()->getRedeclContext() != SearchDC)
11083           F.erase();
11084       }
11085       F.done();
11086     }
11087 
11088     // C++11 [namespace.memdef]p3:
11089     //   If the name in a friend declaration is neither qualified nor
11090     //   a template-id and the declaration is a function or an
11091     //   elaborated-type-specifier, the lookup to determine whether
11092     //   the entity has been previously declared shall not consider
11093     //   any scopes outside the innermost enclosing namespace.
11094     //
11095     // MSVC doesn't implement the above rule for types, so a friend tag
11096     // declaration may be a redeclaration of a type declared in an enclosing
11097     // scope.  They do implement this rule for friend functions.
11098     //
11099     // Does it matter that this should be by scope instead of by
11100     // semantic context?
11101     if (!Previous.empty() && TUK == TUK_Friend) {
11102       DeclContext *EnclosingNS = SearchDC->getEnclosingNamespaceContext();
11103       LookupResult::Filter F = Previous.makeFilter();
11104       bool FriendSawTagOutsideEnclosingNamespace = false;
11105       while (F.hasNext()) {
11106         NamedDecl *ND = F.next();
11107         DeclContext *DC = ND->getDeclContext()->getRedeclContext();
11108         if (DC->isFileContext() &&
11109             !EnclosingNS->Encloses(ND->getDeclContext())) {
11110           if (getLangOpts().MSVCCompat)
11111             FriendSawTagOutsideEnclosingNamespace = true;
11112           else
11113             F.erase();
11114         }
11115       }
11116       F.done();
11117 
11118       // Diagnose this MSVC extension in the easy case where lookup would have
11119       // unambiguously found something outside the enclosing namespace.
11120       if (Previous.isSingleResult() && FriendSawTagOutsideEnclosingNamespace) {
11121         NamedDecl *ND = Previous.getFoundDecl();
11122         Diag(NameLoc, diag::ext_friend_tag_redecl_outside_namespace)
11123             << createFriendTagNNSFixIt(*this, ND, S, NameLoc);
11124       }
11125     }
11126 
11127     // Note:  there used to be some attempt at recovery here.
11128     if (Previous.isAmbiguous())
11129       return nullptr;
11130 
11131     if (!getLangOpts().CPlusPlus && TUK != TUK_Reference) {
11132       // FIXME: This makes sure that we ignore the contexts associated
11133       // with C structs, unions, and enums when looking for a matching
11134       // tag declaration or definition. See the similar lookup tweak
11135       // in Sema::LookupName; is there a better way to deal with this?
11136       while (isa<RecordDecl>(SearchDC) || isa<EnumDecl>(SearchDC))
11137         SearchDC = SearchDC->getParent();
11138     }
11139   }
11140 
11141   if (Previous.isSingleResult() &&
11142       Previous.getFoundDecl()->isTemplateParameter()) {
11143     // Maybe we will complain about the shadowed template parameter.
11144     DiagnoseTemplateParameterShadow(NameLoc, Previous.getFoundDecl());
11145     // Just pretend that we didn't see the previous declaration.
11146     Previous.clear();
11147   }
11148 
11149   if (getLangOpts().CPlusPlus && Name && DC && StdNamespace &&
11150       DC->Equals(getStdNamespace()) && Name->isStr("bad_alloc")) {
11151     // This is a declaration of or a reference to "std::bad_alloc".
11152     isStdBadAlloc = true;
11153 
11154     if (Previous.empty() && StdBadAlloc) {
11155       // std::bad_alloc has been implicitly declared (but made invisible to
11156       // name lookup). Fill in this implicit declaration as the previous
11157       // declaration, so that the declarations get chained appropriately.
11158       Previous.addDecl(getStdBadAlloc());
11159     }
11160   }
11161 
11162   // If we didn't find a previous declaration, and this is a reference
11163   // (or friend reference), move to the correct scope.  In C++, we
11164   // also need to do a redeclaration lookup there, just in case
11165   // there's a shadow friend decl.
11166   if (Name && Previous.empty() &&
11167       (TUK == TUK_Reference || TUK == TUK_Friend)) {
11168     if (Invalid) goto CreateNewDecl;
11169     assert(SS.isEmpty());
11170 
11171     if (TUK == TUK_Reference) {
11172       // C++ [basic.scope.pdecl]p5:
11173       //   -- for an elaborated-type-specifier of the form
11174       //
11175       //          class-key identifier
11176       //
11177       //      if the elaborated-type-specifier is used in the
11178       //      decl-specifier-seq or parameter-declaration-clause of a
11179       //      function defined in namespace scope, the identifier is
11180       //      declared as a class-name in the namespace that contains
11181       //      the declaration; otherwise, except as a friend
11182       //      declaration, the identifier is declared in the smallest
11183       //      non-class, non-function-prototype scope that contains the
11184       //      declaration.
11185       //
11186       // C99 6.7.2.3p8 has a similar (but not identical!) provision for
11187       // C structs and unions.
11188       //
11189       // It is an error in C++ to declare (rather than define) an enum
11190       // type, including via an elaborated type specifier.  We'll
11191       // diagnose that later; for now, declare the enum in the same
11192       // scope as we would have picked for any other tag type.
11193       //
11194       // GNU C also supports this behavior as part of its incomplete
11195       // enum types extension, while GNU C++ does not.
11196       //
11197       // Find the context where we'll be declaring the tag.
11198       // FIXME: We would like to maintain the current DeclContext as the
11199       // lexical context,
11200       while (!SearchDC->isFileContext() && !SearchDC->isFunctionOrMethod())
11201         SearchDC = SearchDC->getParent();
11202 
11203       // Find the scope where we'll be declaring the tag.
11204       while (S->isClassScope() ||
11205              (getLangOpts().CPlusPlus &&
11206               S->isFunctionPrototypeScope()) ||
11207              ((S->getFlags() & Scope::DeclScope) == 0) ||
11208              (S->getEntity() && S->getEntity()->isTransparentContext()))
11209         S = S->getParent();
11210     } else {
11211       assert(TUK == TUK_Friend);
11212       // C++ [namespace.memdef]p3:
11213       //   If a friend declaration in a non-local class first declares a
11214       //   class or function, the friend class or function is a member of
11215       //   the innermost enclosing namespace.
11216       SearchDC = SearchDC->getEnclosingNamespaceContext();
11217     }
11218 
11219     // In C++, we need to do a redeclaration lookup to properly
11220     // diagnose some problems.
11221     if (getLangOpts().CPlusPlus) {
11222       Previous.setRedeclarationKind(ForRedeclaration);
11223       LookupQualifiedName(Previous, SearchDC);
11224     }
11225   }
11226 
11227   if (!Previous.empty()) {
11228     NamedDecl *PrevDecl = Previous.getFoundDecl();
11229     NamedDecl *DirectPrevDecl =
11230         getLangOpts().MSVCCompat ? *Previous.begin() : PrevDecl;
11231 
11232     // It's okay to have a tag decl in the same scope as a typedef
11233     // which hides a tag decl in the same scope.  Finding this
11234     // insanity with a redeclaration lookup can only actually happen
11235     // in C++.
11236     //
11237     // This is also okay for elaborated-type-specifiers, which is
11238     // technically forbidden by the current standard but which is
11239     // okay according to the likely resolution of an open issue;
11240     // see http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#407
11241     if (getLangOpts().CPlusPlus) {
11242       if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(PrevDecl)) {
11243         if (const TagType *TT = TD->getUnderlyingType()->getAs<TagType>()) {
11244           TagDecl *Tag = TT->getDecl();
11245           if (Tag->getDeclName() == Name &&
11246               Tag->getDeclContext()->getRedeclContext()
11247                           ->Equals(TD->getDeclContext()->getRedeclContext())) {
11248             PrevDecl = Tag;
11249             Previous.clear();
11250             Previous.addDecl(Tag);
11251             Previous.resolveKind();
11252           }
11253         }
11254       }
11255     }
11256 
11257     if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {
11258       // If this is a use of a previous tag, or if the tag is already declared
11259       // in the same scope (so that the definition/declaration completes or
11260       // rementions the tag), reuse the decl.
11261       if (TUK == TUK_Reference || TUK == TUK_Friend ||
11262           isDeclInScope(DirectPrevDecl, SearchDC, S,
11263                         SS.isNotEmpty() || isExplicitSpecialization)) {
11264         // Make sure that this wasn't declared as an enum and now used as a
11265         // struct or something similar.
11266         if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind,
11267                                           TUK == TUK_Definition, KWLoc,
11268                                           *Name)) {
11269           bool SafeToContinue
11270             = (PrevTagDecl->getTagKind() != TTK_Enum &&
11271                Kind != TTK_Enum);
11272           if (SafeToContinue)
11273             Diag(KWLoc, diag::err_use_with_wrong_tag)
11274               << Name
11275               << FixItHint::CreateReplacement(SourceRange(KWLoc),
11276                                               PrevTagDecl->getKindName());
11277           else
11278             Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;
11279           Diag(PrevTagDecl->getLocation(), diag::note_previous_use);
11280 
11281           if (SafeToContinue)
11282             Kind = PrevTagDecl->getTagKind();
11283           else {
11284             // Recover by making this an anonymous redefinition.
11285             Name = nullptr;
11286             Previous.clear();
11287             Invalid = true;
11288           }
11289         }
11290 
11291         if (Kind == TTK_Enum && PrevTagDecl->getTagKind() == TTK_Enum) {
11292           const EnumDecl *PrevEnum = cast<EnumDecl>(PrevTagDecl);
11293 
11294           // If this is an elaborated-type-specifier for a scoped enumeration,
11295           // the 'class' keyword is not necessary and not permitted.
11296           if (TUK == TUK_Reference || TUK == TUK_Friend) {
11297             if (ScopedEnum)
11298               Diag(ScopedEnumKWLoc, diag::err_enum_class_reference)
11299                 << PrevEnum->isScoped()
11300                 << FixItHint::CreateRemoval(ScopedEnumKWLoc);
11301             return PrevTagDecl;
11302           }
11303 
11304           QualType EnumUnderlyingTy;
11305           if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
11306             EnumUnderlyingTy = TI->getType().getUnqualifiedType();
11307           else if (const Type *T = EnumUnderlying.dyn_cast<const Type*>())
11308             EnumUnderlyingTy = QualType(T, 0);
11309 
11310           // All conflicts with previous declarations are recovered by
11311           // returning the previous declaration, unless this is a definition,
11312           // in which case we want the caller to bail out.
11313           if (CheckEnumRedeclaration(NameLoc.isValid() ? NameLoc : KWLoc,
11314                                      ScopedEnum, EnumUnderlyingTy, PrevEnum))
11315             return TUK == TUK_Declaration ? PrevTagDecl : nullptr;
11316         }
11317 
11318         // C++11 [class.mem]p1:
11319         //   A member shall not be declared twice in the member-specification,
11320         //   except that a nested class or member class template can be declared
11321         //   and then later defined.
11322         if (TUK == TUK_Declaration && PrevDecl->isCXXClassMember() &&
11323             S->isDeclScope(PrevDecl)) {
11324           Diag(NameLoc, diag::ext_member_redeclared);
11325           Diag(PrevTagDecl->getLocation(), diag::note_previous_declaration);
11326         }
11327 
11328         if (!Invalid) {
11329           // If this is a use, just return the declaration we found, unless
11330           // we have attributes.
11331 
11332           // FIXME: In the future, return a variant or some other clue
11333           // for the consumer of this Decl to know it doesn't own it.
11334           // For our current ASTs this shouldn't be a problem, but will
11335           // need to be changed with DeclGroups.
11336           if (!Attr &&
11337               ((TUK == TUK_Reference &&
11338                 (!PrevTagDecl->getFriendObjectKind() || getLangOpts().MicrosoftExt))
11339                || TUK == TUK_Friend))
11340             return PrevTagDecl;
11341 
11342           // Diagnose attempts to redefine a tag.
11343           if (TUK == TUK_Definition) {
11344             if (TagDecl *Def = PrevTagDecl->getDefinition()) {
11345               // If we're defining a specialization and the previous definition
11346               // is from an implicit instantiation, don't emit an error
11347               // here; we'll catch this in the general case below.
11348               bool IsExplicitSpecializationAfterInstantiation = false;
11349               if (isExplicitSpecialization) {
11350                 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Def))
11351                   IsExplicitSpecializationAfterInstantiation =
11352                     RD->getTemplateSpecializationKind() !=
11353                     TSK_ExplicitSpecialization;
11354                 else if (EnumDecl *ED = dyn_cast<EnumDecl>(Def))
11355                   IsExplicitSpecializationAfterInstantiation =
11356                     ED->getTemplateSpecializationKind() !=
11357                     TSK_ExplicitSpecialization;
11358               }
11359 
11360               if (!IsExplicitSpecializationAfterInstantiation) {
11361                 // A redeclaration in function prototype scope in C isn't
11362                 // visible elsewhere, so merely issue a warning.
11363                 if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())
11364                   Diag(NameLoc, diag::warn_redefinition_in_param_list) << Name;
11365                 else
11366                   Diag(NameLoc, diag::err_redefinition) << Name;
11367                 Diag(Def->getLocation(), diag::note_previous_definition);
11368                 // If this is a redefinition, recover by making this
11369                 // struct be anonymous, which will make any later
11370                 // references get the previous definition.
11371                 Name = nullptr;
11372                 Previous.clear();
11373                 Invalid = true;
11374               }
11375             } else {
11376               // If the type is currently being defined, complain
11377               // about a nested redefinition.
11378               const TagType *Tag
11379                 = cast<TagType>(Context.getTagDeclType(PrevTagDecl));
11380               if (Tag->isBeingDefined()) {
11381                 Diag(NameLoc, diag::err_nested_redefinition) << Name;
11382                 Diag(PrevTagDecl->getLocation(),
11383                      diag::note_previous_definition);
11384                 Name = nullptr;
11385                 Previous.clear();
11386                 Invalid = true;
11387               }
11388             }
11389 
11390             // Okay, this is definition of a previously declared or referenced
11391             // tag. We're going to create a new Decl for it.
11392           }
11393 
11394           // Okay, we're going to make a redeclaration.  If this is some kind
11395           // of reference, make sure we build the redeclaration in the same DC
11396           // as the original, and ignore the current access specifier.
11397           if (TUK == TUK_Friend || TUK == TUK_Reference) {
11398             SearchDC = PrevTagDecl->getDeclContext();
11399             AS = AS_none;
11400           }
11401         }
11402         // If we get here we have (another) forward declaration or we
11403         // have a definition.  Just create a new decl.
11404 
11405       } else {
11406         // If we get here, this is a definition of a new tag type in a nested
11407         // scope, e.g. "struct foo; void bar() { struct foo; }", just create a
11408         // new decl/type.  We set PrevDecl to NULL so that the entities
11409         // have distinct types.
11410         Previous.clear();
11411       }
11412       // If we get here, we're going to create a new Decl. If PrevDecl
11413       // is non-NULL, it's a definition of the tag declared by
11414       // PrevDecl. If it's NULL, we have a new definition.
11415 
11416 
11417     // Otherwise, PrevDecl is not a tag, but was found with tag
11418     // lookup.  This is only actually possible in C++, where a few
11419     // things like templates still live in the tag namespace.
11420     } else {
11421       // Use a better diagnostic if an elaborated-type-specifier
11422       // found the wrong kind of type on the first
11423       // (non-redeclaration) lookup.
11424       if ((TUK == TUK_Reference || TUK == TUK_Friend) &&
11425           !Previous.isForRedeclaration()) {
11426         unsigned Kind = 0;
11427         if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
11428         else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11429         else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
11430         Diag(NameLoc, diag::err_tag_reference_non_tag) << Kind;
11431         Diag(PrevDecl->getLocation(), diag::note_declared_at);
11432         Invalid = true;
11433 
11434       // Otherwise, only diagnose if the declaration is in scope.
11435       } else if (!isDeclInScope(PrevDecl, SearchDC, S,
11436                                 SS.isNotEmpty() || isExplicitSpecialization)) {
11437         // do nothing
11438 
11439       // Diagnose implicit declarations introduced by elaborated types.
11440       } else if (TUK == TUK_Reference || TUK == TUK_Friend) {
11441         unsigned Kind = 0;
11442         if (isa<TypedefDecl>(PrevDecl)) Kind = 1;
11443         else if (isa<TypeAliasDecl>(PrevDecl)) Kind = 2;
11444         else if (isa<ClassTemplateDecl>(PrevDecl)) Kind = 3;
11445         Diag(NameLoc, diag::err_tag_reference_conflict) << Kind;
11446         Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11447         Invalid = true;
11448 
11449       // Otherwise it's a declaration.  Call out a particularly common
11450       // case here.
11451       } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {
11452         unsigned Kind = 0;
11453         if (isa<TypeAliasDecl>(PrevDecl)) Kind = 1;
11454         Diag(NameLoc, diag::err_tag_definition_of_typedef)
11455           << Name << Kind << TND->getUnderlyingType();
11456         Diag(PrevDecl->getLocation(), diag::note_previous_decl) << PrevDecl;
11457         Invalid = true;
11458 
11459       // Otherwise, diagnose.
11460       } else {
11461         // The tag name clashes with something else in the target scope,
11462         // issue an error and recover by making this tag be anonymous.
11463         Diag(NameLoc, diag::err_redefinition_different_kind) << Name;
11464         Diag(PrevDecl->getLocation(), diag::note_previous_definition);
11465         Name = nullptr;
11466         Invalid = true;
11467       }
11468 
11469       // The existing declaration isn't relevant to us; we're in a
11470       // new scope, so clear out the previous declaration.
11471       Previous.clear();
11472     }
11473   }
11474 
11475 CreateNewDecl:
11476 
11477   TagDecl *PrevDecl = nullptr;
11478   if (Previous.isSingleResult())
11479     PrevDecl = cast<TagDecl>(Previous.getFoundDecl());
11480 
11481   // If there is an identifier, use the location of the identifier as the
11482   // location of the decl, otherwise use the location of the struct/union
11483   // keyword.
11484   SourceLocation Loc = NameLoc.isValid() ? NameLoc : KWLoc;
11485 
11486   // Otherwise, create a new declaration. If there is a previous
11487   // declaration of the same entity, the two will be linked via
11488   // PrevDecl.
11489   TagDecl *New;
11490 
11491   bool IsForwardReference = false;
11492   if (Kind == TTK_Enum) {
11493     // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
11494     // enum X { A, B, C } D;    D should chain to X.
11495     New = EnumDecl::Create(Context, SearchDC, KWLoc, Loc, Name,
11496                            cast_or_null<EnumDecl>(PrevDecl), ScopedEnum,
11497                            ScopedEnumUsesClassTag, !EnumUnderlying.isNull());
11498     // If this is an undefined enum, warn.
11499     if (TUK != TUK_Definition && !Invalid) {
11500       TagDecl *Def;
11501       if ((getLangOpts().CPlusPlus11 || getLangOpts().ObjC2) &&
11502           cast<EnumDecl>(New)->isFixed()) {
11503         // C++0x: 7.2p2: opaque-enum-declaration.
11504         // Conflicts are diagnosed above. Do nothing.
11505       }
11506       else if (PrevDecl && (Def = cast<EnumDecl>(PrevDecl)->getDefinition())) {
11507         Diag(Loc, diag::ext_forward_ref_enum_def)
11508           << New;
11509         Diag(Def->getLocation(), diag::note_previous_definition);
11510       } else {
11511         unsigned DiagID = diag::ext_forward_ref_enum;
11512         if (getLangOpts().MSVCCompat)
11513           DiagID = diag::ext_ms_forward_ref_enum;
11514         else if (getLangOpts().CPlusPlus)
11515           DiagID = diag::err_forward_ref_enum;
11516         Diag(Loc, DiagID);
11517 
11518         // If this is a forward-declared reference to an enumeration, make a
11519         // note of it; we won't actually be introducing the declaration into
11520         // the declaration context.
11521         if (TUK == TUK_Reference)
11522           IsForwardReference = true;
11523       }
11524     }
11525 
11526     if (EnumUnderlying) {
11527       EnumDecl *ED = cast<EnumDecl>(New);
11528       if (TypeSourceInfo *TI = EnumUnderlying.dyn_cast<TypeSourceInfo*>())
11529         ED->setIntegerTypeSourceInfo(TI);
11530       else
11531         ED->setIntegerType(QualType(EnumUnderlying.get<const Type*>(), 0));
11532       ED->setPromotionType(ED->getIntegerType());
11533     }
11534 
11535   } else {
11536     // struct/union/class
11537 
11538     // FIXME: Tag decls should be chained to any simultaneous vardecls, e.g.:
11539     // struct X { int A; } D;    D should chain to X.
11540     if (getLangOpts().CPlusPlus) {
11541       // FIXME: Look for a way to use RecordDecl for simple structs.
11542       New = CXXRecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
11543                                   cast_or_null<CXXRecordDecl>(PrevDecl));
11544 
11545       if (isStdBadAlloc && (!StdBadAlloc || getStdBadAlloc()->isImplicit()))
11546         StdBadAlloc = cast<CXXRecordDecl>(New);
11547     } else
11548       New = RecordDecl::Create(Context, Kind, SearchDC, KWLoc, Loc, Name,
11549                                cast_or_null<RecordDecl>(PrevDecl));
11550   }
11551 
11552   // C++11 [dcl.type]p3:
11553   //   A type-specifier-seq shall not define a class or enumeration [...].
11554   if (getLangOpts().CPlusPlus && IsTypeSpecifier && TUK == TUK_Definition) {
11555     Diag(New->getLocation(), diag::err_type_defined_in_type_specifier)
11556       << Context.getTagDeclType(New);
11557     Invalid = true;
11558   }
11559 
11560   // Maybe add qualifier info.
11561   if (SS.isNotEmpty()) {
11562     if (SS.isSet()) {
11563       // If this is either a declaration or a definition, check the
11564       // nested-name-specifier against the current context. We don't do this
11565       // for explicit specializations, because they have similar checking
11566       // (with more specific diagnostics) in the call to
11567       // CheckMemberSpecialization, below.
11568       if (!isExplicitSpecialization &&
11569           (TUK == TUK_Definition || TUK == TUK_Declaration) &&
11570           diagnoseQualifiedDeclaration(SS, DC, OrigName, NameLoc))
11571         Invalid = true;
11572 
11573       New->setQualifierInfo(SS.getWithLocInContext(Context));
11574       if (TemplateParameterLists.size() > 0) {
11575         New->setTemplateParameterListsInfo(Context,
11576                                            TemplateParameterLists.size(),
11577                                            TemplateParameterLists.data());
11578       }
11579     }
11580     else
11581       Invalid = true;
11582   }
11583 
11584   if (RecordDecl *RD = dyn_cast<RecordDecl>(New)) {
11585     // Add alignment attributes if necessary; these attributes are checked when
11586     // the ASTContext lays out the structure.
11587     //
11588     // It is important for implementing the correct semantics that this
11589     // happen here (in act on tag decl). The #pragma pack stack is
11590     // maintained as a result of parser callbacks which can occur at
11591     // many points during the parsing of a struct declaration (because
11592     // the #pragma tokens are effectively skipped over during the
11593     // parsing of the struct).
11594     if (TUK == TUK_Definition) {
11595       AddAlignmentAttributesForRecord(RD);
11596       AddMsStructLayoutForRecord(RD);
11597     }
11598   }
11599 
11600   if (ModulePrivateLoc.isValid()) {
11601     if (isExplicitSpecialization)
11602       Diag(New->getLocation(), diag::err_module_private_specialization)
11603         << 2
11604         << FixItHint::CreateRemoval(ModulePrivateLoc);
11605     // __module_private__ does not apply to local classes. However, we only
11606     // diagnose this as an error when the declaration specifiers are
11607     // freestanding. Here, we just ignore the __module_private__.
11608     else if (!SearchDC->isFunctionOrMethod())
11609       New->setModulePrivate();
11610   }
11611 
11612   // If this is a specialization of a member class (of a class template),
11613   // check the specialization.
11614   if (isExplicitSpecialization && CheckMemberSpecialization(New, Previous))
11615     Invalid = true;
11616 
11617   // If we're declaring or defining a tag in function prototype scope in C,
11618   // note that this type can only be used within the function and add it to
11619   // the list of decls to inject into the function definition scope.
11620   if ((Name || Kind == TTK_Enum) &&
11621       getNonFieldDeclScope(S)->isFunctionPrototypeScope()) {
11622     if (getLangOpts().CPlusPlus) {
11623       // C++ [dcl.fct]p6:
11624       //   Types shall not be defined in return or parameter types.
11625       if (TUK == TUK_Definition && !IsTypeSpecifier) {
11626         Diag(Loc, diag::err_type_defined_in_param_type)
11627             << Name;
11628         Invalid = true;
11629       }
11630     } else {
11631       Diag(Loc, diag::warn_decl_in_param_list) << Context.getTagDeclType(New);
11632     }
11633     DeclsInPrototypeScope.push_back(New);
11634   }
11635 
11636   if (Invalid)
11637     New->setInvalidDecl();
11638 
11639   if (Attr)
11640     ProcessDeclAttributeList(S, New, Attr);
11641 
11642   // Set the lexical context. If the tag has a C++ scope specifier, the
11643   // lexical context will be different from the semantic context.
11644   New->setLexicalDeclContext(CurContext);
11645 
11646   // Mark this as a friend decl if applicable.
11647   // In Microsoft mode, a friend declaration also acts as a forward
11648   // declaration so we always pass true to setObjectOfFriendDecl to make
11649   // the tag name visible.
11650   if (TUK == TUK_Friend)
11651     New->setObjectOfFriendDecl(getLangOpts().MSVCCompat);
11652 
11653   // Set the access specifier.
11654   if (!Invalid && SearchDC->isRecord())
11655     SetMemberAccessSpecifier(New, PrevDecl, AS);
11656 
11657   if (TUK == TUK_Definition)
11658     New->startDefinition();
11659 
11660   // If this has an identifier, add it to the scope stack.
11661   if (TUK == TUK_Friend) {
11662     // We might be replacing an existing declaration in the lookup tables;
11663     // if so, borrow its access specifier.
11664     if (PrevDecl)
11665       New->setAccess(PrevDecl->getAccess());
11666 
11667     DeclContext *DC = New->getDeclContext()->getRedeclContext();
11668     DC->makeDeclVisibleInContext(New);
11669     if (Name) // can be null along some error paths
11670       if (Scope *EnclosingScope = getScopeForDeclContext(S, DC))
11671         PushOnScopeChains(New, EnclosingScope, /* AddToContext = */ false);
11672   } else if (Name) {
11673     S = getNonFieldDeclScope(S);
11674     PushOnScopeChains(New, S, !IsForwardReference);
11675     if (IsForwardReference)
11676       SearchDC->makeDeclVisibleInContext(New);
11677 
11678   } else {
11679     CurContext->addDecl(New);
11680   }
11681 
11682   // If this is the C FILE type, notify the AST context.
11683   if (IdentifierInfo *II = New->getIdentifier())
11684     if (!New->isInvalidDecl() &&
11685         New->getDeclContext()->getRedeclContext()->isTranslationUnit() &&
11686         II->isStr("FILE"))
11687       Context.setFILEDecl(New);
11688 
11689   if (PrevDecl)
11690     mergeDeclAttributes(New, PrevDecl);
11691 
11692   // If there's a #pragma GCC visibility in scope, set the visibility of this
11693   // record.
11694   AddPushedVisibilityAttribute(New);
11695 
11696   OwnedDecl = true;
11697   // In C++, don't return an invalid declaration. We can't recover well from
11698   // the cases where we make the type anonymous.
11699   return (Invalid && getLangOpts().CPlusPlus) ? nullptr : New;
11700 }
11701 
11702 void Sema::ActOnTagStartDefinition(Scope *S, Decl *TagD) {
11703   AdjustDeclIfTemplate(TagD);
11704   TagDecl *Tag = cast<TagDecl>(TagD);
11705 
11706   // Enter the tag context.
11707   PushDeclContext(S, Tag);
11708 
11709   ActOnDocumentableDecl(TagD);
11710 
11711   // If there's a #pragma GCC visibility in scope, set the visibility of this
11712   // record.
11713   AddPushedVisibilityAttribute(Tag);
11714 }
11715 
11716 Decl *Sema::ActOnObjCContainerStartDefinition(Decl *IDecl) {
11717   assert(isa<ObjCContainerDecl>(IDecl) &&
11718          "ActOnObjCContainerStartDefinition - Not ObjCContainerDecl");
11719   DeclContext *OCD = cast<DeclContext>(IDecl);
11720   assert(getContainingDC(OCD) == CurContext &&
11721       "The next DeclContext should be lexically contained in the current one.");
11722   CurContext = OCD;
11723   return IDecl;
11724 }
11725 
11726 void Sema::ActOnStartCXXMemberDeclarations(Scope *S, Decl *TagD,
11727                                            SourceLocation FinalLoc,
11728                                            bool IsFinalSpelledSealed,
11729                                            SourceLocation LBraceLoc) {
11730   AdjustDeclIfTemplate(TagD);
11731   CXXRecordDecl *Record = cast<CXXRecordDecl>(TagD);
11732 
11733   FieldCollector->StartClass();
11734 
11735   if (!Record->getIdentifier())
11736     return;
11737 
11738   if (FinalLoc.isValid())
11739     Record->addAttr(new (Context)
11740                     FinalAttr(FinalLoc, Context, IsFinalSpelledSealed));
11741 
11742   // C++ [class]p2:
11743   //   [...] The class-name is also inserted into the scope of the
11744   //   class itself; this is known as the injected-class-name. For
11745   //   purposes of access checking, the injected-class-name is treated
11746   //   as if it were a public member name.
11747   CXXRecordDecl *InjectedClassName
11748     = CXXRecordDecl::Create(Context, Record->getTagKind(), CurContext,
11749                             Record->getLocStart(), Record->getLocation(),
11750                             Record->getIdentifier(),
11751                             /*PrevDecl=*/nullptr,
11752                             /*DelayTypeCreation=*/true);
11753   Context.getTypeDeclType(InjectedClassName, Record);
11754   InjectedClassName->setImplicit();
11755   InjectedClassName->setAccess(AS_public);
11756   if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate())
11757       InjectedClassName->setDescribedClassTemplate(Template);
11758   PushOnScopeChains(InjectedClassName, S);
11759   assert(InjectedClassName->isInjectedClassName() &&
11760          "Broken injected-class-name");
11761 }
11762 
11763 void Sema::ActOnTagFinishDefinition(Scope *S, Decl *TagD,
11764                                     SourceLocation RBraceLoc) {
11765   AdjustDeclIfTemplate(TagD);
11766   TagDecl *Tag = cast<TagDecl>(TagD);
11767   Tag->setRBraceLoc(RBraceLoc);
11768 
11769   // Make sure we "complete" the definition even it is invalid.
11770   if (Tag->isBeingDefined()) {
11771     assert(Tag->isInvalidDecl() && "We should already have completed it");
11772     if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
11773       RD->completeDefinition();
11774   }
11775 
11776   if (isa<CXXRecordDecl>(Tag))
11777     FieldCollector->FinishClass();
11778 
11779   // Exit this scope of this tag's definition.
11780   PopDeclContext();
11781 
11782   if (getCurLexicalContext()->isObjCContainer() &&
11783       Tag->getDeclContext()->isFileContext())
11784     Tag->setTopLevelDeclInObjCContainer();
11785 
11786   // Notify the consumer that we've defined a tag.
11787   if (!Tag->isInvalidDecl())
11788     Consumer.HandleTagDeclDefinition(Tag);
11789 }
11790 
11791 void Sema::ActOnObjCContainerFinishDefinition() {
11792   // Exit this scope of this interface definition.
11793   PopDeclContext();
11794 }
11795 
11796 void Sema::ActOnObjCTemporaryExitContainerContext(DeclContext *DC) {
11797   assert(DC == CurContext && "Mismatch of container contexts");
11798   OriginalLexicalContext = DC;
11799   ActOnObjCContainerFinishDefinition();
11800 }
11801 
11802 void Sema::ActOnObjCReenterContainerContext(DeclContext *DC) {
11803   ActOnObjCContainerStartDefinition(cast<Decl>(DC));
11804   OriginalLexicalContext = nullptr;
11805 }
11806 
11807 void Sema::ActOnTagDefinitionError(Scope *S, Decl *TagD) {
11808   AdjustDeclIfTemplate(TagD);
11809   TagDecl *Tag = cast<TagDecl>(TagD);
11810   Tag->setInvalidDecl();
11811 
11812   // Make sure we "complete" the definition even it is invalid.
11813   if (Tag->isBeingDefined()) {
11814     if (RecordDecl *RD = dyn_cast<RecordDecl>(Tag))
11815       RD->completeDefinition();
11816   }
11817 
11818   // We're undoing ActOnTagStartDefinition here, not
11819   // ActOnStartCXXMemberDeclarations, so we don't have to mess with
11820   // the FieldCollector.
11821 
11822   PopDeclContext();
11823 }
11824 
11825 // Note that FieldName may be null for anonymous bitfields.
11826 ExprResult Sema::VerifyBitField(SourceLocation FieldLoc,
11827                                 IdentifierInfo *FieldName,
11828                                 QualType FieldTy, bool IsMsStruct,
11829                                 Expr *BitWidth, bool *ZeroWidth) {
11830   // Default to true; that shouldn't confuse checks for emptiness
11831   if (ZeroWidth)
11832     *ZeroWidth = true;
11833 
11834   // C99 6.7.2.1p4 - verify the field type.
11835   // C++ 9.6p3: A bit-field shall have integral or enumeration type.
11836   if (!FieldTy->isDependentType() && !FieldTy->isIntegralOrEnumerationType()) {
11837     // Handle incomplete types with specific error.
11838     if (RequireCompleteType(FieldLoc, FieldTy, diag::err_field_incomplete))
11839       return ExprError();
11840     if (FieldName)
11841       return Diag(FieldLoc, diag::err_not_integral_type_bitfield)
11842         << FieldName << FieldTy << BitWidth->getSourceRange();
11843     return Diag(FieldLoc, diag::err_not_integral_type_anon_bitfield)
11844       << FieldTy << BitWidth->getSourceRange();
11845   } else if (DiagnoseUnexpandedParameterPack(const_cast<Expr *>(BitWidth),
11846                                              UPPC_BitFieldWidth))
11847     return ExprError();
11848 
11849   // If the bit-width is type- or value-dependent, don't try to check
11850   // it now.
11851   if (BitWidth->isValueDependent() || BitWidth->isTypeDependent())
11852     return BitWidth;
11853 
11854   llvm::APSInt Value;
11855   ExprResult ICE = VerifyIntegerConstantExpression(BitWidth, &Value);
11856   if (ICE.isInvalid())
11857     return ICE;
11858   BitWidth = ICE.get();
11859 
11860   if (Value != 0 && ZeroWidth)
11861     *ZeroWidth = false;
11862 
11863   // Zero-width bitfield is ok for anonymous field.
11864   if (Value == 0 && FieldName)
11865     return Diag(FieldLoc, diag::err_bitfield_has_zero_width) << FieldName;
11866 
11867   if (Value.isSigned() && Value.isNegative()) {
11868     if (FieldName)
11869       return Diag(FieldLoc, diag::err_bitfield_has_negative_width)
11870                << FieldName << Value.toString(10);
11871     return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width)
11872       << Value.toString(10);
11873   }
11874 
11875   if (!FieldTy->isDependentType()) {
11876     uint64_t TypeSize = Context.getTypeSize(FieldTy);
11877     if (Value.getZExtValue() > TypeSize) {
11878       if (!getLangOpts().CPlusPlus || IsMsStruct ||
11879           Context.getTargetInfo().getCXXABI().isMicrosoft()) {
11880         if (FieldName)
11881           return Diag(FieldLoc, diag::err_bitfield_width_exceeds_type_size)
11882             << FieldName << (unsigned)Value.getZExtValue()
11883             << (unsigned)TypeSize;
11884 
11885         return Diag(FieldLoc, diag::err_anon_bitfield_width_exceeds_type_size)
11886           << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
11887       }
11888 
11889       if (FieldName)
11890         Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_size)
11891           << FieldName << (unsigned)Value.getZExtValue()
11892           << (unsigned)TypeSize;
11893       else
11894         Diag(FieldLoc, diag::warn_anon_bitfield_width_exceeds_type_size)
11895           << (unsigned)Value.getZExtValue() << (unsigned)TypeSize;
11896     }
11897   }
11898 
11899   return BitWidth;
11900 }
11901 
11902 /// ActOnField - Each field of a C struct/union is passed into this in order
11903 /// to create a FieldDecl object for it.
11904 Decl *Sema::ActOnField(Scope *S, Decl *TagD, SourceLocation DeclStart,
11905                        Declarator &D, Expr *BitfieldWidth) {
11906   FieldDecl *Res = HandleField(S, cast_or_null<RecordDecl>(TagD),
11907                                DeclStart, D, static_cast<Expr*>(BitfieldWidth),
11908                                /*InitStyle=*/ICIS_NoInit, AS_public);
11909   return Res;
11910 }
11911 
11912 /// HandleField - Analyze a field of a C struct or a C++ data member.
11913 ///
11914 FieldDecl *Sema::HandleField(Scope *S, RecordDecl *Record,
11915                              SourceLocation DeclStart,
11916                              Declarator &D, Expr *BitWidth,
11917                              InClassInitStyle InitStyle,
11918                              AccessSpecifier AS) {
11919   IdentifierInfo *II = D.getIdentifier();
11920   SourceLocation Loc = DeclStart;
11921   if (II) Loc = D.getIdentifierLoc();
11922 
11923   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
11924   QualType T = TInfo->getType();
11925   if (getLangOpts().CPlusPlus) {
11926     CheckExtraCXXDefaultArguments(D);
11927 
11928     if (DiagnoseUnexpandedParameterPack(D.getIdentifierLoc(), TInfo,
11929                                         UPPC_DataMemberType)) {
11930       D.setInvalidType();
11931       T = Context.IntTy;
11932       TInfo = Context.getTrivialTypeSourceInfo(T, Loc);
11933     }
11934   }
11935 
11936   // TR 18037 does not allow fields to be declared with address spaces.
11937   if (T.getQualifiers().hasAddressSpace()) {
11938     Diag(Loc, diag::err_field_with_address_space);
11939     D.setInvalidType();
11940   }
11941 
11942   // OpenCL 1.2 spec, s6.9 r:
11943   // The event type cannot be used to declare a structure or union field.
11944   if (LangOpts.OpenCL && T->isEventT()) {
11945     Diag(Loc, diag::err_event_t_struct_field);
11946     D.setInvalidType();
11947   }
11948 
11949   DiagnoseFunctionSpecifiers(D.getDeclSpec());
11950 
11951   if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
11952     Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
11953          diag::err_invalid_thread)
11954       << DeclSpec::getSpecifierName(TSCS);
11955 
11956   // Check to see if this name was declared as a member previously
11957   NamedDecl *PrevDecl = nullptr;
11958   LookupResult Previous(*this, II, Loc, LookupMemberName, ForRedeclaration);
11959   LookupName(Previous, S);
11960   switch (Previous.getResultKind()) {
11961     case LookupResult::Found:
11962     case LookupResult::FoundUnresolvedValue:
11963       PrevDecl = Previous.getAsSingle<NamedDecl>();
11964       break;
11965 
11966     case LookupResult::FoundOverloaded:
11967       PrevDecl = Previous.getRepresentativeDecl();
11968       break;
11969 
11970     case LookupResult::NotFound:
11971     case LookupResult::NotFoundInCurrentInstantiation:
11972     case LookupResult::Ambiguous:
11973       break;
11974   }
11975   Previous.suppressDiagnostics();
11976 
11977   if (PrevDecl && PrevDecl->isTemplateParameter()) {
11978     // Maybe we will complain about the shadowed template parameter.
11979     DiagnoseTemplateParameterShadow(D.getIdentifierLoc(), PrevDecl);
11980     // Just pretend that we didn't see the previous declaration.
11981     PrevDecl = nullptr;
11982   }
11983 
11984   if (PrevDecl && !isDeclInScope(PrevDecl, Record, S))
11985     PrevDecl = nullptr;
11986 
11987   bool Mutable
11988     = (D.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_mutable);
11989   SourceLocation TSSL = D.getLocStart();
11990   FieldDecl *NewFD
11991     = CheckFieldDecl(II, T, TInfo, Record, Loc, Mutable, BitWidth, InitStyle,
11992                      TSSL, AS, PrevDecl, &D);
11993 
11994   if (NewFD->isInvalidDecl())
11995     Record->setInvalidDecl();
11996 
11997   if (D.getDeclSpec().isModulePrivateSpecified())
11998     NewFD->setModulePrivate();
11999 
12000   if (NewFD->isInvalidDecl() && PrevDecl) {
12001     // Don't introduce NewFD into scope; there's already something
12002     // with the same name in the same scope.
12003   } else if (II) {
12004     PushOnScopeChains(NewFD, S);
12005   } else
12006     Record->addDecl(NewFD);
12007 
12008   return NewFD;
12009 }
12010 
12011 /// \brief Build a new FieldDecl and check its well-formedness.
12012 ///
12013 /// This routine builds a new FieldDecl given the fields name, type,
12014 /// record, etc. \p PrevDecl should refer to any previous declaration
12015 /// with the same name and in the same scope as the field to be
12016 /// created.
12017 ///
12018 /// \returns a new FieldDecl.
12019 ///
12020 /// \todo The Declarator argument is a hack. It will be removed once
12021 FieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T,
12022                                 TypeSourceInfo *TInfo,
12023                                 RecordDecl *Record, SourceLocation Loc,
12024                                 bool Mutable, Expr *BitWidth,
12025                                 InClassInitStyle InitStyle,
12026                                 SourceLocation TSSL,
12027                                 AccessSpecifier AS, NamedDecl *PrevDecl,
12028                                 Declarator *D) {
12029   IdentifierInfo *II = Name.getAsIdentifierInfo();
12030   bool InvalidDecl = false;
12031   if (D) InvalidDecl = D->isInvalidType();
12032 
12033   // If we receive a broken type, recover by assuming 'int' and
12034   // marking this declaration as invalid.
12035   if (T.isNull()) {
12036     InvalidDecl = true;
12037     T = Context.IntTy;
12038   }
12039 
12040   QualType EltTy = Context.getBaseElementType(T);
12041   if (!EltTy->isDependentType()) {
12042     if (RequireCompleteType(Loc, EltTy, diag::err_field_incomplete)) {
12043       // Fields of incomplete type force their record to be invalid.
12044       Record->setInvalidDecl();
12045       InvalidDecl = true;
12046     } else {
12047       NamedDecl *Def;
12048       EltTy->isIncompleteType(&Def);
12049       if (Def && Def->isInvalidDecl()) {
12050         Record->setInvalidDecl();
12051         InvalidDecl = true;
12052       }
12053     }
12054   }
12055 
12056   // OpenCL v1.2 s6.9.c: bitfields are not supported.
12057   if (BitWidth && getLangOpts().OpenCL) {
12058     Diag(Loc, diag::err_opencl_bitfields);
12059     InvalidDecl = true;
12060   }
12061 
12062   // C99 6.7.2.1p8: A member of a structure or union may have any type other
12063   // than a variably modified type.
12064   if (!InvalidDecl && T->isVariablyModifiedType()) {
12065     bool SizeIsNegative;
12066     llvm::APSInt Oversized;
12067 
12068     TypeSourceInfo *FixedTInfo =
12069       TryToFixInvalidVariablyModifiedTypeSourceInfo(TInfo, Context,
12070                                                     SizeIsNegative,
12071                                                     Oversized);
12072     if (FixedTInfo) {
12073       Diag(Loc, diag::warn_illegal_constant_array_size);
12074       TInfo = FixedTInfo;
12075       T = FixedTInfo->getType();
12076     } else {
12077       if (SizeIsNegative)
12078         Diag(Loc, diag::err_typecheck_negative_array_size);
12079       else if (Oversized.getBoolValue())
12080         Diag(Loc, diag::err_array_too_large)
12081           << Oversized.toString(10);
12082       else
12083         Diag(Loc, diag::err_typecheck_field_variable_size);
12084       InvalidDecl = true;
12085     }
12086   }
12087 
12088   // Fields can not have abstract class types
12089   if (!InvalidDecl && RequireNonAbstractType(Loc, T,
12090                                              diag::err_abstract_type_in_decl,
12091                                              AbstractFieldType))
12092     InvalidDecl = true;
12093 
12094   bool ZeroWidth = false;
12095   // If this is declared as a bit-field, check the bit-field.
12096   if (!InvalidDecl && BitWidth) {
12097     BitWidth = VerifyBitField(Loc, II, T, Record->isMsStruct(Context), BitWidth,
12098                               &ZeroWidth).get();
12099     if (!BitWidth) {
12100       InvalidDecl = true;
12101       BitWidth = nullptr;
12102       ZeroWidth = false;
12103     }
12104   }
12105 
12106   // Check that 'mutable' is consistent with the type of the declaration.
12107   if (!InvalidDecl && Mutable) {
12108     unsigned DiagID = 0;
12109     if (T->isReferenceType())
12110       DiagID = diag::err_mutable_reference;
12111     else if (T.isConstQualified())
12112       DiagID = diag::err_mutable_const;
12113 
12114     if (DiagID) {
12115       SourceLocation ErrLoc = Loc;
12116       if (D && D->getDeclSpec().getStorageClassSpecLoc().isValid())
12117         ErrLoc = D->getDeclSpec().getStorageClassSpecLoc();
12118       Diag(ErrLoc, DiagID);
12119       Mutable = false;
12120       InvalidDecl = true;
12121     }
12122   }
12123 
12124   // C++11 [class.union]p8 (DR1460):
12125   //   At most one variant member of a union may have a
12126   //   brace-or-equal-initializer.
12127   if (InitStyle != ICIS_NoInit)
12128     checkDuplicateDefaultInit(*this, cast<CXXRecordDecl>(Record), Loc);
12129 
12130   FieldDecl *NewFD = FieldDecl::Create(Context, Record, TSSL, Loc, II, T, TInfo,
12131                                        BitWidth, Mutable, InitStyle);
12132   if (InvalidDecl)
12133     NewFD->setInvalidDecl();
12134 
12135   if (PrevDecl && !isa<TagDecl>(PrevDecl)) {
12136     Diag(Loc, diag::err_duplicate_member) << II;
12137     Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12138     NewFD->setInvalidDecl();
12139   }
12140 
12141   if (!InvalidDecl && getLangOpts().CPlusPlus) {
12142     if (Record->isUnion()) {
12143       if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12144         CXXRecordDecl* RDecl = cast<CXXRecordDecl>(RT->getDecl());
12145         if (RDecl->getDefinition()) {
12146           // C++ [class.union]p1: An object of a class with a non-trivial
12147           // constructor, a non-trivial copy constructor, a non-trivial
12148           // destructor, or a non-trivial copy assignment operator
12149           // cannot be a member of a union, nor can an array of such
12150           // objects.
12151           if (CheckNontrivialField(NewFD))
12152             NewFD->setInvalidDecl();
12153         }
12154       }
12155 
12156       // C++ [class.union]p1: If a union contains a member of reference type,
12157       // the program is ill-formed, except when compiling with MSVC extensions
12158       // enabled.
12159       if (EltTy->isReferenceType()) {
12160         Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ?
12161                                     diag::ext_union_member_of_reference_type :
12162                                     diag::err_union_member_of_reference_type)
12163           << NewFD->getDeclName() << EltTy;
12164         if (!getLangOpts().MicrosoftExt)
12165           NewFD->setInvalidDecl();
12166       }
12167     }
12168   }
12169 
12170   // FIXME: We need to pass in the attributes given an AST
12171   // representation, not a parser representation.
12172   if (D) {
12173     // FIXME: The current scope is almost... but not entirely... correct here.
12174     ProcessDeclAttributes(getCurScope(), NewFD, *D);
12175 
12176     if (NewFD->hasAttrs())
12177       CheckAlignasUnderalignment(NewFD);
12178   }
12179 
12180   // In auto-retain/release, infer strong retension for fields of
12181   // retainable type.
12182   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewFD))
12183     NewFD->setInvalidDecl();
12184 
12185   if (T.isObjCGCWeak())
12186     Diag(Loc, diag::warn_attribute_weak_on_field);
12187 
12188   NewFD->setAccess(AS);
12189   return NewFD;
12190 }
12191 
12192 bool Sema::CheckNontrivialField(FieldDecl *FD) {
12193   assert(FD);
12194   assert(getLangOpts().CPlusPlus && "valid check only for C++");
12195 
12196   if (FD->isInvalidDecl() || FD->getType()->isDependentType())
12197     return false;
12198 
12199   QualType EltTy = Context.getBaseElementType(FD->getType());
12200   if (const RecordType *RT = EltTy->getAs<RecordType>()) {
12201     CXXRecordDecl *RDecl = cast<CXXRecordDecl>(RT->getDecl());
12202     if (RDecl->getDefinition()) {
12203       // We check for copy constructors before constructors
12204       // because otherwise we'll never get complaints about
12205       // copy constructors.
12206 
12207       CXXSpecialMember member = CXXInvalid;
12208       // We're required to check for any non-trivial constructors. Since the
12209       // implicit default constructor is suppressed if there are any
12210       // user-declared constructors, we just need to check that there is a
12211       // trivial default constructor and a trivial copy constructor. (We don't
12212       // worry about move constructors here, since this is a C++98 check.)
12213       if (RDecl->hasNonTrivialCopyConstructor())
12214         member = CXXCopyConstructor;
12215       else if (!RDecl->hasTrivialDefaultConstructor())
12216         member = CXXDefaultConstructor;
12217       else if (RDecl->hasNonTrivialCopyAssignment())
12218         member = CXXCopyAssignment;
12219       else if (RDecl->hasNonTrivialDestructor())
12220         member = CXXDestructor;
12221 
12222       if (member != CXXInvalid) {
12223         if (!getLangOpts().CPlusPlus11 &&
12224             getLangOpts().ObjCAutoRefCount && RDecl->hasObjectMember()) {
12225           // Objective-C++ ARC: it is an error to have a non-trivial field of
12226           // a union. However, system headers in Objective-C programs
12227           // occasionally have Objective-C lifetime objects within unions,
12228           // and rather than cause the program to fail, we make those
12229           // members unavailable.
12230           SourceLocation Loc = FD->getLocation();
12231           if (getSourceManager().isInSystemHeader(Loc)) {
12232             if (!FD->hasAttr<UnavailableAttr>())
12233               FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12234                                   "this system field has retaining ownership",
12235                                   Loc));
12236             return false;
12237           }
12238         }
12239 
12240         Diag(FD->getLocation(), getLangOpts().CPlusPlus11 ?
12241                diag::warn_cxx98_compat_nontrivial_union_or_anon_struct_member :
12242                diag::err_illegal_union_or_anon_struct_member)
12243           << (int)FD->getParent()->isUnion() << FD->getDeclName() << member;
12244         DiagnoseNontrivial(RDecl, member);
12245         return !getLangOpts().CPlusPlus11;
12246       }
12247     }
12248   }
12249 
12250   return false;
12251 }
12252 
12253 /// TranslateIvarVisibility - Translate visibility from a token ID to an
12254 ///  AST enum value.
12255 static ObjCIvarDecl::AccessControl
12256 TranslateIvarVisibility(tok::ObjCKeywordKind ivarVisibility) {
12257   switch (ivarVisibility) {
12258   default: llvm_unreachable("Unknown visitibility kind");
12259   case tok::objc_private: return ObjCIvarDecl::Private;
12260   case tok::objc_public: return ObjCIvarDecl::Public;
12261   case tok::objc_protected: return ObjCIvarDecl::Protected;
12262   case tok::objc_package: return ObjCIvarDecl::Package;
12263   }
12264 }
12265 
12266 /// ActOnIvar - Each ivar field of an objective-c class is passed into this
12267 /// in order to create an IvarDecl object for it.
12268 Decl *Sema::ActOnIvar(Scope *S,
12269                                 SourceLocation DeclStart,
12270                                 Declarator &D, Expr *BitfieldWidth,
12271                                 tok::ObjCKeywordKind Visibility) {
12272 
12273   IdentifierInfo *II = D.getIdentifier();
12274   Expr *BitWidth = (Expr*)BitfieldWidth;
12275   SourceLocation Loc = DeclStart;
12276   if (II) Loc = D.getIdentifierLoc();
12277 
12278   // FIXME: Unnamed fields can be handled in various different ways, for
12279   // example, unnamed unions inject all members into the struct namespace!
12280 
12281   TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
12282   QualType T = TInfo->getType();
12283 
12284   if (BitWidth) {
12285     // 6.7.2.1p3, 6.7.2.1p4
12286     BitWidth = VerifyBitField(Loc, II, T, /*IsMsStruct*/false, BitWidth).get();
12287     if (!BitWidth)
12288       D.setInvalidType();
12289   } else {
12290     // Not a bitfield.
12291 
12292     // validate II.
12293 
12294   }
12295   if (T->isReferenceType()) {
12296     Diag(Loc, diag::err_ivar_reference_type);
12297     D.setInvalidType();
12298   }
12299   // C99 6.7.2.1p8: A member of a structure or union may have any type other
12300   // than a variably modified type.
12301   else if (T->isVariablyModifiedType()) {
12302     Diag(Loc, diag::err_typecheck_ivar_variable_size);
12303     D.setInvalidType();
12304   }
12305 
12306   // Get the visibility (access control) for this ivar.
12307   ObjCIvarDecl::AccessControl ac =
12308     Visibility != tok::objc_not_keyword ? TranslateIvarVisibility(Visibility)
12309                                         : ObjCIvarDecl::None;
12310   // Must set ivar's DeclContext to its enclosing interface.
12311   ObjCContainerDecl *EnclosingDecl = cast<ObjCContainerDecl>(CurContext);
12312   if (!EnclosingDecl || EnclosingDecl->isInvalidDecl())
12313     return nullptr;
12314   ObjCContainerDecl *EnclosingContext;
12315   if (ObjCImplementationDecl *IMPDecl =
12316       dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
12317     if (LangOpts.ObjCRuntime.isFragile()) {
12318     // Case of ivar declared in an implementation. Context is that of its class.
12319       EnclosingContext = IMPDecl->getClassInterface();
12320       assert(EnclosingContext && "Implementation has no class interface!");
12321     }
12322     else
12323       EnclosingContext = EnclosingDecl;
12324   } else {
12325     if (ObjCCategoryDecl *CDecl =
12326         dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
12327       if (LangOpts.ObjCRuntime.isFragile() || !CDecl->IsClassExtension()) {
12328         Diag(Loc, diag::err_misplaced_ivar) << CDecl->IsClassExtension();
12329         return nullptr;
12330       }
12331     }
12332     EnclosingContext = EnclosingDecl;
12333   }
12334 
12335   // Construct the decl.
12336   ObjCIvarDecl *NewID = ObjCIvarDecl::Create(Context, EnclosingContext,
12337                                              DeclStart, Loc, II, T,
12338                                              TInfo, ac, (Expr *)BitfieldWidth);
12339 
12340   if (II) {
12341     NamedDecl *PrevDecl = LookupSingleName(S, II, Loc, LookupMemberName,
12342                                            ForRedeclaration);
12343     if (PrevDecl && isDeclInScope(PrevDecl, EnclosingContext, S)
12344         && !isa<TagDecl>(PrevDecl)) {
12345       Diag(Loc, diag::err_duplicate_member) << II;
12346       Diag(PrevDecl->getLocation(), diag::note_previous_declaration);
12347       NewID->setInvalidDecl();
12348     }
12349   }
12350 
12351   // Process attributes attached to the ivar.
12352   ProcessDeclAttributes(S, NewID, D);
12353 
12354   if (D.isInvalidType())
12355     NewID->setInvalidDecl();
12356 
12357   // In ARC, infer 'retaining' for ivars of retainable type.
12358   if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(NewID))
12359     NewID->setInvalidDecl();
12360 
12361   if (D.getDeclSpec().isModulePrivateSpecified())
12362     NewID->setModulePrivate();
12363 
12364   if (II) {
12365     // FIXME: When interfaces are DeclContexts, we'll need to add
12366     // these to the interface.
12367     S->AddDecl(NewID);
12368     IdResolver.AddDecl(NewID);
12369   }
12370 
12371   if (LangOpts.ObjCRuntime.isNonFragile() &&
12372       !NewID->isInvalidDecl() && isa<ObjCInterfaceDecl>(EnclosingDecl))
12373     Diag(Loc, diag::warn_ivars_in_interface);
12374 
12375   return NewID;
12376 }
12377 
12378 /// ActOnLastBitfield - This routine handles synthesized bitfields rules for
12379 /// class and class extensions. For every class \@interface and class
12380 /// extension \@interface, if the last ivar is a bitfield of any type,
12381 /// then add an implicit `char :0` ivar to the end of that interface.
12382 void Sema::ActOnLastBitfield(SourceLocation DeclLoc,
12383                              SmallVectorImpl<Decl *> &AllIvarDecls) {
12384   if (LangOpts.ObjCRuntime.isFragile() || AllIvarDecls.empty())
12385     return;
12386 
12387   Decl *ivarDecl = AllIvarDecls[AllIvarDecls.size()-1];
12388   ObjCIvarDecl *Ivar = cast<ObjCIvarDecl>(ivarDecl);
12389 
12390   if (!Ivar->isBitField() || Ivar->getBitWidthValue(Context) == 0)
12391     return;
12392   ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(CurContext);
12393   if (!ID) {
12394     if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(CurContext)) {
12395       if (!CD->IsClassExtension())
12396         return;
12397     }
12398     // No need to add this to end of @implementation.
12399     else
12400       return;
12401   }
12402   // All conditions are met. Add a new bitfield to the tail end of ivars.
12403   llvm::APInt Zero(Context.getTypeSize(Context.IntTy), 0);
12404   Expr * BW = IntegerLiteral::Create(Context, Zero, Context.IntTy, DeclLoc);
12405 
12406   Ivar = ObjCIvarDecl::Create(Context, cast<ObjCContainerDecl>(CurContext),
12407                               DeclLoc, DeclLoc, nullptr,
12408                               Context.CharTy,
12409                               Context.getTrivialTypeSourceInfo(Context.CharTy,
12410                                                                DeclLoc),
12411                               ObjCIvarDecl::Private, BW,
12412                               true);
12413   AllIvarDecls.push_back(Ivar);
12414 }
12415 
12416 void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl,
12417                        ArrayRef<Decl *> Fields, SourceLocation LBrac,
12418                        SourceLocation RBrac, AttributeList *Attr) {
12419   assert(EnclosingDecl && "missing record or interface decl");
12420 
12421   // If this is an Objective-C @implementation or category and we have
12422   // new fields here we should reset the layout of the interface since
12423   // it will now change.
12424   if (!Fields.empty() && isa<ObjCContainerDecl>(EnclosingDecl)) {
12425     ObjCContainerDecl *DC = cast<ObjCContainerDecl>(EnclosingDecl);
12426     switch (DC->getKind()) {
12427     default: break;
12428     case Decl::ObjCCategory:
12429       Context.ResetObjCLayout(cast<ObjCCategoryDecl>(DC)->getClassInterface());
12430       break;
12431     case Decl::ObjCImplementation:
12432       Context.
12433         ResetObjCLayout(cast<ObjCImplementationDecl>(DC)->getClassInterface());
12434       break;
12435     }
12436   }
12437 
12438   RecordDecl *Record = dyn_cast<RecordDecl>(EnclosingDecl);
12439 
12440   // Start counting up the number of named members; make sure to include
12441   // members of anonymous structs and unions in the total.
12442   unsigned NumNamedMembers = 0;
12443   if (Record) {
12444     for (const auto *I : Record->decls()) {
12445       if (const auto *IFD = dyn_cast<IndirectFieldDecl>(I))
12446         if (IFD->getDeclName())
12447           ++NumNamedMembers;
12448     }
12449   }
12450 
12451   // Verify that all the fields are okay.
12452   SmallVector<FieldDecl*, 32> RecFields;
12453 
12454   bool ARCErrReported = false;
12455   for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end();
12456        i != end; ++i) {
12457     FieldDecl *FD = cast<FieldDecl>(*i);
12458 
12459     // Get the type for the field.
12460     const Type *FDTy = FD->getType().getTypePtr();
12461 
12462     if (!FD->isAnonymousStructOrUnion()) {
12463       // Remember all fields written by the user.
12464       RecFields.push_back(FD);
12465     }
12466 
12467     // If the field is already invalid for some reason, don't emit more
12468     // diagnostics about it.
12469     if (FD->isInvalidDecl()) {
12470       EnclosingDecl->setInvalidDecl();
12471       continue;
12472     }
12473 
12474     // C99 6.7.2.1p2:
12475     //   A structure or union shall not contain a member with
12476     //   incomplete or function type (hence, a structure shall not
12477     //   contain an instance of itself, but may contain a pointer to
12478     //   an instance of itself), except that the last member of a
12479     //   structure with more than one named member may have incomplete
12480     //   array type; such a structure (and any union containing,
12481     //   possibly recursively, a member that is such a structure)
12482     //   shall not be a member of a structure or an element of an
12483     //   array.
12484     if (FDTy->isFunctionType()) {
12485       // Field declared as a function.
12486       Diag(FD->getLocation(), diag::err_field_declared_as_function)
12487         << FD->getDeclName();
12488       FD->setInvalidDecl();
12489       EnclosingDecl->setInvalidDecl();
12490       continue;
12491     } else if (FDTy->isIncompleteArrayType() && Record &&
12492                ((i + 1 == Fields.end() && !Record->isUnion()) ||
12493                 ((getLangOpts().MicrosoftExt ||
12494                   getLangOpts().CPlusPlus) &&
12495                  (i + 1 == Fields.end() || Record->isUnion())))) {
12496       // Flexible array member.
12497       // Microsoft and g++ is more permissive regarding flexible array.
12498       // It will accept flexible array in union and also
12499       // as the sole element of a struct/class.
12500       unsigned DiagID = 0;
12501       if (Record->isUnion())
12502         DiagID = getLangOpts().MicrosoftExt
12503                      ? diag::ext_flexible_array_union_ms
12504                      : getLangOpts().CPlusPlus
12505                            ? diag::ext_flexible_array_union_gnu
12506                            : diag::err_flexible_array_union;
12507       else if (Fields.size() == 1)
12508         DiagID = getLangOpts().MicrosoftExt
12509                      ? diag::ext_flexible_array_empty_aggregate_ms
12510                      : getLangOpts().CPlusPlus
12511                            ? diag::ext_flexible_array_empty_aggregate_gnu
12512                            : NumNamedMembers < 1
12513                                  ? diag::err_flexible_array_empty_aggregate
12514                                  : 0;
12515 
12516       if (DiagID)
12517         Diag(FD->getLocation(), DiagID) << FD->getDeclName()
12518                                         << Record->getTagKind();
12519       // While the layout of types that contain virtual bases is not specified
12520       // by the C++ standard, both the Itanium and Microsoft C++ ABIs place
12521       // virtual bases after the derived members.  This would make a flexible
12522       // array member declared at the end of an object not adjacent to the end
12523       // of the type.
12524       if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record))
12525         if (RD->getNumVBases() != 0)
12526           Diag(FD->getLocation(), diag::err_flexible_array_virtual_base)
12527             << FD->getDeclName() << Record->getTagKind();
12528       if (!getLangOpts().C99)
12529         Diag(FD->getLocation(), diag::ext_c99_flexible_array_member)
12530           << FD->getDeclName() << Record->getTagKind();
12531 
12532       // If the element type has a non-trivial destructor, we would not
12533       // implicitly destroy the elements, so disallow it for now.
12534       //
12535       // FIXME: GCC allows this. We should probably either implicitly delete
12536       // the destructor of the containing class, or just allow this.
12537       QualType BaseElem = Context.getBaseElementType(FD->getType());
12538       if (!BaseElem->isDependentType() && BaseElem.isDestructedType()) {
12539         Diag(FD->getLocation(), diag::err_flexible_array_has_nontrivial_dtor)
12540           << FD->getDeclName() << FD->getType();
12541         FD->setInvalidDecl();
12542         EnclosingDecl->setInvalidDecl();
12543         continue;
12544       }
12545       // Okay, we have a legal flexible array member at the end of the struct.
12546       if (Record)
12547         Record->setHasFlexibleArrayMember(true);
12548     } else if (!FDTy->isDependentType() &&
12549                RequireCompleteType(FD->getLocation(), FD->getType(),
12550                                    diag::err_field_incomplete)) {
12551       // Incomplete type
12552       FD->setInvalidDecl();
12553       EnclosingDecl->setInvalidDecl();
12554       continue;
12555     } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {
12556       if (FDTTy->getDecl()->hasFlexibleArrayMember()) {
12557         // If this is a member of a union, then entire union becomes "flexible".
12558         if (Record && Record->isUnion()) {
12559           Record->setHasFlexibleArrayMember(true);
12560         } else {
12561           // If this is a struct/class and this is not the last element, reject
12562           // it.  Note that GCC supports variable sized arrays in the middle of
12563           // structures.
12564           if (i + 1 != Fields.end())
12565             Diag(FD->getLocation(), diag::ext_variable_sized_type_in_struct)
12566               << FD->getDeclName() << FD->getType();
12567           else {
12568             // We support flexible arrays at the end of structs in
12569             // other structs as an extension.
12570             Diag(FD->getLocation(), diag::ext_flexible_array_in_struct)
12571               << FD->getDeclName();
12572             if (Record)
12573               Record->setHasFlexibleArrayMember(true);
12574           }
12575         }
12576       }
12577       if (isa<ObjCContainerDecl>(EnclosingDecl) &&
12578           RequireNonAbstractType(FD->getLocation(), FD->getType(),
12579                                  diag::err_abstract_type_in_decl,
12580                                  AbstractIvarType)) {
12581         // Ivars can not have abstract class types
12582         FD->setInvalidDecl();
12583       }
12584       if (Record && FDTTy->getDecl()->hasObjectMember())
12585         Record->setHasObjectMember(true);
12586       if (Record && FDTTy->getDecl()->hasVolatileMember())
12587         Record->setHasVolatileMember(true);
12588     } else if (FDTy->isObjCObjectType()) {
12589       /// A field cannot be an Objective-c object
12590       Diag(FD->getLocation(), diag::err_statically_allocated_object)
12591         << FixItHint::CreateInsertion(FD->getLocation(), "*");
12592       QualType T = Context.getObjCObjectPointerType(FD->getType());
12593       FD->setType(T);
12594     } else if (getLangOpts().ObjCAutoRefCount && Record && !ARCErrReported &&
12595                (!getLangOpts().CPlusPlus || Record->isUnion())) {
12596       // It's an error in ARC if a field has lifetime.
12597       // We don't want to report this in a system header, though,
12598       // so we just make the field unavailable.
12599       // FIXME: that's really not sufficient; we need to make the type
12600       // itself invalid to, say, initialize or copy.
12601       QualType T = FD->getType();
12602       Qualifiers::ObjCLifetime lifetime = T.getObjCLifetime();
12603       if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone) {
12604         SourceLocation loc = FD->getLocation();
12605         if (getSourceManager().isInSystemHeader(loc)) {
12606           if (!FD->hasAttr<UnavailableAttr>()) {
12607             FD->addAttr(UnavailableAttr::CreateImplicit(Context,
12608                               "this system field has retaining ownership",
12609                               loc));
12610           }
12611         } else {
12612           Diag(FD->getLocation(), diag::err_arc_objc_object_in_tag)
12613             << T->isBlockPointerType() << Record->getTagKind();
12614         }
12615         ARCErrReported = true;
12616       }
12617     } else if (getLangOpts().ObjC1 &&
12618                getLangOpts().getGC() != LangOptions::NonGC &&
12619                Record && !Record->hasObjectMember()) {
12620       if (FD->getType()->isObjCObjectPointerType() ||
12621           FD->getType().isObjCGCStrong())
12622         Record->setHasObjectMember(true);
12623       else if (Context.getAsArrayType(FD->getType())) {
12624         QualType BaseType = Context.getBaseElementType(FD->getType());
12625         if (BaseType->isRecordType() &&
12626             BaseType->getAs<RecordType>()->getDecl()->hasObjectMember())
12627           Record->setHasObjectMember(true);
12628         else if (BaseType->isObjCObjectPointerType() ||
12629                  BaseType.isObjCGCStrong())
12630                Record->setHasObjectMember(true);
12631       }
12632     }
12633     if (Record && FD->getType().isVolatileQualified())
12634       Record->setHasVolatileMember(true);
12635     // Keep track of the number of named members.
12636     if (FD->getIdentifier())
12637       ++NumNamedMembers;
12638   }
12639 
12640   // Okay, we successfully defined 'Record'.
12641   if (Record) {
12642     bool Completed = false;
12643     if (CXXRecordDecl *CXXRecord = dyn_cast<CXXRecordDecl>(Record)) {
12644       if (!CXXRecord->isInvalidDecl()) {
12645         // Set access bits correctly on the directly-declared conversions.
12646         for (CXXRecordDecl::conversion_iterator
12647                I = CXXRecord->conversion_begin(),
12648                E = CXXRecord->conversion_end(); I != E; ++I)
12649           I.setAccess((*I)->getAccess());
12650 
12651         if (!CXXRecord->isDependentType()) {
12652           if (CXXRecord->hasUserDeclaredDestructor()) {
12653             // Adjust user-defined destructor exception spec.
12654             if (getLangOpts().CPlusPlus11)
12655               AdjustDestructorExceptionSpec(CXXRecord,
12656                                             CXXRecord->getDestructor());
12657           }
12658 
12659           // Add any implicitly-declared members to this class.
12660           AddImplicitlyDeclaredMembersToClass(CXXRecord);
12661 
12662           // If we have virtual base classes, we may end up finding multiple
12663           // final overriders for a given virtual function. Check for this
12664           // problem now.
12665           if (CXXRecord->getNumVBases()) {
12666             CXXFinalOverriderMap FinalOverriders;
12667             CXXRecord->getFinalOverriders(FinalOverriders);
12668 
12669             for (CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),
12670                                              MEnd = FinalOverriders.end();
12671                  M != MEnd; ++M) {
12672               for (OverridingMethods::iterator SO = M->second.begin(),
12673                                             SOEnd = M->second.end();
12674                    SO != SOEnd; ++SO) {
12675                 assert(SO->second.size() > 0 &&
12676                        "Virtual function without overridding functions?");
12677                 if (SO->second.size() == 1)
12678                   continue;
12679 
12680                 // C++ [class.virtual]p2:
12681                 //   In a derived class, if a virtual member function of a base
12682                 //   class subobject has more than one final overrider the
12683                 //   program is ill-formed.
12684                 Diag(Record->getLocation(), diag::err_multiple_final_overriders)
12685                   << (const NamedDecl *)M->first << Record;
12686                 Diag(M->first->getLocation(),
12687                      diag::note_overridden_virtual_function);
12688                 for (OverridingMethods::overriding_iterator
12689                           OM = SO->second.begin(),
12690                        OMEnd = SO->second.end();
12691                      OM != OMEnd; ++OM)
12692                   Diag(OM->Method->getLocation(), diag::note_final_overrider)
12693                     << (const NamedDecl *)M->first << OM->Method->getParent();
12694 
12695                 Record->setInvalidDecl();
12696               }
12697             }
12698             CXXRecord->completeDefinition(&FinalOverriders);
12699             Completed = true;
12700           }
12701         }
12702       }
12703     }
12704 
12705     if (!Completed)
12706       Record->completeDefinition();
12707 
12708     if (Record->hasAttrs()) {
12709       CheckAlignasUnderalignment(Record);
12710 
12711       if (const MSInheritanceAttr *IA = Record->getAttr<MSInheritanceAttr>())
12712         checkMSInheritanceAttrOnDefinition(cast<CXXRecordDecl>(Record),
12713                                            IA->getRange(), IA->getBestCase(),
12714                                            IA->getSemanticSpelling());
12715     }
12716 
12717     // Check if the structure/union declaration is a type that can have zero
12718     // size in C. For C this is a language extension, for C++ it may cause
12719     // compatibility problems.
12720     bool CheckForZeroSize;
12721     if (!getLangOpts().CPlusPlus) {
12722       CheckForZeroSize = true;
12723     } else {
12724       // For C++ filter out types that cannot be referenced in C code.
12725       CXXRecordDecl *CXXRecord = cast<CXXRecordDecl>(Record);
12726       CheckForZeroSize =
12727           CXXRecord->getLexicalDeclContext()->isExternCContext() &&
12728           !CXXRecord->isDependentType() &&
12729           CXXRecord->isCLike();
12730     }
12731     if (CheckForZeroSize) {
12732       bool ZeroSize = true;
12733       bool IsEmpty = true;
12734       unsigned NonBitFields = 0;
12735       for (RecordDecl::field_iterator I = Record->field_begin(),
12736                                       E = Record->field_end();
12737            (NonBitFields == 0 || ZeroSize) && I != E; ++I) {
12738         IsEmpty = false;
12739         if (I->isUnnamedBitfield()) {
12740           if (I->getBitWidthValue(Context) > 0)
12741             ZeroSize = false;
12742         } else {
12743           ++NonBitFields;
12744           QualType FieldType = I->getType();
12745           if (FieldType->isIncompleteType() ||
12746               !Context.getTypeSizeInChars(FieldType).isZero())
12747             ZeroSize = false;
12748         }
12749       }
12750 
12751       // Empty structs are an extension in C (C99 6.7.2.1p7). They are
12752       // allowed in C++, but warn if its declaration is inside
12753       // extern "C" block.
12754       if (ZeroSize) {
12755         Diag(RecLoc, getLangOpts().CPlusPlus ?
12756                          diag::warn_zero_size_struct_union_in_extern_c :
12757                          diag::warn_zero_size_struct_union_compat)
12758           << IsEmpty << Record->isUnion() << (NonBitFields > 1);
12759       }
12760 
12761       // Structs without named members are extension in C (C99 6.7.2.1p7),
12762       // but are accepted by GCC.
12763       if (NonBitFields == 0 && !getLangOpts().CPlusPlus) {
12764         Diag(RecLoc, IsEmpty ? diag::ext_empty_struct_union :
12765                                diag::ext_no_named_members_in_struct_union)
12766           << Record->isUnion();
12767       }
12768     }
12769   } else {
12770     ObjCIvarDecl **ClsFields =
12771       reinterpret_cast<ObjCIvarDecl**>(RecFields.data());
12772     if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(EnclosingDecl)) {
12773       ID->setEndOfDefinitionLoc(RBrac);
12774       // Add ivar's to class's DeclContext.
12775       for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
12776         ClsFields[i]->setLexicalDeclContext(ID);
12777         ID->addDecl(ClsFields[i]);
12778       }
12779       // Must enforce the rule that ivars in the base classes may not be
12780       // duplicates.
12781       if (ID->getSuperClass())
12782         DiagnoseDuplicateIvars(ID, ID->getSuperClass());
12783     } else if (ObjCImplementationDecl *IMPDecl =
12784                   dyn_cast<ObjCImplementationDecl>(EnclosingDecl)) {
12785       assert(IMPDecl && "ActOnFields - missing ObjCImplementationDecl");
12786       for (unsigned I = 0, N = RecFields.size(); I != N; ++I)
12787         // Ivar declared in @implementation never belongs to the implementation.
12788         // Only it is in implementation's lexical context.
12789         ClsFields[I]->setLexicalDeclContext(IMPDecl);
12790       CheckImplementationIvars(IMPDecl, ClsFields, RecFields.size(), RBrac);
12791       IMPDecl->setIvarLBraceLoc(LBrac);
12792       IMPDecl->setIvarRBraceLoc(RBrac);
12793     } else if (ObjCCategoryDecl *CDecl =
12794                 dyn_cast<ObjCCategoryDecl>(EnclosingDecl)) {
12795       // case of ivars in class extension; all other cases have been
12796       // reported as errors elsewhere.
12797       // FIXME. Class extension does not have a LocEnd field.
12798       // CDecl->setLocEnd(RBrac);
12799       // Add ivar's to class extension's DeclContext.
12800       // Diagnose redeclaration of private ivars.
12801       ObjCInterfaceDecl *IDecl = CDecl->getClassInterface();
12802       for (unsigned i = 0, e = RecFields.size(); i != e; ++i) {
12803         if (IDecl) {
12804           if (const ObjCIvarDecl *ClsIvar =
12805               IDecl->getIvarDecl(ClsFields[i]->getIdentifier())) {
12806             Diag(ClsFields[i]->getLocation(),
12807                  diag::err_duplicate_ivar_declaration);
12808             Diag(ClsIvar->getLocation(), diag::note_previous_definition);
12809             continue;
12810           }
12811           for (const auto *Ext : IDecl->known_extensions()) {
12812             if (const ObjCIvarDecl *ClsExtIvar
12813                   = Ext->getIvarDecl(ClsFields[i]->getIdentifier())) {
12814               Diag(ClsFields[i]->getLocation(),
12815                    diag::err_duplicate_ivar_declaration);
12816               Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
12817               continue;
12818             }
12819           }
12820         }
12821         ClsFields[i]->setLexicalDeclContext(CDecl);
12822         CDecl->addDecl(ClsFields[i]);
12823       }
12824       CDecl->setIvarLBraceLoc(LBrac);
12825       CDecl->setIvarRBraceLoc(RBrac);
12826     }
12827   }
12828 
12829   if (Attr)
12830     ProcessDeclAttributeList(S, Record, Attr);
12831 }
12832 
12833 /// \brief Determine whether the given integral value is representable within
12834 /// the given type T.
12835 static bool isRepresentableIntegerValue(ASTContext &Context,
12836                                         llvm::APSInt &Value,
12837                                         QualType T) {
12838   assert(T->isIntegralType(Context) && "Integral type required!");
12839   unsigned BitWidth = Context.getIntWidth(T);
12840 
12841   if (Value.isUnsigned() || Value.isNonNegative()) {
12842     if (T->isSignedIntegerOrEnumerationType())
12843       --BitWidth;
12844     return Value.getActiveBits() <= BitWidth;
12845   }
12846   return Value.getMinSignedBits() <= BitWidth;
12847 }
12848 
12849 // \brief Given an integral type, return the next larger integral type
12850 // (or a NULL type of no such type exists).
12851 static QualType getNextLargerIntegralType(ASTContext &Context, QualType T) {
12852   // FIXME: Int128/UInt128 support, which also needs to be introduced into
12853   // enum checking below.
12854   assert(T->isIntegralType(Context) && "Integral type required!");
12855   const unsigned NumTypes = 4;
12856   QualType SignedIntegralTypes[NumTypes] = {
12857     Context.ShortTy, Context.IntTy, Context.LongTy, Context.LongLongTy
12858   };
12859   QualType UnsignedIntegralTypes[NumTypes] = {
12860     Context.UnsignedShortTy, Context.UnsignedIntTy, Context.UnsignedLongTy,
12861     Context.UnsignedLongLongTy
12862   };
12863 
12864   unsigned BitWidth = Context.getTypeSize(T);
12865   QualType *Types = T->isSignedIntegerOrEnumerationType()? SignedIntegralTypes
12866                                                         : UnsignedIntegralTypes;
12867   for (unsigned I = 0; I != NumTypes; ++I)
12868     if (Context.getTypeSize(Types[I]) > BitWidth)
12869       return Types[I];
12870 
12871   return QualType();
12872 }
12873 
12874 EnumConstantDecl *Sema::CheckEnumConstant(EnumDecl *Enum,
12875                                           EnumConstantDecl *LastEnumConst,
12876                                           SourceLocation IdLoc,
12877                                           IdentifierInfo *Id,
12878                                           Expr *Val) {
12879   unsigned IntWidth = Context.getTargetInfo().getIntWidth();
12880   llvm::APSInt EnumVal(IntWidth);
12881   QualType EltTy;
12882 
12883   if (Val && DiagnoseUnexpandedParameterPack(Val, UPPC_EnumeratorValue))
12884     Val = nullptr;
12885 
12886   if (Val)
12887     Val = DefaultLvalueConversion(Val).get();
12888 
12889   if (Val) {
12890     if (Enum->isDependentType() || Val->isTypeDependent())
12891       EltTy = Context.DependentTy;
12892     else {
12893       SourceLocation ExpLoc;
12894       if (getLangOpts().CPlusPlus11 && Enum->isFixed() &&
12895           !getLangOpts().MSVCCompat) {
12896         // C++11 [dcl.enum]p5: If the underlying type is fixed, [...] the
12897         // constant-expression in the enumerator-definition shall be a converted
12898         // constant expression of the underlying type.
12899         EltTy = Enum->getIntegerType();
12900         ExprResult Converted =
12901           CheckConvertedConstantExpression(Val, EltTy, EnumVal,
12902                                            CCEK_Enumerator);
12903         if (Converted.isInvalid())
12904           Val = nullptr;
12905         else
12906           Val = Converted.get();
12907       } else if (!Val->isValueDependent() &&
12908                  !(Val = VerifyIntegerConstantExpression(Val,
12909                                                          &EnumVal).get())) {
12910         // C99 6.7.2.2p2: Make sure we have an integer constant expression.
12911       } else {
12912         if (Enum->isFixed()) {
12913           EltTy = Enum->getIntegerType();
12914 
12915           // In Obj-C and Microsoft mode, require the enumeration value to be
12916           // representable in the underlying type of the enumeration. In C++11,
12917           // we perform a non-narrowing conversion as part of converted constant
12918           // expression checking.
12919           if (!isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
12920             if (getLangOpts().MSVCCompat) {
12921               Diag(IdLoc, diag::ext_enumerator_too_large) << EltTy;
12922               Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
12923             } else
12924               Diag(IdLoc, diag::err_enumerator_too_large) << EltTy;
12925           } else
12926             Val = ImpCastExprToType(Val, EltTy, CK_IntegralCast).get();
12927         } else if (getLangOpts().CPlusPlus) {
12928           // C++11 [dcl.enum]p5:
12929           //   If the underlying type is not fixed, the type of each enumerator
12930           //   is the type of its initializing value:
12931           //     - If an initializer is specified for an enumerator, the
12932           //       initializing value has the same type as the expression.
12933           EltTy = Val->getType();
12934         } else {
12935           // C99 6.7.2.2p2:
12936           //   The expression that defines the value of an enumeration constant
12937           //   shall be an integer constant expression that has a value
12938           //   representable as an int.
12939 
12940           // Complain if the value is not representable in an int.
12941           if (!isRepresentableIntegerValue(Context, EnumVal, Context.IntTy))
12942             Diag(IdLoc, diag::ext_enum_value_not_int)
12943               << EnumVal.toString(10) << Val->getSourceRange()
12944               << (EnumVal.isUnsigned() || EnumVal.isNonNegative());
12945           else if (!Context.hasSameType(Val->getType(), Context.IntTy)) {
12946             // Force the type of the expression to 'int'.
12947             Val = ImpCastExprToType(Val, Context.IntTy, CK_IntegralCast).get();
12948           }
12949           EltTy = Val->getType();
12950         }
12951       }
12952     }
12953   }
12954 
12955   if (!Val) {
12956     if (Enum->isDependentType())
12957       EltTy = Context.DependentTy;
12958     else if (!LastEnumConst) {
12959       // C++0x [dcl.enum]p5:
12960       //   If the underlying type is not fixed, the type of each enumerator
12961       //   is the type of its initializing value:
12962       //     - If no initializer is specified for the first enumerator, the
12963       //       initializing value has an unspecified integral type.
12964       //
12965       // GCC uses 'int' for its unspecified integral type, as does
12966       // C99 6.7.2.2p3.
12967       if (Enum->isFixed()) {
12968         EltTy = Enum->getIntegerType();
12969       }
12970       else {
12971         EltTy = Context.IntTy;
12972       }
12973     } else {
12974       // Assign the last value + 1.
12975       EnumVal = LastEnumConst->getInitVal();
12976       ++EnumVal;
12977       EltTy = LastEnumConst->getType();
12978 
12979       // Check for overflow on increment.
12980       if (EnumVal < LastEnumConst->getInitVal()) {
12981         // C++0x [dcl.enum]p5:
12982         //   If the underlying type is not fixed, the type of each enumerator
12983         //   is the type of its initializing value:
12984         //
12985         //     - Otherwise the type of the initializing value is the same as
12986         //       the type of the initializing value of the preceding enumerator
12987         //       unless the incremented value is not representable in that type,
12988         //       in which case the type is an unspecified integral type
12989         //       sufficient to contain the incremented value. If no such type
12990         //       exists, the program is ill-formed.
12991         QualType T = getNextLargerIntegralType(Context, EltTy);
12992         if (T.isNull() || Enum->isFixed()) {
12993           // There is no integral type larger enough to represent this
12994           // value. Complain, then allow the value to wrap around.
12995           EnumVal = LastEnumConst->getInitVal();
12996           EnumVal = EnumVal.zext(EnumVal.getBitWidth() * 2);
12997           ++EnumVal;
12998           if (Enum->isFixed())
12999             // When the underlying type is fixed, this is ill-formed.
13000             Diag(IdLoc, diag::err_enumerator_wrapped)
13001               << EnumVal.toString(10)
13002               << EltTy;
13003           else
13004             Diag(IdLoc, diag::ext_enumerator_increment_too_large)
13005               << EnumVal.toString(10);
13006         } else {
13007           EltTy = T;
13008         }
13009 
13010         // Retrieve the last enumerator's value, extent that type to the
13011         // type that is supposed to be large enough to represent the incremented
13012         // value, then increment.
13013         EnumVal = LastEnumConst->getInitVal();
13014         EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
13015         EnumVal = EnumVal.zextOrTrunc(Context.getIntWidth(EltTy));
13016         ++EnumVal;
13017 
13018         // If we're not in C++, diagnose the overflow of enumerator values,
13019         // which in C99 means that the enumerator value is not representable in
13020         // an int (C99 6.7.2.2p2). However, we support GCC's extension that
13021         // permits enumerator values that are representable in some larger
13022         // integral type.
13023         if (!getLangOpts().CPlusPlus && !T.isNull())
13024           Diag(IdLoc, diag::warn_enum_value_overflow);
13025       } else if (!getLangOpts().CPlusPlus &&
13026                  !isRepresentableIntegerValue(Context, EnumVal, EltTy)) {
13027         // Enforce C99 6.7.2.2p2 even when we compute the next value.
13028         Diag(IdLoc, diag::ext_enum_value_not_int)
13029           << EnumVal.toString(10) << 1;
13030       }
13031     }
13032   }
13033 
13034   if (!EltTy->isDependentType()) {
13035     // Make the enumerator value match the signedness and size of the
13036     // enumerator's type.
13037     EnumVal = EnumVal.extOrTrunc(Context.getIntWidth(EltTy));
13038     EnumVal.setIsSigned(EltTy->isSignedIntegerOrEnumerationType());
13039   }
13040 
13041   return EnumConstantDecl::Create(Context, Enum, IdLoc, Id, EltTy,
13042                                   Val, EnumVal);
13043 }
13044 
13045 
13046 Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst,
13047                               SourceLocation IdLoc, IdentifierInfo *Id,
13048                               AttributeList *Attr,
13049                               SourceLocation EqualLoc, Expr *Val) {
13050   EnumDecl *TheEnumDecl = cast<EnumDecl>(theEnumDecl);
13051   EnumConstantDecl *LastEnumConst =
13052     cast_or_null<EnumConstantDecl>(lastEnumConst);
13053 
13054   // The scope passed in may not be a decl scope.  Zip up the scope tree until
13055   // we find one that is.
13056   S = getNonFieldDeclScope(S);
13057 
13058   // Verify that there isn't already something declared with this name in this
13059   // scope.
13060   NamedDecl *PrevDecl = LookupSingleName(S, Id, IdLoc, LookupOrdinaryName,
13061                                          ForRedeclaration);
13062   if (PrevDecl && PrevDecl->isTemplateParameter()) {
13063     // Maybe we will complain about the shadowed template parameter.
13064     DiagnoseTemplateParameterShadow(IdLoc, PrevDecl);
13065     // Just pretend that we didn't see the previous declaration.
13066     PrevDecl = nullptr;
13067   }
13068 
13069   if (PrevDecl) {
13070     // When in C++, we may get a TagDecl with the same name; in this case the
13071     // enum constant will 'hide' the tag.
13072     assert((getLangOpts().CPlusPlus || !isa<TagDecl>(PrevDecl)) &&
13073            "Received TagDecl when not in C++!");
13074     if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {
13075       if (isa<EnumConstantDecl>(PrevDecl))
13076         Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;
13077       else
13078         Diag(IdLoc, diag::err_redefinition) << Id;
13079       Diag(PrevDecl->getLocation(), diag::note_previous_definition);
13080       return nullptr;
13081     }
13082   }
13083 
13084   // C++ [class.mem]p15:
13085   // If T is the name of a class, then each of the following shall have a name
13086   // different from T:
13087   // - every enumerator of every member of class T that is an unscoped
13088   // enumerated type
13089   if (CXXRecordDecl *Record
13090                       = dyn_cast<CXXRecordDecl>(
13091                              TheEnumDecl->getDeclContext()->getRedeclContext()))
13092     if (!TheEnumDecl->isScoped() &&
13093         Record->getIdentifier() && Record->getIdentifier() == Id)
13094       Diag(IdLoc, diag::err_member_name_of_class) << Id;
13095 
13096   EnumConstantDecl *New =
13097     CheckEnumConstant(TheEnumDecl, LastEnumConst, IdLoc, Id, Val);
13098 
13099   if (New) {
13100     // Process attributes.
13101     if (Attr) ProcessDeclAttributeList(S, New, Attr);
13102 
13103     // Register this decl in the current scope stack.
13104     New->setAccess(TheEnumDecl->getAccess());
13105     PushOnScopeChains(New, S);
13106   }
13107 
13108   ActOnDocumentableDecl(New);
13109 
13110   return New;
13111 }
13112 
13113 // Returns true when the enum initial expression does not trigger the
13114 // duplicate enum warning.  A few common cases are exempted as follows:
13115 // Element2 = Element1
13116 // Element2 = Element1 + 1
13117 // Element2 = Element1 - 1
13118 // Where Element2 and Element1 are from the same enum.
13119 static bool ValidDuplicateEnum(EnumConstantDecl *ECD, EnumDecl *Enum) {
13120   Expr *InitExpr = ECD->getInitExpr();
13121   if (!InitExpr)
13122     return true;
13123   InitExpr = InitExpr->IgnoreImpCasts();
13124 
13125   if (BinaryOperator *BO = dyn_cast<BinaryOperator>(InitExpr)) {
13126     if (!BO->isAdditiveOp())
13127       return true;
13128     IntegerLiteral *IL = dyn_cast<IntegerLiteral>(BO->getRHS());
13129     if (!IL)
13130       return true;
13131     if (IL->getValue() != 1)
13132       return true;
13133 
13134     InitExpr = BO->getLHS();
13135   }
13136 
13137   // This checks if the elements are from the same enum.
13138   DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(InitExpr);
13139   if (!DRE)
13140     return true;
13141 
13142   EnumConstantDecl *EnumConstant = dyn_cast<EnumConstantDecl>(DRE->getDecl());
13143   if (!EnumConstant)
13144     return true;
13145 
13146   if (cast<EnumDecl>(TagDecl::castFromDeclContext(ECD->getDeclContext())) !=
13147       Enum)
13148     return true;
13149 
13150   return false;
13151 }
13152 
13153 struct DupKey {
13154   int64_t val;
13155   bool isTombstoneOrEmptyKey;
13156   DupKey(int64_t val, bool isTombstoneOrEmptyKey)
13157     : val(val), isTombstoneOrEmptyKey(isTombstoneOrEmptyKey) {}
13158 };
13159 
13160 static DupKey GetDupKey(const llvm::APSInt& Val) {
13161   return DupKey(Val.isSigned() ? Val.getSExtValue() : Val.getZExtValue(),
13162                 false);
13163 }
13164 
13165 struct DenseMapInfoDupKey {
13166   static DupKey getEmptyKey() { return DupKey(0, true); }
13167   static DupKey getTombstoneKey() { return DupKey(1, true); }
13168   static unsigned getHashValue(const DupKey Key) {
13169     return (unsigned)(Key.val * 37);
13170   }
13171   static bool isEqual(const DupKey& LHS, const DupKey& RHS) {
13172     return LHS.isTombstoneOrEmptyKey == RHS.isTombstoneOrEmptyKey &&
13173            LHS.val == RHS.val;
13174   }
13175 };
13176 
13177 // Emits a warning when an element is implicitly set a value that
13178 // a previous element has already been set to.
13179 static void CheckForDuplicateEnumValues(Sema &S, ArrayRef<Decl *> Elements,
13180                                         EnumDecl *Enum,
13181                                         QualType EnumType) {
13182   if (S.Diags.isIgnored(diag::warn_duplicate_enum_values, Enum->getLocation()))
13183     return;
13184   // Avoid anonymous enums
13185   if (!Enum->getIdentifier())
13186     return;
13187 
13188   // Only check for small enums.
13189   if (Enum->getNumPositiveBits() > 63 || Enum->getNumNegativeBits() > 64)
13190     return;
13191 
13192   typedef SmallVector<EnumConstantDecl *, 3> ECDVector;
13193   typedef SmallVector<ECDVector *, 3> DuplicatesVector;
13194 
13195   typedef llvm::PointerUnion<EnumConstantDecl*, ECDVector*> DeclOrVector;
13196   typedef llvm::DenseMap<DupKey, DeclOrVector, DenseMapInfoDupKey>
13197           ValueToVectorMap;
13198 
13199   DuplicatesVector DupVector;
13200   ValueToVectorMap EnumMap;
13201 
13202   // Populate the EnumMap with all values represented by enum constants without
13203   // an initialier.
13204   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13205     EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
13206 
13207     // Null EnumConstantDecl means a previous diagnostic has been emitted for
13208     // this constant.  Skip this enum since it may be ill-formed.
13209     if (!ECD) {
13210       return;
13211     }
13212 
13213     if (ECD->getInitExpr())
13214       continue;
13215 
13216     DupKey Key = GetDupKey(ECD->getInitVal());
13217     DeclOrVector &Entry = EnumMap[Key];
13218 
13219     // First time encountering this value.
13220     if (Entry.isNull())
13221       Entry = ECD;
13222   }
13223 
13224   // Create vectors for any values that has duplicates.
13225   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13226     EnumConstantDecl *ECD = cast<EnumConstantDecl>(Elements[i]);
13227     if (!ValidDuplicateEnum(ECD, Enum))
13228       continue;
13229 
13230     DupKey Key = GetDupKey(ECD->getInitVal());
13231 
13232     DeclOrVector& Entry = EnumMap[Key];
13233     if (Entry.isNull())
13234       continue;
13235 
13236     if (EnumConstantDecl *D = Entry.dyn_cast<EnumConstantDecl*>()) {
13237       // Ensure constants are different.
13238       if (D == ECD)
13239         continue;
13240 
13241       // Create new vector and push values onto it.
13242       ECDVector *Vec = new ECDVector();
13243       Vec->push_back(D);
13244       Vec->push_back(ECD);
13245 
13246       // Update entry to point to the duplicates vector.
13247       Entry = Vec;
13248 
13249       // Store the vector somewhere we can consult later for quick emission of
13250       // diagnostics.
13251       DupVector.push_back(Vec);
13252       continue;
13253     }
13254 
13255     ECDVector *Vec = Entry.get<ECDVector*>();
13256     // Make sure constants are not added more than once.
13257     if (*Vec->begin() == ECD)
13258       continue;
13259 
13260     Vec->push_back(ECD);
13261   }
13262 
13263   // Emit diagnostics.
13264   for (DuplicatesVector::iterator DupVectorIter = DupVector.begin(),
13265                                   DupVectorEnd = DupVector.end();
13266        DupVectorIter != DupVectorEnd; ++DupVectorIter) {
13267     ECDVector *Vec = *DupVectorIter;
13268     assert(Vec->size() > 1 && "ECDVector should have at least 2 elements.");
13269 
13270     // Emit warning for one enum constant.
13271     ECDVector::iterator I = Vec->begin();
13272     S.Diag((*I)->getLocation(), diag::warn_duplicate_enum_values)
13273       << (*I)->getName() << (*I)->getInitVal().toString(10)
13274       << (*I)->getSourceRange();
13275     ++I;
13276 
13277     // Emit one note for each of the remaining enum constants with
13278     // the same value.
13279     for (ECDVector::iterator E = Vec->end(); I != E; ++I)
13280       S.Diag((*I)->getLocation(), diag::note_duplicate_element)
13281         << (*I)->getName() << (*I)->getInitVal().toString(10)
13282         << (*I)->getSourceRange();
13283     delete Vec;
13284   }
13285 }
13286 
13287 void Sema::ActOnEnumBody(SourceLocation EnumLoc, SourceLocation LBraceLoc,
13288                          SourceLocation RBraceLoc, Decl *EnumDeclX,
13289                          ArrayRef<Decl *> Elements,
13290                          Scope *S, AttributeList *Attr) {
13291   EnumDecl *Enum = cast<EnumDecl>(EnumDeclX);
13292   QualType EnumType = Context.getTypeDeclType(Enum);
13293 
13294   if (Attr)
13295     ProcessDeclAttributeList(S, Enum, Attr);
13296 
13297   if (Enum->isDependentType()) {
13298     for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13299       EnumConstantDecl *ECD =
13300         cast_or_null<EnumConstantDecl>(Elements[i]);
13301       if (!ECD) continue;
13302 
13303       ECD->setType(EnumType);
13304     }
13305 
13306     Enum->completeDefinition(Context.DependentTy, Context.DependentTy, 0, 0);
13307     return;
13308   }
13309 
13310   // TODO: If the result value doesn't fit in an int, it must be a long or long
13311   // long value.  ISO C does not support this, but GCC does as an extension,
13312   // emit a warning.
13313   unsigned IntWidth = Context.getTargetInfo().getIntWidth();
13314   unsigned CharWidth = Context.getTargetInfo().getCharWidth();
13315   unsigned ShortWidth = Context.getTargetInfo().getShortWidth();
13316 
13317   // Verify that all the values are okay, compute the size of the values, and
13318   // reverse the list.
13319   unsigned NumNegativeBits = 0;
13320   unsigned NumPositiveBits = 0;
13321 
13322   // Keep track of whether all elements have type int.
13323   bool AllElementsInt = true;
13324 
13325   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13326     EnumConstantDecl *ECD =
13327       cast_or_null<EnumConstantDecl>(Elements[i]);
13328     if (!ECD) continue;  // Already issued a diagnostic.
13329 
13330     const llvm::APSInt &InitVal = ECD->getInitVal();
13331 
13332     // Keep track of the size of positive and negative values.
13333     if (InitVal.isUnsigned() || InitVal.isNonNegative())
13334       NumPositiveBits = std::max(NumPositiveBits,
13335                                  (unsigned)InitVal.getActiveBits());
13336     else
13337       NumNegativeBits = std::max(NumNegativeBits,
13338                                  (unsigned)InitVal.getMinSignedBits());
13339 
13340     // Keep track of whether every enum element has type int (very commmon).
13341     if (AllElementsInt)
13342       AllElementsInt = ECD->getType() == Context.IntTy;
13343   }
13344 
13345   // Figure out the type that should be used for this enum.
13346   QualType BestType;
13347   unsigned BestWidth;
13348 
13349   // C++0x N3000 [conv.prom]p3:
13350   //   An rvalue of an unscoped enumeration type whose underlying
13351   //   type is not fixed can be converted to an rvalue of the first
13352   //   of the following types that can represent all the values of
13353   //   the enumeration: int, unsigned int, long int, unsigned long
13354   //   int, long long int, or unsigned long long int.
13355   // C99 6.4.4.3p2:
13356   //   An identifier declared as an enumeration constant has type int.
13357   // The C99 rule is modified by a gcc extension
13358   QualType BestPromotionType;
13359 
13360   bool Packed = Enum->hasAttr<PackedAttr>();
13361   // -fshort-enums is the equivalent to specifying the packed attribute on all
13362   // enum definitions.
13363   if (LangOpts.ShortEnums)
13364     Packed = true;
13365 
13366   if (Enum->isFixed()) {
13367     BestType = Enum->getIntegerType();
13368     if (BestType->isPromotableIntegerType())
13369       BestPromotionType = Context.getPromotedIntegerType(BestType);
13370     else
13371       BestPromotionType = BestType;
13372     // We don't need to set BestWidth, because BestType is going to be the type
13373     // of the enumerators, but we do anyway because otherwise some compilers
13374     // warn that it might be used uninitialized.
13375     BestWidth = CharWidth;
13376   }
13377   else if (NumNegativeBits) {
13378     // If there is a negative value, figure out the smallest integer type (of
13379     // int/long/longlong) that fits.
13380     // If it's packed, check also if it fits a char or a short.
13381     if (Packed && NumNegativeBits <= CharWidth && NumPositiveBits < CharWidth) {
13382       BestType = Context.SignedCharTy;
13383       BestWidth = CharWidth;
13384     } else if (Packed && NumNegativeBits <= ShortWidth &&
13385                NumPositiveBits < ShortWidth) {
13386       BestType = Context.ShortTy;
13387       BestWidth = ShortWidth;
13388     } else if (NumNegativeBits <= IntWidth && NumPositiveBits < IntWidth) {
13389       BestType = Context.IntTy;
13390       BestWidth = IntWidth;
13391     } else {
13392       BestWidth = Context.getTargetInfo().getLongWidth();
13393 
13394       if (NumNegativeBits <= BestWidth && NumPositiveBits < BestWidth) {
13395         BestType = Context.LongTy;
13396       } else {
13397         BestWidth = Context.getTargetInfo().getLongLongWidth();
13398 
13399         if (NumNegativeBits > BestWidth || NumPositiveBits >= BestWidth)
13400           Diag(Enum->getLocation(), diag::ext_enum_too_large);
13401         BestType = Context.LongLongTy;
13402       }
13403     }
13404     BestPromotionType = (BestWidth <= IntWidth ? Context.IntTy : BestType);
13405   } else {
13406     // If there is no negative value, figure out the smallest type that fits
13407     // all of the enumerator values.
13408     // If it's packed, check also if it fits a char or a short.
13409     if (Packed && NumPositiveBits <= CharWidth) {
13410       BestType = Context.UnsignedCharTy;
13411       BestPromotionType = Context.IntTy;
13412       BestWidth = CharWidth;
13413     } else if (Packed && NumPositiveBits <= ShortWidth) {
13414       BestType = Context.UnsignedShortTy;
13415       BestPromotionType = Context.IntTy;
13416       BestWidth = ShortWidth;
13417     } else if (NumPositiveBits <= IntWidth) {
13418       BestType = Context.UnsignedIntTy;
13419       BestWidth = IntWidth;
13420       BestPromotionType
13421         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13422                            ? Context.UnsignedIntTy : Context.IntTy;
13423     } else if (NumPositiveBits <=
13424                (BestWidth = Context.getTargetInfo().getLongWidth())) {
13425       BestType = Context.UnsignedLongTy;
13426       BestPromotionType
13427         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13428                            ? Context.UnsignedLongTy : Context.LongTy;
13429     } else {
13430       BestWidth = Context.getTargetInfo().getLongLongWidth();
13431       assert(NumPositiveBits <= BestWidth &&
13432              "How could an initializer get larger than ULL?");
13433       BestType = Context.UnsignedLongLongTy;
13434       BestPromotionType
13435         = (NumPositiveBits == BestWidth || !getLangOpts().CPlusPlus)
13436                            ? Context.UnsignedLongLongTy : Context.LongLongTy;
13437     }
13438   }
13439 
13440   // Loop over all of the enumerator constants, changing their types to match
13441   // the type of the enum if needed.
13442   for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
13443     EnumConstantDecl *ECD = cast_or_null<EnumConstantDecl>(Elements[i]);
13444     if (!ECD) continue;  // Already issued a diagnostic.
13445 
13446     // Standard C says the enumerators have int type, but we allow, as an
13447     // extension, the enumerators to be larger than int size.  If each
13448     // enumerator value fits in an int, type it as an int, otherwise type it the
13449     // same as the enumerator decl itself.  This means that in "enum { X = 1U }"
13450     // that X has type 'int', not 'unsigned'.
13451 
13452     // Determine whether the value fits into an int.
13453     llvm::APSInt InitVal = ECD->getInitVal();
13454 
13455     // If it fits into an integer type, force it.  Otherwise force it to match
13456     // the enum decl type.
13457     QualType NewTy;
13458     unsigned NewWidth;
13459     bool NewSign;
13460     if (!getLangOpts().CPlusPlus &&
13461         !Enum->isFixed() &&
13462         isRepresentableIntegerValue(Context, InitVal, Context.IntTy)) {
13463       NewTy = Context.IntTy;
13464       NewWidth = IntWidth;
13465       NewSign = true;
13466     } else if (ECD->getType() == BestType) {
13467       // Already the right type!
13468       if (getLangOpts().CPlusPlus)
13469         // C++ [dcl.enum]p4: Following the closing brace of an
13470         // enum-specifier, each enumerator has the type of its
13471         // enumeration.
13472         ECD->setType(EnumType);
13473       continue;
13474     } else {
13475       NewTy = BestType;
13476       NewWidth = BestWidth;
13477       NewSign = BestType->isSignedIntegerOrEnumerationType();
13478     }
13479 
13480     // Adjust the APSInt value.
13481     InitVal = InitVal.extOrTrunc(NewWidth);
13482     InitVal.setIsSigned(NewSign);
13483     ECD->setInitVal(InitVal);
13484 
13485     // Adjust the Expr initializer and type.
13486     if (ECD->getInitExpr() &&
13487         !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
13488       ECD->setInitExpr(ImplicitCastExpr::Create(Context, NewTy,
13489                                                 CK_IntegralCast,
13490                                                 ECD->getInitExpr(),
13491                                                 /*base paths*/ nullptr,
13492                                                 VK_RValue));
13493     if (getLangOpts().CPlusPlus)
13494       // C++ [dcl.enum]p4: Following the closing brace of an
13495       // enum-specifier, each enumerator has the type of its
13496       // enumeration.
13497       ECD->setType(EnumType);
13498     else
13499       ECD->setType(NewTy);
13500   }
13501 
13502   Enum->completeDefinition(BestType, BestPromotionType,
13503                            NumPositiveBits, NumNegativeBits);
13504 
13505   CheckForDuplicateEnumValues(*this, Elements, Enum, EnumType);
13506 
13507   // Now that the enum type is defined, ensure it's not been underaligned.
13508   if (Enum->hasAttrs())
13509     CheckAlignasUnderalignment(Enum);
13510 }
13511 
13512 Decl *Sema::ActOnFileScopeAsmDecl(Expr *expr,
13513                                   SourceLocation StartLoc,
13514                                   SourceLocation EndLoc) {
13515   StringLiteral *AsmString = cast<StringLiteral>(expr);
13516 
13517   FileScopeAsmDecl *New = FileScopeAsmDecl::Create(Context, CurContext,
13518                                                    AsmString, StartLoc,
13519                                                    EndLoc);
13520   CurContext->addDecl(New);
13521   return New;
13522 }
13523 
13524 static void checkModuleImportContext(Sema &S, Module *M,
13525                                      SourceLocation ImportLoc,
13526                                      DeclContext *DC) {
13527   if (auto *LSD = dyn_cast<LinkageSpecDecl>(DC)) {
13528     switch (LSD->getLanguage()) {
13529     case LinkageSpecDecl::lang_c:
13530       if (!M->IsExternC) {
13531         S.Diag(ImportLoc, diag::err_module_import_in_extern_c)
13532           << M->getFullModuleName();
13533         S.Diag(LSD->getLocStart(), diag::note_module_import_in_extern_c);
13534         return;
13535       }
13536       break;
13537     case LinkageSpecDecl::lang_cxx:
13538       break;
13539     }
13540     DC = LSD->getParent();
13541   }
13542 
13543   while (isa<LinkageSpecDecl>(DC))
13544     DC = DC->getParent();
13545   if (!isa<TranslationUnitDecl>(DC)) {
13546     S.Diag(ImportLoc, diag::err_module_import_not_at_top_level)
13547       << M->getFullModuleName() << DC;
13548     S.Diag(cast<Decl>(DC)->getLocStart(),
13549            diag::note_module_import_not_at_top_level)
13550       << DC;
13551   }
13552 }
13553 
13554 DeclResult Sema::ActOnModuleImport(SourceLocation AtLoc,
13555                                    SourceLocation ImportLoc,
13556                                    ModuleIdPath Path) {
13557   Module *Mod =
13558       getModuleLoader().loadModule(ImportLoc, Path, Module::AllVisible,
13559                                    /*IsIncludeDirective=*/false);
13560   if (!Mod)
13561     return true;
13562 
13563   checkModuleImportContext(*this, Mod, ImportLoc, CurContext);
13564 
13565   // FIXME: we should support importing a submodule within a different submodule
13566   // of the same top-level module. Until we do, make it an error rather than
13567   // silently ignoring the import.
13568   if (Mod->getTopLevelModuleName() == getLangOpts().CurrentModule)
13569     Diag(ImportLoc, diag::err_module_self_import)
13570         << Mod->getFullModuleName() << getLangOpts().CurrentModule;
13571   else if (Mod->getTopLevelModuleName() == getLangOpts().ImplementationOfModule)
13572     Diag(ImportLoc, diag::err_module_import_in_implementation)
13573         << Mod->getFullModuleName() << getLangOpts().ImplementationOfModule;
13574 
13575   SmallVector<SourceLocation, 2> IdentifierLocs;
13576   Module *ModCheck = Mod;
13577   for (unsigned I = 0, N = Path.size(); I != N; ++I) {
13578     // If we've run out of module parents, just drop the remaining identifiers.
13579     // We need the length to be consistent.
13580     if (!ModCheck)
13581       break;
13582     ModCheck = ModCheck->Parent;
13583 
13584     IdentifierLocs.push_back(Path[I].second);
13585   }
13586 
13587   ImportDecl *Import = ImportDecl::Create(Context,
13588                                           Context.getTranslationUnitDecl(),
13589                                           AtLoc.isValid()? AtLoc : ImportLoc,
13590                                           Mod, IdentifierLocs);
13591   Context.getTranslationUnitDecl()->addDecl(Import);
13592   return Import;
13593 }
13594 
13595 void Sema::ActOnModuleInclude(SourceLocation DirectiveLoc, Module *Mod) {
13596   checkModuleImportContext(*this, Mod, DirectiveLoc, CurContext);
13597 
13598   // FIXME: Should we synthesize an ImportDecl here?
13599   getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, DirectiveLoc,
13600                                       /*Complain=*/true);
13601 }
13602 
13603 void Sema::createImplicitModuleImportForErrorRecovery(SourceLocation Loc,
13604                                                       Module *Mod) {
13605   // Bail if we're not allowed to implicitly import a module here.
13606   if (isSFINAEContext() || !getLangOpts().ModulesErrorRecovery)
13607     return;
13608 
13609   // Create the implicit import declaration.
13610   TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
13611   ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
13612                                                    Loc, Mod, Loc);
13613   TU->addDecl(ImportD);
13614   Consumer.HandleImplicitImportDecl(ImportD);
13615 
13616   // Make the module visible.
13617   getModuleLoader().makeModuleVisible(Mod, Module::AllVisible, Loc,
13618                                       /*Complain=*/false);
13619 }
13620 
13621 void Sema::ActOnPragmaRedefineExtname(IdentifierInfo* Name,
13622                                       IdentifierInfo* AliasName,
13623                                       SourceLocation PragmaLoc,
13624                                       SourceLocation NameLoc,
13625                                       SourceLocation AliasNameLoc) {
13626   Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc,
13627                                     LookupOrdinaryName);
13628   AsmLabelAttr *Attr = ::new (Context) AsmLabelAttr(AliasNameLoc, Context,
13629                                                     AliasName->getName(), 0);
13630 
13631   if (PrevDecl)
13632     PrevDecl->addAttr(Attr);
13633   else
13634     (void)ExtnameUndeclaredIdentifiers.insert(
13635       std::pair<IdentifierInfo*,AsmLabelAttr*>(Name, Attr));
13636 }
13637 
13638 void Sema::ActOnPragmaWeakID(IdentifierInfo* Name,
13639                              SourceLocation PragmaLoc,
13640                              SourceLocation NameLoc) {
13641   Decl *PrevDecl = LookupSingleName(TUScope, Name, NameLoc, LookupOrdinaryName);
13642 
13643   if (PrevDecl) {
13644     PrevDecl->addAttr(WeakAttr::CreateImplicit(Context, PragmaLoc));
13645   } else {
13646     (void)WeakUndeclaredIdentifiers.insert(
13647       std::pair<IdentifierInfo*,WeakInfo>
13648         (Name, WeakInfo((IdentifierInfo*)nullptr, NameLoc)));
13649   }
13650 }
13651 
13652 void Sema::ActOnPragmaWeakAlias(IdentifierInfo* Name,
13653                                 IdentifierInfo* AliasName,
13654                                 SourceLocation PragmaLoc,
13655                                 SourceLocation NameLoc,
13656                                 SourceLocation AliasNameLoc) {
13657   Decl *PrevDecl = LookupSingleName(TUScope, AliasName, AliasNameLoc,
13658                                     LookupOrdinaryName);
13659   WeakInfo W = WeakInfo(Name, NameLoc);
13660 
13661   if (PrevDecl) {
13662     if (!PrevDecl->hasAttr<AliasAttr>())
13663       if (NamedDecl *ND = dyn_cast<NamedDecl>(PrevDecl))
13664         DeclApplyPragmaWeak(TUScope, ND, W);
13665   } else {
13666     (void)WeakUndeclaredIdentifiers.insert(
13667       std::pair<IdentifierInfo*,WeakInfo>(AliasName, W));
13668   }
13669 }
13670 
13671 Decl *Sema::getObjCDeclContext() const {
13672   return (dyn_cast_or_null<ObjCContainerDecl>(CurContext));
13673 }
13674 
13675 AvailabilityResult Sema::getCurContextAvailability() const {
13676   const Decl *D = cast<Decl>(getCurObjCLexicalContext());
13677   // If we are within an Objective-C method, we should consult
13678   // both the availability of the method as well as the
13679   // enclosing class.  If the class is (say) deprecated,
13680   // the entire method is considered deprecated from the
13681   // purpose of checking if the current context is deprecated.
13682   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
13683     AvailabilityResult R = MD->getAvailability();
13684     if (R != AR_Available)
13685       return R;
13686     D = MD->getClassInterface();
13687   }
13688   // If we are within an Objective-c @implementation, it
13689   // gets the same availability context as the @interface.
13690   else if (const ObjCImplementationDecl *ID =
13691             dyn_cast<ObjCImplementationDecl>(D)) {
13692     D = ID->getClassInterface();
13693   }
13694   // Recover from user error.
13695   return D ? D->getAvailability() : AR_Available;
13696 }
13697